@wopr-network/platform-core 1.66.1 → 1.67.1

package/src/billing/crypto/oracle/__tests__/convert.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { centsToNative, nativeToCents } from "../convert.js";
-
-describe("centsToNative", () => {
-  it("converts $50 to ETH wei at $3,500", () => {
-    // 5000 cents × 10000 × 10^18 / 3_500_000_000 micros = 14285714285714285n wei
-    const wei = centsToNative(5000, 3_500_000_000, 18);
-    expect(wei).toBe(14_285_714_285_714_285n);
-  });
-
-  it("converts $50 to BTC sats at $65,000", () => {
-    // 5000 cents × 10000 × 10^8 / 65_000_000_000 micros = 76923n sats
-    const sats = centsToNative(5000, 65_000_000_000, 8);
-    expect(sats).toBe(76_923n);
-  });
-
-  it("converts $50 to DOGE at $0.094147", () => {
-    // 5000 cents × 10000 × 10^8 / 94_147 micros = 53_107_898_982n base units (531.08 DOGE)
-    const dogeUnits = centsToNative(5000, 94_147, 8);
-    expect(Number(dogeUnits) / 1e8).toBeCloseTo(531.08, 0);
-  });
-
-  it("converts $50 to LTC at $55.79", () => {
-    // 5000 cents × 10000 × 10^8 / 55_790_000 micros = 89_622_512n base units (0.896 LTC)
-    const ltcUnits = centsToNative(5000, 55_790_000, 8);
-    expect(Number(ltcUnits) / 1e8).toBeCloseTo(0.896, 2);
-  });
-
-  it("converts $100 to ETH wei at $2,000", () => {
-    // 10000 cents × 10000 × 10^18 / 2_000_000_000 micros = 50_000_000_000_000_000n (0.05 ETH)
-    const wei = centsToNative(10_000, 2_000_000_000, 18);
-    expect(wei).toBe(50_000_000_000_000_000n);
-  });
-
-  it("rejects non-integer amountCents", () => {
-    expect(() => centsToNative(50.5, 3_500_000_000, 18)).toThrow("positive integer");
-  });
-
-  it("rejects zero amountCents", () => {
-    expect(() => centsToNative(0, 3_500_000_000, 18)).toThrow("positive integer");
-  });
-
-  it("rejects zero priceMicros", () => {
-    expect(() => centsToNative(5000, 0, 18)).toThrow("positive integer");
-  });
-
-  it("rejects negative decimals", () => {
-    expect(() => centsToNative(5000, 3_500_000_000, -1)).toThrow("non-negative integer");
-  });
-});
-
-describe("nativeToCents", () => {
-  it("converts ETH wei back to cents at $3,500", () => {
-    // 14285714285714285n × 3_500_000_000 / (10000 × 10^18) = 4999 cents (truncated)
-    const cents = nativeToCents(14_285_714_285_714_285n, 3_500_000_000, 18);
-    expect(cents).toBe(4999);
-  });
-
-  it("converts BTC sats back to cents at $65,000", () => {
-    // 76923n × 65_000_000_000 / (10000 × 10^8) = 4999 cents
-    const cents = nativeToCents(76_923n, 65_000_000_000, 8);
-    expect(cents).toBe(4999);
-  });
-
-  it("exact round-trip for clean division", () => {
-    // 0.05 ETH at $2,000 = $100
-    const cents = nativeToCents(50_000_000_000_000_000n, 2_000_000_000, 18);
-    expect(cents).toBe(10_000); // $100.00
-  });
-
-  it("rejects negative rawAmount", () => {
-    expect(() => nativeToCents(-1n, 3_500_000_000, 18)).toThrow("non-negative");
-  });
-});

