@wopr-network/platform-core 1.42.3 → 1.44.0

package/dist/billing/crypto/client.test.js

@@ -1,100 +1,83 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { BTCPayClient, loadCryptoConfig } from "./client.js";
-describe("BTCPayClient", () => {
-    it("createInvoice sends correct request and returns id + checkoutLink", async () => {
-        const mockResponse = { id: "inv-001", checkoutLink: "https://btcpay.example.com/i/inv-001" };
-        const fetchSpy = vi
-            .spyOn(globalThis, "fetch")
-            .mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
-        const client = new BTCPayClient({
-            apiKey: "test-key",
-            baseUrl: "https://btcpay.example.com",
-            storeId: "store-abc",
-        });
-        const result = await client.createInvoice({
-            amountUsd: 25,
-            orderId: "order-123",
-            buyerEmail: "test@example.com",
-        });
-        expect(result.id).toBe("inv-001");
-        expect(result.checkoutLink).toBe("https://btcpay.example.com/i/inv-001");
-        expect(fetchSpy).toHaveBeenCalledOnce();
-        const [url, opts] = fetchSpy.mock.calls[0];
-        expect(url).toBe("https://btcpay.example.com/api/v1/stores/store-abc/invoices");
+import { CryptoServiceClient, loadCryptoConfig } from "./client.js";
+describe("CryptoServiceClient", () => {
+    afterEach(() => vi.restoreAllMocks());
+    it("deriveAddress sends POST /address with chain", async () => {
+        const mockResponse = { address: "bc1q...", index: 42, chain: "bitcoin", token: "BTC" };
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 201 }));
+        const client = new CryptoServiceClient({ baseUrl: "http://localhost:3100" });
+        const result = await client.deriveAddress("btc");
+        expect(result.address).toBe("bc1q...");
+        expect(result.index).toBe(42);
+        const [url, opts] = vi.mocked(fetch).mock.calls[0];
+        expect(url).toBe("http://localhost:3100/address");
         expect(opts?.method).toBe("POST");
+        expect(JSON.parse(opts?.body)).toEqual({ chain: "btc" });
+    });
+    it("createCharge sends POST /charges", async () => {
+        const mockResponse = {
+            chargeId: "btc:bc1q...",
+            address: "bc1q...",
+            chain: "btc",
+            token: "BTC",
+            amountUsd: 50,
+            derivationIndex: 42,
+            expiresAt: "2026-03-20T04:00:00Z",
+        };
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 201 }));
+        const client = new CryptoServiceClient({
+            baseUrl: "http://localhost:3100",
+            serviceKey: "sk-test",
+            tenantId: "tenant-1",
+        });
+        const result = await client.createCharge({ chain: "btc", amountUsd: 50 });
+        expect(result.chargeId).toBe("btc:bc1q...");
+        expect(result.address).toBe("bc1q...");
+        const [, opts] = vi.mocked(fetch).mock.calls[0];
         const headers = opts?.headers;
-        expect(headers.Authorization).toBe("token test-key");
-        expect(headers["Content-Type"]).toBe("application/json");
-        const body = JSON.parse(opts?.body);
-        expect(body.amount).toBe("25");
-        expect(body.currency).toBe("USD");
-        expect(body.metadata.orderId).toBe("order-123");
-        expect(body.metadata.buyerEmail).toBe("test@example.com");
-        expect(body.checkout.speedPolicy).toBe("MediumSpeed");
-        fetchSpy.mockRestore();
+        expect(headers.Authorization).toBe("Bearer sk-test");
+        expect(headers["X-Tenant-Id"]).toBe("tenant-1");
     });
