@wopr-network/platform-core 1.19.0 → 1.21.0

package/dist/billing/crypto/btc/__tests__/address-gen.test.d.ts

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

package/dist/billing/crypto/btc/__tests__/address-gen.test.js

@@ -0,0 +1,44 @@
+import { HDKey } from "@scure/bip32";
+import { describe, expect, it } from "vitest";
+import { deriveBtcAddress, deriveBtcTreasury } from "../address-gen.js";
+function makeTestXpub() {
+    const seed = new Uint8Array(32);
+    seed[0] = 1;
+    const master = HDKey.fromMasterSeed(seed);
+    return master.derive("m/44'/0'/0'").publicExtendedKey;
+}
+const TEST_XPUB = makeTestXpub();
+describe("deriveBtcAddress", () => {
+    it("derives a valid bech32 address", () => {
+        const addr = deriveBtcAddress(TEST_XPUB, 0);
+        expect(addr).toMatch(/^bc1q[a-z0-9]+$/);
+    });
+    it("derives different addresses for different indices", () => {
+        const a = deriveBtcAddress(TEST_XPUB, 0);
+        const b = deriveBtcAddress(TEST_XPUB, 1);
+        expect(a).not.toBe(b);
+    });
+    it("is deterministic", () => {
+        const a = deriveBtcAddress(TEST_XPUB, 42);
+        const b = deriveBtcAddress(TEST_XPUB, 42);
+        expect(a).toBe(b);
+    });
+    it("uses tb prefix for testnet/regtest", () => {
+        const addr = deriveBtcAddress(TEST_XPUB, 0, "testnet");
+        expect(addr).toMatch(/^tb1q[a-z0-9]+$/);
+    });
+    it("rejects negative index", () => {
+        expect(() => deriveBtcAddress(TEST_XPUB, -1)).toThrow("Invalid");
+    });
+});
+describe("deriveBtcTreasury", () => {
+    it("derives a valid bech32 address", () => {
+        const addr = deriveBtcTreasury(TEST_XPUB);
+        expect(addr).toMatch(/^bc1q[a-z0-9]+$/);
+    });
+    it("differs from deposit address at index 0", () => {
+        const deposit = deriveBtcAddress(TEST_XPUB, 0);
+        const treasury = deriveBtcTreasury(TEST_XPUB);
+        expect(deposit).not.toBe(treasury);
+    });
+});

package/dist/billing/crypto/btc/__tests__/config.test.d.ts

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

package/dist/billing/crypto/btc/__tests__/config.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { centsToSats, satsToCents } from "../config.js";
+describe("centsToSats", () => {
+    it("converts $10 at $100k BTC", () => {
+        // $10 = 1000 cents, BTC at $100,000
+        // 10 / 100000 = 0.0001 BTC = 10000 sats
+        expect(centsToSats(1000, 100_000)).toBe(10000);
+    });
+    it("converts $100 at $50k BTC", () => {
+        // $100 = 10000 cents, BTC at $50,000
+        // 100 / 50000 = 0.002 BTC = 200000 sats
+        expect(centsToSats(10000, 50_000)).toBe(200000);
+    });
+});
+describe("satsToCents", () => {
+    it("converts 10000 sats at $100k BTC", () => {
+        // 10000 sats = 0.0001 BTC, at $100k = $10 = 1000 cents
+        expect(satsToCents(10000, 100_000)).toBe(1000);
+    });
+    it("rounds to nearest cent", () => {
+        // 15000 sats at $100k = 0.00015 BTC = $15 = 1500 cents
+        expect(satsToCents(15000, 100_000)).toBe(1500);
+    });
+});

package/dist/billing/crypto/btc/__tests__/settler.test.d.ts

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

