Added A seperate migration for traceability

.vscode/launch.json

@@ -4,7 +4,7 @@
       {
         "type": "node",
         "request": "launch",
-        "name": "Launch via NPM",
+        "name": "Debug e2e Test",
         "runtimeExecutable": "npm",
         "runtimeArgs": [
           "run",

e2e/indexer.e2e-spec.ts

@@ -1,5 +1,5 @@
 import { UTXO, WalletHelper, AddressType } from '@e2e/helpers/wallet.helper';
-import { transactionToEntity } from '@e2e/helpers/common.helper';
+import { btcToSats, transactionToEntity } from '@e2e/helpers/common.helper';
 import { initialiseDep } from '@e2e/setup';
 import { ApiHelper } from '@e2e/helpers/api.helper';
 import { SilentBlocksService } from '@/silent-blocks/silent-blocks.service';
@@ -74,4 +74,62 @@ describe('Indexer', () => {
             expect(response.data).toEqual(silentBlock);
         },
     );
+
+    it('Should exclude spent transactions when the "FilterSpent" flag is set to true', async () => {
+        const taprootOutput = walletHelper.generateAddresses(
+            1,
+            AddressType.P2TR,
+        )[0];
+        const outputs = walletHelper.generateAddresses(6, AddressType.P2WPKH);
+        const utxos: UTXO[] = [];
+
+        for (const [index, output] of outputs.entries()) {
+            const utxo = await walletHelper.addFundToUTXO(
+                output,
+                1,
+                AddressType.P2WPKH,
+                index,
+            );
+            utxos.push(utxo);
+        }
+
+        const { transaction, txid, blockHash } =
+            await walletHelper.craftAndSendTransaction(
+                utxos,
+                taprootOutput,
+                5.999,
+                0.001,
+            );
+
+        const utxo: UTXO = {
+            rawTx: transaction.toHex(),
+            txid,
+            vout: 0,
+            value: btcToSats(5.999),
+            addressType: AddressType.P2TR,
+            index: 0,
+        };
+
+        await walletHelper.craftAndSendTransaction(
+            [utxo],
+            taprootOutput,
+            5.998,
+            0.001,
+        );
+
+        await new Promise((resolve) => setTimeout(resolve, 30000));
+        const response = await apiHelper.get(
+            `/silent-block/hash/${blockHash}?filterSpent=true`,
+            {
+                responseType: 'arraybuffer',
+            },
+        );
+
+        const silentBlock = new SilentBlocksService(
+            {} as any,
+            {} as any,
+        ).encodeSilentBlock([]);
+
+        expect(response.data).toEqual(silentBlock);
+    });
 });

migrations/1736332353003-migrations.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class Migrations1736332353003 implements MigrationInterface {
+    name = 'MIgrations1736332353003';
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            CREATE TABLE "transaction_output" (
+                "id" integer PRIMARY KEY NOT NULL,
+                "pubKey" text NOT NULL,
+                "vout" integer NOT NULL,
+                "value" integer NOT NULL,
+                "isSpent" boolean NOT NULL DEFAULT false,
+                "transactionId" INTEGER NOT NULL,
+                CONSTRAINT "FK_transaction_transaction_output" FOREIGN KEY ("transactionId") REFERENCES "transaction"("id") ON DELETE CASCADE
+            )
+        `);
+        await queryRunner.query(`
+            ALTER TABLE "transaction" DROP COLUMN "isSpent"
+        `);
+        await queryRunner.query(`
+            ALTER TABLE "transaction" DROP COLUMN "outputs"
+        `);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            DROP TABLE "transaction_output"
+        `);
+        await queryRunner.query(`
+            ALTER TABLE "transaction" ADD COLUMN "isSpent" boolean NOT NULL
+        `);
+        await queryRunner.query(`
+            ALTER TABLE "transaction" ADD COLUMN "outputs" text NOT NULL
+        `);
+    }
+}

src/app.module.ts

@@ -10,7 +10,6 @@ import { OperationStateModule } from '@/operation-state/operation-state.module';
 import { ScheduleModule } from '@nestjs/schedule';
 import { BlockProviderModule } from '@/block-data-providers/block-provider.module';
 import { EventEmitterModule } from '@nestjs/event-emitter';
-import { TransactionOutputModule } from '@/transaction-output/transaction-output.module';
 
 @Module({
     imports: [
@@ -35,7 +34,6 @@ import { TransactionOutputModule } from '@/transaction-output/transaction-output
         SilentBlocksModule,
         OperationStateModule,
         BlockProviderModule,
-        TransactionOutputModule,
     ],
     controllers: [AppController],
     providers: [AppService],

src/indexer/indexer.service.ts

@@ -1,5 +1,5 @@
 import { Transaction } from '@/transactions/transaction.entity';
-import { TransactionOutput as TransactionOutputEntity } from '@/transaction-output/transaction-output.entity';
+import { TransactionOutput as TransactionOutputEntity } from '@/transactions/transaction-output.entity';
 import { createTaggedHash, extractPubKeyFromScript } from '@/common/common';
 import { publicKeyCombine, publicKeyTweakMul } from 'secp256k1';
 import { Injectable } from '@nestjs/common';
@@ -40,8 +40,6 @@ export class IndexerService {
             transaction.scanTweak = scanTweak.toString('hex');
             transaction.outputs = eligibleOutputs;
 
-            console.log(transaction);
-
             await manager.save(Transaction, transaction);
         }
     }
@@ -57,13 +55,17 @@ export class IndexerService {
             })),
         });
 