package/src/billing/crypto/oracle/__tests__/fixed.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { FixedPriceOracle } from "../fixed.js";
-
-describe("FixedPriceOracle", () => {
-  it("returns default ETH price", async () => {
-    const oracle = new FixedPriceOracle();
-    const result = await oracle.getPrice("ETH");
-    expect(result.priceMicros).toBe(3_500_000_000); // $3,500
-    expect(result.updatedAt).toBeInstanceOf(Date);
-  });
-
-  it("returns default BTC price", async () => {
-    const oracle = new FixedPriceOracle();
-    const result = await oracle.getPrice("BTC");
-    expect(result.priceMicros).toBe(65_000_000_000); // $65,000
-  });
-
-  it("accepts custom prices", async () => {
-    const oracle = new FixedPriceOracle({ ETH: 2_000_000_000, BTC: 50_000_000_000 });
-    expect((await oracle.getPrice("ETH")).priceMicros).toBe(2_000_000_000);
-    expect((await oracle.getPrice("BTC")).priceMicros).toBe(50_000_000_000);
-  });
-});

package/src/billing/crypto/oracle/chainlink.ts

@@ -1,86 +0,0 @@
-import type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";
-
-/**
- * Chainlink price feed addresses on Base mainnet.
- * These are ERC-1967 proxy contracts — addresses are stable.
- */
-const FEED_ADDRESSES: Record<PriceAsset, `0x${string}`> = {
-  ETH: "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70",
-  BTC: "0x64c911996D3c6aC71f9b455B1E8E7266BcbD848F",
-};
-
-/** Function selector for latestRoundData(). */
-const LATEST_ROUND_DATA = "0xfeaf968c";
-
-/** Default max staleness: 1 hour. */
-const DEFAULT_MAX_STALENESS_MS = 60 * 60 * 1000;
-
-type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
-
-export interface ChainlinkOracleOpts {
-  rpcCall: RpcCall;
-  /** Override feed addresses (e.g. for testnet or Anvil forks). */
-  feedAddresses?: Partial<Record<PriceAsset, `0x${string}`>>;
-  /** Maximum age of price data before rejecting (ms). Default: 1 hour. */
-  maxStalenessMs?: number;
-}
-
-/**
- * On-chain Chainlink price oracle.
- *
- * Reads latestRoundData() from Chainlink aggregator contracts via eth_call.
- * No API key, no rate limits — just an RPC call to our own node.
- *
- * Chainlink USD feeds use 8 decimals. We convert to integer USD cents:
- *   priceMicros = answer / 100  (i.e. answer / 10^8 * 10^6)
- */
-export class ChainlinkOracle implements IPriceOracle {
-  private readonly rpc: RpcCall;
-  private readonly feeds: Map<string, `0x${string}`>;
-  private readonly maxStalenessMs: number;
-
-  constructor(opts: ChainlinkOracleOpts) {
-    this.rpc = opts.rpcCall;
-    this.feeds = new Map(Object.entries({ ...FEED_ADDRESSES, ...opts.feedAddresses })) as Map<string, `0x${string}`>;
-    this.maxStalenessMs = opts.maxStalenessMs ?? DEFAULT_MAX_STALENESS_MS;
-  }
-
-  async getPrice(asset: PriceAsset, feedAddress?: `0x${string}`): Promise<PriceResult> {
-    const resolvedFeed = feedAddress ?? this.feeds.get(asset);
-    if (!resolvedFeed) throw new Error(`No price feed for asset: ${asset}`);
-
-    const result = (await this.rpc("eth_call", [{ to: resolvedFeed, data: LATEST_ROUND_DATA }, "latest"])) as string;
-
-    // ABI decode latestRoundData() return:
-    //   [0]  roundId       (uint80)  — skip
-    //   [1]  answer        (int256)  — price × 10^8
-    //   [2]  startedAt     (uint256) — skip
-    //   [3]  updatedAt     (uint256) — unix seconds
-    //   [4]  answeredInRound (uint80) — skip
-    const hex = result.slice(2);
-    if (hex.length < 320) {
-      throw new Error(`Malformed Chainlink response for ${asset}: expected 320 hex chars, got ${hex.length}`);
-    }
-
-    const answer = BigInt(`0x${hex.slice(64, 128)}`);
-    const updatedAtSec = Number(BigInt(`0x${hex.slice(192, 256)}`));
-    const updatedAt = new Date(updatedAtSec * 1000);
-
-    // Staleness guard.
-    const ageMs = Date.now() - updatedAt.getTime();
-    if (ageMs > this.maxStalenessMs) {
-      throw new Error(
-        `Price feed for ${asset} is stale (${Math.round(ageMs / 1000)}s old, max ${Math.round(this.maxStalenessMs / 1000)}s)`,
-      );
-    }
-
-    // Chainlink USD feeds: 8 decimals. answer / 100 = microdollars (10^-6 USD).
-    // e.g. BTC at $70,315 → answer = 7_031_500_000_000 → 70_315_000_000 microdollars
-    const priceMicros = Number(answer / 100n);
-    if (priceMicros <= 0) {
-      throw new Error(`Invalid price for ${asset}: ${priceMicros} microdollars`);
-    }
-
-    return { priceMicros, updatedAt };
-  }
-}

