@wopr-network/platform-core 1.43.0 → 1.44.0

package/src/billing/crypto/client.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { BTCPayClient, CryptoServiceClient, loadCryptoConfig } from "./client.js";
+import { CryptoServiceClient, loadCryptoConfig } from "./client.js";
 
 describe("CryptoServiceClient", () => {
   afterEach(() => vi.restoreAllMocks());
@@ -78,18 +78,6 @@ describe("CryptoServiceClient", () => {
   });
 });
 
-describe("BTCPayClient (deprecated)", () => {
-  it("throws on createInvoice", async () => {
-    const client = new BTCPayClient({ apiKey: "k", baseUrl: "https://example.com", storeId: "s" });
-    await expect(client.createInvoice({ amountUsd: 10, orderId: "o" })).rejects.toThrow("deprecated");
-  });
-
-  it("throws on getInvoice", async () => {
-    const client = new BTCPayClient({ apiKey: "k", baseUrl: "https://example.com", storeId: "s" });
-    await expect(client.getInvoice("inv-1")).rejects.toThrow("deprecated");
-  });
-});
-
 describe("loadCryptoConfig", () => {
   beforeEach(() => {
     delete process.env.CRYPTO_SERVICE_URL;

package/src/billing/crypto/client.ts

@@ -143,24 +143,3 @@ export function loadCryptoConfig(): CryptoServiceConfig | null {
 
 // Legacy type alias for backwards compat
 export type CryptoConfig = CryptoServiceConfig;
-
-/**
- * @deprecated Use CryptoServiceClient instead. BTCPay is replaced by the crypto key server.
- * Kept for backwards compat — products still import BTCPayClient during migration.
- */
-export class BTCPayClient {
-  constructor(_config: { apiKey: string; baseUrl: string; storeId: string }) {}
-
-  async createInvoice(_opts: {
-    amountUsd: number;
-    orderId: string;
-    buyerEmail?: string;
-    redirectURL?: string;
-  }): Promise<{ id: string; checkoutLink: string }> {
-    throw new Error("BTCPayClient is deprecated — migrate to CryptoServiceClient");
-  }
-
-  async getInvoice(_invoiceId: string): Promise<{ id: string; status: string; amount: string; currency: string }> {
-    throw new Error("BTCPayClient is deprecated — migrate to CryptoServiceClient");
-  }
-}

package/src/billing/crypto/index.ts

@@ -1,7 +1,6 @@
 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 {
   ChainInfo,
   ChargeStatus,
@@ -10,24 +9,21 @@ export type {
   CryptoServiceConfig,
   DeriveAddressResult,
 } from "./client.js";
-export { BTCPayClient, CryptoServiceClient, loadCryptoConfig } 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/src/billing/crypto/key-server-entry.ts

@@ -13,13 +13,21 @@ 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");
@@ -40,10 +48,46 @@ async function main(): Promise<void> {
   const chargeStore = new DrizzleCryptoChargeRepository(db);
   const methodStore = new DrizzlePaymentMethodStore(db);
 
-  const app = createKeyServerApp({ db, chargeStore, methodStore, serviceKey: SERVICE_KEY, adminToken: ADMIN_TOKEN });
+  // 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}`);
-  serve({ fetch: app.fetch, port: 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) => {

package/src/billing/crypto/key-server-webhook.ts

@@ -0,0 +1,119 @@
+/**
+ * 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";
+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 async function handleKeyServerWebhook(
+  deps: KeyServerWebhookDeps,
+  payload: KeyServerWebhookPayload,
+): Promise<KeyServerWebhookResult> {
+  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: string[] | undefined;
+    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 as "Processing",
+    charge.token ?? undefined,
+    payload.amountReceived,
+  );
+  await deps.replayGuard.markSeen(dedupeKey, "crypto");
+  return { handled: true, tenant: charge.tenantId };
+}

package/src/billing/crypto/key-server.ts

@@ -14,12 +14,15 @@ import { derivedAddresses, pathAllocations, paymentMethods } from "../../db/sche
 import { deriveAddress, deriveP2pkhAddress } from "./btc/address-gen.js";
 import type { ICryptoChargeRepository } from "./charge-store.js";
 import { deriveDepositAddress } from "./evm/address-gen.js";
+import { centsToNative } from "./oracle/convert.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. */
@@ -145,7 +148,24 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
     const tenantId = c.req.header("X-Tenant-Id") ?? "unknown";
     const { address, index, chain, token } = await deriveNextAddress(deps.db, body.chain, tenantId);
 
+    // Look up payment method for decimals + oracle config
+    const method = await deps.methodStore.getById(body.chain);
+    if (!method) return c.json({ error: `Unknown chain: ${body.chain}` }, 400);
+
     const amountUsdCents = Math.round(body.amountUsd * 100);
+
+    // Compute expected crypto amount in native base units.
+    // Price is locked NOW — this is what the user must send.
+    let expectedAmount: bigint;
+    if (method.oracleAddress) {
+      // Volatile asset (BTC, ETH, DOGE) — oracle-priced
+      const { priceCents } = await deps.oracle.getPrice(token);
+      expectedAmount = centsToNative(amountUsdCents, priceCents, method.decimals);
+    } else {
+      // Stablecoin (1:1 USD) — e.g. $50 USDC = 50_000_000 base units (6 decimals)
+      expectedAmount = (BigInt(amountUsdCents) * 10n ** BigInt(method.decimals)) / 100n;
+    }
+
     const referenceId = `${token.toLowerCase()}:${address.toLowerCase()}`;
 
     await deps.chargeStore.createStablecoinCharge({
@@ -156,15 +176,23 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       token,
       depositAddress: address,
       derivationIndex: index,
+      callbackUrl: body.callbackUrl,
+      expectedAmount: expectedAmount.toString(),
     });
 
+    // Format display amount for the client
+    const divisor = 10 ** method.decimals;
+    const displayAmount = `${(Number(expectedAmount) / divisor).toFixed(Math.min(method.decimals, 8))} ${token}`;
+
     return c.json(
       {
         chargeId: referenceId,
         address,
-        chain: body.chain,
+        chain,
         token,
         amountUsd: body.amountUsd,
+        expectedAmount: expectedAmount.toString(),
+        displayAmount,
         derivationIndex: index,
         expiresAt: new Date(Date.now() + 30 * 60 * 1000).toISOString(), // 30 min
       },