@wopr-network/platform-core 1.48.0 → 1.49.0

package/src/billing/crypto/__tests__/webhook-confirmations.test.ts

@@ -0,0 +1,367 @@
+import { describe, expect, it, vi } from "vitest";
+import type { KeyServerWebhookDeps, KeyServerWebhookPayload } from "../key-server-webhook.js";
+import { handleKeyServerWebhook, normalizeStatus } from "../key-server-webhook.js";
+
+function mockChargeStore(overrides: Record<string, unknown> = {}) {
+  return {
+    getByReferenceId: vi.fn().mockResolvedValue({
+      referenceId: "btc:bc1qtest",
+      tenantId: "t1",
+      amountUsdCents: 5000,
+      creditedAt: null,
+      chain: "bitcoin",
+      token: "BTC",
+      ...overrides,
+    }),
+    updateProgress: vi.fn().mockResolvedValue(undefined),
+    updateStatus: vi.fn().mockResolvedValue(undefined),
+    markCredited: vi.fn().mockResolvedValue(undefined),
+    get: vi.fn().mockResolvedValue(null),
+    create: vi.fn(),
+    isCredited: vi.fn(),
+    createStablecoinCharge: vi.fn(),
+    getByDepositAddress: vi.fn(),
+    getNextDerivationIndex: vi.fn(),
+    listActiveDepositAddresses: vi.fn(),
+  };
+}
+
+function mockLedger() {
+  return {
+    credit: vi.fn().mockResolvedValue({ id: "j1" }),
+    debit: vi.fn(),
+    balance: vi.fn(),
+    hasReferenceId: vi.fn().mockResolvedValue(false),
+    post: vi.fn(),
+    expiredCredits: vi.fn(),
+  };
+}
+
+function mockReplayGuard() {
+  return {
+    isDuplicate: vi.fn().mockResolvedValue(false),
+    markSeen: vi.fn().mockResolvedValue({ eventId: "", source: "", seenAt: 0 }),
+    purgeExpired: vi.fn(),
+  };
+}
+
+function makeDeps(overrides: Partial<KeyServerWebhookDeps> = {}): KeyServerWebhookDeps {
+  return {
+    chargeStore: mockChargeStore() as never,
+    creditLedger: mockLedger() as never,
+    replayGuard: mockReplayGuard() as never,
+    ...overrides,
+  };
+}
+
+describe("normalizeStatus", () => {
+  it("maps canonical statuses through unchanged", () => {
+    expect(normalizeStatus("confirmed")).toBe("confirmed");
+    expect(normalizeStatus("partial")).toBe("partial");
+    expect(normalizeStatus("expired")).toBe("expired");
+    expect(normalizeStatus("failed")).toBe("failed");
+    expect(normalizeStatus("pending")).toBe("pending");
+  });
+
+  it("maps legacy BTCPay statuses to canonical", () => {
+    expect(normalizeStatus("Settled")).toBe("confirmed");
+    expect(normalizeStatus("Processing")).toBe("partial");
+    expect(normalizeStatus("Expired")).toBe("expired");
+    expect(normalizeStatus("Invalid")).toBe("failed");
+    expect(normalizeStatus("New")).toBe("pending");
+  });
+
+  it("maps BTCPay event type strings to canonical", () => {
+    expect(normalizeStatus("InvoiceSettled")).toBe("confirmed");
+    expect(normalizeStatus("InvoiceProcessing")).toBe("partial");
+    expect(normalizeStatus("InvoiceReceivedPayment")).toBe("partial");
+    expect(normalizeStatus("InvoiceExpired")).toBe("expired");
+    expect(normalizeStatus("InvoiceInvalid")).toBe("failed");
+    expect(normalizeStatus("InvoiceCreated")).toBe("pending");
+  });
+
+  it("defaults unknown statuses to pending", () => {
+    expect(normalizeStatus("SomethingWeird")).toBe("pending");
+    expect(normalizeStatus("")).toBe("pending");
+  });
+});
+
+describe("handleKeyServerWebhook — confirmation tracking", () => {
+  it("calls updateProgress on partial payment (not just terminal)", async () => {
+    const chargeStore = mockChargeStore();
+    const deps = makeDeps({ chargeStore: chargeStore as never });
+
+    const payload: KeyServerWebhookPayload = {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "partial",
+      amountReceivedCents: 2500,
+      confirmations: 2,
+      confirmationsRequired: 6,
+      txHash: "0xabc",
+    };
+
+    const result = await handleKeyServerWebhook(deps, payload);
+
+    expect(result.handled).toBe(true);
+    expect(result.status).toBe("partial");
+    expect(result.confirmations).toBe(2);
+    expect(result.confirmationsRequired).toBe(6);
+    expect(chargeStore.updateProgress).toHaveBeenCalledWith("btc:bc1qtest", {
+      status: "partial",
+      amountReceivedCents: 2500,
+      confirmations: 2,
+      confirmationsRequired: 6,
+      txHash: "0xabc",
+    });
+  });
+
+  it("calls updateProgress AND credits ledger on confirmed", async () => {
+    const chargeStore = mockChargeStore();
+    const ledger = mockLedger();
+    const deps = makeDeps({ chargeStore: chargeStore as never, creditLedger: ledger as never });
+
+    const payload: KeyServerWebhookPayload = {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "confirmed",
+      amountReceivedCents: 5000,
+      confirmations: 6,
+      confirmationsRequired: 6,
+      txHash: "0xfinal",
+    };
+
+    const result = await handleKeyServerWebhook(deps, payload);
+
+    expect(result.handled).toBe(true);
+    expect(result.status).toBe("confirmed");
+    expect(result.creditedCents).toBe(5000);
+    expect(chargeStore.updateProgress).toHaveBeenCalledWith("btc:bc1qtest", {
+      status: "confirmed",
+      amountReceivedCents: 5000,
+      confirmations: 6,
+      confirmationsRequired: 6,
+      txHash: "0xfinal",
+    });
+    expect(ledger.credit).toHaveBeenCalledOnce();
+    expect(chargeStore.markCredited).toHaveBeenCalledWith("btc:bc1qtest");
+  });
+
+  it("does NOT credit ledger on partial status", async () => {
+    const ledger = mockLedger();
+    const deps = makeDeps({ creditLedger: ledger as never });
+
+    await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "Processing",
+      amountReceivedCents: 2500,
+      confirmations: 1,
+      confirmationsRequired: 6,
+    });
+
+    expect(ledger.credit).not.toHaveBeenCalled();
+  });
+
+  it("does NOT credit ledger on expired status", async () => {
+    const ledger = mockLedger();
+    const deps = makeDeps({ creditLedger: ledger as never });
+
+    await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "expired",
+      amountReceivedCents: 0,
+      confirmations: 0,
+      confirmationsRequired: 6,
+    });
+
+    expect(ledger.credit).not.toHaveBeenCalled();
+  });
+
+  it("normalizes legacy 'Settled' status to 'confirmed' and credits", async () => {
+    const chargeStore = mockChargeStore();
+    const ledger = mockLedger();
+    const deps = makeDeps({ chargeStore: chargeStore as never, creditLedger: ledger as never });
+
+    const result = await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "Settled",
+      amountReceivedCents: 5000,
+      confirmations: 6,
+      confirmationsRequired: 6,
+      txHash: "0xlegacy",
+    });
+
+    expect(result.status).toBe("confirmed");
+    expect(ledger.credit).toHaveBeenCalledOnce();
+    expect(chargeStore.updateProgress).toHaveBeenCalledWith(
+      "btc:bc1qtest",
+      expect.objectContaining({ status: "confirmed" }),
+    );
+  });
+
+  it("deduplicates exact same chargeId + status + confirmations", async () => {
+    const replayGuard = mockReplayGuard();
+    replayGuard.isDuplicate.mockResolvedValue(true);
+    const deps = makeDeps({ replayGuard: replayGuard as never });
+
+    const result = await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "partial",
+      confirmations: 2,
+      confirmationsRequired: 6,
+    });
+
+    expect(result.duplicate).toBe(true);
+  });
+
+  it("allows same charge with different confirmation counts through", async () => {
+    const replayGuard = mockReplayGuard();
+    const seenKeys = new Set<string>();
+    replayGuard.isDuplicate.mockImplementation(async (key: string) => seenKeys.has(key));
+    replayGuard.markSeen.mockImplementation(async (key: string) => {
+      seenKeys.add(key);
+      return { eventId: key, source: "crypto", seenAt: 0 };
+    });
+    const deps = makeDeps({ replayGuard: replayGuard as never });
+
+    const base = {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "partial",
+      amountReceivedCents: 5000,
+      confirmationsRequired: 6,
+    };
+
+    const r1 = await handleKeyServerWebhook(deps, { ...base, confirmations: 1 });
+    const r2 = await handleKeyServerWebhook(deps, { ...base, confirmations: 2 });
+    const r3 = await handleKeyServerWebhook(deps, { ...base, confirmations: 1 }); // duplicate
+
+    expect(r1.handled).toBe(true);
+    expect(r1.duplicate).toBeUndefined();
+    expect(r2.handled).toBe(true);
+    expect(r2.duplicate).toBeUndefined();
+    expect(r3.duplicate).toBe(true);
+  });
+
+  it("supports deprecated amountUsdCents field as fallback", async () => {
+    const chargeStore = mockChargeStore();
+    const deps = makeDeps({ chargeStore: chargeStore as never });
+
+    await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "partial",
+      amountUsdCents: 3000,
+      confirmations: 1,
+      confirmationsRequired: 6,
+    });
+
+    expect(chargeStore.updateProgress).toHaveBeenCalledWith(
+      "btc:bc1qtest",
+      expect.objectContaining({ amountReceivedCents: 3000 }),
+    );
+  });
+
+  it("prefers amountReceivedCents over deprecated amountUsdCents", async () => {
+    const chargeStore = mockChargeStore();
+    const deps = makeDeps({ chargeStore: chargeStore as never });
+
+    await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "partial",
+      amountReceivedCents: 4000,
+      amountUsdCents: 3000,
+      confirmations: 1,
+      confirmationsRequired: 6,
+    });
+
+    expect(chargeStore.updateProgress).toHaveBeenCalledWith(
+      "btc:bc1qtest",
+      expect.objectContaining({ amountReceivedCents: 4000 }),
+    );
+  });
+
+  it("returns handled: false for unknown charges", async () => {
+    const chargeStore = mockChargeStore();
+    chargeStore.getByReferenceId.mockResolvedValue(null);
+    const deps = makeDeps({ chargeStore: chargeStore as never });
+
+    const result = await handleKeyServerWebhook(deps, {
+      chargeId: "unknown",
+      chain: "bitcoin",
+      address: "bc1qunknown",
+      status: "partial",
+    });
+
+    expect(result.handled).toBe(false);
+  });
+
+  it("defaults confirmations to 0 and confirmationsRequired to 1 when absent", async () => {
+    const chargeStore = mockChargeStore();
+    const deps = makeDeps({ chargeStore: chargeStore as never });
+
+    await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "partial",
+    });
+
+    expect(chargeStore.updateProgress).toHaveBeenCalledWith(
+      "btc:bc1qtest",
+      expect.objectContaining({ confirmations: 0, confirmationsRequired: 1 }),
+    );
+  });
+
+  it("also calls legacy updateStatus for backward compat", async () => {
+    const chargeStore = mockChargeStore();
+    const deps = makeDeps({ chargeStore: chargeStore as never });
+
+    await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "partial",
+      amountReceived: "25000",
+    });
+
+    expect(chargeStore.updateStatus).toHaveBeenCalledWith("btc:bc1qtest", "Processing", "BTC", "25000");
+  });
+
+  it("calls onCreditsPurchased on confirmed and returns reactivatedBots", async () => {
+    const chargeStore = mockChargeStore();
+    const ledger = mockLedger();
+    const onCreditsPurchased = vi.fn().mockResolvedValue(["bot-1", "bot-2"]);
+    const deps = makeDeps({
+      chargeStore: chargeStore as never,
+      creditLedger: ledger as never,
+      onCreditsPurchased,
+    });
+
+    const result = await handleKeyServerWebhook(deps, {
+      chargeId: "btc:bc1qtest",
+      chain: "bitcoin",
+      address: "bc1qtest",
+      status: "confirmed",
+      confirmations: 6,
+      confirmationsRequired: 6,
+    });
+
+    expect(onCreditsPurchased).toHaveBeenCalledWith("t1", ledger);
+    expect(result.reactivatedBots).toEqual(["bot-1", "bot-2"]);
+  });
+});