package/dist/billing/crypto/btc/__tests__/settler.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from "vitest";
+import { settleBtcPayment } from "../settler.js";
+const mockEvent = {
+    address: "bc1qtest",
+    txid: "abc123",
+    amountSats: 15000,
+    amountUsdCents: 1000,
+    confirmations: 6,
+};
+describe("settleBtcPayment", () => {
+    it("credits ledger when charge found", async () => {
+        const deps = {
+            chargeStore: {
+                getByDepositAddress: vi.fn().mockResolvedValue({
+                    referenceId: "btc:test",
+                    tenantId: "t1",
+                    amountUsdCents: 1000,
+                    creditedAt: null,
+                }),
+                updateStatus: vi.fn().mockResolvedValue(undefined),
+                markCredited: vi.fn().mockResolvedValue(undefined),
+            },
+            creditLedger: {
+                hasReferenceId: vi.fn().mockResolvedValue(false),
+                credit: vi.fn().mockResolvedValue({}),
+            },
+            onCreditsPurchased: vi.fn().mockResolvedValue([]),
+        };
+        const result = await settleBtcPayment(deps, mockEvent);
+        expect(result.handled).toBe(true);
+        expect(result.creditedCents).toBe(1000);
+        expect(deps.creditLedger.credit).toHaveBeenCalledOnce();
+        // Verify Credit.fromCents was used
+        const creditArg = deps.creditLedger.credit.mock.calls[0][1];
+        expect(creditArg.toCentsRounded()).toBe(1000);
+    });
+    it("rejects double-credit on already-credited charge", async () => {
+        const deps = {
+            chargeStore: {
+                getByDepositAddress: vi.fn().mockResolvedValue({
+                    referenceId: "btc:test",
+                    tenantId: "t1",
+                    amountUsdCents: 1000,
+                    creditedAt: "2026-01-01",
+                }),
+                updateStatus: vi.fn().mockResolvedValue(undefined),
+                markCredited: vi.fn(),
+            },
+            creditLedger: {
+                hasReferenceId: vi.fn().mockResolvedValue(false),
+                credit: vi.fn(),
+            },
+        };
+        const result = await settleBtcPayment(deps, mockEvent);
+        expect(result.creditedCents).toBe(0);
+        expect(deps.creditLedger.credit).not.toHaveBeenCalled();
+    });
+    it("rejects underpayment", async () => {
+        const underpaid = { ...mockEvent, amountUsdCents: 500 };
+        const deps = {
+            chargeStore: {
+                getByDepositAddress: vi.fn().mockResolvedValue({
+                    referenceId: "btc:test",
+                    tenantId: "t1",
+                    amountUsdCents: 1000,
+                    creditedAt: null,
+                }),
+                updateStatus: vi.fn().mockResolvedValue(undefined),
+                markCredited: vi.fn(),
+            },
+            creditLedger: {
+                hasReferenceId: vi.fn().mockResolvedValue(false),
+                credit: vi.fn(),
+            },
+        };
+        const result = await settleBtcPayment(deps, underpaid);
+        expect(result.creditedCents).toBe(0);
+        expect(deps.creditLedger.credit).not.toHaveBeenCalled();
+    });
+    it("returns handled:false when no charge found", async () => {
+        const deps = {
+            chargeStore: {
+                getByDepositAddress: vi.fn().mockResolvedValue(null),
+                updateStatus: vi.fn(),
+                markCredited: vi.fn(),
+            },
+            creditLedger: { hasReferenceId: vi.fn(), credit: vi.fn() },
+        };
+        const result = await settleBtcPayment(deps, mockEvent);
+        expect(result.handled).toBe(false);
+    });
+});

package/dist/billing/crypto/btc/address-gen.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Derive a native segwit (bech32, bc1q...) BTC address from an xpub at a given index.
+ * Path: xpub / 0 / index (external chain).
+ * No private keys involved.
+ */
+export declare function deriveBtcAddress(xpub: string, index: number, network?: "mainnet" | "testnet" | "regtest"): string;
+/** Derive the BTC treasury address (internal chain, index 0). */
+export declare function deriveBtcTreasury(xpub: string, network?: "mainnet" | "testnet" | "regtest"): string;

package/dist/billing/crypto/btc/address-gen.js

