@wopr-network/platform-core 1.64.0 → 1.65.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.js

@@ -287,6 +287,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()];
+    }
+}