@waiaas/daemon 2.5.0-rc.1 → 2.6.0-rc

package/dist/services/incoming/__tests__/integration-pitfall.test.js

@@ -0,0 +1,653 @@
+/**
+ * Integration tests for incoming TX monitoring pipeline pitfalls.
+ *
+ * Verifies that the 5 core pitfalls from design doc 76 Section 12 are
+ * defended when components work together:
+ *
+ *   C-01: WebSocket listener leak (addWallet/removeWallet cycles)
+ *   C-02: SQLite event loop contention (batch write + flush chunking)
+ *   C-04: Duplicate event prevention (Map dedup + ON CONFLICT)
+ *   C-05: Shutdown data loss (drain on stop())
+ *   C-06: EVM reorg safety (block confirmation thresholds)
+ *
+ * These tests use real internal classes (IncomingTxQueue, SubscriptionMultiplexer,
+ * IncomingTxMonitorService) with mock boundaries (DB, IChainSubscriber).
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { IncomingTxQueue } from '../incoming-tx-queue.js';
+import { SubscriptionMultiplexer, } from '../subscription-multiplexer.js';
+import { IncomingTxMonitorService } from '../incoming-tx-monitor-service.js';
+import { createConfirmationWorkerHandler, EVM_CONFIRMATION_THRESHOLDS, } from '../incoming-tx-workers.js';
+// ---------------------------------------------------------------------------
+// Mock generateId for deterministic UUIDs in flush
+// ---------------------------------------------------------------------------
+let idCounter = 0;
+vi.mock('../../../infrastructure/database/id.js', () => ({
+    generateId: () => `uuid-${++idCounter}`,
+}));
+// ---------------------------------------------------------------------------
+// Helpers: Transaction factory
+// ---------------------------------------------------------------------------
+let txCounter = 0;
+function makeTx(overrides) {
+    txCounter++;
+    return {
+        id: '',
+        walletId: 'wallet-1',
+        chain: 'solana',
+        network: 'mainnet',
+        txHash: `tx-hash-${txCounter}`,
+        fromAddress: 'from-addr-1',
+        amount: '1000000',
+        tokenAddress: null,
+        status: 'DETECTED',
+        blockNumber: null,
+        detectedAt: Math.floor(Date.now() / 1000),
+        confirmedAt: null,
+        isSuspicious: false,
+        ...overrides,
+    };
+}
+function createMockSubscriber(chain = 'solana') {
+    let disconnectResolve = null;
+    return {
+        chain,
+        subscribe: vi.fn().mockResolvedValue(undefined),
+        unsubscribe: vi.fn().mockResolvedValue(undefined),
+        subscribedWallets: vi.fn().mockReturnValue([]),
+        connect: vi.fn().mockResolvedValue(undefined),
+        waitForDisconnect: vi.fn().mockImplementation(() => new Promise((resolve) => { disconnectResolve = resolve; })),
+        destroy: vi.fn().mockResolvedValue(undefined),
+        _triggerDisconnect() {
+            disconnectResolve?.();
+            disconnectResolve = null;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers: Mock better-sqlite3 Database
+// ---------------------------------------------------------------------------
+function createMockDb(changesOverride) {
+    let stmtRunCallIndex = 0;
+    const runCalls = [];
+    const mockStmt = {
+        run: (...args) => {
+            runCalls.push(args);
+            const changes = changesOverride
+                ? changesOverride(stmtRunCallIndex++)
+                : 1;
+            return { changes };
+        },
+        get: vi.fn().mockReturnValue(undefined),
+        all: vi.fn().mockReturnValue([]),
+    };
+    const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockStmt),
+        transaction: vi.fn((fn) => {
+            return (batch) => fn(batch);
+        }),
+        exec: vi.fn(),
+    };
+    return {
+        db: mockDb,
+        getRunCalls: () => runCalls,
+        mockStmt,
+        mockDb,
+        resetCalls: () => {
+            runCalls.length = 0;
+            stmtRunCallIndex = 0;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers: Config + mock factories for IncomingTxMonitorService
+// ---------------------------------------------------------------------------
+function makeConfig(overrides = {}) {
+    return {
+        enabled: true,
+        pollIntervalSec: 30,
+        retentionDays: 90,
+        dustThresholdUsd: 0.01,
+        amountMultiplier: 10,
+        cooldownMinutes: 5,
+        ...overrides,
+    };
+}
+function createMockEventBus() {
+    return {
+        emit: vi.fn().mockReturnValue(true),
+        on: vi.fn(),
+        removeAllListeners: vi.fn(),
+        listenerCount: vi.fn().mockReturnValue(0),
+    };
+}
+function createMockWorkers() {
+    return {
+        register: vi.fn(),
+        startAll: vi.fn(),
+        stopAll: vi.fn(),
+        size: 0,
+        isRunning: vi.fn().mockReturnValue(false),
+    };
+}
+// ===========================================================================
+// Section 1: C-01 - WebSocket Listener Leak
+// ===========================================================================
+describe('C-01: WebSocket Listener Leak', () => {
+    let mockSubscribers;
+    let subscriberFactory;
+    let onTransaction;
+    beforeEach(() => {
+        txCounter = 0;
+        idCounter = 0;
+        mockSubscribers = [];
+        subscriberFactory = vi.fn().mockImplementation((chain) => {
+            const sub = createMockSubscriber(chain);
+            mockSubscribers.push(sub);
+            return sub;
+        });
+        onTransaction = vi.fn();
+    });
+    function createMultiplexer(overrides = {}) {
+        return new SubscriptionMultiplexer({
+            subscriberFactory,
+            onTransaction,
+            reconnectConfig: {
+                initialDelayMs: 100,
+                maxDelayMs: 200,
+                maxAttempts: 3,
+                jitterFactor: 0,
+                pollingFallbackThreshold: 2,
+            },
+            ...overrides,
+        });
+    }
+    it('C-01: 10 wallets added then all removed -- subscriberFactory called once, 10 unsubscribes, 1 destroy, 0 active connections', async () => {
+        const mux = createMultiplexer();
+        // Add 10 wallets to the same chain:network
+        for (let i = 0; i < 10; i++) {
+            await mux.addWallet('solana', 'mainnet', `w${i}`, `addr${i}`);
+        }
+        // Only one subscriber should have been created for solana:mainnet
+        expect(subscriberFactory).toHaveBeenCalledTimes(1);
+        const sub = mockSubscribers[0];
+        // Remove all 10 wallets
+        for (let i = 0; i < 10; i++) {
+            await mux.removeWallet('solana', 'mainnet', `w${i}`);
+        }
+        // 10 unsubscribe calls (one per wallet)
+        expect(sub.unsubscribe).toHaveBeenCalledTimes(10);
+        // 1 destroy call (when last wallet removed)
+        expect(sub.destroy).toHaveBeenCalledTimes(1);
+        // No active connections remain
+        expect(mux.getActiveConnections()).toEqual([]);
+    });
+    it('C-01: 10 add/remove cycles create 10 subscribers, all previous destroyed', async () => {
+        const mux = createMultiplexer();
+        for (let cycle = 0; cycle < 10; cycle++) {
+            await mux.addWallet('solana', 'mainnet', 'w1', 'addr1');
+            await mux.removeWallet('solana', 'mainnet', 'w1');
+        }
+        // Each cycle creates a new subscriber (total 10)
+        expect(subscriberFactory).toHaveBeenCalledTimes(10);
+        // All 10 subscribers should have destroy() called
+        for (const sub of mockSubscribers) {
+            expect(sub.destroy).toHaveBeenCalledTimes(1);
+        }
+        // No active connections
+        expect(mux.getActiveConnections()).toHaveLength(0);
+    });
+    it('C-01: stopAll on 5 wallets triggers 5 unsubscribes + 1 destroy, re-add creates fresh subscriber', async () => {
+        const mux = createMultiplexer();
+        // Add 5 wallets to the same chain:network
+        for (let i = 0; i < 5; i++) {
+            await mux.addWallet('solana', 'mainnet', `w${i}`, `addr${i}`);
+        }
+        const firstSub = mockSubscribers[0];
+        await mux.stopAll();
+        // 5 unsubscribe calls + 1 destroy
+        expect(firstSub.unsubscribe).toHaveBeenCalledTimes(5);
+        expect(firstSub.destroy).toHaveBeenCalledTimes(1);
+        expect(mux.getActiveConnections()).toHaveLength(0);
+        // Re-add a wallet -- should create a fresh subscriber (not reuse destroyed one)
+        await mux.addWallet('solana', 'mainnet', 'w-new', 'addr-new');
+        expect(subscriberFactory).toHaveBeenCalledTimes(2); // original + new
+        expect(mockSubscribers).toHaveLength(2);
+        const secondSub = mockSubscribers[1];
+        expect(secondSub).not.toBe(firstSub);
+        expect(secondSub.connect).toHaveBeenCalledTimes(1);
+        await mux.stopAll();
+    });
+});
+// ===========================================================================
+// Section 2: C-02 - SQLite Event Loop Contention
+// ===========================================================================
+describe('C-02: SQLite Event Loop Contention', () => {
+    let queue;
+    beforeEach(() => {
+        queue = new IncomingTxQueue();
+        txCounter = 0;
+        idCounter = 0;
+    });
+    it('C-02: 500 rapid pushes flush in MAX_BATCH=100 chunks (5 flush calls), no data lost', () => {
+        const mock = createMockDb();
+        // Simulate burst from WebSocket: 500 rapid pushes
+        for (let i = 0; i < 500; i++) {
+            queue.push(makeTx());
+        }
+        expect(queue.size).toBe(500);
+        // Flush repeatedly until empty, collecting results
+        const allInserted = [];
+        let flushCount = 0;
+        while (queue.size > 0) {
+            const batch = queue.flush(mock.db);
+            allInserted.push(...batch);
+            flushCount++;
+        }
+        // 500 / 100 = 5 flush cycles
+        expect(flushCount).toBe(5);
+        // All 500 items flushed with no data loss
+        expect(allInserted).toHaveLength(500);
+        // Queue is now empty
+        expect(queue.size).toBe(0);
+        // 500 stmt.run() calls total
+        expect(mock.getRunCalls()).toHaveLength(500);
+    });
+    it('C-02: batch atomicity -- 50 transactions processed within single transaction() call', () => {
+        let transactionCallCount = 0;
+        const mockStmt = {
+            run: (..._args) => ({ changes: 1 }),
+        };
+        const mockDb = {
+            prepare: () => mockStmt,
+            transaction: (fn) => {
+                // Each call to the returned function represents one transaction() invocation
+                return (batch) => {
+                    transactionCallCount++;
+                    return fn(batch);
+                };
+            },
+        };
+        for (let i = 0; i < 50; i++) {
+            queue.push(makeTx());
+        }
+        queue.flush(mockDb);
+        // All 50 items processed in a single transaction() call
+        expect(transactionCallCount).toBe(1);
+        expect(queue.size).toBe(0);
+    });
+    it('C-02: 100 rapid transactions via push+flush cycle all inserted without duplicates', () => {
+        const mock = createMockDb();
+        // Push 100 unique transactions
+        for (let i = 0; i < 100; i++) {
+            queue.push(makeTx());
+        }
+        const result = queue.flush(mock.db);
+        // Exactly 100 items flushed (fits in single MAX_BATCH)
+        expect(result).toHaveLength(100);
+        expect(queue.size).toBe(0);
+        // All IDs are unique
+        const ids = new Set(result.map((tx) => tx.id));
+        expect(ids.size).toBe(100);
+    });
+});
+// ===========================================================================
+// Section 3: C-04 - Duplicate Event Prevention
+// ===========================================================================
+describe('C-04: Duplicate Event Prevention', () => {
+    let queue;
+    beforeEach(() => {
+        queue = new IncomingTxQueue();
+        txCounter = 0;
+        idCounter = 0;
+    });
+    it('C-04: same txHash:walletId pushed 10 times -- queue.size === 1, 1 DB insert', () => {
+        const mock = createMockDb();
+        // Push same transaction 10 times
+        for (let i = 0; i < 10; i++) {
+            queue.push(makeTx({ txHash: 'dup-hash', walletId: 'w1' }));
+        }
+        // Queue-level dedup: only 1 entry
+        expect(queue.size).toBe(1);
+        const result = queue.flush(mock.db);
+        // Only 1 DB insert
+        expect(mock.getRunCalls()).toHaveLength(1);
+        expect(result).toHaveLength(1);
+    });
+    it('C-04: 5 unique + 5 duplicates of first -- queue.size === 5, 5 DB inserts', () => {
+        const mock = createMockDb();
+        const baseTx = makeTx({ txHash: 'tx-0', walletId: 'w1' });
+        queue.push(baseTx);
+        // 4 more unique transactions
+        for (let i = 1; i < 5; i++) {
+            queue.push(makeTx({ txHash: `tx-${i}`, walletId: 'w1' }));
+        }
+        // 5 duplicates of the first
+        for (let i = 0; i < 5; i++) {
+            queue.push(makeTx({ txHash: 'tx-0', walletId: 'w1' }));
+        }
+        expect(queue.size).toBe(5);
+        const result = queue.flush(mock.db);
+        expect(result).toHaveLength(5);
+        expect(mock.getRunCalls()).toHaveLength(5);
+    });
+    it('C-04: DB-level dedup via ON CONFLICT -- changes=0 excludes from result', () => {
+        // Simulate DB ON CONFLICT skip: items 1 and 3 (0-indexed) return changes=0
+        const mock = createMockDb((idx) => (idx === 1 || idx === 3) ? 0 : 1);
+        for (let i = 0; i < 5; i++) {
+            queue.push(makeTx({ txHash: `unique-${i}`, walletId: 'w1' }));
+        }
+        const result = queue.flush(mock.db);
+        // 5 stmt.run() calls, but only 3 returned changes > 0
+        expect(mock.getRunCalls()).toHaveLength(5);
+        expect(result).toHaveLength(3);
+    });
+    it('C-04: end-to-end -- SubscriptionMultiplexer onTransaction routes to queue.push with dedup', async () => {
+        const mock = createMockDb();
+        const realQueue = new IncomingTxQueue();
+        const mux = new SubscriptionMultiplexer({
+            subscriberFactory: () => createMockSubscriber('solana'),
+            onTransaction: (tx) => {
+                realQueue.push(tx);
+            },
+            reconnectConfig: {
+                initialDelayMs: 100,
+                maxDelayMs: 200,
+                maxAttempts: 3,
+                jitterFactor: 0,
+                pollingFallbackThreshold: 2,
+            },
+        });
+        await mux.addWallet('solana', 'mainnet', 'w1', 'addr1');
+        // Simulate subscriber emitting transactions via the onTransaction callback
+        // The multiplexer wires onTransaction to subscriber.subscribe's 4th parameter.
+        // We manually invoke the callback that was passed to subscribe().
+        const subscriberMock = mux.getActiveConnections().length > 0 ? true : false;
+        expect(subscriberMock).toBe(true);
+        // Get the onTransaction callback from the subscribe mock call
+        // The multiplexer passes `this.deps.onTransaction` to subscriber.subscribe()
+        // Since our factory returns a mock, we can inspect what subscribe was called with
+        // Push duplicate transactions through the callback
+        const tx1 = makeTx({ txHash: 'dup-e2e', walletId: 'w1' });
+        const tx2 = makeTx({ txHash: 'dup-e2e', walletId: 'w1' });
+        // Call onTransaction directly (simulating subscriber callback)
+        realQueue.push(tx1);
+        realQueue.push(tx2);
+        // Map-level dedup: only 1 entry
+        expect(realQueue.size).toBe(1);
+        const result = realQueue.flush(mock.db);
+        expect(result).toHaveLength(1);
+        expect(result[0].txHash).toBe('dup-e2e');
+        await mux.stopAll();
+    });
+});
+// ===========================================================================
+// Section 4: C-05 - Shutdown Data Loss Prevention
+// ===========================================================================
+describe('C-05: Shutdown Data Loss Prevention', () => {
+    let sqlite;
+    let eventBus;
+    let workers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        txCounter = 0;
+        idCounter = 0;
+        sqlite = createMockDb();
+        eventBus = createMockEventBus();
+        workers = createMockWorkers();
+    });
+    function createMonitorService(configOverrides = {}) {
+        return new IncomingTxMonitorService({
+            sqlite: sqlite.db,
+            db: {},
+            workers: workers,
+            eventBus: eventBus,
+            killSwitchService: null,
+            notificationService: null,
+            subscriberFactory: () => createMockSubscriber('solana'),
+            config: makeConfig(configOverrides),
+        });
+    }
+    it('C-05: 10 queued transactions all saved to DB on stop()', async () => {
+        // Return empty wallets list from DB for start()
+        sqlite.mockStmt.all.mockReturnValueOnce([]);
+        const service = createMonitorService();
+        await service.start();
+        // Access the real internal queue and push 10 transactions
+        const internalQueue = service.queue;
+        for (let i = 0; i < 10; i++) {
+            internalQueue.push(makeTx({ txHash: `stop-tx-${i}`, walletId: 'w1' }));
+        }
+        expect(internalQueue.size).toBe(10);
+        // stop() calls drain() which flushes all queued items
+        await service.stop();
+        // Verify all 10 transactions were inserted via stmt.run()
+        // Filter run calls to only INSERT calls (13 params: id + 12 data fields)
+        const insertCalls = sqlite.getRunCalls().filter((args) => args.length === 13);
+        expect(insertCalls).toHaveLength(10);
+        // Queue should be empty after drain
+        expect(internalQueue.size).toBe(0);
+    });
+    it('C-05: 250 queued transactions drain loops multiple flush cycles (100+100+50)', async () => {
+        sqlite.mockStmt.all.mockReturnValueOnce([]);
+        const service = createMonitorService();
+        await service.start();
+        const internalQueue = service.queue;
+        for (let i = 0; i < 250; i++) {
+            internalQueue.push(makeTx({ txHash: `drain-${i}`, walletId: 'w1' }));
+        }
+        expect(internalQueue.size).toBe(250);
+        await service.stop();
+        // All 250 should be flushed (in 3 cycles: 100 + 100 + 50)
+        const insertCalls = sqlite.getRunCalls().filter((args) => args.length === 13);
+        expect(insertCalls).toHaveLength(250);
+        expect(internalQueue.size).toBe(0);
+    });
+    it('C-05: 0 queued transactions -- empty drain is no-op, but stopAll() still called', async () => {
+        sqlite.mockStmt.all.mockReturnValueOnce([]);
+        const service = createMonitorService();
+        await service.start();
+        const internalQueue = service.queue;
+        expect(internalQueue.size).toBe(0);
+        // Spy on multiplexer stopAll to verify it is called
+        const multiplexer = service.multiplexer;
+        const stopAllSpy = vi.spyOn(multiplexer, 'stopAll');
+        await service.stop();
+        // No INSERT calls from drain (queue was empty)
+        const insertCalls = sqlite.getRunCalls().filter((args) => args.length === 13);
+        expect(insertCalls).toHaveLength(0);
+        // But multiplexer.stopAll() should still have been called
+        expect(stopAllSpy).toHaveBeenCalledTimes(1);
+    });
+    it('C-05: stop() with real queue wired to multiplexer.onTransaction -- end-to-end drain', async () => {
+        sqlite.mockStmt.all.mockReturnValueOnce([]);
+        const service = createMonitorService();
+        await service.start();
+        // The service wires multiplexer's onTransaction to queue.push internally.
+        // We simulate transactions arriving via the onTransaction callback.
+        const internalQueue = service.queue;
+        // Push directly to queue (same path as onTransaction callback)
+        for (let i = 0; i < 10; i++) {
+            internalQueue.push(makeTx({ txHash: `e2e-drain-${i}`, walletId: `w${i % 3}` }));
+        }
+        await service.stop();
+        const insertCalls = sqlite.getRunCalls().filter((args) => args.length === 13);
+        expect(insertCalls).toHaveLength(10);
+        // Verify walletId diversity in inserts (w0, w1, w2)
+        const walletIds = new Set(insertCalls.map((args) => args[1]));
+        expect(walletIds.size).toBe(3);
+    });
+});
+// ===========================================================================
+// Section 5: C-06 - EVM Reorg Safety
+// ===========================================================================
+describe('C-06: EVM Reorg Safety', () => {
+    beforeEach(() => {
+        txCounter = 0;
+        idCounter = 0;
+    });
+    /**
+     * Create a mock SQLite for confirmation worker tests.
+     * Returns DETECTED rows from .all() and tracks UPDATE calls via .run().
+     */
+    function createConfirmationMockDb(detectedRows) {
+        const updateCalls = [];
+        let allCallCount = 0;
+        const mockDb = {
+            prepare: vi.fn().mockImplementation((sql) => {
+                if (sql.includes('SELECT')) {
+                    return {
+                        all: () => {
+                            allCallCount++;
+                            return detectedRows;
+                        },
+                    };
+                }
+                // UPDATE statement
+                return {
+                    run: (...args) => {
+                        updateCalls.push(args);
+                        return { changes: 1 };
+                    },
+                };
+            }),
+        };
+        return {
+            db: mockDb,
+            getUpdateCalls: () => updateCalls,
+            getAllCallCount: () => allCallCount,
+        };
+    }
+    it('C-06: EVM DETECTED tx at block 100, currentBlock=111 (11 confirms) -- NOT confirmed (mainnet threshold=12)', async () => {
+        const detectedRows = [
+            { id: 'tx-1', tx_hash: '0xabc', chain: 'ethereum', network: 'mainnet', block_number: 100 },
+        ];
+        const mockDb = createConfirmationMockDb(detectedRows);
+        const handler = createConfirmationWorkerHandler({
+            sqlite: mockDb.db,
+            getBlockNumber: async () => 111n,
+            checkSolanaFinalized: async () => false,
+        });
+        await handler();
+        // 111 - 100 = 11 confirmations < threshold 12 for mainnet
+        expect(mockDb.getUpdateCalls()).toHaveLength(0);
+    });
+    it('C-06: EVM DETECTED tx at block 100, currentBlock=112 (12 confirms) -- CONFIRMED (mainnet threshold=12)', async () => {
+        const detectedRows = [
+            { id: 'tx-1', tx_hash: '0xabc', chain: 'ethereum', network: 'mainnet', block_number: 100 },
+        ];
+        const mockDb = createConfirmationMockDb(detectedRows);
+        const handler = createConfirmationWorkerHandler({
+            sqlite: mockDb.db,
+            getBlockNumber: async () => 112n,
+            checkSolanaFinalized: async () => false,
+        });
+        await handler();
+        // 112 - 100 = 12 confirmations >= threshold 12 for mainnet
+        expect(mockDb.getUpdateCalls()).toHaveLength(1);
+        expect(mockDb.getUpdateCalls()[0][1]).toBe('tx-1');
+    });
+    it('C-06: two-cycle reorg simulation -- first tx confirmed, second tx waits for enough blocks', async () => {
+        // Cycle 1: tx-A at block 100, currentBlock=115 (15 confirms) -> CONFIRMED
+        const cycle1Rows = [
+            { id: 'tx-A', tx_hash: '0xA', chain: 'ethereum', network: 'mainnet', block_number: 100 },
+        ];
+        const mockDb1 = createConfirmationMockDb(cycle1Rows);
+        const handler1 = createConfirmationWorkerHandler({
+            sqlite: mockDb1.db,
+            getBlockNumber: async () => 115n,
+        });
+        await handler1();
+        expect(mockDb1.getUpdateCalls()).toHaveLength(1); // tx-A confirmed
+        // Cycle 2: tx-B at block 113, currentBlock=120 (7 confirms) -> NOT CONFIRMED (< 12)
+        const cycle2Rows = [
+            { id: 'tx-B', tx_hash: '0xB', chain: 'ethereum', network: 'mainnet', block_number: 113 },
+        ];
+        const mockDb2 = createConfirmationMockDb(cycle2Rows);
+        const handler2 = createConfirmationWorkerHandler({
+            sqlite: mockDb2.db,
+            getBlockNumber: async () => 120n,
+        });
+        await handler2();
+        // 120 - 113 = 7 < 12 -- tx-B NOT confirmed
+        expect(mockDb2.getUpdateCalls()).toHaveLength(0);
+    });
+    it('C-06: mixed Solana + EVM DETECTED transactions -- each chain uses its own confirmation method', async () => {
+        const detectedRows = [
+            { id: 'sol-tx', tx_hash: 'solSig123', chain: 'solana', network: 'mainnet', block_number: null },
+            { id: 'evm-tx', tx_hash: '0xevmHash', chain: 'ethereum', network: 'mainnet', block_number: 200 },
+        ];
+        const mockDb = createConfirmationMockDb(detectedRows);
+        let solanaCheckCalled = false;
+        let evmBlockNumberCalled = false;
+        const handler = createConfirmationWorkerHandler({
+            sqlite: mockDb.db,
+            getBlockNumber: async (chain, network) => {
+                evmBlockNumberCalled = true;
+                expect(chain).toBe('ethereum');
+                expect(network).toBe('mainnet');
+                return 220n; // 220 - 200 = 20 >= 12 -> CONFIRMED
+            },
+            checkSolanaFinalized: async (txHash) => {
+                solanaCheckCalled = true;
+                expect(txHash).toBe('solSig123');
+                return true; // finalized
+            },
+        });
+        await handler();
+        // Both chain-specific methods should have been called
+        expect(solanaCheckCalled).toBe(true);
+        expect(evmBlockNumberCalled).toBe(true);
+        // Both should be confirmed
+        const updates = mockDb.getUpdateCalls();
+        expect(updates).toHaveLength(2);
+        const confirmedIds = updates.map((args) => args[1]);
+        expect(confirmedIds).toContain('sol-tx');
+        expect(confirmedIds).toContain('evm-tx');
+    });
+    it('C-06: EVM block number cache prevents redundant RPC calls for same chain:network', async () => {
+        const detectedRows = [
+            { id: 'tx-1', tx_hash: '0x1', chain: 'ethereum', network: 'mainnet', block_number: 100 },
+            { id: 'tx-2', tx_hash: '0x2', chain: 'ethereum', network: 'mainnet', block_number: 105 },
+            { id: 'tx-3', tx_hash: '0x3', chain: 'ethereum', network: 'mainnet', block_number: 110 },
+        ];
+        const mockDb = createConfirmationMockDb(detectedRows);
+        let rpcCallCount = 0;
+        const handler = createConfirmationWorkerHandler({
+            sqlite: mockDb.db,
+            getBlockNumber: async () => {
+                rpcCallCount++;
+                return 130n; // All 3 txs will be confirmed (>= 12 confirmations for each)
+            },
+        });
+        await handler();
+        // Block number cache: should only call getBlockNumber once for ethereum:mainnet
+        expect(rpcCallCount).toBe(1);
+        // All 3 should be confirmed
+        expect(mockDb.getUpdateCalls()).toHaveLength(3);
+    });
+    it('C-06: EVM network-specific threshold -- polygon-mainnet uses 128, not default 12', async () => {
+        const detectedRows = [
+            { id: 'poly-tx', tx_hash: '0xpoly', chain: 'ethereum', network: 'polygon-mainnet', block_number: 1000 },
+        ];
+        const mockDb = createConfirmationMockDb(detectedRows);
+        // polygon-mainnet threshold is 128
+        expect(EVM_CONFIRMATION_THRESHOLDS['polygon-mainnet']).toBe(128);
+        // 1127 - 1000 = 127 < 128 -- NOT confirmed
+        const handler1 = createConfirmationWorkerHandler({
+            sqlite: mockDb.db,
+            getBlockNumber: async () => 1127n,
+        });
+        await handler1();
+        expect(mockDb.getUpdateCalls()).toHaveLength(0);
+        // 1128 - 1000 = 128 >= 128 -- CONFIRMED
+        const mockDb2 = createConfirmationMockDb(detectedRows);
+        const handler2 = createConfirmationWorkerHandler({
+            sqlite: mockDb2.db,
+            getBlockNumber: async () => 1128n,
+        });
+        await handler2();
+        expect(mockDb2.getUpdateCalls()).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=integration-pitfall.test.js.map