package/src/billing/crypto/oracle/coingecko.ts

@@ -1,96 +0,0 @@
-import type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";
-import { AssetNotSupportedError } from "./types.js";
-
-/**
- * Token symbol → CoinGecko API ID mapping.
- * CoinGecko uses lowercase slugs, not ticker symbols.
- */
-const COINGECKO_IDS: Record<string, string> = {
-  BTC: "bitcoin",
-  ETH: "ethereum",
-  DOGE: "dogecoin",
-  LTC: "litecoin",
-  SOL: "solana",
-  LINK: "chainlink",
-  UNI: "uniswap",
-  AERO: "aerodrome-finance",
-  TRX: "tron",
-  BNB: "binancecoin",
-  POL: "matic-network",
-  AVAX: "avalanche-2",
-};
-
-/** Default cache TTL: 60 seconds. CoinGecko free tier allows 10-30 req/min. */
-const DEFAULT_CACHE_TTL_MS = 60_000;
-
-interface CachedPrice {
-  priceMicros: number;
-  updatedAt: Date;
-  fetchedAt: number;
-}
-
-export interface CoinGeckoOracleOpts {
-  /** Override token→id mapping. */
-  tokenIds?: Record<string, string>;
-  /** Cache TTL in ms. Default: 60s. */
-  cacheTtlMs?: number;
-  /** Custom fetch function (for testing). */
-  fetchFn?: typeof fetch;
-}
-
-/**
- * CoinGecko price oracle — free API, no key required.
- * Used for assets without Chainlink on-chain feeds (DOGE, LTC).
- * Caches prices to stay within rate limits.
- */
-export class CoinGeckoOracle implements IPriceOracle {
-  private readonly ids: Record<string, string>;
-  private readonly cacheTtlMs: number;
-  private readonly fetchFn: typeof fetch;
-  private readonly cache = new Map<string, CachedPrice>();
-
-  constructor(opts: CoinGeckoOracleOpts = {}) {
-    this.ids = { ...COINGECKO_IDS, ...opts.tokenIds };
-    this.cacheTtlMs = opts.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
-    this.fetchFn = opts.fetchFn ?? fetch;
-  }
-
-  async getPrice(asset: PriceAsset, _feedAddress?: `0x${string}`): Promise<PriceResult> {
-    const cached = this.cache.get(asset);
-    if (cached && Date.now() - cached.fetchedAt < this.cacheTtlMs) {
-      return { priceMicros: cached.priceMicros, updatedAt: cached.updatedAt };
-    }
-
-    const coinId = this.ids[asset];
-    if (!coinId) throw new AssetNotSupportedError(asset);
-
-    const url = `https://api.coingecko.com/api/v3/simple/price?ids=${coinId}&vs_currencies=usd`;
-    try {
-      const res = await this.fetchFn(url);
-      if (!res.ok) {
-        throw new Error(`CoinGecko API error for ${asset}: ${res.status} ${res.statusText}`);
-      }
-
-      const data = (await res.json()) as Record<string, { usd?: number }>;
-      const usdPrice = data[coinId]?.usd;
-      if (usdPrice === undefined || usdPrice <= 0) {
-        throw new Error(`Invalid CoinGecko price for ${asset}: ${usdPrice}`);
-      }
-
-      const priceMicros = Math.round(usdPrice * 1_000_000);
-      const updatedAt = new Date();
-
-      this.cache.set(asset, { priceMicros, updatedAt, fetchedAt: Date.now() });
-
-      return { priceMicros, updatedAt };
-    } catch (err) {
-      // Serve stale cache on transient failure (rate limit, network error).
-      // A slightly old price is better than rejecting the charge entirely.
-      const stale = this.cache.get(asset);
-      if (stale) {
-        return { priceMicros: stale.priceMicros, updatedAt: stale.updatedAt };
-      }
-      throw err;
-    }
-  }
-}