@@ -0,0 +1,34 @@
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bech32 } from "@scure/base";
+import { HDKey } from "@scure/bip32";
+/**
+ * Derive a native segwit (bech32, bc1q...) BTC address from an xpub at a given index.
+ * Path: xpub / 0 / index (external chain).
+ * No private keys involved.
+ */
+export function deriveBtcAddress(xpub, index, network = "mainnet") {
+    if (!Number.isInteger(index) || index < 0)
+        throw new Error(`Invalid derivation index: ${index}`);
+    const master = HDKey.fromExtendedKey(xpub);
+    const child = master.deriveChild(0).deriveChild(index);
+    if (!child.publicKey)
+        throw new Error("Failed to derive public key");
+    // HASH160 = RIPEMD160(SHA256(compressedPubKey))
+    const hash160 = ripemd160(sha256(child.publicKey));
+    // Bech32 encode: witness version 0 + 20-byte hash
+    const prefix = network === "mainnet" ? "bc" : "tb";
+    const words = bech32.toWords(hash160);
+    return bech32.encode(prefix, [0, ...words]);
+}
+/** Derive the BTC treasury address (internal chain, index 0). */
+export function deriveBtcTreasury(xpub, network = "mainnet") {
+    const master = HDKey.fromExtendedKey(xpub);
+    const child = master.deriveChild(1).deriveChild(0); // internal chain
+    if (!child.publicKey)
+        throw new Error("Failed to derive public key");
+    const hash160 = ripemd160(sha256(child.publicKey));
+    const prefix = network === "mainnet" ? "bc" : "tb";
+    const words = bech32.toWords(hash160);
+    return bech32.encode(prefix, [0, ...words]);
+}

package/dist/billing/crypto/btc/checkout.d.ts

@@ -0,0 +1,21 @@
+import type { ICryptoChargeRepository } from "../charge-store.js";
+import type { BtcCheckoutOpts } from "./types.js";
+export declare const MIN_BTC_USD = 10;
+export interface BtcCheckoutDeps {
+    chargeStore: Pick<ICryptoChargeRepository, "getNextDerivationIndex" | "createStablecoinCharge">;
+    xpub: string;
+    network?: "mainnet" | "testnet" | "regtest";
+}
+export interface BtcCheckoutResult {
+    depositAddress: string;
+    amountUsd: number;
+    referenceId: string;
+}
+/**
+ * Create a BTC checkout — derive a unique deposit address, store the charge.
+ *
+ * Same pattern as stablecoin checkout: HD derivation + charge store + retry on conflict.
+ *
+ * CRITICAL: amountUsd → integer cents via Credit.fromDollars().toCentsRounded().
+ */
+export declare function createBtcCheckout(deps: BtcCheckoutDeps, opts: BtcCheckoutOpts): Promise<BtcCheckoutResult>;

package/dist/billing/crypto/btc/checkout.js

@@ -0,0 +1,42 @@
+import { Credit } from "../../../credits/credit.js";
+import { deriveBtcAddress } from "./address-gen.js";
+export const MIN_BTC_USD = 10;
+/**
+ * Create a BTC checkout — derive a unique deposit address, store the charge.
+ *
+ * Same pattern as stablecoin checkout: HD derivation + charge store + retry on conflict.
+ *
+ * CRITICAL: amountUsd → integer cents via Credit.fromDollars().toCentsRounded().
+ */
+export async function createBtcCheckout(deps, opts) {
+    if (!Number.isFinite(opts.amountUsd) || opts.amountUsd < MIN_BTC_USD) {
+        throw new Error(`Minimum payment amount is $${MIN_BTC_USD}`);
+    }
+    const amountUsdCents = Credit.fromDollars(opts.amountUsd).toCentsRounded();
+    const network = deps.network ?? "mainnet";
+    const maxRetries = 3;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const derivationIndex = await deps.chargeStore.getNextDerivationIndex();
+        const depositAddress = deriveBtcAddress(deps.xpub, derivationIndex, network);
+        const referenceId = `btc:${depositAddress}`;
+        try {
+            await deps.chargeStore.createStablecoinCharge({
+                referenceId,
+                tenantId: opts.tenant,
+                amountUsdCents,
+                chain: "bitcoin",
+                token: "BTC",
+                depositAddress,
+                derivationIndex,
+            });
+            return { depositAddress, amountUsd: opts.amountUsd, referenceId };
+        }
+        catch (err) {
+            const code = err.code;
+            const isConflict = code === "23505" || (err instanceof Error && err.message.includes("unique_violation"));
+            if (!isConflict || attempt === maxRetries)
+                throw err;
+        }
+    }
+    throw new Error("Failed to claim derivation index after retries");
+}

package/dist/billing/crypto/btc/config.d.ts

