@wopr-network/platform-core 1.64.0 → 1.65.0

package/dist/db/schema/crypto.d.ts

@@ -784,6 +784,57 @@ export declare const paymentMethods: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        keyRingId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key_ring_id";
+            tableName: "payment_methods";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        encoding: import("drizzle-orm/pg-core").PgColumn<{
+            name: "encoding";
+            tableName: "payment_methods";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pluginId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "plugin_id";
+            tableName: "payment_methods";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
             tableName: "payment_methods";
@@ -1237,3 +1288,280 @@ export declare const watcherProcessed: import("drizzle-orm/pg-core").PgTableWith
     };
     dialect: "pg";
 }>;
+/**
+ * Key rings — decouples key material (xpub/seed) from payment methods.
+ * Each key ring maps to a BIP-44 coin type + account index.
+ */
+export declare const keyRings: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "key_rings";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "key_rings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        curve: import("drizzle-orm/pg-core").PgColumn<{
+            name: "curve";
+            tableName: "key_rings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        derivationScheme: import("drizzle-orm/pg-core").PgColumn<{
+            name: "derivation_scheme";
+            tableName: "key_rings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        derivationMode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "derivation_mode";
+            tableName: "key_rings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        keyMaterial: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key_material";
+            tableName: "key_rings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        coinType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "coin_type";
+            tableName: "key_rings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        accountIndex: import("drizzle-orm/pg-core").PgColumn<{
+            name: "account_index";
+            tableName: "key_rings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "key_rings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Pre-derived address pool — for Ed25519 chains that need offline derivation.
+ * Addresses are derived in batches and assigned on demand.
+ */
+export declare const addressPool: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "address_pool";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "address_pool";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        keyRingId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key_ring_id";
+            tableName: "address_pool";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        derivationIndex: import("drizzle-orm/pg-core").PgColumn<{
+            name: "derivation_index";
+            tableName: "address_pool";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        publicKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "public_key";
+            tableName: "address_pool";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        address: import("drizzle-orm/pg-core").PgColumn<{
+            name: "address";
+            tableName: "address_pool";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        assignedTo: import("drizzle-orm/pg-core").PgColumn<{
+            name: "assigned_to";
+            tableName: "address_pool";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "address_pool";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/db/schema/crypto.js

@@ -1,5 +1,5 @@
 import { sql } from "drizzle-orm";
-import { boolean, index, integer, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
+import { boolean, index, integer, pgTable, primaryKey, serial, text, uniqueIndex } from "drizzle-orm/pg-core";
 /**
  * Crypto payment charges — tracks the lifecycle of each payment.
  * reference_id is the charge ID (e.g. "btc:bc1q...").
@@ -82,6 +82,9 @@ export const paymentMethods = pgTable("payment_methods", {
     oracleAssetId: text("oracle_asset_id"), // CoinGecko slug (e.g. "bitcoin", "tron"). Null = stablecoin (1:1 USD) or use token symbol fallback.
     confirmations: integer("confirmations").notNull().default(1),
     nextIndex: integer("next_index").notNull().default(0), // atomic derivation counter, never reuses
+    keyRingId: text("key_ring_id"), // FK to key_rings.id (nullable during migration)
+    encoding: text("encoding"), // address encoding override (e.g. "bech32", "p2pkh", "evm")
+    pluginId: text("plugin_id"), // plugin identifier (e.g. "evm", "utxo", "solana")
     createdAt: text("created_at").notNull().default(sql `(now())`),
 });
 /**
@@ -134,3 +137,32 @@ export const watcherProcessed = pgTable("watcher_processed", {
     txId: text("tx_id").notNull(),
     processedAt: text("processed_at").notNull().default(sql `(now())`),
 }, (table) => [primaryKey({ columns: [table.watcherId, table.txId] })]);
+/**
+ * Key rings — decouples key material (xpub/seed) from payment methods.
+ * Each key ring maps to a BIP-44 coin type + account index.
+ */
+export const keyRings = pgTable("key_rings", {
+    id: text("id").primaryKey(),
+    curve: text("curve").notNull(), // "secp256k1" | "ed25519"
+    derivationScheme: text("derivation_scheme").notNull(), // "bip32" | "slip10" | "ed25519-hd"
+    derivationMode: text("derivation_mode").notNull().default("on-demand"), // "on-demand" | "pre-derived"
+    keyMaterial: text("key_material").notNull().default("{}"), // JSON: { xpub: "..." }
+    coinType: integer("coin_type").notNull(), // BIP-44 coin type
+    accountIndex: integer("account_index").notNull().default(0),
+    createdAt: text("created_at").notNull().default(sql `(now())`),
+}, (table) => [uniqueIndex("key_rings_path_unique").on(table.coinType, table.accountIndex)]);
+/**
+ * Pre-derived address pool — for Ed25519 chains that need offline derivation.
+ * Addresses are derived in batches and assigned on demand.
+ */
+export const addressPool = pgTable("address_pool", {
+    id: serial("id").primaryKey(),
+    keyRingId: text("key_ring_id")
+        .notNull()
+        .references(() => keyRings.id),
+    derivationIndex: integer("derivation_index").notNull(),
+    publicKey: text("public_key").notNull(),
+    address: text("address").notNull(),
+    assignedTo: text("assigned_to"), // charge reference or tenant ID
+    createdAt: text("created_at").notNull().default(sql `(now())`),
+}, (table) => [uniqueIndex("address_pool_ring_index").on(table.keyRingId, table.derivationIndex)]);

package/dist/db/schema/snapshots.d.ts

@@ -92,7 +92,7 @@ export declare const snapshots: import("drizzle-orm/pg-core").PgTableWithColumns
             tableName: "snapshots";
             dataType: "string";
             columnType: "PgText";
-            data: "nightly" | "on-demand" | "pre-restore";
+            data: "on-demand" | "nightly" | "pre-restore";
             driverParam: string;
             notNull: true;
             hasDefault: true;

package/drizzle/migrations/0023_key_rings_table.sql

@@ -0,0 +1,35 @@
+-- Key rings: decouples key material from payment methods
+CREATE TABLE IF NOT EXISTS "key_rings" (
+  "id" text PRIMARY KEY,
+  "curve" text NOT NULL,
+  "derivation_scheme" text NOT NULL,
+  "derivation_mode" text NOT NULL DEFAULT 'on-demand',
+  "key_material" text NOT NULL DEFAULT '{}',
+  "coin_type" integer NOT NULL,
+  "account_index" integer NOT NULL DEFAULT 0,
+  "created_at" text NOT NULL DEFAULT (now())
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "key_rings_path_unique" ON "key_rings" ("coin_type", "account_index");
+--> statement-breakpoint
+
+-- Pre-derived address pool (for Ed25519 chains)
+CREATE TABLE IF NOT EXISTS "address_pool" (
+  "id" serial PRIMARY KEY,
+  "key_ring_id" text NOT NULL REFERENCES "key_rings"("id"),
+  "derivation_index" integer NOT NULL,
+  "public_key" text NOT NULL,
+  "address" text NOT NULL,
+  "assigned_to" text,
+  "created_at" text NOT NULL DEFAULT (now())
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "address_pool_ring_index" ON "address_pool" ("key_ring_id", "derivation_index");
+--> statement-breakpoint
+
+-- Add new columns to payment_methods
+ALTER TABLE "payment_methods" ADD COLUMN IF NOT EXISTS "key_ring_id" text REFERENCES "key_rings"("id");
+--> statement-breakpoint
+ALTER TABLE "payment_methods" ADD COLUMN IF NOT EXISTS "encoding" text;
+--> statement-breakpoint
+ALTER TABLE "payment_methods" ADD COLUMN IF NOT EXISTS "plugin_id" text;

package/drizzle/migrations/0024_backfill_key_rings.sql

@@ -0,0 +1,75 @@
+-- Create key rings from existing payment method xpubs
+-- Each unique (coin_type via path_allocations) gets a key ring
+
+-- EVM chains (coin type 60)
+INSERT INTO "key_rings" ("id", "curve", "derivation_scheme", "derivation_mode", "key_material", "coin_type", "account_index")
+SELECT DISTINCT 'evm-main', 'secp256k1', 'bip32', 'on-demand',
+  json_build_object('xpub', pm.xpub)::text,
+  pa.coin_type, pa.account_index
+FROM path_allocations pa
+JOIN payment_methods pm ON pm.id = pa.chain_id
+WHERE pa.coin_type = 60
+LIMIT 1
+ON CONFLICT DO NOTHING;
+--> statement-breakpoint
+
+-- BTC (coin type 0)
+INSERT INTO "key_rings" ("id", "curve", "derivation_scheme", "derivation_mode", "key_material", "coin_type", "account_index")
+SELECT DISTINCT 'btc-main', 'secp256k1', 'bip32', 'on-demand',
+  json_build_object('xpub', pm.xpub)::text,
+  pa.coin_type, pa.account_index
+FROM path_allocations pa
+JOIN payment_methods pm ON pm.id = pa.chain_id
+WHERE pa.coin_type = 0
+LIMIT 1
+ON CONFLICT DO NOTHING;
+--> statement-breakpoint
+
+-- LTC (coin type 2)
+INSERT INTO "key_rings" ("id", "curve", "derivation_scheme", "derivation_mode", "key_material", "coin_type", "account_index")
+SELECT DISTINCT 'ltc-main', 'secp256k1', 'bip32', 'on-demand',
+  json_build_object('xpub', pm.xpub)::text,
+  pa.coin_type, pa.account_index
+FROM path_allocations pa
+JOIN payment_methods pm ON pm.id = pa.chain_id
+WHERE pa.coin_type = 2
+LIMIT 1
+ON CONFLICT DO NOTHING;
+--> statement-breakpoint
+
+-- DOGE (coin type 3)
+INSERT INTO "key_rings" ("id", "curve", "derivation_scheme", "derivation_mode", "key_material", "coin_type", "account_index")
+SELECT DISTINCT 'doge-main', 'secp256k1', 'bip32', 'on-demand',
+  json_build_object('xpub', pm.xpub)::text,
+  pa.coin_type, pa.account_index
+FROM path_allocations pa
+JOIN payment_methods pm ON pm.id = pa.chain_id
+WHERE pa.coin_type = 3
+LIMIT 1
+ON CONFLICT DO NOTHING;
+--> statement-breakpoint
+
+-- TRON (coin type 195)
+INSERT INTO "key_rings" ("id", "curve", "derivation_scheme", "derivation_mode", "key_material", "coin_type", "account_index")
+SELECT DISTINCT 'tron-main', 'secp256k1', 'bip32', 'on-demand',
+  json_build_object('xpub', pm.xpub)::text,
+  pa.coin_type, pa.account_index
+FROM path_allocations pa
+JOIN payment_methods pm ON pm.id = pa.chain_id
+WHERE pa.coin_type = 195
+LIMIT 1
+ON CONFLICT DO NOTHING;
+--> statement-breakpoint
+
+-- Backfill payment_methods with key_ring_id, encoding, plugin_id
+UPDATE payment_methods SET
+  key_ring_id = CASE
+    WHEN chain IN ('arbitrum','avalanche','base','base-sepolia','bsc','optimism','polygon','sepolia') THEN 'evm-main'
+    WHEN chain = 'bitcoin' THEN 'btc-main'
+    WHEN chain = 'litecoin' THEN 'ltc-main'
+    WHEN chain = 'dogecoin' THEN 'doge-main'
+    WHEN chain = 'tron' THEN 'tron-main'
+  END,
+  encoding = address_type,
+  plugin_id = watcher_type
+WHERE key_ring_id IS NULL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.64.0",
+  "version": "1.65.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -72,6 +72,10 @@
     "./api/routes/verify-email": "./dist/api/routes/verify-email.js",
     "./api/routes/ws-auth": "./dist/api/routes/ws-auth.js",
     "./trpc": "./dist/trpc/index.js",
+    "./crypto-plugin": {
+      "import": "./dist/billing/crypto/plugin/index.js",
+      "types": "./dist/billing/crypto/plugin/index.d.ts"
+    },
     "./*": "./dist/*.js"
   },
   "scripts": {

package/src/billing/crypto/index.ts

@@ -33,6 +33,15 @@ export {
 export * from "./oracle/index.js";
 export type { IPaymentMethodStore, PaymentMethodRecord } from "./payment-method-store.js";
 export { DrizzlePaymentMethodStore } from "./payment-method-store.js";
+export type {
+  IAddressEncoder,
+  IChainPlugin,
+  IChainWatcher,
+  ICurveDeriver,
+  ISweepStrategy,
+  PaymentEvent,
+} from "./plugin/index.js";
+export { PluginRegistry } from "./plugin/index.js";
 export type { CryptoCharge, CryptoChargeStatus, CryptoPaymentState } from "./types.js";
 export type { UnifiedCheckoutDeps, UnifiedCheckoutResult } from "./unified-checkout.js";
 export { createUnifiedCheckout, MIN_CHECKOUT_USD as MIN_PAYMENT_USD, MIN_CHECKOUT_USD } from "./unified-checkout.js";

package/src/billing/crypto/key-server.ts

@@ -364,6 +364,9 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       watcherType: body.watcher_type ?? "evm",
       oracleAssetId: body.oracle_asset_id ?? null,
       confirmations: body.confirmations ?? 6,
+      keyRingId: null,
+      encoding: null,
+      pluginId: null,
     });
 
     // Record the path allocation (idempotent — ignore if already exists)

package/src/billing/crypto/payment-method-store.ts

@@ -22,6 +22,9 @@ export interface PaymentMethodRecord {
   watcherType: string;
   oracleAssetId: string | null;
   confirmations: number;
+  keyRingId: string | null;
+  encoding: string | null;
+  pluginId: string | null;
 }
 
 export interface IPaymentMethodStore {
@@ -98,6 +101,9 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
         watcherType: method.watcherType,
         oracleAssetId: method.oracleAssetId,
         confirmations: method.confirmations,
+        keyRingId: method.keyRingId,
+        encoding: method.encoding,
+        pluginId: method.pluginId,
       })
       .onConflictDoUpdate({
         target: paymentMethods.id,
@@ -119,6 +125,9 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
           watcherType: method.watcherType,
           oracleAssetId: method.oracleAssetId,
           confirmations: method.confirmations,
+          keyRingId: method.keyRingId,
+          encoding: method.encoding,
+          pluginId: method.pluginId,
         },
       });
   }
@@ -164,5 +173,8 @@ function toRecord(row: typeof paymentMethods.$inferSelect): PaymentMethodRecord
     watcherType: row.watcherType,
     oracleAssetId: row.oracleAssetId,
     confirmations: row.confirmations,
+    keyRingId: row.keyRingId,
+    encoding: row.encoding,
+    pluginId: row.pluginId,
   };
 }

