@wopr-network/platform-core 1.63.2 → 1.65.0

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/watcher-service.js

@@ -277,13 +277,13 @@ export async function startWatchers(opts) {
     // Address conversion for EVM-watched chains with non-0x address formats (Tron T...).
     // Only applies to chains routed through the EVM watcher but storing non-hex addresses.
     // UTXO chains (DOGE p2pkh) never enter this path — they use the UTXO watcher.
-    const isTronMethod = (method) => method.addressType === "p2pkh" && method.chain === "tron";
+    const isTronMethod = (method) => (method.addressType === "p2pkh" || method.addressType === "keccak-b58check") && method.chain === "tron";
     const toWatcherAddr = (addr, method) => isTronMethod(method) && isTronAddress(addr) ? tronToHex(addr) : addr;
     const fromWatcherAddr = (addr, method) => isTronMethod(method) ? hexToTron(addr) : addr;
     for (const method of nativeEvmMethods) {
         if (!method.rpcUrl)
             continue;
-        const rpcCall = createRpcCaller(method.rpcUrl);
+        const rpcCall = createRpcCaller(method.rpcUrl, JSON.parse(method.rpcHeaders ?? "{}"));
         let latestBlock;
         try {
             const latestHex = (await rpcCall("eth_blockNumber", []));
@@ -352,7 +352,7 @@ export async function startWatchers(opts) {
     for (const method of erc20Methods) {
         if (!method.rpcUrl || !method.contractAddress)
             continue;
-        const rpcCall = createRpcCaller(method.rpcUrl);
+        const rpcCall = createRpcCaller(method.rpcUrl, JSON.parse(method.rpcHeaders ?? "{}"));
         let latestBlock;
         try {
             const latestHex = (await rpcCall("eth_blockNumber", []));
@@ -370,7 +370,7 @@ export async function startWatchers(opts) {
             rpcCall,
             fromBlock: latestBlock,
             watchedAddresses: chainAddresses.map((a) => toWatcherAddr(a, method)),
-            contractAddress: method.contractAddress,
+            contractAddress: toWatcherAddr(method.contractAddress, method),
             decimals: method.decimals,
             confirmations: method.confirmations,
             cursorStore,