@@ -0,0 +1,12 @@
+import type { BitcoindConfig } from "./types.js";
+export declare function loadBitcoindConfig(): BitcoindConfig | null;
+/**
+ * Convert USD cents to satoshis given a BTC/USD price.
+ * Integer math only.
+ */
+export declare function centsToSats(cents: number, btcPriceUsd: number): number;
+/**
+ * Convert satoshis to USD cents given a BTC/USD price.
+ * Integer math only (rounds to nearest cent).
+ */
+export declare function satsToCents(sats: number, btcPriceUsd: number): number;

package/dist/billing/crypto/btc/config.js

@@ -0,0 +1,28 @@
+export function loadBitcoindConfig() {
+    const rpcUrl = process.env.BITCOIND_RPC_URL;
+    const rpcUser = process.env.BITCOIND_RPC_USER;
+    const rpcPassword = process.env.BITCOIND_RPC_PASSWORD;
+    if (!rpcUrl || !rpcUser || !rpcPassword)
+        return null;
+    const network = (process.env.BITCOIND_NETWORK ?? "mainnet");
+    const confirmations = network === "regtest" ? 1 : 6;
+    return { rpcUrl, rpcUser, rpcPassword, network, confirmations };
+}
+/**
+ * Convert USD cents to satoshis given a BTC/USD price.
+ * Integer math only.
+ */
+export function centsToSats(cents, btcPriceUsd) {
+    // 1 BTC = 100_000_000 sats, price is in dollars
+    // cents / 100 = dollars, dollars / btcPrice = BTC, BTC * 1e8 = sats
+    // To avoid float: (cents * 1e8) / (btcPrice * 100)
+    return Math.round((cents * 100_000_000) / (btcPriceUsd * 100));
+}
+/**
+ * Convert satoshis to USD cents given a BTC/USD price.
+ * Integer math only (rounds to nearest cent).
+ */
+export function satsToCents(sats, btcPriceUsd) {
+    // sats / 1e8 = BTC, BTC * btcPrice = dollars, dollars * 100 = cents
+    return Math.round((sats * btcPriceUsd * 100) / 100_000_000);
+}

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

@@ -0,0 +1,9 @@
+export { deriveBtcAddress, deriveBtcTreasury } from "./address-gen.js";
+export type { BtcCheckoutDeps, BtcCheckoutResult } from "./checkout.js";
+export { createBtcCheckout, MIN_BTC_USD } from "./checkout.js";
+export { centsToSats, loadBitcoindConfig, satsToCents } from "./config.js";
+export type { BtcSettlerDeps } from "./settler.js";
+export { settleBtcPayment } from "./settler.js";
+export type { BitcoindConfig, BtcCheckoutOpts, BtcPaymentEvent } from "./types.js";
+export type { BtcWatcherOpts } from "./watcher.js";
+export { BtcWatcher, createBitcoindRpc } from "./watcher.js";

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

@@ -0,0 +1,5 @@
+export { deriveBtcAddress, deriveBtcTreasury } from "./address-gen.js";
+export { createBtcCheckout, MIN_BTC_USD } from "./checkout.js";
+export { centsToSats, loadBitcoindConfig, satsToCents } from "./config.js";
+export { settleBtcPayment } from "./settler.js";
+export { BtcWatcher, createBitcoindRpc } from "./watcher.js";

package/dist/billing/crypto/btc/settler.d.ts

@@ -0,0 +1,23 @@
+import type { ILedger } from "../../../credits/ledger.js";
+import type { ICryptoChargeRepository } from "../charge-store.js";
+import type { CryptoWebhookResult } from "../types.js";
+import type { BtcPaymentEvent } from "./types.js";
+export interface BtcSettlerDeps {
+    chargeStore: Pick<ICryptoChargeRepository, "getByDepositAddress" | "updateStatus" | "markCredited">;
+    creditLedger: Pick<ILedger, "credit" | "hasReferenceId">;
+    onCreditsPurchased?: (tenantId: string, ledger: ILedger) => Promise<string[]>;
+}
+/**
+ * Settle a BTC payment — look up charge by deposit address, credit ledger.
+ *
+ * Same idempotency pattern as EVM settler and BTCPay webhook handler:
+ *   1. Charge-level: check creditedAt (prevents second tx double-credit)
+ *   2. Transfer-level: creditLedger.hasReferenceId (atomic)
+ *   3. Advisory: chargeStore.markCredited
+ *
+ * Credits the CHARGE amount (not the BTC amount) for consistency.
+ *
+ * CRITICAL: charge.amountUsdCents is in USD cents (integer).
+ * Credit.fromCents() converts cents → nanodollars for the ledger.
+ */
+export declare function settleBtcPayment(deps: BtcSettlerDeps, event: BtcPaymentEvent): Promise<CryptoWebhookResult>;

