@wopr-network/platform-core 1.67.0 → 1.67.1

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

@@ -1,64 +0,0 @@
-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();
-  });
-});

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

@@ -1,51 +0,0 @@
-// src/billing/crypto/plugin/__tests__/interfaces.test.ts
-import { describe, expect, it } from "vitest";
-import type { EncodingParams, IAddressEncoder, IChainWatcher, ICurveDeriver, PaymentEvent } from "../interfaces.js";
-
-describe("plugin interfaces — type contracts", () => {
-  it("PaymentEvent has required fields", () => {
-    const event: PaymentEvent = {
-      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: ICurveDeriver = {
-      derivePublicKey: (_chain: number, _index: number) => new Uint8Array(33),
-      getCurve: () => "secp256k1",
-    };
-    expect(deriver.getCurve()).toBe("secp256k1");
-    expect(deriver.derivePublicKey(0, 0)).toBeInstanceOf(Uint8Array);
-  });
-
-  it("IAddressEncoder contract is satisfiable", () => {
-    const encoder: IAddressEncoder = {
-      encode: (_pk: Uint8Array, _params: EncodingParams) => "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: IChainWatcher = {
-      init: async () => {},
-      poll: async () => [],
-      setWatchedAddresses: () => {},
-      getCursor: () => 0,
-      stop: () => {},
-    };
-    expect(watcher.getCursor()).toBe(0);
-  });
-});

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

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { IChainPlugin } from "../interfaces.js";
-import { PluginRegistry } from "../registry.js";
-
-function mockPlugin(id: string, curve: "secp256k1" | "ed25519" = "secp256k1"): IChainPlugin {
-  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/src/billing/crypto/plugin/index.ts

@@ -1,17 +0,0 @@
-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/src/billing/crypto/plugin/interfaces.ts

@@ -1,106 +0,0 @@
-// src/billing/crypto/plugin/interfaces.ts
-
-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/src/billing/crypto/plugin/registry.ts

@@ -1,26 +0,0 @@
-import type { IChainPlugin } from "./interfaces.js";
-
-export class PluginRegistry {
-  private plugins = new Map<string, IChainPlugin>();
-
-  register(plugin: IChainPlugin): void {
-    if (this.plugins.has(plugin.pluginId)) {
-      throw new Error(`Plugin "${plugin.pluginId}" is already registered`);
-    }
-    this.plugins.set(plugin.pluginId, plugin);
-  }
-
-  get(pluginId: string): IChainPlugin | undefined {
-    return this.plugins.get(pluginId);
-  }
-
-  getOrThrow(pluginId: string): IChainPlugin {
-    const plugin = this.plugins.get(pluginId);
-    if (!plugin) throw new Error(`Plugin "${pluginId}" is not registered`);
-    return plugin;
-  }
-
-  list(): IChainPlugin[] {
-    return [...this.plugins.values()];
-  }
-}

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

@@ -1,148 +0,0 @@
-/**
- * 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/billing/crypto/tron/__tests__/address-convert.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { hexToTron, isTronAddress, tronToHex } from "../address-convert.js";
-
-// Known Tron address / hex pair (Tron foundation address)
-const TRON_ADDR = "TJCnKsPa7y5okkXvQAidZBzqx3QyQ6sxMW";
-const HEX_ADDR = "0x5a523b449890854c8fc460ab602df9f31fe4293f";
-
-describe("tronToHex", () => {
-  it("converts T... to 0x hex", () => {
-    const hex = tronToHex(TRON_ADDR);
-    expect(hex).toBe(HEX_ADDR);
-  });
-
-  it("rejects non-Tron address", () => {
-    expect(() => tronToHex("0x1234")).toThrow("Not a Tron address");
-  });
-
-  it("rejects invalid checksum", () => {
-    // Flip last character
-    const bad = `${TRON_ADDR.slice(0, -1)}X`;
-    expect(() => tronToHex(bad)).toThrow();
-  });
-});
-
-describe("hexToTron", () => {
-  it("converts 0x hex to T...", () => {
-    const tron = hexToTron(HEX_ADDR);
-    expect(tron).toBe(TRON_ADDR);
-  });
-
-  it("handles hex without 0x prefix", () => {
-    const tron = hexToTron(HEX_ADDR.slice(2));
-    expect(tron).toBe(TRON_ADDR);
-  });
-
-  it("rejects wrong length", () => {
-    expect(() => hexToTron("0x1234")).toThrow("Invalid hex address length");
-  });
-});
-
-describe("roundtrip", () => {
-  it("tronToHex → hexToTron is identity", () => {
-    const hex = tronToHex(TRON_ADDR);
-    const back = hexToTron(hex);
-    expect(back).toBe(TRON_ADDR);
-  });
-
-  it("hexToTron → tronToHex is identity", () => {
-    const tron = hexToTron(HEX_ADDR);
-    const back = tronToHex(tron);
-    expect(back).toBe(HEX_ADDR);
-  });
-});
-
-describe("isTronAddress", () => {
-  it("returns true for T... address", () => {
-    expect(isTronAddress(TRON_ADDR)).toBe(true);
-  });
-
-  it("returns false for 0x address", () => {
-    expect(isTronAddress(HEX_ADDR)).toBe(false);
-  });
-
-  it("returns false for BTC address", () => {
-    expect(isTronAddress("bc1qtest")).toBe(false);
-  });
-});

package/src/billing/crypto/tron/address-convert.ts

@@ -1,89 +0,0 @@
-/**
- * Tron address conversion — T... Base58Check ↔ 0x hex.
- *
- * Tron addresses are 21 bytes: 0x41 prefix + 20-byte address.
- * The JSON-RPC layer strips the 0x41 and returns standard 0x-prefixed hex.
- * We need to convert between the two at the watcher boundary.
- */
-import { sha256 } from "@noble/hashes/sha2.js";
-
-const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-
-function base58decode(s: string): Uint8Array {
-  // Count leading '1' characters (each represents a 0x00 byte)
-  let leadingZeros = 0;
-  for (const ch of s) {
-    if (ch !== "1") break;
-    leadingZeros++;
-  }
-  let num = 0n;
-  for (const ch of s) {
-    const idx = BASE58_ALPHABET.indexOf(ch);
-    if (idx < 0) throw new Error(`Invalid base58 character: ${ch}`);
-    num = num * 58n + BigInt(idx);
-  }
-  const hex = num.toString(16).padStart(2, "0");
-  const dataBytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < dataBytes.length; i++) dataBytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  // Prepend leading zero bytes
-  const result = new Uint8Array(leadingZeros + dataBytes.length);
-  result.set(dataBytes, leadingZeros);
-  return result;
-}
-
-/**
- * Convert a Tron T... address to 0x hex (20 bytes, no 0x41 prefix).
- * For feeding addresses to the EVM watcher JSON-RPC filters.
- */
-export function tronToHex(tronAddr: string): string {
-  if (!tronAddr.startsWith("T")) throw new Error(`Not a Tron address: ${tronAddr}`);
-  const decoded = base58decode(tronAddr);
-  // decoded: [0x41, ...20 bytes address..., ...4 bytes checksum]
-  // Verify checksum
-  const payload = decoded.slice(0, 21);
-  const checksum = sha256(sha256(payload)).slice(0, 4);
-  for (let i = 0; i < 4; i++) {
-    if (decoded[21 + i] !== checksum[i]) throw new Error(`Invalid checksum for Tron address: ${tronAddr}`);
-  }
-  // Strip 0x41 prefix, return 20-byte hex with 0x prefix
-  const addrBytes = payload.slice(1);
-  return `0x${Array.from(addrBytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
-}
-
-/**
- * Convert a 0x hex address (20 bytes) back to Tron T... Base58Check.
- * For converting watcher event addresses back to DB format.
- */
-export function hexToTron(hexAddr: string): string {
-  const hex = hexAddr.startsWith("0x") ? hexAddr.slice(2) : hexAddr;
-  if (hex.length !== 40) throw new Error(`Invalid hex address length: ${hex.length}`);
-  // Build payload: 0x41 + 20 bytes
-  const payload = new Uint8Array(21);
-  payload[0] = 0x41;
-  for (let i = 0; i < 20; i++) payload[i + 1] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  // Compute checksum
-  const checksum = sha256(sha256(payload)).slice(0, 4);
-  const full = new Uint8Array(25);
-  full.set(payload);
-  full.set(checksum, 21);
-  // Base58 encode
-  let num = 0n;
-  for (const byte of full) num = num * 256n + BigInt(byte);
-  let encoded = "";
-  while (num > 0n) {
-    encoded = BASE58_ALPHABET[Number(num % 58n)] + encoded;
-    num = num / 58n;
-  }
-  for (const byte of full) {
-    if (byte !== 0) break;
-    encoded = `1${encoded}`;
-  }
-  return encoded;
-}
-
-/**
- * Check if an address is a Tron T... address.
- */
-export function isTronAddress(addr: string): boolean {
-  return addr.startsWith("T") && addr.length >= 33 && addr.length <= 35;
-}