+        if (outputs.length == 0) {
+            return;
+        }
+
         // Mark each output as spent
         const spentOutputs = outputs.map((output) => ({
             ...output,
             isSpent: true,
         }));
 
-        await manager.save(spentOutputs);
+        await manager.save(TransactionOutputEntity, spentOutputs);
     }
 
     public deriveOutputsAndComputeScanTweak(

src/silent-blocks/silent-blocks.controller.ts

@@ -25,15 +25,15 @@ export class SilentBlocksController {
     @Get('hash/:blockHash')
     async getSilentBlockByHash(
         @Param('blockHash') blockHash: string,
-        @Query('unspent') unspent = 'false',
+        @Query('filterSpent') filterSpentFlag = 'false',
         @Res() res: Response,
     ) {
-        // Convert unspent to boolean
-        const unspentFlag = unspent === 'true';
+        // Convert  to boolean
+        const filterSpent = filterSpentFlag === 'true';
 
         const buffer = await this.silentBlocksService.getSilentBlockByHash(
             blockHash,
-            unspentFlag,
+            filterSpent,
         );
 
         res.set({

src/silent-blocks/silent-blocks.service.ts

@@ -62,22 +62,20 @@ export class SilentBlocksService {
             await this.transactionsService.getTransactionByBlockHeight(
                 blockHeight,
             );
-        console.log("outputs length", transactions[0]);
+
         return this.encodeSilentBlock(transactions);
     }
 
     async getSilentBlockByHash(
         blockHash: string,
-        unspentFlag: boolean,
+        filterSpent: boolean,
     ): Promise<Buffer> {
         let transactions =
             await this.transactionsService.getTransactionByBlockHash(blockHash);
 
-        console.log("outputs length", transactions[0]);
-
-        if (unspentFlag) {
+        if (filterSpent) {
             transactions = transactions.filter((transaction) =>
-                transaction.outputs.every((output) => output.isSpent),
+                transaction.outputs.some((output) => !output.isSpent),
             );
         }
 

src/transactions/transaction.controller.spec.ts

@@ -17,9 +17,11 @@ const mockTransactions: Transaction[] = [
                 pubKey: '51203e9fce73d4e77a4809908e3c3a2e54ee147b9312dc5044a193d1fc85de46e3c1',
                 vout: 1,
                 value: 100000,
+                id: 0,
+                isSpent: false,
+                transaction: new Transaction(),
             },
         ],
-        isSpent: false,
     },
     {
         id: '2',
@@ -33,9 +35,11 @@ const mockTransactions: Transaction[] = [
                 pubKey: '51203e9fce73d4e77a4809908e3c3a2e54ee147b9312dc5044a193d1fc85de46e3c1',
                 vout: 2,
                 value: 100000,
+                id: 0,
+                isSpent: false,
+                transaction: new Transaction(),
             },
         ],
-        isSpent: true,
     },
     {
         id: '3',
@@ -49,9 +53,11 @@ const mockTransactions: Transaction[] = [
                 pubKey: '5120f4c2da807f89cb1501f1a77322a895acfb93c28e08ed2724d2beb8e44539ba38',
                 vout: 3,
                 value: 100000,
+                id: 0,
+                isSpent: false,
+                transaction: new Transaction(),
             },
         ],
-        isSpent: false,
     },
 ];
 

src/transactions/transaction.entity.ts

@@ -1,4 +1,4 @@
-import { TransactionOutput } from '@/transaction-output/transaction-output.entity';
+import { TransactionOutput } from '@/transactions/transaction-output.entity';
 import { Column, Entity, OneToMany, PrimaryColumn } from 'typeorm';
 
 @Entity()

src/transactions/transactions.module.ts

@@ -1,11 +1,14 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { TransactionsService } from '@/transactions/transactions.service';
-import { Transaction } from '@/transactions/transaction.entity';
+import {
+    Transaction,
+    TransactionOutput,
+} from '@/transactions/transaction.entity';
 import { TransactionController } from '@/transactions/transactions.controller';
 
 @Module({
-    imports: [TypeOrmModule.forFeature([Transaction])],
+    imports: [TypeOrmModule.forFeature([Transaction, TransactionOutput])],
     controllers: [TransactionController],
     providers: [TransactionsService],
     exports: [TransactionsService],

src/transactions/transactions.service.ts

@@ -13,11 +13,17 @@ export class TransactionsService {
     async getTransactionByBlockHeight(
         blockHeight: number,
     ): Promise<Transaction[]> {
-        return this.transactionRepository.find({ where: { blockHeight } });
+        return this.transactionRepository.find({
+            where: { blockHeight },
+            relations: { outputs: true },
+        });
     }
 
     async getTransactionByBlockHash(blockHash: string): Promise<Transaction[]> {
-        return this.transactionRepository.find({ where: { blockHash }, relations: { outputs: true} });
+        return this.transactionRepository.find({
+            where: { blockHash },
+            relations: { outputs: true },
+        });
     }
 
     async saveTransaction(transaction: Transaction): Promise<Transaction> {