package/src/billing/crypto/plugin/__tests__/integration.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import type { IChainPlugin, PaymentEvent, WatcherOpts } from "../interfaces.js";
+import { PluginRegistry } from "../registry.js";
+
+describe("plugin integration — registry → watcher → events", () => {
+  it("full lifecycle: register → create watcher → poll → events", async () => {
+    const mockEvent: PaymentEvent = {
+      chain: "test",
+      token: "TEST",
+      from: "0xsender",
+      to: "0xreceiver",
+      rawAmount: "1000",
+      amountUsdCents: 100,
+      txHash: "0xhash",
+      blockNumber: 42,
+      confirmations: 6,
+      confirmationsRequired: 6,
+    };
+
+    const plugin: IChainPlugin = {
+      pluginId: "test",
+      supportedCurve: "secp256k1",
+      encoders: {},
+      createWatcher: (_opts: WatcherOpts) => ({
+        init: async () => {},
+        poll: async () => [mockEvent],
+        setWatchedAddresses: () => {},
+        getCursor: () => 42,
+        stop: () => {},
+      }),
+      createSweeper: () => ({ scan: async () => [], sweep: async () => [] }),
+      version: 1,
+    };
+
+    const registry = new PluginRegistry();
+    registry.register(plugin);
+
+    const resolved = registry.getOrThrow("test");
+    const watcher = resolved.createWatcher({
+      rpcUrl: "http://localhost:8545",
+      rpcHeaders: {},
+      oracle: {
+        getPrice: async () => ({ priceMicros: 3500_000000 }),
+      },
+      cursorStore: {
+        get: async () => null,
+        save: async () => {},
+        getConfirmationCount: async () => null,
+        saveConfirmationCount: async () => {},
+      },
+      token: "TEST",
+      chain: "test",
+      decimals: 18,
+      confirmations: 6,
+    });
+
+    await watcher.init();
+    const events = await watcher.poll();
+    expect(events).toHaveLength(1);
+    expect(events[0].txHash).toBe("0xhash");
+    expect(watcher.getCursor()).toBe(42);
+    watcher.stop();
+  });
+});