package/dist/billing/crypto/btc/settler.js

@@ -0,0 +1,55 @@
+import { Credit } from "../../../credits/credit.js";
+/**
+ * Settle a BTC payment — look up charge by deposit address, credit ledger.
+ *
+ * Same idempotency pattern as EVM settler and BTCPay webhook handler:
+ *   1. Charge-level: check creditedAt (prevents second tx double-credit)
+ *   2. Transfer-level: creditLedger.hasReferenceId (atomic)
+ *   3. Advisory: chargeStore.markCredited
+ *
+ * Credits the CHARGE amount (not the BTC amount) for consistency.
+ *
+ * CRITICAL: charge.amountUsdCents is in USD cents (integer).
+ * Credit.fromCents() converts cents → nanodollars for the ledger.
+ */
+export async function settleBtcPayment(deps, event) {
+    const { chargeStore, creditLedger } = deps;
+    const charge = await chargeStore.getByDepositAddress(event.address);
+    if (!charge) {
+        return { handled: false, status: "Settled" };
+    }
+    await chargeStore.updateStatus(charge.referenceId, "Settled");
+    // Charge-level idempotency
+    if (charge.creditedAt != null) {
+        return { handled: true, status: "Settled", tenant: charge.tenantId, creditedCents: 0 };
+    }
+    // Transfer-level idempotency
+    const creditRef = `btc:${event.txid}`;
+    if (await creditLedger.hasReferenceId(creditRef)) {
+        return { handled: true, status: "Settled", tenant: charge.tenantId, creditedCents: 0 };
+    }
+    // Underpayment check
+    if (event.amountUsdCents < charge.amountUsdCents) {
+        return { handled: true, status: "Settled", tenant: charge.tenantId, creditedCents: 0 };
+    }
+    const creditCents = charge.amountUsdCents;
+    await creditLedger.credit(charge.tenantId, Credit.fromCents(creditCents), "purchase", {
+        description: `BTC credit purchase (txid: ${event.txid})`,
+        referenceId: creditRef,
+        fundingSource: "crypto",
+    });
+    await chargeStore.markCredited(charge.referenceId);
+    let reactivatedBots;
+    if (deps.onCreditsPurchased) {
+        reactivatedBots = await deps.onCreditsPurchased(charge.tenantId, creditLedger);
+        if (reactivatedBots.length === 0)
+            reactivatedBots = undefined;
+    }
+    return {
+        handled: true,
+        status: "Settled",
+        tenant: charge.tenantId,
+        creditedCents: creditCents,
+        reactivatedBots,
+    };
+}

package/dist/billing/crypto/btc/types.d.ts

@@ -0,0 +1,23 @@
+/** BTC payment event emitted when a deposit is confirmed. */
+export interface BtcPaymentEvent {
+    readonly address: string;
+    readonly txid: string;
+    /** Amount in satoshis (integer). */
+    readonly amountSats: number;
+    /** USD cents equivalent (integer). */
+    readonly amountUsdCents: number;
+    readonly confirmations: number;
+}
+/** Options for creating a BTC checkout. */
+export interface BtcCheckoutOpts {
+    tenant: string;
+    amountUsd: number;
+}
+/** Bitcoind RPC configuration. */
+export interface BitcoindConfig {
+    readonly rpcUrl: string;
+    readonly rpcUser: string;
+    readonly rpcPassword: string;
+    readonly network: "mainnet" | "testnet" | "regtest";
+    readonly confirmations: number;
+}

package/dist/billing/crypto/btc/types.js

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

package/dist/billing/crypto/btc/watcher.d.ts