package/src/billing/crypto/oracle/composite.ts

@@ -1,35 +0,0 @@
-import type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";
-
-/**
- * Composite oracle — tries primary (Chainlink on-chain), falls back to secondary (CoinGecko).
- *
- * When a feedAddress is provided (from payment_methods.oracle_address), the primary
- * oracle is used with that address. When no feed exists or the primary fails,
- * the fallback oracle is consulted.
- */
-export class CompositeOracle implements IPriceOracle {
-  constructor(
-    private readonly primary: IPriceOracle,
-    private readonly fallback: IPriceOracle,
-  ) {}
-
-  async getPrice(asset: PriceAsset, feedAddress?: `0x${string}`): Promise<PriceResult> {
-    // If a specific feed address is provided, try the primary (Chainlink) first
-    if (feedAddress) {
-      try {
-        return await this.primary.getPrice(asset, feedAddress);
-      } catch {
-        // Primary failed (stale, network error) — fall through to fallback
-      }
-    }
-
-    // Try primary without explicit feed (uses built-in feed map for BTC/ETH)
-    try {
-      return await this.primary.getPrice(asset);
-    } catch {
-      // No feed configured or call failed — use fallback
-    }
-
-    return this.fallback.getPrice(asset);
-  }
-}

package/src/billing/crypto/oracle/convert.ts

@@ -1,53 +0,0 @@
-/**
- * Price units: **microdollars** (1 microdollar = $0.000001 = 10^-6 USD).
- *
- * Why not cents? DOGE at $0.094 rounds to 9 cents — 6% error.
- * Microdollars give 6 decimal places: $0.094147 = 94,147 microdollars.
- *
- * Chainlink feeds: 8 decimals → answer / 100 = microdollars.
- * CoinGecko: Math.round(usd * 1_000_000) = microdollars.
- * All math is integer bigint — no floating point.
- */
-
-/** Microdollars per cent. Multiply amountCents by this to get microdollars. */
-const MICROS_PER_CENT = 10_000n;
-
-/**
- * Convert USD cents to native token amount using a price in microdollars.
- *
- * Formula: rawAmount = (amountCents × 10_000) × 10^decimals / priceMicros
- *
- * Examples:
- *   $50 in BTC at $70,315:  centsToNative(5000, 70_315_000_000, 8) = 71,119 sats
- *   $50 in DOGE at $0.094:  centsToNative(5000, 94_147, 8) = 53,107,898,982 base units (531.08 DOGE)
- *
- * Integer math only. No floating point.
- */
-export function centsToNative(amountCents: number, priceMicros: number, decimals: number): bigint {
-  if (!Number.isInteger(amountCents) || amountCents <= 0) {
-    throw new Error(`amountCents must be a positive integer, got ${amountCents}`);
-  }
-  if (!Number.isInteger(priceMicros) || priceMicros <= 0) {
-    throw new Error(`priceMicros must be a positive integer, got ${priceMicros}`);
-  }
-  if (!Number.isInteger(decimals) || decimals < 0) {
-    throw new Error(`decimals must be a non-negative integer, got ${decimals}`);
-  }
-  // Convert amountCents to microdollars to match priceMicros units
-  return (BigInt(amountCents) * MICROS_PER_CENT * 10n ** BigInt(decimals)) / BigInt(priceMicros);
-}
-
-/**
- * Convert native token amount back to USD cents using a price in microdollars.
- *
- * Inverse of centsToNative. Truncates fractional cents.
- *
- * Integer math only.
- */
-export function nativeToCents(rawAmount: bigint, priceMicros: number, decimals: number): number {
-  if (rawAmount < 0n) throw new Error("rawAmount must be non-negative");
-  if (!Number.isInteger(priceMicros) || priceMicros <= 0) {
-    throw new Error(`priceMicros must be a positive integer, got ${priceMicros}`);
-  }
-  return Number((rawAmount * BigInt(priceMicros)) / (MICROS_PER_CENT * 10n ** BigInt(decimals)));
-}

