@wopr-network/platform-core 1.64.0 → 1.66.0

package/dist/billing/crypto/index.d.ts

@@ -13,6 +13,8 @@ export { handleKeyServerWebhook, handleKeyServerWebhook as handleCryptoWebhook,
 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/dist/billing/crypto/index.js

@@ -7,4 +7,5 @@ export { createKeyServerApp } from "./key-server.js";
 export { handleKeyServerWebhook, handleKeyServerWebhook as handleCryptoWebhook, normalizeStatus, } from "./key-server-webhook.js";
 export * from "./oracle/index.js";
 export { DrizzlePaymentMethodStore } from "./payment-method-store.js";
+export { PluginRegistry } from "./plugin/index.js";
 export { createUnifiedCheckout, MIN_CHECKOUT_USD as MIN_PAYMENT_USD, MIN_CHECKOUT_USD } from "./unified-checkout.js";

package/dist/billing/crypto/key-server-entry.js

@@ -8,6 +8,7 @@
  */
 /* biome-ignore-all lint/suspicious/noConsole: standalone entry point */
 import { serve } from "@hono/node-server";
+import { bitcoinPlugin, dogecoinPlugin, evmPlugin, litecoinPlugin, solanaPlugin, tronPlugin, } from "@wopr-network/crypto-plugins";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { migrate } from "drizzle-orm/node-postgres/migrator";
 import pg from "pg";
@@ -21,6 +22,8 @@ import { CoinGeckoOracle } from "./oracle/coingecko.js";
 import { CompositeOracle } from "./oracle/composite.js";
 import { FixedPriceOracle } from "./oracle/fixed.js";
 import { DrizzlePaymentMethodStore } from "./payment-method-store.js";
+import { PluginRegistry } from "./plugin/registry.js";
+import { startPluginWatchers } from "./plugin-watcher-service.js";
 import { startWatchers } from "./watcher-service.js";
 const PORT = Number(process.env.PORT ?? "3100");
 const DATABASE_URL = process.env.DATABASE_URL;
@@ -57,6 +60,15 @@ async function main() {
     }
     const coingecko = new CoinGeckoOracle({ tokenIds: dbTokenIds });
     const oracle = new CompositeOracle(chainlink, coingecko);
+    // Build plugin registry — one plugin per chain family
+    const registry = new PluginRegistry();
+    registry.register(bitcoinPlugin);
+    registry.register(litecoinPlugin);
+    registry.register(dogecoinPlugin);
+    registry.register(evmPlugin);
+    registry.register(tronPlugin);
+    registry.register(solanaPlugin);
+    console.log(`[crypto-key-server] Registered ${registry.list().length} chain plugins:`, registry.list().map((p) => p.pluginId));
     const app = createKeyServerApp({
         db,
         chargeStore,
@@ -64,20 +76,33 @@ async function main() {
         oracle,
         serviceKey: SERVICE_KEY,
         adminToken: ADMIN_TOKEN,
+        registry,
     });
-    // Boot watchers (BTC + EVM) — polls for payments, sends webhooks
+    // Boot plugin-driven watchers — polls for payments, sends webhooks.
+    // Falls back to legacy startWatchers() if USE_LEGACY_WATCHERS=1 is set.
     const cursorStore = new DrizzleWatcherCursorStore(db);
-    const stopWatchers = await startWatchers({
-        db,
-        chargeStore,
-        methodStore,
-        cursorStore,
-        oracle,
-        bitcoindUser: BITCOIND_USER,
-        bitcoindPassword: BITCOIND_PASSWORD,
-        serviceKey: SERVICE_KEY,
-        log: (msg, meta) => console.log(`[watcher] ${msg}`, meta ?? ""),
-    });
+    const useLegacy = process.env.USE_LEGACY_WATCHERS === "1";
+    const stopWatchers = useLegacy
+        ? await startWatchers({
+            db,
+            chargeStore,
+            methodStore,
+            cursorStore,
+            oracle,
+            bitcoindUser: BITCOIND_USER,
+            bitcoindPassword: BITCOIND_PASSWORD,
+            serviceKey: SERVICE_KEY,
+            log: (msg, meta) => console.log(`[watcher] ${msg}`, meta ?? ""),
+        })
+        : await startPluginWatchers({
+            db,
+            chargeStore,
+            methodStore,
+            cursorStore,
+            oracle,
+            registry,
+            log: (msg, meta) => console.log(`[watcher] ${msg}`, meta ?? ""),
+        });
     const server = serve({ fetch: app.fetch, port: PORT });
     console.log(`[crypto-key-server] Listening on :${PORT}`);
     // Graceful shutdown — stop accepting requests, drain watchers, close pool

package/dist/billing/crypto/key-server.d.ts

@@ -1,8 +1,18 @@
+/**
+ * Crypto Key Server — shared address derivation + charge management.
+ *
+ * Deploys on the chain server (pay.wopr.bot) alongside bitcoind.
+ * Products don't run watchers or hold xpubs. They request addresses
+ * and receive webhooks.
+ *
+ * ~200 lines of new code wrapping platform-core's existing crypto modules.
+ */
 import { Hono } from "hono";
 import type { DrizzleDb } from "../../db/index.js";
 import type { ICryptoChargeRepository } from "./charge-store.js";
 import type { IPriceOracle } from "./oracle/types.js";
 import type { IPaymentMethodStore } from "./payment-method-store.js";
+import type { PluginRegistry } from "./plugin/registry.js";
 export interface KeyServerDeps {
     db: DrizzleDb;
     chargeStore: ICryptoChargeRepository;
@@ -12,6 +22,8 @@ export interface KeyServerDeps {
     serviceKey?: string;
     /** Bearer token for admin routes. If unset, admin routes are disabled. */
     adminToken?: string;
+    /** Plugin registry for address encoding. Falls back to address-gen.ts when absent. */
+    registry?: PluginRegistry;
 }
 /**
  * Create the Hono app for the crypto key server.

package/dist/billing/crypto/key-server.js

@@ -7,6 +7,7 @@
  *
  * ~200 lines of new code wrapping platform-core's existing crypto modules.
  */
+import { HDKey } from "@scure/bip32";
 import { eq, sql } from "drizzle-orm";
 import { Hono } from "hono";
 import { derivedAddresses, pathAllocations, paymentMethods } from "../../db/schema/crypto.js";
@@ -21,7 +22,7 @@ import { AssetNotSupportedError } from "./oracle/types.js";
  * address. The unique constraint on derived_addresses.address prevents reuse.
  * On collision, we skip the index and retry (up to maxRetries).
  */
-async function deriveNextAddress(db, chainId, tenantId) {
+async function deriveNextAddress(db, chainId, tenantId, registry) {
     const maxRetries = 10;
     const dbWithTx = db;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -46,7 +47,23 @@ async function deriveNextAddress(db, chainId, tenantId) {
         catch {
             throw new Error(`Invalid encoding_params JSON for chain ${chainId}: ${method.encodingParams}`);
         }
-        const address = deriveAddress(method.xpub, index, method.addressType, encodingParams);
+        // Plugin-driven encoding: look up the plugin, use its encoder.
+        // Falls back to legacy deriveAddress() when no registry or no matching plugin.
+        let address;
+        const pluginId = method.pluginId ?? (method.watcherType === "utxo" ? "bitcoin" : method.watcherType);
+        const plugin = registry?.get(pluginId ?? "");
+        const encodingKey = method.encoding ?? method.addressType;
+        const encoder = plugin?.encoders[encodingKey];
+        if (encoder) {
+            const master = HDKey.fromExtendedKey(method.xpub);
+            const child = master.deriveChild(0).deriveChild(index);
+            if (!child.publicKey)
+                throw new Error("Failed to derive public key");
+            address = encoder.encode(child.publicKey, encodingParams);
+        }
+        else {
+            address = deriveAddress(method.xpub, index, method.addressType, encodingParams);
+        }
         // Step 2: Record in immutable log. If this address was already derived by a
         // sibling chain (shared xpub), the unique constraint fires and we retry
         // with the next index (which is already incremented above).
@@ -121,7 +138,7 @@ export function createKeyServerApp(deps) {
         if (!body.chain)
             return c.json({ error: "chain is required" }, 400);
         const tenantId = c.req.header("X-Tenant-Id");
-        const result = await deriveNextAddress(deps.db, body.chain, tenantId ?? undefined);
+        const result = await deriveNextAddress(deps.db, body.chain, tenantId ?? undefined, deps.registry);
         return c.json(result, 201);
     });
     /** POST /charges — create charge + derive address + start watching */
@@ -131,7 +148,7 @@ export function createKeyServerApp(deps) {
             return c.json({ error: "chain is required and amountUsd must be a positive finite number" }, 400);
         }
         const tenantId = c.req.header("X-Tenant-Id") ?? "unknown";
-        const { address, index, chain, token } = await deriveNextAddress(deps.db, body.chain, tenantId);
+        const { address, index, chain, token } = await deriveNextAddress(deps.db, body.chain, tenantId, deps.registry);
         // Look up payment method for decimals + oracle config
         const method = await deps.methodStore.getById(body.chain);
         if (!method)
@@ -287,6 +304,9 @@ export function createKeyServerApp(deps) {
             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)
         const inserted = (await deps.db

package/dist/billing/crypto/payment-method-store.d.ts

@@ -19,6 +19,9 @@ export interface PaymentMethodRecord {
     watcherType: string;
     oracleAssetId: string | null;
     confirmations: number;
+    keyRingId: string | null;
+    encoding: string | null;
+    pluginId: string | null;
 }
 export interface IPaymentMethodStore {
     /** List all enabled payment methods, ordered by displayOrder. */

package/dist/billing/crypto/payment-method-store.js

@@ -52,6 +52,9 @@ export class DrizzlePaymentMethodStore {
             watcherType: method.watcherType,
             oracleAssetId: method.oracleAssetId,
             confirmations: method.confirmations,
+            keyRingId: method.keyRingId,
+            encoding: method.encoding,
+            pluginId: method.pluginId,
         })
             .onConflictDoUpdate({
             target: paymentMethods.id,
@@ -73,6 +76,9 @@ export class DrizzlePaymentMethodStore {
                 watcherType: method.watcherType,
                 oracleAssetId: method.oracleAssetId,
                 confirmations: method.confirmations,
+                keyRingId: method.keyRingId,
+                encoding: method.encoding,
+                pluginId: method.pluginId,
             },
         });
     }
@@ -114,5 +120,8 @@ function toRecord(row) {
         watcherType: row.watcherType,
         oracleAssetId: row.oracleAssetId,
         confirmations: row.confirmations,
+        keyRingId: row.keyRingId,
+        encoding: row.encoding,
+        pluginId: row.pluginId,
     };
 }

package/dist/billing/crypto/plugin/__tests__/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/billing/crypto/plugin/__tests__/integration.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { PluginRegistry } from "../registry.js";
+describe("plugin integration — registry → watcher → events", () => {
+    it("full lifecycle: register → create watcher → poll → events", async () => {
+        const mockEvent = {
+            chain: "test",
+            token: "TEST",
+            from: "0xsender",
+            to: "0xreceiver",
+            rawAmount: "1000",
+            amountUsdCents: 100,
+            txHash: "0xhash",
+            blockNumber: 42,
+            confirmations: 6,
+            confirmationsRequired: 6,
+        };
+        const plugin = {
+            pluginId: "test",
+            supportedCurve: "secp256k1",
+            encoders: {},
+            createWatcher: (_opts) => ({
+                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();
+    });
+});

package/dist/billing/crypto/plugin/__tests__/interfaces.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/billing/crypto/plugin/__tests__/interfaces.test.js

@@ -0,0 +1,46 @@
+// src/billing/crypto/plugin/__tests__/interfaces.test.ts
+import { describe, expect, it } from "vitest";
+describe("plugin interfaces — type contracts", () => {
+    it("PaymentEvent has required fields", () => {
+        const event = {
+            chain: "ethereum",
+            token: "ETH",
+            from: "0xabc",
+            to: "0xdef",
+            rawAmount: "1000000000000000000",
+            amountUsdCents: 350000,
+            txHash: "0x123",
+            blockNumber: 100,
+            confirmations: 6,
+            confirmationsRequired: 6,
+        };
+        expect(event.chain).toBe("ethereum");
+        expect(event.amountUsdCents).toBe(350000);
+    });
+    it("ICurveDeriver contract is satisfiable", () => {
+        const deriver = {
+            derivePublicKey: (_chain, _index) => new Uint8Array(33),
+            getCurve: () => "secp256k1",
+        };
+        expect(deriver.getCurve()).toBe("secp256k1");
+        expect(deriver.derivePublicKey(0, 0)).toBeInstanceOf(Uint8Array);
+    });
+    it("IAddressEncoder contract is satisfiable", () => {
+        const encoder = {
+            encode: (_pk, _params) => "bc1qtest",
+            encodingType: () => "bech32",
+        };
+        expect(encoder.encodingType()).toBe("bech32");
+        expect(encoder.encode(new Uint8Array(33), { hrp: "bc" })).toBe("bc1qtest");
+    });
+    it("IChainWatcher contract is satisfiable", () => {
+        const watcher = {
+            init: async () => { },
+            poll: async () => [],
+            setWatchedAddresses: () => { },
+            getCursor: () => 0,
+            stop: () => { },
+        };
+        expect(watcher.getCursor()).toBe(0);
+    });
+});

package/dist/billing/crypto/plugin/__tests__/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/billing/crypto/plugin/__tests__/registry.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { PluginRegistry } from "../registry.js";
+function mockPlugin(id, curve = "secp256k1") {
+    return {
+        pluginId: id,
+        supportedCurve: curve,
+        encoders: {},
+        createWatcher: () => ({
+            init: async () => { },
+            poll: async () => [],
+            setWatchedAddresses: () => { },
+            getCursor: () => 0,
+            stop: () => { },
+        }),
+        createSweeper: () => ({ scan: async () => [], sweep: async () => [] }),
+        version: 1,
+    };
+}
+describe("PluginRegistry", () => {
+    it("registers and retrieves a plugin", () => {
+        const reg = new PluginRegistry();
+        reg.register(mockPlugin("evm"));
+        expect(reg.get("evm")).toBeDefined();
+        expect(reg.get("evm")?.pluginId).toBe("evm");
+    });
+    it("throws on duplicate registration", () => {
+        const reg = new PluginRegistry();
+        reg.register(mockPlugin("evm"));
+        expect(() => reg.register(mockPlugin("evm"))).toThrow("already registered");
+    });
+    it("returns undefined for unknown plugin", () => {
+        const reg = new PluginRegistry();
+        expect(reg.get("unknown")).toBeUndefined();
+    });
+    it("lists all registered plugins", () => {
+        const reg = new PluginRegistry();
+        reg.register(mockPlugin("evm"));
+        reg.register(mockPlugin("solana", "ed25519"));
+        expect(reg.list()).toHaveLength(2);
+        expect(reg
+            .list()
+            .map((p) => p.pluginId)
+            .sort()).toEqual(["evm", "solana"]);
+    });
+    it("getOrThrow throws for unknown plugin", () => {
+        const reg = new PluginRegistry();
+        expect(() => reg.getOrThrow("nope")).toThrow("not registered");
+    });
+});

package/dist/billing/crypto/plugin/index.d.ts

@@ -0,0 +1,2 @@
+export type { DepositInfo, EncodingParams, IAddressEncoder, IChainPlugin, IChainWatcher, ICurveDeriver, IPriceOracle, ISweepStrategy, IWatcherCursorStore, KeyPair, PaymentEvent, SweeperOpts, SweepResult, WatcherOpts, } from "./interfaces.js";
+export { PluginRegistry } from "./registry.js";

package/dist/billing/crypto/plugin/index.js

@@ -0,0 +1 @@
+export { PluginRegistry } from "./registry.js";

package/dist/billing/crypto/plugin/interfaces.d.ts

@@ -0,0 +1,97 @@
+export interface PaymentEvent {
+    chain: string;
+    token: string;
+    from: string;
+    to: string;
+    rawAmount: string;
+    amountUsdCents: number;
+    txHash: string;
+    blockNumber: number;
+    confirmations: number;
+    confirmationsRequired: number;
+}
+export interface ICurveDeriver {
+    derivePublicKey(chainIndex: number, addressIndex: number): Uint8Array;
+    getCurve(): "secp256k1" | "ed25519";
+}
+export interface EncodingParams {
+    hrp?: string;
+    version?: string;
+    [key: string]: string | undefined;
+}
+export interface IAddressEncoder {
+    encode(publicKey: Uint8Array, params: EncodingParams): string;
+    encodingType(): string;
+}
+export interface KeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+    address: string;
+    index: number;
+}
+export interface DepositInfo {
+    index: number;
+    address: string;
+    nativeBalance: bigint;
+    tokenBalances: Array<{
+        token: string;
+        balance: bigint;
+        decimals: number;
+    }>;
+}
+export interface SweepResult {
+    index: number;
+    address: string;
+    token: string;
+    amount: string;
+    txHash: string;
+}
+export interface ISweepStrategy {
+    scan(keys: KeyPair[], treasury: string): Promise<DepositInfo[]>;
+    sweep(keys: KeyPair[], treasury: string, dryRun: boolean): Promise<SweepResult[]>;
+}
+export interface IPriceOracle {
+    getPrice(token: string, feedAddress?: string): Promise<{
+        priceMicros: number;
+    }>;
+}
+export interface IWatcherCursorStore {
+    get(watcherId: string): Promise<number | null>;
+    save(watcherId: string, cursor: number): Promise<void>;
+    getConfirmationCount(watcherId: string, txKey: string): Promise<number | null>;
+    saveConfirmationCount(watcherId: string, txKey: string, count: number): Promise<void>;
+}
+export interface WatcherOpts {
+    rpcUrl: string;
+    rpcHeaders: Record<string, string>;
+    oracle: IPriceOracle;
+    cursorStore: IWatcherCursorStore;
+    token: string;
+    chain: string;
+    contractAddress?: string;
+    decimals: number;
+    confirmations: number;
+}
+export interface SweeperOpts {
+    rpcUrl: string;
+    rpcHeaders: Record<string, string>;
+    token: string;
+    chain: string;
+    contractAddress?: string;
+    decimals: number;
+}
+export interface IChainWatcher {
+    init(): Promise<void>;
+    poll(): Promise<PaymentEvent[]>;
+    setWatchedAddresses(addresses: string[]): void;
+    getCursor(): number;
+    stop(): void;
+}
+export interface IChainPlugin {
+    pluginId: string;
+    supportedCurve: "secp256k1" | "ed25519";
+    encoders: Record<string, IAddressEncoder>;
+    createWatcher(opts: WatcherOpts): IChainWatcher;
+    createSweeper(opts: SweeperOpts): ISweepStrategy;
+    version: number;
+}

package/dist/billing/crypto/plugin/interfaces.js

@@ -0,0 +1,2 @@
+// src/billing/crypto/plugin/interfaces.ts
+export {};

package/dist/billing/crypto/plugin/registry.d.ts

@@ -0,0 +1,8 @@
+import type { IChainPlugin } from "./interfaces.js";
+export declare class PluginRegistry {
+    private plugins;
+    register(plugin: IChainPlugin): void;
+    get(pluginId: string): IChainPlugin | undefined;
+    getOrThrow(pluginId: string): IChainPlugin;
+    list(): IChainPlugin[];
+}

package/dist/billing/crypto/plugin/registry.js

@@ -0,0 +1,21 @@
+export class PluginRegistry {
+    plugins = new Map();
+    register(plugin) {
+        if (this.plugins.has(plugin.pluginId)) {
+            throw new Error(`Plugin "${plugin.pluginId}" is already registered`);
+        }
+        this.plugins.set(plugin.pluginId, plugin);
+    }
+    get(pluginId) {
+        return this.plugins.get(pluginId);
+    }
+    getOrThrow(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        if (!plugin)
+            throw new Error(`Plugin "${pluginId}" is not registered`);
+        return plugin;
+    }
+    list() {
+        return [...this.plugins.values()];
+    }
+}

package/dist/billing/crypto/plugin-watcher-service.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 } from "./payment-method-store.js";
+import type { PluginRegistry } from "./plugin/registry.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;
+}
+/**
+ * Boot plugin-driven watchers for all enabled payment methods.
+ *
+ * Returns a cleanup function that stops all poll timers and watchers.
+ */
+export declare function startPluginWatchers(opts: PluginWatcherServiceOpts): Promise<() => void>;