@@ -0,0 +1,28 @@
+import type { BitcoindConfig, BtcPaymentEvent } from "./types.js";
+type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
+export interface BtcWatcherOpts {
+    config: BitcoindConfig;
+    rpcCall: RpcCall;
+    /** Addresses to watch (must be imported into bitcoind wallet first). */
+    watchedAddresses: string[];
+    onPayment: (event: BtcPaymentEvent) => void | Promise<void>;
+    /** Current BTC/USD price for conversion. */
+    getBtcPrice: () => Promise<number>;
+}
+export declare class BtcWatcher {
+    private readonly rpc;
+    private readonly addresses;
+    private readonly onPayment;
+    private readonly minConfirmations;
+    private readonly getBtcPrice;
+    constructor(opts: BtcWatcherOpts);
+    /** Update the set of watched addresses. */
+    setWatchedAddresses(addresses: string[]): void;
+    /** Import an address into bitcoind's wallet (watch-only, no rescan). */
+    importAddress(address: string): Promise<void>;
+    /** Poll for confirmed payments to watched addresses. */
+    poll(): Promise<void>;
+}
+/** Create a bitcoind JSON-RPC caller with basic auth. */
+export declare function createBitcoindRpc(config: BitcoindConfig): RpcCall;
+export {};

package/dist/billing/crypto/btc/watcher.js

