@wopr-network/platform-core 1.48.0 → 1.49.0

package/src/billing/crypto/charge-store.test.ts

@@ -34,6 +34,10 @@ describe("CryptoChargeRepository", () => {
     expect(charge?.amountUsdCents).toBe(2500);
     expect(charge?.status).toBe("New");
     expect(charge?.creditedAt).toBeNull();
+    expect(charge?.confirmations).toBe(0);
+    expect(charge?.confirmationsRequired).toBe(1);
+    expect(charge?.txHash).toBeNull();
+    expect(charge?.amountReceivedCents).toBe(0);
   });
 
   it("getByReferenceId() returns null when not found", async () => {
@@ -41,7 +45,7 @@ describe("CryptoChargeRepository", () => {
     expect(charge).toBeNull();
   });
 
-  it("updateStatus() updates status, currency and filled_amount", async () => {
+  it("updateStatus() updates status, currency and filled_amount (deprecated compat)", async () => {
     await store.create("inv-002", "tenant-2", 5000);
     await store.updateStatus("inv-002", "Settled", "BTC", "0.00025");
 
@@ -79,6 +83,205 @@ describe("CryptoChargeRepository", () => {
     expect(await store.isCredited("inv-006")).toBe(true);
   });
 
+  describe("updateProgress", () => {
+    it("updates partial payment progress", async () => {
+      await store.createStablecoinCharge({
+        referenceId: "prog-001",
+        tenantId: "t-1",
+        amountUsdCents: 5000,
+        chain: "base",
+        token: "USDC",
+        depositAddress: "0xprog001",
+        derivationIndex: 0,
+      });
+
+      await store.updateProgress("prog-001", {
+        status: "partial",
+        amountReceivedCents: 2500,
+        confirmations: 2,
+        confirmationsRequired: 6,
+        txHash: "0xabc123",
+      });
+
+      const record = await store.getByReferenceId("prog-001");
+      expect(record?.status).toBe("Processing");
+      expect(record?.amountReceivedCents).toBe(2500);
+      expect(record?.confirmations).toBe(2);
+      expect(record?.confirmationsRequired).toBe(6);
+      expect(record?.txHash).toBe("0xabc123");
+    });
+
+    it("increments confirmations over multiple updates", async () => {
+      await store.createStablecoinCharge({
+        referenceId: "prog-002",
+        tenantId: "t-2",
+        amountUsdCents: 1000,
+        chain: "base",
+        token: "USDC",
+        depositAddress: "0xprog002",
+        derivationIndex: 1,
+      });
+
+      await store.updateProgress("prog-002", {
+        status: "partial",
+        amountReceivedCents: 1000,
+        confirmations: 1,
+        confirmationsRequired: 6,
+        txHash: "0xdef456",
+      });
+
+      await store.updateProgress("prog-002", {
+        status: "partial",
+        amountReceivedCents: 1000,
+        confirmations: 3,
+        confirmationsRequired: 6,
+        txHash: "0xdef456",
+      });
+
+      const record = await store.getByReferenceId("prog-002");
+      expect(record?.confirmations).toBe(3);
+    });
+
+    it("maps confirmed status to Settled in DB", async () => {
+      await store.createStablecoinCharge({
+        referenceId: "prog-003",
+        tenantId: "t-3",
+        amountUsdCents: 2000,
+        chain: "base",
+        token: "USDC",
+        depositAddress: "0xprog003",
+        derivationIndex: 2,
+      });
+
+      await store.updateProgress("prog-003", {
+        status: "confirmed",
+        amountReceivedCents: 2000,
+        confirmations: 6,
+        confirmationsRequired: 6,
+        txHash: "0xfinal",
+      });
+
+      const record = await store.getByReferenceId("prog-003");
+      expect(record?.status).toBe("Settled");
+    });
+  });
+
+  describe("get (UI-facing CryptoCharge)", () => {
+    it("returns null when not found", async () => {
+      const charge = await store.get("nonexistent");
+      expect(charge).toBeNull();
+    });
+
+    it("returns full CryptoCharge with all fields for a new charge", async () => {
+      await store.createStablecoinCharge({
+        referenceId: "get-001",
+        tenantId: "t-get",
+        amountUsdCents: 5000,
+        chain: "base",
+        token: "USDC",
+        depositAddress: "0xget001",
+        derivationIndex: 10,
+      });
+
+      const charge = await store.get("get-001");
+      expect(charge).not.toBeNull();
+      expect(charge?.id).toBe("get-001");
+      expect(charge?.tenantId).toBe("t-get");
+      expect(charge?.chain).toBe("base");
+      expect(charge?.status).toBe("pending");
+      expect(charge?.amountExpectedCents).toBe(5000);
+      expect(charge?.amountReceivedCents).toBe(0);
+      expect(charge?.confirmations).toBe(0);
+      expect(charge?.confirmationsRequired).toBe(1);
+      expect(charge?.txHash).toBeUndefined();
+      expect(charge?.credited).toBe(false);
+      expect(charge?.createdAt).toBeInstanceOf(Date);
+    });
+
+    it("reflects partial payment progress", async () => {
+      await store.createStablecoinCharge({
+        referenceId: "get-002",
+        tenantId: "t-get2",
+        amountUsdCents: 5000,
+        chain: "base",
+        token: "USDC",
+        depositAddress: "0xget002",
+        derivationIndex: 11,
+      });
+
+      await store.updateProgress("get-002", {
+        status: "partial",
+        amountReceivedCents: 2500,
+        confirmations: 3,
+        confirmationsRequired: 6,
+        txHash: "0xpartial",
+      });
+
+      const charge = await store.get("get-002");
+      expect(charge?.status).toBe("partial");
+      expect(charge?.amountReceivedCents).toBe(2500);
+      expect(charge?.confirmations).toBe(3);
+      expect(charge?.confirmationsRequired).toBe(6);
+      expect(charge?.txHash).toBe("0xpartial");
+      expect(charge?.credited).toBe(false);
+    });
+
+    it("shows confirmed+credited status after markCredited", async () => {
+      await store.createStablecoinCharge({
+        referenceId: "get-003",
+        tenantId: "t-get3",
+        amountUsdCents: 1000,
+        chain: "base",
+        token: "USDC",
+        depositAddress: "0xget003",
+        derivationIndex: 12,
+      });
+
+      await store.updateProgress("get-003", {
+        status: "confirmed",
+        amountReceivedCents: 1000,
+        confirmations: 6,
+        confirmationsRequired: 6,
+        txHash: "0xfull",
+      });
+      await store.markCredited("get-003");
+
+      const charge = await store.get("get-003");
+      expect(charge?.status).toBe("confirmed");
+      expect(charge?.credited).toBe(true);
+      expect(charge?.amountReceivedCents).toBe(1000);
+    });
+
+    it("maps expired status correctly", async () => {
+      await store.createStablecoinCharge({
+        referenceId: "get-004",
+        tenantId: "t-get4",
+        amountUsdCents: 3000,
+        chain: "base",
+        token: "USDC",
+        depositAddress: "0xget004",
+        derivationIndex: 13,
+      });
+
+      await store.updateProgress("get-004", {
+        status: "expired",
+        amountReceivedCents: 0,
+        confirmations: 0,
+        confirmationsRequired: 6,
+      });
+
+      const charge = await store.get("get-004");
+      expect(charge?.status).toBe("expired");
+    });
+
+    it("returns chain as 'unknown' for legacy charges without chain", async () => {
+      await store.create("get-005", "t-get5", 500);
+
+      const charge = await store.get("get-005");
+      expect(charge?.chain).toBe("unknown");
+    });
+  });
+
   describe("stablecoin charges", () => {
     it("creates a stablecoin charge with chain/token/address", async () => {
       await store.createStablecoinCharge({

package/src/billing/crypto/charge-store.ts

@@ -1,7 +1,7 @@
 import { and, eq, isNotNull, isNull, sql } from "drizzle-orm";
 import type { PlatformDb } from "../../db/index.js";
 import { cryptoCharges } from "../../db/schema/crypto.js";
-import type { CryptoPaymentState } from "./types.js";
+import type { CryptoCharge, CryptoChargeStatus, CryptoPaymentState } from "./types.js";
 
 export interface CryptoChargeRecord {
   referenceId: string;
@@ -20,6 +20,10 @@ export interface CryptoChargeRecord {
   callbackUrl: string | null;
   expectedAmount: string | null;
   receivedAmount: string | null;
+  confirmations: number;
+  confirmationsRequired: number;
+  txHash: string | null;
+  amountReceivedCents: number;
 }
 
 export interface CryptoDepositChargeInput {
@@ -35,15 +39,28 @@ export interface CryptoDepositChargeInput {
   expectedAmount?: string;
 }
 
+export interface CryptoChargeProgressUpdate {
+  status: CryptoChargeStatus;
+  amountReceivedCents: number;
+  confirmations: number;
+  confirmationsRequired: number;
+  txHash?: string;
+}
+
 export interface ICryptoChargeRepository {
   create(referenceId: string, tenantId: string, amountUsdCents: number): Promise<void>;
   getByReferenceId(referenceId: string): Promise<CryptoChargeRecord | null>;
+  /** @deprecated Use updateProgress() instead. Kept for one release cycle. */
   updateStatus(
     referenceId: string,
     status: CryptoPaymentState,
     currency?: string,
     filledAmount?: string,
   ): Promise<void>;
+  /** Update partial payment progress, confirmations, and tx hash. */
+  updateProgress(referenceId: string, update: CryptoChargeProgressUpdate): Promise<void>;
+  /** Get a charge as a UI-facing CryptoCharge with all progress fields. */
+  get(referenceId: string): Promise<CryptoCharge | null>;
   markCredited(referenceId: string): Promise<void>;
   isCredited(referenceId: string): Promise<boolean>;
   createStablecoinCharge(input: CryptoDepositChargeInput): Promise<void>;
@@ -101,10 +118,77 @@ export class DrizzleCryptoChargeRepository implements ICryptoChargeRepository {
       callbackUrl: row.callbackUrl ?? null,
       expectedAmount: row.expectedAmount ?? null,
       receivedAmount: row.receivedAmount ?? null,
+      confirmations: row.confirmations,
+      confirmationsRequired: row.confirmationsRequired,
+      txHash: row.txHash ?? null,
+      amountReceivedCents: row.amountReceivedCents,
+    };
+  }
+
+  /** Map DB status strings to CryptoChargeStatus for UI consumption. */
+  private mapStatus(dbStatus: string, credited: boolean): CryptoChargeStatus {
+    if (credited) return "confirmed";
+    switch (dbStatus) {
+      case "New":
+        return "pending";
+      case "Processing":
+        return "partial";
+      case "Settled":
+        return "confirmed";
+      case "Expired":
+        return "expired";
+      case "Invalid":
+        return "failed";
+      default:
+        return "pending";
+    }
+  }
+
+  /** Get a charge as a UI-facing CryptoCharge with all progress fields. */
+  async get(referenceId: string): Promise<CryptoCharge | null> {
+    const row = (await this.db.select().from(cryptoCharges).where(eq(cryptoCharges.referenceId, referenceId)))[0];
+    if (!row) return null;
+    return {
+      id: row.referenceId,
+      tenantId: row.tenantId,
+      chain: row.chain ?? "unknown",
+      status: this.mapStatus(row.status, row.creditedAt != null),
+      amountExpectedCents: row.amountUsdCents,
+      amountReceivedCents: row.amountReceivedCents,
+      confirmations: row.confirmations,
+      confirmationsRequired: row.confirmationsRequired,
+      txHash: row.txHash ?? undefined,
+      credited: row.creditedAt != null,
+      createdAt: new Date(row.createdAt),
     };
   }
 
-  /** Update charge status and payment details from webhook. */
+  /** Update partial payment progress, confirmations, and tx hash. */
+  async updateProgress(referenceId: string, update: CryptoChargeProgressUpdate): Promise<void> {
+    const statusMap: Record<CryptoChargeStatus, string> = {
+      pending: "New",
+      partial: "Processing",
+      confirmed: "Settled",
+      expired: "Expired",
+      failed: "Invalid",
+    };
+    await this.db
+      .update(cryptoCharges)
+      .set({
+        status: statusMap[update.status],
+        amountReceivedCents: update.amountReceivedCents,
+        confirmations: update.confirmations,
+        confirmationsRequired: update.confirmationsRequired,
+        txHash: update.txHash,
+        updatedAt: sql`now()`,
+      })
+      .where(eq(cryptoCharges.referenceId, referenceId));
+  }
+
+  /**
+   * @deprecated Use updateProgress() instead. Kept for one release cycle.
+   * Update charge status and payment details from webhook.
+   */
   async updateStatus(
     referenceId: string,
     status: CryptoPaymentState,

package/src/billing/crypto/client.ts

@@ -29,6 +29,8 @@ export interface CreateChargeResult {
   amountUsd: number;
   derivationIndex: number;
   expiresAt: string;
+  displayAmount?: string;
+  priceCents?: number;
 }
 
 export interface ChargeStatus {

package/src/billing/crypto/cursor-store.ts

@@ -7,18 +7,23 @@ export interface IWatcherCursorStore {
   get(watcherId: string): Promise<number | null>;
   /** Save block cursor after processing a range. */
   save(watcherId: string, cursorBlock: number): Promise<void>;
-  /** Check if a specific tx has been processed (for watchers without block cursors). */
+  /** Check if a specific tx has been fully processed (reached confirmation threshold). */
   hasProcessedTx(watcherId: string, txId: string): Promise<boolean>;
-  /** Mark a tx as processed (for watchers without block cursors). */
+  /** Mark a tx as fully processed (reached confirmation threshold). */
   markProcessedTx(watcherId: string, txId: string): Promise<void>;
+  /** Get the last-seen confirmation count for a tx (for intermediate confirmation tracking). */
+  getConfirmationCount(watcherId: string, txId: string): Promise<number | null>;
+  /** Save the current confirmation count for a tx (for intermediate confirmation tracking). */
+  saveConfirmationCount(watcherId: string, txId: string, count: number): Promise<void>;
 }
 
 /**
  * Persists watcher state to PostgreSQL.
  *
- * Two patterns:
+ * Three patterns:
  *   - Block cursor (EVM watchers): save/get cursor block number
  *   - Processed txids (BTC watcher): hasProcessedTx/markProcessedTx
+ *   - Confirmation counts (all watchers): getConfirmationCount/saveConfirmationCount
  *
  * Eliminates all in-memory watcher state. Clean restart recovery.
  */
@@ -58,4 +63,27 @@ export class DrizzleWatcherCursorStore implements IWatcherCursorStore {
   async markProcessedTx(watcherId: string, txId: string): Promise<void> {
     await this.db.insert(watcherProcessed).values({ watcherId, txId }).onConflictDoNothing();
   }
+
+  async getConfirmationCount(watcherId: string, txId: string): Promise<number | null> {
+    // Store confirmation counts as synthetic cursor entries: "watcherId:conf:txId" -> count
+    const key = `${watcherId}:conf:${txId}`;
+    const row = (
+      await this.db
+        .select({ cursorBlock: watcherCursors.cursorBlock })
+        .from(watcherCursors)
+        .where(eq(watcherCursors.watcherId, key))
+    )[0];
+    return row?.cursorBlock ?? null;
+  }
+
+  async saveConfirmationCount(watcherId: string, txId: string, count: number): Promise<void> {
+    const key = `${watcherId}:conf:${txId}`;
+    await this.db
+      .insert(watcherCursors)
+      .values({ watcherId: key, cursorBlock: count })
+      .onConflictDoUpdate({
+        target: watcherCursors.watcherId,
+        set: { cursorBlock: count, updatedAt: sql`(now())` },
+      });
+  }
 }

package/src/billing/crypto/evm/__tests__/eth-settler.test.ts

@@ -11,6 +11,8 @@ function makeEvent(overrides: Partial<EthPaymentEvent> = {}): EthPaymentEvent {
     amountUsdCents: 5000,
     txHash: "0xabc123",
     blockNumber: 100,
+    confirmations: 1,
+    confirmationsRequired: 1,
     ...overrides,
   };
 }

package/src/billing/crypto/evm/__tests__/eth-watcher.test.ts

@@ -10,8 +10,9 @@ const mockOracle = { getPrice: vi.fn().mockResolvedValue({ priceCents: 350_000,
 describe("EthWatcher", () => {
   it("detects native ETH transfer to watched address", async () => {
     const onPayment = vi.fn();
+    // latest = 0xa (10), fromBlock = 10 → scans exactly block 10
     const rpc = makeRpc({
-      eth_blockNumber: "0xb",
+      eth_blockNumber: "0xa",
       eth_getBlockByNumber: {
         transactions: [
           {
@@ -42,6 +43,8 @@ describe("EthWatcher", () => {
     expect(event.valueWei).toBe("1000000000000000000");
     expect(event.amountUsdCents).toBe(350_000); // 1 ETH × $3,500
     expect(event.txHash).toBe("0xabc");
+    expect(event.confirmations).toBe(0);
+    expect(event.confirmationsRequired).toBe(1);
   });
 
   it("skips transactions not to watched addresses", async () => {
@@ -90,6 +93,19 @@ describe("EthWatcher", () => {
 
   it("does not double-process same txid", async () => {
     const onPayment = vi.fn();
+    const confirmations = new Map<string, number>();
+    const cursorStore = {
+      get: vi.fn().mockResolvedValue(null),
+      save: vi.fn().mockResolvedValue(undefined),
+      hasProcessedTx: vi.fn().mockResolvedValue(false),
+      markProcessedTx: vi.fn().mockResolvedValue(undefined),
+      getConfirmationCount: vi
+        .fn()
+        .mockImplementation(async (_: string, txId: string) => confirmations.get(txId) ?? null),
+      saveConfirmationCount: vi.fn().mockImplementation(async (_: string, txId: string, count: number) => {
+        confirmations.set(txId, count);
+      }),
+    };
     const rpc = makeRpc({
       eth_blockNumber: "0xb",
       eth_getBlockByNumber: {
@@ -104,10 +120,11 @@ describe("EthWatcher", () => {
       fromBlock: 10,
       onPayment,
       watchedAddresses: ["0xDeposit"],
+      cursorStore,
     });
 
     await watcher.poll();
-    // Reset cursor to re-scan same block
+    // Second poll — same block, same confirmations → no duplicate emission
     await watcher.poll();
 
     expect(onPayment).toHaveBeenCalledOnce();
@@ -132,8 +149,17 @@ describe("EthWatcher", () => {
 
   it("does not mark txid as processed if onPayment throws", async () => {
     const onPayment = vi.fn().mockRejectedValueOnce(new Error("db fail")).mockResolvedValueOnce(undefined);
+    const cursorStore = {
+      get: vi.fn().mockResolvedValue(null),
+      save: vi.fn().mockResolvedValue(undefined),
+      hasProcessedTx: vi.fn().mockResolvedValue(false),
+      markProcessedTx: vi.fn().mockResolvedValue(undefined),
+      getConfirmationCount: vi.fn().mockResolvedValue(null),
+      saveConfirmationCount: vi.fn().mockResolvedValue(undefined),
+    };
+    // latest = 0xa (10) = fromBlock → exactly one block to scan
     const rpc = makeRpc({
-      eth_blockNumber: "0xb",
+      eth_blockNumber: "0xa",
       eth_getBlockByNumber: {
         transactions: [{ hash: "0xabc", from: "0xa", to: "0xdeposit", value: "0xDE0B6B3A7640000", blockNumber: "0xa" }],
       },
@@ -146,11 +172,12 @@ describe("EthWatcher", () => {
       fromBlock: 10,
       onPayment,
       watchedAddresses: ["0xDeposit"],
+      cursorStore,
     });
 
     await expect(watcher.poll()).rejects.toThrow("db fail");
 
-    // Retry — should process the same tx again since it wasn't marked
+    // Retry — should process the same tx again since confirmationCount wasn't saved (error before save)
     await watcher.poll();
     expect(onPayment).toHaveBeenCalledTimes(2);
   });

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

@@ -12,6 +12,8 @@ const mockEvent: EvmPaymentEvent = {
   txHash: "0xtx123",
   blockNumber: 100,
   logIndex: 0,
+  confirmations: 1,
+  confirmationsRequired: 1,
 };
 
 describe("settleEvmPayment", () => {

package/src/billing/crypto/evm/__tests__/watcher-confirmations.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it, vi } from "vitest";
+import { EvmWatcher } from "../watcher.js";
+
+const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+
+function mockTransferLog(to: string, amount: bigint, blockNumber: number) {
+  return {
+    address: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    topics: [
+      TRANSFER_TOPIC,
+      `0x${"00".repeat(12)}${"ab".repeat(20)}`,
+      `0x${"00".repeat(12)}${to.slice(2).toLowerCase()}`,
+    ],
+    data: `0x${amount.toString(16).padStart(64, "0")}`,
+    blockNumber: `0x${blockNumber.toString(16)}`,
+    transactionHash: `0x${"ff".repeat(32)}`,
+    logIndex: "0x0",
+  };
+}
+
+function makeCursorStore() {
+  const cursors = new Map<string, number>();
+  return {
+    get: vi.fn().mockImplementation(async (id: string) => cursors.get(id) ?? null),
+    save: vi.fn().mockImplementation(async (id: string, val: number) => {
+      cursors.set(id, val);
+    }),
+    hasProcessedTx: vi.fn().mockResolvedValue(false),
+    markProcessedTx: vi.fn().mockResolvedValue(undefined),
+    getConfirmationCount: vi.fn().mockResolvedValue(null),
+    saveConfirmationCount: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe("EvmWatcher — intermediate confirmations", () => {
+  it("emits events with confirmation count", async () => {
+    const toAddr = `0x${"cc".repeat(20)}`;
+    const events: Array<{ confirmations: number; confirmationsRequired: number }> = [];
+
+    // Base has confirmations: 1. Latest block is 105. Log at block 103 -> 2 confirmations.
+    const mockRpc = vi
+      .fn()
+      .mockResolvedValueOnce(`0x${(105).toString(16)}`) // eth_blockNumber
+      .mockResolvedValueOnce([mockTransferLog(toAddr, 10_000_000n, 103)]); // eth_getLogs
+
+    const watcher = new EvmWatcher({
+      chain: "base",
+      token: "USDC",
+      rpcCall: mockRpc,
+      fromBlock: 100,
+      watchedAddresses: [toAddr],
+      cursorStore: makeCursorStore(),
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].confirmations).toBe(2); // 105 - 103
+    expect(events[0].confirmationsRequired).toBe(1); // Base chain config
+  });
+
+  it("skips event when confirmation count unchanged", async () => {
+    const toAddr = `0x${"cc".repeat(20)}`;
+    const events: Array<{ confirmations: number }> = [];
+    const cursorStore = makeCursorStore();
+    cursorStore.getConfirmationCount.mockResolvedValue(2);
+
+    const mockRpc = vi
+      .fn()
+      .mockResolvedValueOnce(`0x${(105).toString(16)}`)
+      .mockResolvedValueOnce([mockTransferLog(toAddr, 10_000_000n, 103)]);
+
+    const watcher = new EvmWatcher({
+      chain: "base",
+      token: "USDC",
+      rpcCall: mockRpc,
+      fromBlock: 100,
+      watchedAddresses: [toAddr],
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(0);
+  });
+
+  it("re-emits when confirmations increase", async () => {
+    const toAddr = `0x${"cc".repeat(20)}`;
+    const events: Array<{ confirmations: number }> = [];
+    const cursorStore = makeCursorStore();
+    cursorStore.getConfirmationCount.mockResolvedValue(1);
+
+    const mockRpc = vi
+      .fn()
+      .mockResolvedValueOnce(`0x${(105).toString(16)}`)
+      .mockResolvedValueOnce([mockTransferLog(toAddr, 10_000_000n, 103)]);
+
+    const watcher = new EvmWatcher({
+      chain: "base",
+      token: "USDC",
+      rpcCall: mockRpc,
+      fromBlock: 100,
+      watchedAddresses: [toAddr],
+      cursorStore,
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].confirmations).toBe(2);
+  });
+
+  it("includes confirmationsRequired from chain config", async () => {
+    const toAddr = `0x${"cc".repeat(20)}`;
+    const events: Array<{ confirmationsRequired: number }> = [];
+
+    const mockRpc = vi
+      .fn()
+      .mockResolvedValueOnce(`0x${(110).toString(16)}`)
+      .mockResolvedValueOnce([mockTransferLog(toAddr, 10_000_000n, 105)]);
+
+    const watcher = new EvmWatcher({
+      chain: "base",
+      token: "USDC",
+      rpcCall: mockRpc,
+      fromBlock: 100,
+      watchedAddresses: [toAddr],
+      cursorStore: makeCursorStore(),
+      onPayment: (evt) => {
+        events.push(evt);
+      },
+    });
+
+    await watcher.poll();
+
+    expect(events).toHaveLength(1);
+    expect(events[0].confirmationsRequired).toBe(1); // Base chain config
+  });
+
+  it("saves confirmation count after emitting", async () => {
+    const toAddr = `0x${"cc".repeat(20)}`;
+    const cursorStore = makeCursorStore();
+
+    const mockRpc = vi
+      .fn()
+      .mockResolvedValueOnce(`0x${(105).toString(16)}`)
+      .mockResolvedValueOnce([mockTransferLog(toAddr, 10_000_000n, 103)]);
+
+    const watcher = new EvmWatcher({
+      chain: "base",
+      token: "USDC",
+      rpcCall: mockRpc,
+      fromBlock: 100,
+      watchedAddresses: [toAddr],
+      cursorStore,
+      onPayment: () => {},
+    });
+
+    await watcher.poll();
+
+    expect(cursorStore.saveConfirmationCount).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.stringContaining("0x"),
+      2,
+    );
+  });
+});