-    it("createInvoice includes redirectURL when provided", async () => {
-        const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response(JSON.stringify({ id: "inv-002", checkoutLink: "https://btcpay.example.com/i/inv-002" }), {
-            status: 200,
-        }));
-        const client = new BTCPayClient({ apiKey: "k", baseUrl: "https://btcpay.example.com", storeId: "s" });
-        await client.createInvoice({ amountUsd: 10, orderId: "o", redirectURL: "https://app.example.com/success" });
-        const body = JSON.parse(fetchSpy.mock.calls[0][1]?.body);
-        expect(body.checkout.redirectURL).toBe("https://app.example.com/success");
-        fetchSpy.mockRestore();
+    it("getCharge sends GET /charges/:id", async () => {
+        const mockResponse = { chargeId: "btc:bc1q...", status: "confirmed" };
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+        const client = new CryptoServiceClient({ baseUrl: "http://localhost:3100" });
+        const result = await client.getCharge("btc:bc1q...");
+        expect(result.status).toBe("confirmed");
+        expect(vi.mocked(fetch).mock.calls[0][0]).toBe("http://localhost:3100/charges/btc%3Abc1q...");
     });
-    it("createInvoice throws on non-ok response", async () => {
-        const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response("Unauthorized", { status: 401 }));
-        const client = new BTCPayClient({ apiKey: "bad-key", baseUrl: "https://btcpay.example.com", storeId: "s" });
-        await expect(client.createInvoice({ amountUsd: 10, orderId: "o" })).rejects.toThrow("BTCPay createInvoice failed (401)");
-        fetchSpy.mockRestore();
+    it("listChains sends GET /chains", async () => {
+        const mockResponse = [{ id: "btc", token: "BTC", chain: "bitcoin", decimals: 8 }];
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+        const client = new CryptoServiceClient({ baseUrl: "http://localhost:3100" });
+        const result = await client.listChains();
+        expect(result).toHaveLength(1);
+        expect(result[0].token).toBe("BTC");
     });
-    it("getInvoice sends correct request", async () => {
-        const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response(JSON.stringify({ id: "inv-001", status: "Settled", amount: "25", currency: "USD" }), {
-            status: 200,
-        }));
-        const client = new BTCPayClient({ apiKey: "k", baseUrl: "https://btcpay.example.com", storeId: "store-abc" });
-        const result = await client.getInvoice("inv-001");
-        expect(result.status).toBe("Settled");
-        expect(fetchSpy.mock.calls[0][0]).toBe("https://btcpay.example.com/api/v1/stores/store-abc/invoices/inv-001");
-        fetchSpy.mockRestore();
+    it("throws on non-ok response", async () => {
+        vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response("Not found", { status: 404 }));
+        const client = new CryptoServiceClient({ baseUrl: "http://localhost:3100" });
+        await expect(client.getCharge("missing")).rejects.toThrow("CryptoService getCharge failed (404)");
     });
 });
 describe("loadCryptoConfig", () => {
     beforeEach(() => {
-        delete process.env.BTCPAY_API_KEY;
-        delete process.env.BTCPAY_BASE_URL;
-        delete process.env.BTCPAY_STORE_ID;
-    });
-    afterEach(() => {
-        vi.unstubAllEnvs();
-    });
-    it("returns null when BTCPAY_API_KEY is missing", () => {
-        vi.stubEnv("BTCPAY_BASE_URL", "https://btcpay.test");
-        vi.stubEnv("BTCPAY_STORE_ID", "store-1");
-        expect(loadCryptoConfig()).toBeNull();
-    });
-    it("returns null when BTCPAY_BASE_URL is missing", () => {
-        vi.stubEnv("BTCPAY_API_KEY", "test-key");
-        vi.stubEnv("BTCPAY_STORE_ID", "store-1");
-        expect(loadCryptoConfig()).toBeNull();
-    });
-    it("returns null when BTCPAY_STORE_ID is missing", () => {
-        vi.stubEnv("BTCPAY_API_KEY", "test-key");
-        vi.stubEnv("BTCPAY_BASE_URL", "https://btcpay.test");
-        expect(loadCryptoConfig()).toBeNull();
+        delete process.env.CRYPTO_SERVICE_URL;
+        delete process.env.CRYPTO_SERVICE_KEY;
+        delete process.env.TENANT_ID;
     });
-    it("returns config when all env vars are set", () => {
-        vi.stubEnv("BTCPAY_API_KEY", "test-key");
-        vi.stubEnv("BTCPAY_BASE_URL", "https://btcpay.test");
-        vi.stubEnv("BTCPAY_STORE_ID", "store-1");
+    afterEach(() => vi.unstubAllEnvs());
+    it("returns config when CRYPTO_SERVICE_URL is set", () => {
+        vi.stubEnv("CRYPTO_SERVICE_URL", "http://10.120.0.5:3100");
+        vi.stubEnv("CRYPTO_SERVICE_KEY", "sk-test");
+        vi.stubEnv("TENANT_ID", "tenant-1");
         expect(loadCryptoConfig()).toEqual({
-            apiKey: "test-key",
-            baseUrl: "https://btcpay.test",
-            storeId: "store-1",
+            baseUrl: "http://10.120.0.5:3100",
+            serviceKey: "sk-test",
+            tenantId: "tenant-1",
         });
     });
-    it("returns null when all env vars are missing", () => {
+    it("returns null when CRYPTO_SERVICE_URL is missing", () => {
         expect(loadCryptoConfig()).toBeNull();
     });
 });

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

@@ -1,18 +1,18 @@
 export * from "./btc/index.js";
 export type { CryptoChargeRecord, CryptoDepositChargeInput, ICryptoChargeRepository } from "./charge-store.js";
 export { CryptoChargeRepository, DrizzleCryptoChargeRepository } from "./charge-store.js";
-export { createCryptoCheckout, MIN_PAYMENT_USD } from "./checkout.js";
-export type { CryptoConfig } from "./client.js";
-export { BTCPayClient, loadCryptoConfig } from "./client.js";
+export type { ChainInfo, ChargeStatus, CreateChargeResult, CryptoConfig, CryptoServiceConfig, DeriveAddressResult, } from "./client.js";
+export { CryptoServiceClient, loadCryptoConfig } from "./client.js";
 export type { IWatcherCursorStore } from "./cursor-store.js";
 export { DrizzleWatcherCursorStore } from "./cursor-store.js";
 export * from "./evm/index.js";
+export type { KeyServerDeps } from "./key-server.js";
+export { createKeyServerApp } from "./key-server.js";
+export type { KeyServerWebhookDeps as CryptoWebhookDeps, KeyServerWebhookPayload as CryptoWebhookPayload, KeyServerWebhookResult as CryptoWebhookResult, } from "./key-server-webhook.js";
+export { handleKeyServerWebhook, handleKeyServerWebhook as handleCryptoWebhook } from "./key-server-webhook.js";
 export * from "./oracle/index.js";
 export type { IPaymentMethodStore, PaymentMethodRecord } from "./payment-method-store.js";
 export { DrizzlePaymentMethodStore } from "./payment-method-store.js";
-export type { CryptoBillingConfig, CryptoCheckoutOpts, CryptoPaymentState, CryptoWebhookPayload, CryptoWebhookResult, } from "./types.js";
-export { mapBtcPayEventToStatus } from "./types.js";
+export type { CryptoPaymentState } from "./types.js";
 export type { UnifiedCheckoutDeps, UnifiedCheckoutResult } from "./unified-checkout.js";
-export { createUnifiedCheckout, MIN_CHECKOUT_USD } from "./unified-checkout.js";
-export type { CryptoWebhookDeps } from "./webhook.js";
-export { handleCryptoWebhook, verifyCryptoWebhookSignature } from "./webhook.js";
+export { createUnifiedCheckout, MIN_CHECKOUT_USD as MIN_PAYMENT_USD, MIN_CHECKOUT_USD } from "./unified-checkout.js";

package/dist/billing/crypto/index.js

@@ -1,11 +1,10 @@
 export * from "./btc/index.js";
 export { CryptoChargeRepository, DrizzleCryptoChargeRepository } from "./charge-store.js";
-export { createCryptoCheckout, MIN_PAYMENT_USD } from "./checkout.js";
-export { BTCPayClient, loadCryptoConfig } from "./client.js";
+export { CryptoServiceClient, loadCryptoConfig } from "./client.js";
 export { DrizzleWatcherCursorStore } from "./cursor-store.js";
 export * from "./evm/index.js";
+export { createKeyServerApp } from "./key-server.js";
+export { handleKeyServerWebhook, handleKeyServerWebhook as handleCryptoWebhook } from "./key-server-webhook.js";
 export * from "./oracle/index.js";
 export { DrizzlePaymentMethodStore } from "./payment-method-store.js";
-export { mapBtcPayEventToStatus } from "./types.js";
-export { createUnifiedCheckout, MIN_CHECKOUT_USD } from "./unified-checkout.js";
-export { handleCryptoWebhook, verifyCryptoWebhookSignature } from "./webhook.js";
+export { createUnifiedCheckout, MIN_CHECKOUT_USD as MIN_PAYMENT_USD, MIN_CHECKOUT_USD } from "./unified-checkout.js";

package/dist/billing/crypto/key-server-entry.js

@@ -0,0 +1,84 @@
+/**
+ * Standalone entry point for the crypto key server.
+ *
+ * Deploys on the chain server (pay.wopr.bot:3100).
+ * Boots: postgres → migrations → key server routes → watchers → serve.
+ *
+ * Usage: node dist/billing/crypto/key-server-entry.js
+ */
+/* biome-ignore-all lint/suspicious/noConsole: standalone entry point */
+import { serve } from "@hono/node-server";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import pg from "pg";
+import * as schema from "../../db/schema/index.js";
+import { DrizzleCryptoChargeRepository } from "./charge-store.js";
+import { DrizzleWatcherCursorStore } from "./cursor-store.js";
+import { createRpcCaller } from "./evm/watcher.js";
+import { createKeyServerApp } from "./key-server.js";
+import { ChainlinkOracle } from "./oracle/chainlink.js";
+import { FixedPriceOracle } from "./oracle/fixed.js";
+import { DrizzlePaymentMethodStore } from "./payment-method-store.js";
+import { startWatchers } from "./watcher-service.js";
+const PORT = Number(process.env.PORT ?? "3100");
+const DATABASE_URL = process.env.DATABASE_URL;
+const SERVICE_KEY = process.env.SERVICE_KEY;
+const ADMIN_TOKEN = process.env.ADMIN_TOKEN;
+const BITCOIND_USER = process.env.BITCOIND_USER ?? "btcpay";
+const BITCOIND_PASSWORD = process.env.BITCOIND_PASSWORD ?? "";
+const BASE_RPC_URL = process.env.BASE_RPC_URL ?? "https://mainnet.base.org";
+if (!DATABASE_URL) {
+    console.error("DATABASE_URL is required");
+    process.exit(1);
+}
+async function main() {
+    const pool = new pg.Pool({ connectionString: DATABASE_URL });
+    // Run migrations FIRST, before creating schema-typed db
+    console.log("[crypto-key-server] Running migrations...");
+    await migrate(drizzle(pool), { migrationsFolder: "./drizzle/migrations" });
+    // Now create the schema-typed db (columns guaranteed to exist)
+    console.log("[crypto-key-server] Connecting...");
+    const db = drizzle(pool, { schema });
+    const chargeStore = new DrizzleCryptoChargeRepository(db);
+    const methodStore = new DrizzlePaymentMethodStore(db);
+    // Chainlink on-chain oracle for volatile assets (BTC, ETH).
+    const oracle = BASE_RPC_URL
+        ? new ChainlinkOracle({ rpcCall: createRpcCaller(BASE_RPC_URL) })
+        : new FixedPriceOracle();
+    const app = createKeyServerApp({
+        db,
+        chargeStore,
+        methodStore,
+        oracle,
+        serviceKey: SERVICE_KEY,
+        adminToken: ADMIN_TOKEN,
+    });
+    // Boot watchers (BTC + EVM) — polls for payments, sends webhooks
+    const cursorStore = new DrizzleWatcherCursorStore(db);
+    const stopWatchers = await startWatchers({
+        db,
+        chargeStore,
+        methodStore,
+        cursorStore,
+        oracle,
+        bitcoindUser: BITCOIND_USER,
+        bitcoindPassword: BITCOIND_PASSWORD,
+        log: (msg, meta) => console.log(`[watcher] ${msg}`, meta ?? ""),
+    });
+    const server = serve({ fetch: app.fetch, port: PORT });
+    console.log(`[crypto-key-server] Listening on :${PORT}`);
+    // Graceful shutdown — stop accepting requests, drain watchers, close pool
+    const shutdown = async () => {
+        console.log("[crypto-key-server] Shutting down...");
+        stopWatchers();
+        server.close();
+        await pool.end();
+        process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+}
+main().catch((err) => {
+    console.error("[crypto-key-server] Fatal:", err);
+    process.exit(1);
+});

package/dist/billing/crypto/key-server-webhook.d.ts

@@ -0,0 +1,33 @@
+import type { ILedger } from "../../credits/ledger.js";
+import type { IWebhookSeenRepository } from "../webhook-seen-repository.js";
+import type { ICryptoChargeRepository } from "./charge-store.js";
+export interface KeyServerWebhookPayload {
+    chargeId: string;
+    chain: string;
+    address: string;
+    amountUsdCents: number;
+    status: string;
+    txHash?: string;
+    amountReceived?: string;
+    confirmations?: number;
+}
+export interface KeyServerWebhookDeps {
+    chargeStore: ICryptoChargeRepository;
+    creditLedger: ILedger;
+    replayGuard: IWebhookSeenRepository;
+    onCreditsPurchased?: (tenantId: string, ledger: ILedger) => Promise<string[]>;
+}
+export interface KeyServerWebhookResult {
+    handled: boolean;
+    duplicate?: boolean;
+    tenant?: string;
+    creditedCents?: number;
+    reactivatedBots?: string[];
+}
+/**
+ * Process a payment confirmation from the crypto key server.
+ *
+ * Credits the ledger when status is "confirmed".
+ * Idempotency: ledger referenceId + replay guard (same pattern as Stripe handler).
+ */
+export declare function handleKeyServerWebhook(deps: KeyServerWebhookDeps, payload: KeyServerWebhookPayload): Promise<KeyServerWebhookResult>;

package/dist/billing/crypto/key-server-webhook.js

@@ -0,0 +1,73 @@
+/**
+ * Key Server webhook handler — processes payment confirmations from the
+ * centralized crypto key server.
+ *
+ * Payload shape (from watcher-service.ts):
+ * {
+ *   chargeId: "btc:bc1q...",
+ *   chain: "bitcoin",
+ *   address: "bc1q...",
+ *   amountUsdCents: 5000,
+ *   status: "confirmed",
+ *   txHash: "abc123...",
+ *   amountReceived: "50000 sats",
+ *   confirmations: 6
+ * }
+ *
+ * Replaces handleCryptoWebhook() for products using the key server.
+ */
+import { Credit } from "../../credits/credit.js";
+/**
+ * Process a payment confirmation from the crypto key server.
+ *
+ * Credits the ledger when status is "confirmed".
+ * Idempotency: ledger referenceId + replay guard (same pattern as Stripe handler).
+ */
+export async function handleKeyServerWebhook(deps, payload) {
+    const { chargeStore, creditLedger } = deps;
+    // Replay guard: deduplicate by chargeId
+    const dedupeKey = `ks:${payload.chargeId}`;
+    if (await deps.replayGuard.isDuplicate(dedupeKey, "crypto")) {
+        return { handled: true, duplicate: true };
+    }
+    // Look up the charge to find the tenant + amount
+    const charge = await chargeStore.getByReferenceId(payload.chargeId);
+    if (!charge) {
+        return { handled: false };
+    }
+    if (payload.status === "confirmed") {
+        // Only settle when payment is confirmed
+        await chargeStore.updateStatus(payload.chargeId, "Settled", charge.token ?? undefined, payload.amountReceived);
+        // Idempotency: check ledger referenceId (atomic, same as BTCPay handler)
+        const creditRef = `crypto:${payload.chargeId}`;
+        if (await creditLedger.hasReferenceId(creditRef)) {
+            await deps.replayGuard.markSeen(dedupeKey, "crypto");
+            return { handled: true, duplicate: true, tenant: charge.tenantId };
+        }
+        // Credit the original USD amount requested.
+        // charge.amountUsdCents is integer cents. Credit.fromCents() → nanodollars.
+        await creditLedger.credit(charge.tenantId, Credit.fromCents(charge.amountUsdCents), "purchase", {
+            description: `Crypto payment confirmed (${payload.chain}, tx: ${payload.txHash ?? "unknown"})`,
+            referenceId: creditRef,
+            fundingSource: "crypto",
+        });
+        await chargeStore.markCredited(payload.chargeId);
+        let reactivatedBots;
+        if (deps.onCreditsPurchased) {
+            reactivatedBots = await deps.onCreditsPurchased(charge.tenantId, creditLedger);
+            if (reactivatedBots.length === 0)
+                reactivatedBots = undefined;
+        }
+        await deps.replayGuard.markSeen(dedupeKey, "crypto");
+        return {
+            handled: true,
+            tenant: charge.tenantId,
+            creditedCents: charge.amountUsdCents,
+            reactivatedBots,
+        };
+    }
+    // Non-confirmed status — update status but don't settle or credit
+    await chargeStore.updateStatus(payload.chargeId, payload.status, charge.token ?? undefined, payload.amountReceived);
+    await deps.replayGuard.markSeen(dedupeKey, "crypto");
+    return { handled: true, tenant: charge.tenantId };
+}

package/dist/billing/crypto/key-server.d.ts

@@ -0,0 +1,20 @@
+import { Hono } from "hono";
+import type { DrizzleDb } from "../../db/index.js";
+import type { ICryptoChargeRepository } from "./charge-store.js";
+import type { IPriceOracle } from "./oracle/types.js";
+import type { IPaymentMethodStore } from "./payment-method-store.js";
+export interface KeyServerDeps {
+    db: DrizzleDb;
+    chargeStore: ICryptoChargeRepository;
+    methodStore: IPaymentMethodStore;
+    oracle: IPriceOracle;
+    /** Bearer token for product API routes. If unset, auth is disabled. */
+    serviceKey?: string;
+    /** Bearer token for admin routes. If unset, admin routes are disabled. */
+    adminToken?: string;
+}
+/**
+ * Create the Hono app for the crypto key server.
+ * Mount this on the chain server at the root.
+ */
+export declare function createKeyServerApp(deps: KeyServerDeps): Hono;