@wopr-network/platform-core 1.67.0 → 1.67.1

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

@@ -1,161 +0,0 @@
-import type { IWatcherCursorStore } from "../cursor-store.js";
-import { nativeToCents } from "../oracle/convert.js";
-import type { IPriceOracle } from "../oracle/types.js";
-import type { BitcoindConfig, BtcPaymentEvent } from "./types.js";
-
-type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
-
-export interface BtcWatcherOpts {
-  config: BitcoindConfig;
-  rpcCall: RpcCall;
-  /** Addresses to watch (must be imported into bitcoind wallet first). */
-  watchedAddresses: string[];
-  onPayment: (event: BtcPaymentEvent) => void | Promise<void>;
-  /** Price oracle for BTC/USD conversion. */
-  oracle: IPriceOracle;
-  /** Required — BTC has no block cursor, so txid dedup must be persisted. */
-  cursorStore: IWatcherCursorStore;
-  /** Override chain identity for cursor namespace (default: config.network). Prevents txid collisions across BTC/LTC/DOGE. */
-  chainId?: string;
-}
-
-interface ReceivedByAddress {
-  address: string;
-  amount: number;
-  confirmations: number;
-  txids: string[];
-}
-
-export class BtcWatcher {
-  private readonly rpc: RpcCall;
-  private readonly addresses: Set<string>;
-  private readonly onPayment: BtcWatcherOpts["onPayment"];
-  private readonly minConfirmations: number;
-  private readonly oracle: IPriceOracle;
-  private readonly cursorStore: IWatcherCursorStore;
-  private readonly watcherId: string;
-
-  constructor(opts: BtcWatcherOpts) {
-    this.rpc = opts.rpcCall;
-    this.addresses = new Set(opts.watchedAddresses);
-    this.onPayment = opts.onPayment;
-    this.minConfirmations = opts.config.confirmations;
-    this.oracle = opts.oracle;
-    this.cursorStore = opts.cursorStore;
-    this.watcherId = `btc:${opts.chainId ?? opts.config.network}`;
-  }
-
-  /** Update the set of watched addresses. */
-  setWatchedAddresses(addresses: string[]): void {
-    this.addresses.clear();
-    for (const a of addresses) this.addresses.add(a);
-  }
-
-  /**
-   * Import an address into bitcoind's wallet (watch-only).
-   * Uses `importdescriptors` (modern bitcoind v24+) with fallback to legacy `importaddress`.
-   */
-  async importAddress(address: string): Promise<void> {
-    try {
-      // Modern bitcoind: get descriptor checksum, then import
-      const info = (await this.rpc("getdescriptorinfo", [`addr(${address})`])) as {
-        descriptor: string;
-      };
-      const result = (await this.rpc("importdescriptors", [[{ desc: info.descriptor, timestamp: 0 }]])) as Array<{
-        success: boolean;
-        error?: { message: string };
-      }>;
-      if (result[0] && !result[0].success) {
-        throw new Error(result[0].error?.message ?? "importdescriptors failed");
-      }
-    } catch {
-      // Fallback: legacy importaddress (bitcoind <v24)
-      await this.rpc("importaddress", [address, "", false]);
-    }
-    this.addresses.add(address);
-  }
-
-  /**
-   * 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", [
-      0, // minconf=0: see ALL txs including unconfirmed
-      false, // include_empty
-      true, // include_watchonly
-    ])) as ReceivedByAddress[];
-
-    const { priceMicros } = await this.oracle.getPrice("BTC");
-
-    for (const entry of received) {
-      if (!this.addresses.has(entry.address)) continue;
-
-      for (const txid of entry.txids) {
-        // 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
-        const tx = (await this.rpc("gettransaction", [txid, true])) as {
-          details: Array<{ address: string; amount: number; category: string }>;
-          confirmations: number;
-        };
-
-        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);
-        // priceMicros is microdollars per 1 BTC. Convert sats→USD cents via nativeToCents.
-        const amountUsdCents = nativeToCents(BigInt(amountSats), priceMicros, 8);
-
-        const event: BtcPaymentEvent = {
-          address: entry.address,
-          txid,
-          amountSats,
-          amountUsdCents,
-          confirmations: tx.confirmations,
-          confirmationsRequired: this.minConfirmations,
-        };
-
-        await this.onPayment(event);
-
-        // 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);
-        }
-      }
-    }
-  }
-}
-
-/** Create a bitcoind JSON-RPC caller with basic auth. */
-export function createBitcoindRpc(config: BitcoindConfig): RpcCall {
-  let id = 0;
-  const auth = btoa(`${config.rpcUser}:${config.rpcPassword}`);
-  return async (method: string, params: unknown[]): Promise<unknown> => {
-    const res = await fetch(config.rpcUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Basic ${auth}`,
-      },
-      body: JSON.stringify({ jsonrpc: "1.0", id: ++id, method, params }),
-    });
-    if (!res.ok) throw new Error(`bitcoind ${method} failed: ${res.status}`);
-    const data = (await res.json()) as { result?: unknown; error?: { message: string } };
-    if (data.error) throw new Error(`bitcoind ${method}: ${data.error.message}`);
-    return data.result;
-  };
-}

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

@@ -1,190 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { EthWatcher } from "../eth-watcher.js";
-
-function makeRpc(responses: Record<string, unknown>) {
-  return vi.fn(async (method: string) => responses[method]);
-}
-
-const mockOracle = { getPrice: vi.fn().mockResolvedValue({ priceMicros: 3_500_000_000, updatedAt: new Date() }) };
-
-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: "0xa",
-      eth_getBlockByNumber: {
-        transactions: [
-          {
-            hash: "0xabc",
-            from: "0xsender",
-            to: "0xdeposit",
-            value: "0xDE0B6B3A7640000", // 1 ETH = 10^18 wei
-            blockNumber: "0xa",
-          },
-        ],
-      },
-    });
-
-    const watcher = new EthWatcher({
-      chain: "base",
-      rpcCall: rpc,
-      oracle: mockOracle,
-      fromBlock: 10,
-      confirmations: 1,
-      onPayment,
-      watchedAddresses: ["0xDeposit"],
-    });
-
-    await watcher.poll();
-
-    expect(onPayment).toHaveBeenCalledOnce();
-    const event = onPayment.mock.calls[0][0];
-    expect(event.to).toBe("0xdeposit");
-    expect(event.valueWei).toBe("1000000000000000000");
-    expect(event.amountUsdCents).toBe(350_000); // 1 ETH × $3,500 = $3,500 = 350,000 cents
-    expect(event.txHash).toBe("0xabc");
-    expect(event.confirmations).toBe(0);
-    expect(event.confirmationsRequired).toBe(1);
-  });
-
-  it("skips transactions not to watched addresses", async () => {
-    const onPayment = vi.fn();
-    const rpc = makeRpc({
-      eth_blockNumber: "0xb",
-      eth_getBlockByNumber: {
-        transactions: [{ hash: "0xabc", from: "0xa", to: "0xother", value: "0xDE0B6B3A7640000", blockNumber: "0xa" }],
-      },
-    });
-
-    const watcher = new EthWatcher({
-      chain: "base",
-      rpcCall: rpc,
-      oracle: mockOracle,
-      fromBlock: 10,
-      confirmations: 1,
-      onPayment,
-      watchedAddresses: ["0xDeposit"],
-    });
-
-    await watcher.poll();
-    expect(onPayment).not.toHaveBeenCalled();
-  });
-
-  it("skips zero-value transactions", async () => {
-    const onPayment = vi.fn();
-    const rpc = makeRpc({
-      eth_blockNumber: "0xb",
-      eth_getBlockByNumber: {
-        transactions: [{ hash: "0xabc", from: "0xa", to: "0xdeposit", value: "0x0", blockNumber: "0xa" }],
-      },
-    });
-
-    const watcher = new EthWatcher({
-      chain: "base",
-      rpcCall: rpc,
-      oracle: mockOracle,
-      fromBlock: 10,
-      confirmations: 1,
-      onPayment,
-      watchedAddresses: ["0xDeposit"],
-    });
-
-    await watcher.poll();
-    expect(onPayment).not.toHaveBeenCalled();
-  });
-
-  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: {
-        transactions: [{ hash: "0xabc", from: "0xa", to: "0xdeposit", value: "0xDE0B6B3A7640000", blockNumber: "0xa" }],
-      },
-    });
-
-    const watcher = new EthWatcher({
-      chain: "base",
-      rpcCall: rpc,
-      oracle: mockOracle,
-      fromBlock: 10,
-      confirmations: 1,
-      onPayment,
-      watchedAddresses: ["0xDeposit"],
-      cursorStore,
-    });
-
-    await watcher.poll();
-    // Second poll — same block, same confirmations → no duplicate emission
-    await watcher.poll();
-
-    expect(onPayment).toHaveBeenCalledOnce();
-  });
-
-  it("skips poll when no watched addresses", async () => {
-    const onPayment = vi.fn();
-    const rpc = vi.fn();
-
-    const watcher = new EthWatcher({
-      chain: "base",
-      rpcCall: rpc,
-      oracle: mockOracle,
-      fromBlock: 10,
-      confirmations: 1,
-      onPayment,
-      watchedAddresses: [],
-    });
-
-    await watcher.poll();
-    expect(rpc).not.toHaveBeenCalled();
-  });
-
-  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: "0xa",
-      eth_getBlockByNumber: {
-        transactions: [{ hash: "0xabc", from: "0xa", to: "0xdeposit", value: "0xDE0B6B3A7640000", blockNumber: "0xa" }],
-      },
-    });
-
-    const watcher = new EthWatcher({
-      chain: "base",
-      rpcCall: rpc,
-      oracle: mockOracle,
-      fromBlock: 10,
-      confirmations: 1,
-      onPayment,
-      watchedAddresses: ["0xDeposit"],
-      cursorStore,
-    });
-
-    await expect(watcher.poll()).rejects.toThrow("db fail");
-
-    // 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__/watcher-confirmations.test.ts

@@ -1,191 +0,0 @@
-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",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      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",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      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",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      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",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      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",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      rpcCall: mockRpc,
-      fromBlock: 100,
-      watchedAddresses: [toAddr],
-      cursorStore,
-      onPayment: () => {},
-    });
-
-    await watcher.poll();
-
-    expect(cursorStore.saveConfirmationCount).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.stringContaining("0x"),
-      2,
-    );
-  });
-});

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

@@ -1,167 +0,0 @@
-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)}`, // from (padded)
-      `0x${"00".repeat(12)}${to.slice(2).toLowerCase()}`, // to (padded)
-    ],
-    data: `0x${amount.toString(16).padStart(64, "0")}`,
-    blockNumber: `0x${blockNumber.toString(16)}`,
-    transactionHash: `0x${"ff".repeat(32)}`,
-    logIndex: "0x0",
-  };
-}
-
-describe("EvmWatcher", () => {
-  it("parses Transfer log into EvmPaymentEvent", async () => {
-    const toAddr = `0x${"cc".repeat(20)}`;
-    const events: { amountUsdCents: number; to: string }[] = [];
-    const mockRpc = vi
-      .fn()
-      .mockResolvedValueOnce(`0x${(102).toString(16)}`)
-      .mockResolvedValueOnce([mockTransferLog(toAddr, 10_000_000n, 99)]);
-
-    const watcher = new EvmWatcher({
-      chain: "base",
-      token: "USDC",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      rpcCall: mockRpc,
-      fromBlock: 99,
-      watchedAddresses: [toAddr],
-      onPayment: (evt) => {
-        events.push(evt);
-      },
-    });
-
-    await watcher.poll();
-
-    expect(events).toHaveLength(1);
-    expect(events[0].amountUsdCents).toBe(1000);
-    expect(events[0].to).toMatch(/^0x/);
-  });
-
-  it("advances cursor after processing", async () => {
-    const mockRpc = vi
-      .fn()
-      .mockResolvedValueOnce(`0x${(200).toString(16)}`)
-      .mockResolvedValueOnce([]);
-
-    const watcher = new EvmWatcher({
-      chain: "base",
-      token: "USDC",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      rpcCall: mockRpc,
-      fromBlock: 100,
-      watchedAddresses: ["0xdeadbeef"],
-      onPayment: vi.fn(),
-    });
-
-    await watcher.poll();
-    expect(watcher.cursor).toBeGreaterThan(100);
-  });
-
-  it("skips blocks not yet confirmed", async () => {
-    const events: unknown[] = [];
-    // latest = 50, cursor = 50 → latest < cursor is false, but range is empty (50..50)
-    // With intermediate confirmations, we still scan the range but find no logs
-    const mockRpc = vi
-      .fn()
-      .mockResolvedValueOnce(`0x${(50).toString(16)}`) // eth_blockNumber
-      .mockResolvedValueOnce([]); // eth_getLogs (empty)
-
-    const watcher = new EvmWatcher({
-      chain: "base",
-      token: "USDC",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      rpcCall: mockRpc,
-      fromBlock: 50,
-      watchedAddresses: ["0xdeadbeef"],
-      onPayment: (evt) => {
-        events.push(evt);
-      },
-    });
-
-    await watcher.poll();
-    expect(events).toHaveLength(0);
-  });
-
-  it("processes multiple logs in one poll", async () => {
-    const addr1 = `0x${"aa".repeat(20)}`;
-    const addr2 = `0x${"bb".repeat(20)}`;
-    const events: { amountUsdCents: number }[] = [];
-    const mockRpc = vi
-      .fn()
-      .mockResolvedValueOnce(`0x${(110).toString(16)}`)
-      .mockResolvedValueOnce([mockTransferLog(addr1, 5_000_000n, 105), mockTransferLog(addr2, 20_000_000n, 107)]);
-
-    const watcher = new EvmWatcher({
-      chain: "base",
-      token: "USDC",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      rpcCall: mockRpc,
-      fromBlock: 100,
-      watchedAddresses: [addr1, addr2],
-      onPayment: (evt) => {
-        events.push(evt);
-      },
-    });
-
-    await watcher.poll();
-
-    expect(events).toHaveLength(2);
-    expect(events[0].amountUsdCents).toBe(500);
-    expect(events[1].amountUsdCents).toBe(2000);
-  });
-
-  it("does nothing when no new blocks", async () => {
-    const mockRpc = vi.fn().mockResolvedValueOnce(`0x${(99).toString(16)}`);
-
-    const watcher = new EvmWatcher({
-      chain: "base",
-      token: "USDC",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      rpcCall: mockRpc,
-      fromBlock: 100,
-      watchedAddresses: ["0xdeadbeef"],
-      onPayment: vi.fn(),
-    });
-
-    await watcher.poll();
-    expect(watcher.cursor).toBe(100);
-    expect(mockRpc).toHaveBeenCalledTimes(1);
-  });
-
-  it("early-returns when no watched addresses are set", async () => {
-    const mockRpc = vi.fn();
-
-    const watcher = new EvmWatcher({
-      chain: "base",
-      token: "USDC",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      decimals: 6,
-      confirmations: 1,
-      rpcCall: mockRpc,
-      fromBlock: 0,
-      onPayment: vi.fn(),
-    });
-
-    await watcher.poll();
-    expect(mockRpc).not.toHaveBeenCalled(); // no RPC calls at all
-  });
-});