diff --git a/src/app.module.ts b/src/app.module.ts
index f9ff66d..07b3a4e 100644
--- a/src/app.module.ts
+++ b/src/app.module.ts
@@ -26,7 +26,7 @@ import { BackupModule } from './backup/backup.module';
 import { TrackingModule } from './tracking/tracking.module';
 import { NotificationsModule } from './notifications/notifications.module';
 import { TransactionsModule } from './transactions/transactions.module';
-import { EmailDigestModule } from './email-digest/email-digest.module';
+
 @Module({
   imports: [
     ConfigModule.forRoot({
@@ -63,8 +63,8 @@ import { EmailDigestModule } from './email-digest/email-digest.module';
     TrackingModule,
     NotificationsModule,
     TransactionsModule,
-    EmailDigestModule,
   ],
+
   controllers: [AppController],
 })
 export class AppModule {}
diff --git a/src/transactions/dto/transactions.dto.ts b/src/transactions/dto/transactions.dto.ts
new file mode 100644
index 0000000..2e48d0a
--- /dev/null
+++ b/src/transactions/dto/transactions.dto.ts
@@ -0,0 +1,73 @@
+import { Type } from 'class-transformer';
+import {
+  IsDate,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Max,
+  Min,
+} from 'class-validator';
+import { TransactionStatus, TransactionType } from '../../types/prisma.types';
+
+export enum TransactionSortField {
+  CREATED_AT = 'createdAt',
+  AMOUNT = 'amount',
+  STATUS = 'status',
+  TYPE = 'type',
+}
+
+export enum SortOrder {
+  ASC = 'asc',
+  DESC = 'desc',
+}
+
+export class TransactionHistoryQueryDto {
+  @IsOptional()
+  @IsEnum(TransactionStatus)
+  status?: TransactionStatus;
+
+  @IsOptional()
+  @IsEnum(TransactionType)
+  type?: TransactionType;
+
+  @IsOptional()
+  @Type(() => Date)
+  @IsDate()
+  startDate?: Date;
+
+  @IsOptional()
+  @Type(() => Date)
+  @IsDate()
+  endDate?: Date;
+
+  @IsOptional()
+  @IsUUID('4')
+  propertyId?: string;
+
+  @IsOptional()
+  @IsUUID('4')
+  userId?: string;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page: number = 1;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit: number = 20;
+
+  @IsOptional()
+  @IsEnum(TransactionSortField)
+  sortBy: TransactionSortField = TransactionSortField.CREATED_AT;
+
+  @IsOptional()
+  @IsEnum(SortOrder)
+  sortOrder: SortOrder = SortOrder.DESC;
+}
diff --git a/src/transactions/transactions.controller.ts b/src/transactions/transactions.controller.ts
index b1ae10b..f5f0b0c 100644
--- a/src/transactions/transactions.controller.ts
+++ b/src/transactions/transactions.controller.ts
@@ -1,68 +1,63 @@
-import { Body, Controller, Get, Param, Patch, Post, Query, UseGuards } from '@nestjs/common';
-import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import {
+  Controller,
+  Get,
+  Param,
+  Query,
+  UseGuards,
+  NotFoundException,
+  ForbiddenException,
+} from '@nestjs/common';
 import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { RolesGuard } from '../auth/guards/roles.guard';
+import { Roles } from '../auth/decorators/roles.decorator';
 import { CurrentUser } from '../auth/decorators/current-user.decorator';
 import { AuthUserPayload } from '../auth/types/auth-user.type';
-import { TransactionSearchQueryDto } from './dto/transaction-search.dto';
-import {
-  CreateTransactionDto,
-  CreateTransactionTaxStrategyDto,
-  UpdateTransactionTaxStrategyDto,
-} from './dto/transaction.dto';
+import { UserRole } from '../types/prisma.types';
 import { TransactionsService } from './transactions.service';
+import { TransactionHistoryQueryDto } from './dto/transactions.dto';
 
-@ApiTags('transactions')
 @Controller('transactions')
+@UseGuards(JwtAuthGuard, RolesGuard)
 export class TransactionsController {
   constructor(private readonly transactionsService: TransactionsService) {}
 
-  @UseGuards(JwtAuthGuard)
-  @Get('search')
-  @ApiOperation({ summary: 'Search transactions with filters and pagination' })
-  @ApiResponse({ status: 200, description: 'Transaction search results returned successfully' })
-  search(@Query() query: TransactionSearchQueryDto, @CurrentUser() user: AuthUserPayload) {
-    return this.transactionsService.search(query, user);
+  @Get('me')
+  getMyTransactions(
+    @CurrentUser() user: AuthUserPayload,
+    @Query() query: TransactionHistoryQueryDto,
+  ) {
+    return this.transactionsService.getTransactions(query, user.sub);
   }
 
-  @UseGuards(JwtAuthGuard)
-  @Post()
-  create(@Body() createTransactionDto: CreateTransactionDto, @CurrentUser() user: AuthUserPayload) {
-    return this.transactionsService.createTransaction(createTransactionDto, user);
+  @Get('property/:propertyId')
+  getPropertyTransactions(
+    @Param('propertyId') propertyId: string,
+    @Query() query: TransactionHistoryQueryDto,
+  ) {
+    // Note: In a real scenario, we might want to check if the user has access to this property's history
+    // For now, we allow authenticated users to see property history as requested.
+    const propertyQuery = { ...query, propertyId };
+    return this.transactionsService.getTransactions(propertyQuery);
   }
 
-  @UseGuards(JwtAuthGuard)
-  @Get(':id/tax-strategies')
-  listTaxStrategies(@Param('id') transactionId: string, @CurrentUser() user: AuthUserPayload) {
-    return this.transactionsService.listTaxStrategies(transactionId, user);
+  @Roles(UserRole.ADMIN)
+  @Get()
+  getAllTransactions(@Query() query: TransactionHistoryQueryDto) {
+    return this.transactionsService.getTransactions(query);
   }
 
-  @UseGuards(JwtAuthGuard)
-  @Post(':id/tax-strategies')
-  createTaxStrategySuggestion(
-    @Param('id') transactionId: string,
-    @Body() createTaxStrategyDto: CreateTransactionTaxStrategyDto,
+  @Get(':id')
+  async getTransactionDetails(
+    @Param('id') id: string,
     @CurrentUser() user: AuthUserPayload,
   ) {
-    return this.transactionsService.createTaxStrategySuggestion(
-      transactionId,
-      createTaxStrategyDto,
-      user,
-    );
-  }
+    const isAdmin = user.role === UserRole.ADMIN;
+    const transaction = await this.transactionsService.getTransactionById(id, user.sub, isAdmin);
 
-  @UseGuards(JwtAuthGuard)
-  @Patch(':id/tax-strategies/:strategyId')
-  updateTaxStrategySuggestion(
-    @Param('id') transactionId: string,
-    @Param('strategyId') strategyId: string,
-    @Body() updateTaxStrategyDto: UpdateTransactionTaxStrategyDto,
-    @CurrentUser() user: AuthUserPayload,
-  ) {
-    return this.transactionsService.updateTaxStrategySuggestion(
-      transactionId,
-      strategyId,
-      updateTaxStrategyDto,
-      user,
-    );
+    if (!transaction) {
+      throw new NotFoundException('Transaction not found or access denied');
+    }
+
+    return transaction;
   }
 }
diff --git a/src/transactions/transactions.module.ts b/src/transactions/transactions.module.ts
index 0461079..3d73bb3 100644
--- a/src/transactions/transactions.module.ts
+++ b/src/transactions/transactions.module.ts
@@ -1,17 +1,12 @@
 import { Module } from '@nestjs/common';
-import { PrismaModule } from '../database/prisma.module';
-import { NotificationsModule } from '../notifications/notifications.module';
-import { TransactionsController } from './transactions.controller';
 import { TransactionsService } from './transactions.service';
-import { DisputesService } from './disputes.service';
-import { TimelineService } from './timeline.service';
-import { DisputesController } from './disputes.controller';
-import { TimelineController } from './timeline.controller';
+import { TransactionsController } from './transactions.controller';
+import { PrismaModule } from '../database/prisma.module';
 
 @Module({
-  imports: [PrismaModule, NotificationsModule],
-  controllers: [TransactionsController, DisputesController, TimelineController],
-  providers: [TransactionsService, DisputesService, TimelineService],
+  imports: [PrismaModule],
+  providers: [TransactionsService],
+  controllers: [TransactionsController],
   exports: [TransactionsService],
 })
 export class TransactionsModule {}
diff --git a/src/transactions/transactions.service.spec.ts b/src/transactions/transactions.service.spec.ts
index d557714..7b31ec0 100644
--- a/src/transactions/transactions.service.spec.ts
+++ b/src/transactions/transactions.service.spec.ts
@@ -1,116 +1,84 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { PrismaService } from '../database/prisma.service';
 import { TransactionsService } from './transactions.service';
-import { TransactionStatus, UserRole } from '../types/prisma.types';
+import { PrismaService } from '../database/prisma.service';
+import { TransactionSortField, SortOrder } from './dto/transactions.dto';
 
 describe('TransactionsService', () => {
   let service: TransactionsService;
-  let prisma: {
+  let prisma: PrismaService;
+
+  const mockPrismaService = {
     transaction: {
-      findMany: jest.Mock;
-      count: jest.Mock;
-    };
+      findMany: jest.fn(),
+      count: jest.fn(),
+      findUnique: jest.fn(),
+    },
   };
 
   beforeEach(async () => {
-    prisma = {
-      transaction: {
-        findMany: jest.fn().mockResolvedValue([{ id: 'tx-1' }]),
-        count: jest.fn().mockResolvedValue(1),
-      },
-    };
-
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         TransactionsService,
         {
           provide: PrismaService,
-          useValue: prisma,
+          useValue: mockPrismaService,
         },
       ],
     }).compile();
 
-    service = module.get(TransactionsService);
+    service = module.get<TransactionsService>(TransactionsService);
+    prisma = module.get<PrismaService>(PrismaService);
   });
 
-  it('searches user transactions with status, date, amount, property filters, and pagination', async () => {
-    const result = await service.search(
-      {
-        status: TransactionStatus.COMPLETED,
-        dateFrom: '2026-04-01',
-        dateTo: '2026-04-29',
-        minAmount: 100000,
-        maxAmount: 250000,
-        property: 'Lagos',
-        propertyId: '550e8400-e29b-41d4-a716-446655440000',
-        page: 2,
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('getTransactions', () => {
+    it('should call prisma findMany and count with correct arguments', async () => {
+      const query = {
+        page: 1,
         limit: 10,
-      },
-      {
-        sub: 'user-1',
-        email: 'buyer@example.com',
-        role: UserRole.USER as any,
-        type: 'access',
-      },
-    );
+        sortBy: TransactionSortField.CREATED_AT,
+        sortOrder: SortOrder.DESC,
+      };
+      const userId = 'user-1';
 
-    expect(prisma.transaction.findMany).toHaveBeenCalledWith(
-      expect.objectContaining({
-        skip: 10,
-        take: 10,
-        orderBy: { createdAt: 'desc' },
-        where: {
-          AND: expect.arrayContaining([
-            { OR: [{ buyerId: 'user-1' }, { sellerId: 'user-1' }] },
-            { status: TransactionStatus.COMPLETED },
-            { propertyId: '550e8400-e29b-41d4-a716-446655440000' },
-            {
-              property: {
-                OR: expect.arrayContaining([
-                  { title: { contains: 'Lagos', mode: 'insensitive' } },
-                  { address: { contains: 'Lagos', mode: 'insensitive' } },
-                ]),
-              },
-            },
-            {
-              createdAt: {
-                gte: new Date('2026-04-01'),
-                lte: new Date('2026-04-29T23:59:59.999Z'),
-              },
-            },
-            {
-              amount: {
-                gte: expect.any(Object),
-                lte: expect.any(Object),
-              },
-            },
-          ]),
-        },
-      }),
-    );
-    expect(prisma.transaction.count).toHaveBeenCalledWith({
-      where: prisma.transaction.findMany.mock.calls[0][0].where,
-    });
-    expect(result).toEqual({
-      total: 1,
-      page: 2,
-      limit: 10,
-      totalPages: 1,
-      items: [{ id: 'tx-1' }],
+      mockPrismaService.transaction.findMany.mockResolvedValue([]);
+      mockPrismaService.transaction.count.mockResolvedValue(0);
+
+      const result = await service.getTransactions(query, userId);
+
+      expect(prisma.transaction.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            OR: [{ buyerId: userId }, { sellerId: userId }],
+          }),
+          skip: 0,
+          take: 10,
+        }),
+      );
+      expect(prisma.transaction.count).toHaveBeenCalled();
+      expect(result).toHaveProperty('items');
+      expect(result).toHaveProperty('total');
     });
   });
 
-  it('lets admins search all transactions without buyer or seller scoping', async () => {
-    await service.search(
-      { page: 1, limit: 20 },
-      {
-        sub: 'admin-1',
-        email: 'admin@example.com',
-        role: UserRole.ADMIN as any,
-        type: 'access',
-      },
-    );
+  describe('getTransactionById', () => {
+    it('should return transaction if user is buyer', async () => {
+      const mockTransaction = { id: 't-1', buyerId: 'user-1', sellerId: 'user-2' };
+      mockPrismaService.transaction.findUnique.mockResolvedValue(mockTransaction);
 
-    expect(prisma.transaction.findMany.mock.calls[0][0].where).toEqual({});
+      const result = await service.getTransactionById('t-1', 'user-1');
+      expect(result).toEqual(mockTransaction);
+    });
+
+    it('should return null if user is not buyer, seller or admin', async () => {
+      const mockTransaction = { id: 't-1', buyerId: 'user-1', sellerId: 'user-2' };
+      mockPrismaService.transaction.findUnique.mockResolvedValue(mockTransaction);
+
+      const result = await service.getTransactionById('t-1', 'user-3', false);
+      expect(result).toBeNull();
+    });
   });
 });
diff --git a/src/transactions/transactions.service.ts b/src/transactions/transactions.service.ts
index 36824cd..6a6e080 100644
--- a/src/transactions/transactions.service.ts
+++ b/src/transactions/transactions.service.ts
@@ -1,15 +1,10 @@
-import {
-  BadRequestException,
-  ForbiddenException,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import { TransactionHistoryQueryDto } from './dto/transactions.dto';
 import { Prisma } from '@prisma/client';
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
 import { Decimal } from '@prisma/client/runtime/library';
-import { AuthUserPayload } from '../auth/types/auth-user.type';
-import { PrismaService } from '../database/prisma.service';
-import { NotificationsService } from '../notifications/notifications.service';
-import { TransactionStatus, TransactionType, UserRole } from '../types/prisma.types';
+import { TransactionStatus, TransactionType } from '../types/prisma.types';
 import {
   canTransitionTransactionStatus,
   DEFAULT_TRANSACTION_STATUS,
@@ -93,100 +88,55 @@ export class TransactionsService {
       throw new BadRequestException('Seller must match the property owner');
     }
 
-    return this.prisma.transaction.create({
-      data: {
-        propertyId: input.propertyId,
-        buyerId: input.buyerId,
-        sellerId: input.sellerId,
-        amount: new Decimal(input.amount.toString()),
-        type: input.type ?? TransactionType.SALE,
-        blockchainHash: input.blockchainHash,
-        contractAddress: input.contractAddress,
-        notes: input.notes,
-        status: input.status ?? DEFAULT_TRANSACTION_STATUS,
-      },
-      include: {
-        property: {
-          select: {
-            id: true,
-            title: true,
-            address: true,
-          },
-        },
-        buyer: {
-          select: {
-            id: true,
-            firstName: true,
-            lastName: true,
-            email: true,
-          },
-        },
-        seller: {
-          select: {
-            id: true,
-            firstName: true,
-            lastName: true,
-            email: true,
-          },
-        },
-      },
-    });
-  }
-
-  async updateStatus(id: string, status: TransactionStatus) {
-    const transaction = await this.prisma.transaction.findUnique({
-      where: { id },
-    });
-
-    if (!transaction) {
-      throw new NotFoundException(`Transaction with ID ${id} not found`);
-    }
-
-    const updated = await this.prisma.transaction.update({
-      where: { id },
-      data: { status },
-    });
-
-    // Trigger notification
-    await this.notificationsService.handleTransactionUpdate(id);
-
-    return updated;
-  }
+  async getTransactions(query: TransactionHistoryQueryDto, userId?: string) {
+    const {
+      status,
+      type,
+      startDate,
+      endDate,
+      propertyId,
+      userId: queryUserId,
+      page,
+      limit,
+      sortBy,
+      sortOrder,
+    } = query;
 
-  // Alias for AdminService compatibility
-  async updateTransactionStatus(id: string, status: TransactionStatus) {
-    return this.updateStatus(id, status);
-  }
+    const skip = (page - 1) * limit;
 
-  async findOne(id: string) {
-    const transaction = await this.prisma.transaction.findUnique({
-      where: { id },
-      include: {
-        buyer: true,
-        seller: true,
-        property: true,
+    const where: Prisma.TransactionWhereInput = {
+      status,
+      type,
+      propertyId,
+      createdAt: {
+        gte: startDate,
+        lte: endDate,
       },
-    });
+    };
 
-    if (!transaction) {
-      throw new NotFoundException(`Transaction with ID ${id} not found`);
+    // If userId is provided, filter by that user (as buyer or seller)
+    // This is for "my transactions" view
+    if (userId) {
+      where.OR = [
+        { buyerId: userId },
+        { sellerId: userId },
+      ];
+    } else if (queryUserId) {
+      // If userId is in query (admin view), filter by that user
+      where.OR = [
+        { buyerId: queryUserId },
+        { sellerId: queryUserId },
+      ];
     }
 
-    return transaction;
-  }
-
-  async search(query: TransactionSearchQueryDto, user: AuthUserPayload) {
-    const page = query.page ?? 1;
-    const limit = query.limit ?? 20;
-    const skip = (page - 1) * limit;
-    const where = this.buildSearchWhere(query, user);
-
     const [items, total] = await Promise.all([
       this.prisma.transaction.findMany({
         where,
         skip,
         take: limit,
-        orderBy: { createdAt: 'desc' },
+        orderBy: {
+          [sortBy]: sortOrder,
+        },
         include: {
           property: {
             select: {
@@ -198,10 +148,20 @@ export class TransactionsService {
             },
           },
           buyer: {
-            select: { id: true, email: true, firstName: true, lastName: true },
+            select: {
+              id: true,
+              email: true,
+              firstName: true,
+              lastName: true,
+            },
           },
           seller: {
-            select: { id: true, email: true, firstName: true, lastName: true },
+            select: {
+              id: true,
+              email: true,
+              firstName: true,
+              lastName: true,
+            },
           },
         },
       }),
@@ -209,289 +169,33 @@ export class TransactionsService {
     ]);
 
     return {
+      items,
       total,
       page,
       limit,
       totalPages: Math.ceil(total / limit),
-      items,
     };
   }
 
-  async listTaxStrategies(transactionId: string, actor: AuthUserPayload) {
-    const transaction = await this.getTransactionForTaxStrategy(transactionId);
-    this.assertCanAccessTaxStrategy(transaction, actor);
-
-    return this.prisma.transactionTaxStrategy.findMany({
-      where: { transactionId },
-      orderBy: [{ updatedAt: 'desc' }, { createdAt: 'desc' }],
-    });
-  }
-
-  async createTaxStrategySuggestion(
-    transactionId: string,
-    input: CreateTransactionTaxStrategyDto,
-    actor: AuthUserPayload,
-  ) {
-    const transaction = await this.getTransactionForTaxStrategy(transactionId);
-    this.assertCanAccessTaxStrategy(transaction, actor);
-
-    const estimatedTaxRate = this.toDecimal(input.estimatedTaxRate);
-    const estimatedTaxImpact = this.resolveEstimatedTaxImpact(
-      transaction.amount,
-      estimatedTaxRate,
-      input.estimatedTaxImpact,
-    );
-
-    const strategy = await this.prisma.transactionTaxStrategy.create({
-      data: {
-        transactionId,
-        createdById: actor.sub,
-        strategyType: input.strategyType.trim(),
-        jurisdiction:
-          input.jurisdiction?.trim() || this.buildJurisdictionLabel(transaction.property),
-        estimatedTaxRate,
-        estimatedTaxImpact,
-        explanation: input.explanation.trim(),
-        metadata: this.buildStrategyMetadata(input.metadata),
-        version: input.version ?? 1,
-      },
-    });
-
-    await this.emitTaxStrategyNotification('created', strategy, transaction, actor.sub);
-
-    return strategy;
-  }
-
-  async updateTaxStrategySuggestion(
-    transactionId: string,
-    strategyId: string,
-    input: UpdateTransactionTaxStrategyDto,
-    actor: AuthUserPayload,
-  ) {
-    const transaction = await this.getTransactionForTaxStrategy(transactionId);
-    this.assertCanAccessTaxStrategy(transaction, actor);
-
-    const existing = await this.prisma.transactionTaxStrategy.findFirst({
-      where: {
-        id: strategyId,
-        transactionId,
-      },
-    });
-
-    if (!existing) {
-      throw new NotFoundException(`Tax strategy suggestion ${strategyId} not found`);
-    }
-
-    const estimatedTaxRate =
-      input.estimatedTaxRate !== undefined
-        ? this.toDecimal(input.estimatedTaxRate)
-        : existing.estimatedTaxRate;
-    const estimatedTaxImpact = this.resolveEstimatedTaxImpact(
-      transaction.amount,
-      estimatedTaxRate,
-      input.estimatedTaxImpact !== undefined ? input.estimatedTaxImpact : existing.estimatedTaxImpact,
-    );
-
-    const strategy = await this.prisma.transactionTaxStrategy.update({
-      where: { id: strategyId },
-      data: {
-        strategyType: input.strategyType?.trim() ?? existing.strategyType,
-        jurisdiction:
-          input.jurisdiction !== undefined
-            ? input.jurisdiction.trim() || this.buildJurisdictionLabel(transaction.property)
-            : existing.jurisdiction,
-        estimatedTaxRate,
-        estimatedTaxImpact,
-        explanation: input.explanation?.trim() ?? existing.explanation,
-        metadata:
-          input.metadata !== undefined
-            ? this.buildStrategyMetadata(input.metadata)
-            : existing.metadata ?? this.buildStrategyMetadata(),
-        version: input.version ?? existing.version + 1,
-      },
-    });
-
-    await this.emitTaxStrategyNotification('updated', strategy, transaction, actor.sub);
-
-    return strategy;
-  }
-
-  private async getTransactionForTaxStrategy(transactionId: string) {
+  async getTransactionById(id: string, userId?: string, isAdmin: boolean = false) {
     const transaction = await this.prisma.transaction.findUnique({
-      where: { id: transactionId },
+      where: { id },
       include: {
-        property: {
-          select: {
-            id: true,
-            city: true,
-            state: true,
-            country: true,
-          },
-        },
+        property: true,
+        buyer: true,
+        seller: true,
       },
     });
 
     if (!transaction) {
-      throw new NotFoundException(`Transaction ${transactionId} not found`);
-    }
-
-    return transaction;
-  }
-
-  private buildSearchWhere(
-    query: TransactionSearchQueryDto,
-    user: AuthUserPayload,
-  ): Prisma.TransactionWhereInput {
-    const filters: Prisma.TransactionWhereInput[] = [];
-
-    if (user.role !== UserRole.ADMIN) {
-      filters.push({
-        OR: [{ buyerId: user.sub }, { sellerId: user.sub }],
-      });
-    }
-
-    if (query.status) {
-      filters.push({ status: query.status });
-    }
-
-    if (query.propertyId) {
-      filters.push({ propertyId: query.propertyId });
-    }
-
-    if (query.property) {
-      filters.push({
-        property: {
-          OR: [
-            { title: { contains: query.property, mode: 'insensitive' } },
-            { address: { contains: query.property, mode: 'insensitive' } },
-            { city: { contains: query.property, mode: 'insensitive' } },
-            { state: { contains: query.property, mode: 'insensitive' } },
-          ],
-        },
-      });
-    }
-
-    const createdAt: Prisma.DateTimeFilter = {};
-    if (query.dateFrom) {
-      createdAt.gte = new Date(query.dateFrom);
-    }
-    if (query.dateTo) {
-      createdAt.lte = this.endOfDay(query.dateTo);
-    }
-    if (Object.keys(createdAt).length > 0) {
-      filters.push({ createdAt });
-    }
-
-    const amount: Prisma.DecimalFilter = {};
-    if (query.minAmount !== undefined) {
-      amount.gte = new Decimal(query.minAmount);
-    }
-    if (query.maxAmount !== undefined) {
-      amount.lte = new Decimal(query.maxAmount);
-    }
-    if (Object.keys(amount).length > 0) {
-      filters.push({ amount });
-    }
-
-    return filters.length > 0 ? { AND: filters } : {};
-  }
-
-  private assertCanAccessTaxStrategy(
-    transaction: { buyerId: string; sellerId: string },
-    actor: AuthUserPayload,
-  ) {
-    if (
-      actor.role !== UserRole.ADMIN &&
-      actor.sub !== transaction.buyerId &&
-      actor.sub !== transaction.sellerId
-    ) {
-      throw new ForbiddenException('You are not allowed to manage tax strategy suggestions');
-    }
-  }
-
-  private buildJurisdictionLabel(property?: {
-    city: string | null;
-    state: string | null;
-    country: string | null;
-  } | null) {
-    if (!property) {
       return null;
     }
 
-    const parts = [property.city, property.state, property.country]
-      .map((part) => part?.trim())
-      .filter((part): part is string => Boolean(part));
-
-    return parts.length > 0 ? parts.join(', ') : null;
-  }
-
-  private buildStrategyMetadata(metadata?: Record<string, unknown>): Prisma.InputJsonValue {
-    return {
-      ...(metadata ?? {}),
-      disclaimer: TAX_STRATEGY_DISCLAIMER,
-    } as Prisma.InputJsonValue;
-  }
-
-  private toDecimal(value?: Decimal | number | string | null) {
-    if (value === undefined || value === null) {
+    // Authorization check: User must be buyer, seller, or admin
+    if (!isAdmin && userId && transaction.buyerId !== userId && transaction.sellerId !== userId) {
       return null;
     }
 
-    return new Decimal(value.toString());
-  }
-
-  private resolveEstimatedTaxImpact(
-    transactionAmount: Decimal,
-    estimatedTaxRate?: Decimal | null,
-    fallbackImpact?: Decimal | number | string | null,
-  ) {
-    if (estimatedTaxRate) {
-      return transactionAmount.mul(estimatedTaxRate).div(100);
-    }
-
-    return this.toDecimal(fallbackImpact);
-  }
-
-  private endOfDay(date: string): Date {
-    const parsed = new Date(date);
-    if (date.length <= 10) {
-      parsed.setUTCHours(23, 59, 59, 999);
-    }
-    return parsed;
-  }
-
-  private async emitTaxStrategyNotification(
-    action: 'created' | 'updated',
-    strategy: {
-      id: string;
-      transactionId: string;
-      strategyType: string;
-      jurisdiction: string | null;
-      version: number;
-    },
-    transaction: { buyerId: string; sellerId: string },
-    actorId: string,
-  ) {
-    const recipients = new Set([transaction.buyerId, transaction.sellerId]);
-
-    await Promise.all(
-      Array.from(recipients).map((userId) =>
-        this.notificationsService.sendNotification(
-          userId,
-          `Tax strategy suggestion ${action}`,
-          `A ${strategy.strategyType} tax strategy suggestion was ${action} for transaction ${strategy.transactionId}.`,
-          `transaction_tax_strategy_${action}`,
-          {
-            transactionId: strategy.transactionId,
-            strategyId: strategy.id,
-            strategyType: strategy.strategyType,
-            jurisdiction: strategy.jurisdiction,
-            version: strategy.version,
-            actorId,
-            disclaimer: TAX_STRATEGY_DISCLAIMER,
-          },
-        ),
-      ),
-    );
+    return transaction;
   }
 }