package/src/billing/crypto/oracle/fixed.ts

@@ -1,25 +0,0 @@
-import type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";
-
-/**
- * Fixed-price oracle for testing and local dev (Anvil, regtest).
- * Returns hardcoded prices in microdollars — no RPC calls.
- */
-export class FixedPriceOracle implements IPriceOracle {
-  private readonly prices: Record<string, number>;
-
-  constructor(prices: Partial<Record<PriceAsset, number>> = {}) {
-    this.prices = {
-      ETH: 3_500_000_000, // $3,500 in microdollars
-      BTC: 65_000_000_000, // $65,000 in microdollars
-      DOGE: 94_000, // $0.094 in microdollars
-      LTC: 55_000_000, // $55 in microdollars
-      ...prices,
-    };
-  }
-
-  async getPrice(asset: PriceAsset, _feedAddress?: `0x${string}`): Promise<PriceResult> {
-    const priceMicros = this.prices[asset];
-    if (priceMicros === undefined) throw new Error(`No fixed price for ${asset}`);
-    return { priceMicros, updatedAt: new Date() };
-  }
-}

package/src/billing/crypto/oracle/index.ts

@@ -1,9 +0,0 @@
-export type { ChainlinkOracleOpts } from "./chainlink.js";
-export { ChainlinkOracle } from "./chainlink.js";
-export type { CoinGeckoOracleOpts } from "./coingecko.js";
-export { CoinGeckoOracle } from "./coingecko.js";
-export { CompositeOracle } from "./composite.js";
-export { centsToNative, nativeToCents } from "./convert.js";
-export { FixedPriceOracle } from "./fixed.js";
-export type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";
-export { AssetNotSupportedError } from "./types.js";

package/src/billing/crypto/oracle/types.ts

@@ -1,28 +0,0 @@
-/** Assets with Chainlink price feeds. */
-export type PriceAsset = string;
-
-/** Thrown when no oracle supports a given asset (not a transient failure). */
-export class AssetNotSupportedError extends Error {
-  constructor(asset: string) {
-    super(`No price oracle supports asset: ${asset}`);
-    this.name = "AssetNotSupportedError";
-  }
-}
-
-/** Result from a price oracle query. */
-export interface PriceResult {
-  /** Microdollars per 1 unit of asset (integer, 10^-6 USD). */
-  priceMicros: number;
-  /** When the price was last updated on-chain. */
-  updatedAt: Date;
-}
-
-/** Read-only price oracle. */
-export interface IPriceOracle {
-  /**
-   * Get the current USD price for an asset.
-   * @param asset — token symbol (e.g. "BTC", "DOGE")
-   * @param feedAddress — optional Chainlink feed address override (from payment_methods.oracle_address)
-   */
-  getPrice(asset: PriceAsset, feedAddress?: `0x${string}`): Promise<PriceResult>;
-}

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";