@@ -0,0 +1,83 @@
+/** Track which txids we've already processed to avoid double-crediting. */
+const processedTxids = new Set();
+export class BtcWatcher {
+    rpc;
+    addresses;
+    onPayment;
+    minConfirmations;
+    getBtcPrice;
+    constructor(opts) {
+        this.rpc = opts.rpcCall;
+        this.addresses = new Set(opts.watchedAddresses);
+        this.onPayment = opts.onPayment;
+        this.minConfirmations = opts.config.confirmations;
+        this.getBtcPrice = opts.getBtcPrice;
+    }
+    /** Update the set of watched addresses. */
+    setWatchedAddresses(addresses) {
+        this.addresses.clear();
+        for (const a of addresses)
+            this.addresses.add(a);
+    }
+    /** Import an address into bitcoind's wallet (watch-only, no rescan). */
+    async importAddress(address) {
+        await this.rpc("importaddress", [address, "", false]);
+        this.addresses.add(address);
+    }
+    /** Poll for confirmed payments to watched addresses. */
+    async poll() {
+        if (this.addresses.size === 0)
+            return;
+        const received = (await this.rpc("listreceivedbyaddress", [
+            this.minConfirmations,
+            false, // include_empty
+            true, // include_watchonly
+        ]));
+        const btcPrice = await this.getBtcPrice();
+        for (const entry of received) {
+            if (!this.addresses.has(entry.address))
+                continue;
+            for (const txid of entry.txids) {
+                if (processedTxids.has(txid))
+                    continue;
+                processedTxids.add(txid);
+                // Get transaction details for the exact amount sent to this address
+                const tx = (await this.rpc("gettransaction", [txid, true]));
+                const detail = tx.details.find((d) => d.address === entry.address && d.category === "receive");
+                if (!detail)
+                    continue;
+                const amountSats = Math.round(detail.amount * 100_000_000);
+                const amountUsdCents = Math.round(detail.amount * btcPrice * 100);
+                const event = {
+                    address: entry.address,
+                    txid,
+                    amountSats,
+                    amountUsdCents,
+                    confirmations: tx.confirmations,
+                };
+                await this.onPayment(event);
+            }
+        }
+    }
+}
+/** Create a bitcoind JSON-RPC caller with basic auth. */
+export function createBitcoindRpc(config) {
+    let id = 0;
+    const auth = btoa(`${config.rpcUser}:${config.rpcPassword}`);
+    return async (method, params) => {
+        const res = await fetch(config.rpcUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Basic ${auth}`,
+            },
+            body: JSON.stringify({ jsonrpc: "1.0", id: ++id, method, params }),
+        });
+        if (!res.ok)
+            throw new Error(`bitcoind ${method} failed: ${res.status}`);
+        const data = (await res.json());
+        if (data.error)
+            throw new Error(`bitcoind ${method}: ${data.error.message}`);
+        return data.result;
+    };
+}

package/dist/billing/crypto/charge-store.d.ts

@@ -15,7 +15,7 @@ export interface CryptoChargeRecord {
     depositAddress: string | null;
     derivationIndex: number | null;
 }
-export interface StablecoinChargeInput {
+export interface CryptoDepositChargeInput {
     referenceId: string;
     tenantId: string;
     amountUsdCents: number;
@@ -30,7 +30,7 @@ export interface ICryptoChargeRepository {
     updateStatus(referenceId: string, status: CryptoPaymentState, currency?: string, filledAmount?: string): Promise<void>;
     markCredited(referenceId: string): Promise<void>;
     isCredited(referenceId: string): Promise<boolean>;
-    createStablecoinCharge(input: StablecoinChargeInput): Promise<void>;
+    createStablecoinCharge(input: CryptoDepositChargeInput): Promise<void>;
     getByDepositAddress(address: string): Promise<CryptoChargeRecord | null>;
     getNextDerivationIndex(): Promise<number>;
 }
@@ -59,7 +59,7 @@ export declare class DrizzleCryptoChargeRepository implements ICryptoChargeRepos
     /** Check if a charge has already been credited (for idempotency). */
     isCredited(referenceId: string): Promise<boolean>;
     /** Create a stablecoin charge with chain/token/deposit address. */
-    createStablecoinCharge(input: StablecoinChargeInput): Promise<void>;
+    createStablecoinCharge(input: CryptoDepositChargeInput): Promise<void>;
     /** Look up a charge by its deposit address. */
     getByDepositAddress(address: string): Promise<CryptoChargeRecord | null>;
     /** Get the next available HD derivation index (max + 1, or 0 if empty). */

package/dist/billing/crypto/evm/__tests__/config.test.js

@@ -7,6 +7,21 @@ describe("getChainConfig", () => {
         expect(cfg.confirmations).toBe(1);
         expect(cfg.blockTimeMs).toBe(2000);
     });
+    it("returns Ethereum config", () => {
+        const cfg = getChainConfig("ethereum");
+        expect(cfg.chainId).toBe(1);
+        expect(cfg.confirmations).toBe(12);
+    });
+    it("returns Arbitrum config", () => {
+        const cfg = getChainConfig("arbitrum");
+        expect(cfg.chainId).toBe(42161);
+        expect(cfg.confirmations).toBe(1);
+    });
+    it("returns Polygon config", () => {
+        const cfg = getChainConfig("polygon");
+        expect(cfg.chainId).toBe(137);
+        expect(cfg.confirmations).toBe(32);
+    });
     it("throws on unknown chain", () => {
         // biome-ignore lint/suspicious/noExplicitAny: testing invalid input
         expect(() => getChainConfig("solana")).toThrow("Unsupported chain");
@@ -29,9 +44,34 @@ describe("getTokenConfig", () => {
         expect(cfg.decimals).toBe(18);
         expect(cfg.contractAddress).toBe("0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb");
     });
-    it("throws on unsupported token/chain combo", () => {
+    it("returns USDC on Ethereum", () => {
+        const cfg = getTokenConfig("USDC", "ethereum");
+        expect(cfg.decimals).toBe(6);
+        expect(cfg.contractAddress).toBe("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+    });
+    it("returns USDT on Ethereum", () => {
+        const cfg = getTokenConfig("USDT", "ethereum");
+        expect(cfg.decimals).toBe(6);
+    });
+    it("returns DAI on Ethereum", () => {
+        const cfg = getTokenConfig("DAI", "ethereum");
+        expect(cfg.decimals).toBe(18);
+    });
+    it("returns USDC on Arbitrum", () => {
+        const cfg = getTokenConfig("USDC", "arbitrum");
+        expect(cfg.chain).toBe("arbitrum");
+        expect(cfg.decimals).toBe(6);
+    });
+    it("returns USDT on Polygon", () => {
+        const cfg = getTokenConfig("USDT", "polygon");
+        expect(cfg.decimals).toBe(6);
+    });
+    it("throws on DAI:polygon (not supported)", () => {
+        expect(() => getTokenConfig("DAI", "polygon")).toThrow("Unsupported token");
+    });
+    it("throws on unsupported chain", () => {
         // biome-ignore lint/suspicious/noExplicitAny: testing invalid input
-        expect(() => getTokenConfig("USDC", "ethereum")).toThrow("Unsupported token");
+        expect(() => getTokenConfig("USDC", "solana")).toThrow("Unsupported token");
     });
 });
 describe("tokenAmountFromCents", () => {