package/src/billing/crypto/btc/__tests__/settler.test.ts

@@ -8,6 +8,7 @@ const mockEvent: BtcPaymentEvent = {
   amountSats: 15000,
   amountUsdCents: 1000,
   confirmations: 6,
+  confirmationsRequired: 6,
 };
 
 describe("settleBtcPayment", () => {

package/src/billing/crypto/btc/__tests__/watcher.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it, vi } from "vitest";
+import { BtcWatcher } from "../watcher.js";
+
+function makeCursorStore() {
+  const processed = new Set<string>();
+  const confirmationCounts = new Map<string, number>();
+  return {
+    get: vi.fn().mockResolvedValue(null),
+    save: vi.fn().mockResolvedValue(undefined),
+    hasProcessedTx: vi.fn().mockImplementation(async (_: string, txId: string) => processed.has(txId)),
+    markProcessedTx: vi.fn().mockImplementation(async (_: string, txId: string) => {
+      processed.add(txId);
+    }),
+    getConfirmationCount: vi
+      .fn()
+      .mockImplementation(async (_: string, txId: string) => confirmationCounts.get(txId) ?? null),
+    saveConfirmationCount: vi.fn().mockImplementation(async (_: string, txId: string, count: number) => {
+      confirmationCounts.set(txId, count);
+    }),
+    _processed: processed,
+    _confirmationCounts: confirmationCounts,
+  };
+}
+
+function makeOracle() {
+  return { getPrice: vi.fn().mockResolvedValue({ priceCents: 6_500_000 }) };
+}
+
+describe("BtcWatcher — intermediate confirmations", () => {
+  it("fires onPayment at 0 confirmations when tx first detected", async () => {
+    const events: Array<{ confirmations: number; confirmationsRequired: number }> = [];
+    const cursorStore = makeCursorStore();
+    const rpc = vi
+      .fn()
+      .mockResolvedValueOnce([{ address: "bc1qtest", amount: 0.0005, confirmations: 0, txids: ["tx1"] }])
+      .mockResolvedValueOnce({
+        details: [{ address: "bc1qtest", amount: 0.0005, category: "receive" }],
+        confirmations: 0,
+      });
+
+    const watcher = new BtcWatcher({
+      config: { rpcUrl: "http://localhost", rpcUser: "u", rpcPassword: "p", network: "regtest", confirmations: 3 },
+      rpcCall: rpc,
+      watchedAddresses: ["bc1qtest"],
+      oracle: makeOracle(),
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].confirmations).toBe(0);
+    expect(events[0].confirmationsRequired).toBe(3);
+  });
+
+  it("fires onPayment on each confirmation increment", async () => {
+    const events: Array<{ confirmations: number }> = [];
+    const cursorStore = makeCursorStore();
+    cursorStore._confirmationCounts.set("tx1", 1);
+
+    const rpc = vi
+      .fn()
+      .mockResolvedValueOnce([{ address: "bc1qtest", amount: 0.0005, confirmations: 2, txids: ["tx1"] }])
+      .mockResolvedValueOnce({
+        details: [{ address: "bc1qtest", amount: 0.0005, category: "receive" }],
+        confirmations: 2,
+      });
+
+    const watcher = new BtcWatcher({
+      config: { rpcUrl: "http://localhost", rpcUser: "u", rpcPassword: "p", network: "regtest", confirmations: 3 },
+      rpcCall: rpc,
+      watchedAddresses: ["bc1qtest"],
+      oracle: makeOracle(),
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].confirmations).toBe(2);
+  });
+
+  it("does not fire when confirmation count unchanged", async () => {
+    const events: Array<{ confirmations: number }> = [];
+    const cursorStore = makeCursorStore();
+    cursorStore._confirmationCounts.set("tx1", 2);
+
+    const rpc = vi
+      .fn()
+      .mockResolvedValueOnce([{ address: "bc1qtest", amount: 0.0005, confirmations: 2, txids: ["tx1"] }])
+      .mockResolvedValueOnce({
+        details: [{ address: "bc1qtest", amount: 0.0005, category: "receive" }],
+        confirmations: 2,
+      });
+
+    const watcher = new BtcWatcher({
+      config: { rpcUrl: "http://localhost", rpcUser: "u", rpcPassword: "p", network: "regtest", confirmations: 3 },
+      rpcCall: rpc,
+      watchedAddresses: ["bc1qtest"],
+      oracle: makeOracle(),
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(0);
+  });
+
+  it("marks tx as processed once confirmations reach threshold", async () => {
+    const events: Array<{ confirmations: number }> = [];
+    const cursorStore = makeCursorStore();
+    cursorStore._confirmationCounts.set("tx1", 2);
+
+    const rpc = vi
+      .fn()
+      .mockResolvedValueOnce([{ address: "bc1qtest", amount: 0.0005, confirmations: 3, txids: ["tx1"] }])
+      .mockResolvedValueOnce({
+        details: [{ address: "bc1qtest", amount: 0.0005, category: "receive" }],
+        confirmations: 3,
+      });
+
+    const watcher = new BtcWatcher({
+      config: { rpcUrl: "http://localhost", rpcUser: "u", rpcPassword: "p", network: "regtest", confirmations: 3 },
+      rpcCall: rpc,
+      watchedAddresses: ["bc1qtest"],
+      oracle: makeOracle(),
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].confirmations).toBe(3);
+    expect(cursorStore.markProcessedTx).toHaveBeenCalledWith(expect.any(String), "tx1");
+  });
+
+  it("skips fully-processed txids", async () => {
+    const events: unknown[] = [];
+    const cursorStore = makeCursorStore();
+    cursorStore._processed.add("tx1");
+
+    const rpc = vi
+      .fn()
+      .mockResolvedValueOnce([{ address: "bc1qtest", amount: 0.0005, confirmations: 6, txids: ["tx1"] }]);
+
+    const watcher = new BtcWatcher({
+      config: { rpcUrl: "http://localhost", rpcUser: "u", rpcPassword: "p", network: "regtest", confirmations: 3 },
+      rpcCall: rpc,
+      watchedAddresses: ["bc1qtest"],
+      oracle: makeOracle(),
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(0);
+  });
+
+  it("includes confirmationsRequired in event", async () => {
+    const events: Array<{ confirmationsRequired: number }> = [];
+    const cursorStore = makeCursorStore();
+
+    const rpc = vi
+      .fn()
+      .mockResolvedValueOnce([{ address: "bc1qtest", amount: 0.001, confirmations: 0, txids: ["txNew"] }])
+      .mockResolvedValueOnce({
+        details: [{ address: "bc1qtest", amount: 0.001, category: "receive" }],
+        confirmations: 0,
+      });
+
+    const watcher = new BtcWatcher({
+      config: { rpcUrl: "http://localhost", rpcUser: "u", rpcPassword: "p", network: "regtest", confirmations: 6 },
+      rpcCall: rpc,
+      watchedAddresses: ["bc1qtest"],
+      oracle: makeOracle(),
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events[0].confirmationsRequired).toBe(6);
+  });
+});

package/src/billing/crypto/btc/types.ts

@@ -1,4 +1,4 @@
-/** BTC payment event emitted when a deposit is confirmed. */
+/** BTC payment event emitted on each confirmation increment. */
 export interface BtcPaymentEvent {
   readonly address: string;
   readonly txid: string;
@@ -7,6 +7,8 @@ export interface BtcPaymentEvent {
   /** USD cents equivalent (integer). */
   readonly amountUsdCents: number;
   readonly confirmations: number;
+  /** Required confirmations for this chain (from config). */
+  readonly confirmationsRequired: number;
 }
 
 /** Options for creating a BTC checkout. */

package/src/billing/crypto/btc/watcher.ts

@@ -74,12 +74,18 @@ export class BtcWatcher {
     this.addresses.add(address);
   }
 
-  /** Poll for confirmed payments to watched addresses. */
+  /**
+   * Poll for payments to watched addresses, including unconfirmed txs.
+   *
+   * Fires onPayment on every confirmation increment (0, 1, 2, ... threshold).
+   * Only marks a tx as fully processed once it reaches the confirmation threshold.
+   */
   async poll(): Promise<void> {
     if (this.addresses.size === 0) return;
 
+    // Poll with minconf=0 to see unconfirmed txs
     const received = (await this.rpc("listreceivedbyaddress", [
-      this.minConfirmations,
+      0, // minconf=0: see ALL txs including unconfirmed
       false, // include_empty
       true, // include_watchonly
     ])) as ReceivedByAddress[];
@@ -90,7 +96,7 @@ export class BtcWatcher {
       if (!this.addresses.has(entry.address)) continue;
 
       for (const txid of entry.txids) {
-        // Skip already-processed txids (persisted to DB, survives restart)
+        // Skip fully-processed txids (already reached threshold, persisted to DB)
         if (await this.cursorStore.hasProcessedTx(this.watcherId, txid)) continue;
 
         // Get transaction details for the exact amount sent to this address
@@ -102,8 +108,11 @@ export class BtcWatcher {
         const detail = tx.details.find((d) => d.address === entry.address && d.category === "receive");
         if (!detail) continue;
 
+        // Check if confirmations have increased since last seen
+        const lastSeen = await this.cursorStore.getConfirmationCount(this.watcherId, txid);
+        if (lastSeen !== null && tx.confirmations <= lastSeen) continue; // No change
+
         const amountSats = Math.round(detail.amount * 100_000_000);
-        // priceCents is cents per 1 BTC. detail.amount is in BTC.
         const amountUsdCents = Math.round((amountSats * priceCents) / 100_000_000);
 
         const event: BtcPaymentEvent = {
@@ -112,11 +121,18 @@ export class BtcWatcher {
           amountSats,
           amountUsdCents,
           confirmations: tx.confirmations,
+          confirmationsRequired: this.minConfirmations,
         };
 
         await this.onPayment(event);
-        // Persist AFTER successful onPayment — survives restart, no unbounded memory
-        await this.cursorStore.markProcessedTx(this.watcherId, txid);
+
+        // Persist confirmation count
+        await this.cursorStore.saveConfirmationCount(this.watcherId, txid, tx.confirmations);
+
+        // Mark as fully processed once we reach the threshold
+        if (tx.confirmations >= this.minConfirmations) {
+          await this.cursorStore.markProcessedTx(this.watcherId, txid);
+        }
       }
     }
   }