@wopr-network/platform-core 1.64.0 → 1.66.0

package/src/billing/crypto/plugin-watcher-service.ts

@@ -0,0 +1,148 @@
+/**
+ * Plugin-driven watcher service — replaces the hardcoded watcher-service.ts.
+ *
+ * Instead of importing BtcWatcher/EvmWatcher/EthWatcher directly,
+ * this delegates to IChainPlugin.createWatcher() from the plugin registry.
+ * Adding a new chain = register a plugin + INSERT a payment_methods row.
+ *
+ * Payment flow is unchanged:
+ *   plugin.poll() -> PaymentEvent[] -> handlePayment() -> credit + webhook
+ */
+
+import type { DrizzleDb } from "../../db/index.js";
+import type { ICryptoChargeRepository } from "./charge-store.js";
+import type { IWatcherCursorStore } from "./cursor-store.js";
+import type { IPriceOracle } from "./oracle/types.js";
+import type { IPaymentMethodStore, PaymentMethodRecord } from "./payment-method-store.js";
+import type { IChainPlugin, IChainWatcher } from "./plugin/interfaces.js";
+import type { PluginRegistry } from "./plugin/registry.js";
+import { handlePayment } from "./watcher-service.js";
+
+export interface PluginWatcherServiceOpts {
+  db: DrizzleDb;
+  chargeStore: ICryptoChargeRepository;
+  methodStore: IPaymentMethodStore;
+  cursorStore: IWatcherCursorStore;
+  oracle: IPriceOracle;
+  registry: PluginRegistry;
+  pollIntervalMs?: number;
+  log?: (msg: string, meta?: Record<string, unknown>) => void;
+}
+
+/** Map legacy watcher_type values to plugin IDs for backward compatibility. */
+const WATCHER_TYPE_TO_PLUGIN: Record<string, string> = {
+  utxo: "bitcoin",
+  evm: "evm",
+};
+
+function resolvePlugin(registry: PluginRegistry, method: PaymentMethodRecord): IChainPlugin | undefined {
+  // Prefer explicit plugin_id, fall back to watcher_type mapping
+  const id = method.pluginId ?? WATCHER_TYPE_TO_PLUGIN[method.watcherType];
+  return id ? registry.get(id) : undefined;
+}
+
+/**
+ * Boot plugin-driven watchers for all enabled payment methods.
+ *
+ * Returns a cleanup function that stops all poll timers and watchers.
+ */
+export async function startPluginWatchers(opts: PluginWatcherServiceOpts): Promise<() => void> {
+  const { db, chargeStore, methodStore, cursorStore, oracle, registry } = opts;
+  const pollMs = opts.pollIntervalMs ?? 15_000;
+  const log = opts.log ?? (() => {});
+
+  const methods = await methodStore.listEnabled();
+  const timers: ReturnType<typeof setInterval>[] = [];
+  const watchers: IChainWatcher[] = [];
+
+  for (const method of methods) {
+    if (!method.rpcUrl) continue;
+
+    const plugin = resolvePlugin(registry, method);
+    if (!plugin) {
+      log("No plugin found, skipping method", { id: method.id, chain: method.chain, watcherType: method.watcherType });
+      continue;
+    }
+
+    const watcher = plugin.createWatcher({
+      rpcUrl: method.rpcUrl,
+      rpcHeaders: JSON.parse(method.rpcHeaders ?? "{}"),
+      oracle,
+      cursorStore,
+      token: method.token,
+      chain: method.chain,
+      contractAddress: method.contractAddress ?? undefined,
+      decimals: method.decimals,
+      confirmations: method.confirmations,
+    });
+
+    try {
+      await watcher.init();
+    } catch (err) {
+      log("Watcher init failed, skipping", { chain: method.chain, token: method.token, error: String(err) });
+      continue;
+    }
+
+    // Seed watched addresses from active charges
+    const active = await chargeStore.listActiveDepositAddresses();
+    const addrs = active.filter((a) => a.chain === method.chain && a.token === method.token).map((a) => a.address);
+    watcher.setWatchedAddresses(addrs);
+
+    watchers.push(watcher);
+    log(`Plugin watcher started (${method.chain}:${method.token})`, {
+      plugin: plugin.pluginId,
+      addresses: addrs.length,
+    });
+
+    let polling = false;
+    timers.push(
+      setInterval(async () => {
+        if (polling) return;
+        polling = true;
+        try {
+          // Refresh watched addresses each cycle
+          const fresh = await chargeStore.listActiveDepositAddresses();
+          const freshAddrs = fresh
+            .filter((a) => a.chain === method.chain && a.token === method.token)
+            .map((a) => a.address);
+          watcher.setWatchedAddresses(freshAddrs);
+
+          const events = await watcher.poll();
+          for (const ev of events) {
+            log("Plugin payment", {
+              chain: ev.chain,
+              token: ev.token,
+              to: ev.to,
+              txHash: ev.txHash,
+              confirmations: ev.confirmations,
+            });
+            await handlePayment(
+              db,
+              chargeStore,
+              ev.to,
+              ev.rawAmount,
+              {
+                txHash: ev.txHash,
+                confirmations: ev.confirmations,
+                confirmationsRequired: ev.confirmationsRequired,
+                amountReceivedCents: ev.amountUsdCents,
+              },
+              log,
+            );
+          }
+        } catch (err) {
+          log("Plugin poll error", { chain: method.chain, token: method.token, error: String(err) });
+        } finally {
+          polling = false;
+        }
+      }, pollMs),
+    );
+  }
+
+  log("All plugin watchers started", { count: watchers.length, pollMs });
+
+  return () => {
+    for (const t of timers) clearInterval(t);
+    for (const w of watchers) w.stop();
+  };
+}

package/src/db/schema/crypto.ts

@@ -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.
@@ -89,6 +89,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())`),
 });
 
@@ -161,3 +164,42 @@ export const watcherProcessed = pgTable(
   },
   (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)],
+);