@wopr-network/platform-core 1.42.3 → 1.44.0

package/src/monetization/crypto/__tests__/webhook.test.ts

@@ -2,14 +2,14 @@
  * Unit tests for the monetization crypto webhook handler.
  *
  * This handler is the WOPR-specific layer on top of the platform-core
- * billing/crypto webhook. Key differences from billing/crypto/webhook.ts:
+ * billing/crypto key-server webhook. Key differences from billing layer:
  *  - Uses BotBilling.checkReactivation() instead of onCreditsPurchased callback
  *  - Imports charge store / replay guard types from billing layer (relative)
  */
 import type { PGlite } from "@electric-sql/pglite";
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { CryptoChargeRepository } from "../../../billing/crypto/charge-store.js";
-import type { CryptoWebhookPayload } from "../../../billing/crypto/types.js";
+import type { CryptoWebhookPayload } from "../../../billing/crypto/index.js";
 import { DrizzleWebhookSeenRepository } from "../../../billing/drizzle-webhook-seen-repository.js";
 import { noOpReplayGuard } from "../../../billing/webhook-seen-repository.js";
 import { DrizzleLedger } from "../../../credits/ledger.js";
@@ -20,15 +20,12 @@ import { handleCryptoWebhook } from "../webhook.js";
 
 function makePayload(overrides: Partial<CryptoWebhookPayload> = {}): CryptoWebhookPayload {
   return {
-    deliveryId: "del-001",
-    webhookId: "whk-001",
-    originalDeliveryId: "del-001",
-    isRedelivery: false,
-    type: "InvoiceSettled",
-    timestamp: Date.now(),
-    storeId: "store-test",
-    invoiceId: "inv-test-001",
-    metadata: { orderId: "order-001" },
+    chargeId: "chg-test-001",
+    chain: "bitcoin",
+    address: "bc1q-test-address",
+    amountUsdCents: 2500,
+    status: "confirmed",
+    txHash: "tx-abc123",
     ...overrides,
   };
 }
@@ -57,19 +54,18 @@ describe("handleCryptoWebhook (monetization layer)", () => {
     deps = { chargeStore, creditLedger, replayGuard: noOpReplayGuard };
 
     // Default test charge: $25 = 2500 cents
-    await chargeStore.create("inv-test-001", "tenant-a", 2500);
+    await chargeStore.create("chg-test-001", "tenant-a", 2500);
   });
 
   // ---------------------------------------------------------------------------
-  // InvoiceSettled — credits ledger
+  // confirmed — credits ledger
   // ---------------------------------------------------------------------------
 
-  describe("InvoiceSettled", () => {
+  describe("confirmed status", () => {
     it("credits the ledger with the USD amount in cents", async () => {
-      const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+      const result = await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
 
       expect(result.handled).toBe(true);
-      expect(result.status).toBe("Settled");
       expect(result.tenant).toBe("tenant-a");
       expect(result.creditedCents).toBe(2500);
 
@@ -77,33 +73,33 @@ describe("handleCryptoWebhook (monetization layer)", () => {
       expect(balance.toCents()).toBe(2500);
     });
 
-    it("marks the charge as credited after settlement", async () => {
-      await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
-      expect(await chargeStore.isCredited("inv-test-001")).toBe(true);
+    it("marks the charge as credited after confirmation", async () => {
+      await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
+      expect(await chargeStore.isCredited("chg-test-001")).toBe(true);
     });
 
     it("uses crypto: prefix on reference ID in ledger entry", async () => {
-      await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+      await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
 
       const history = await creditLedger.history("tenant-a");
       expect(history).toHaveLength(1);
-      expect(history[0].referenceId).toBe("crypto:inv-test-001");
+      expect(history[0].referenceId).toBe("crypto:chg-test-001");
       expect(history[0].entryType).toBe("purchase");
     });
 
     it("records fundingSource as crypto", async () => {
-      await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+      await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
 
       const history = await creditLedger.history("tenant-a");
       expect(history[0].metadata?.fundingSource).toBe("crypto");
     });
 
-    it("is idempotent — second InvoiceSettled does not double-credit", async () => {
-      await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
-      const result2 = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+    it("is idempotent — second confirmed does not double-credit", async () => {
+      await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
+      const result2 = await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
 
       expect(result2.handled).toBe(true);
-      expect(result2.creditedCents).toBe(0);
+      expect(result2.creditedCents).toBeUndefined();
 
       // Balance is still $25, not $50
       const balance = await creditLedger.balance("tenant-a");
@@ -112,12 +108,12 @@ describe("handleCryptoWebhook (monetization layer)", () => {
   });
 
   // ---------------------------------------------------------------------------
-  // Non-settlement event types — no ledger credit
+  // Non-confirmed statuses — no ledger credit
   // ---------------------------------------------------------------------------
 
-  describe("InvoiceProcessing", () => {
+  describe("pending status", () => {
     it("does NOT credit the ledger", async () => {
-      const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceProcessing" }));
+      const result = await handleCryptoWebhook(deps, makePayload({ status: "pending" }));
 
       expect(result.handled).toBe(true);
       expect(result.tenant).toBe("tenant-a");
@@ -126,9 +122,9 @@ describe("handleCryptoWebhook (monetization layer)", () => {
     });
   });
 
-  describe("InvoiceCreated", () => {
+  describe("expired status", () => {
     it("does NOT credit the ledger", async () => {
-      const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceCreated" }));
+      const result = await handleCryptoWebhook(deps, makePayload({ status: "expired" }));
 
       expect(result.handled).toBe(true);
       expect(result.creditedCents).toBeUndefined();
@@ -136,19 +132,9 @@ describe("handleCryptoWebhook (monetization layer)", () => {
     });
   });
 
-  describe("InvoiceExpired", () => {
+  describe("failed status", () => {
     it("does NOT credit the ledger", async () => {
-      const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceExpired" }));
-
-      expect(result.handled).toBe(true);
-      expect(result.creditedCents).toBeUndefined();
-      expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
-    });
-  });
-
-  describe("InvoiceInvalid", () => {
-    it("does NOT credit the ledger", async () => {
-      const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceInvalid" }));
+      const result = await handleCryptoWebhook(deps, makePayload({ status: "failed" }));
 
       expect(result.handled).toBe(true);
       expect(result.creditedCents).toBeUndefined();
@@ -157,53 +143,35 @@ describe("handleCryptoWebhook (monetization layer)", () => {
   });
 
   // ---------------------------------------------------------------------------
-  // Unknown invoiceId — returns handled:false
+  // Unknown chargeId — returns handled:false
   // ---------------------------------------------------------------------------
 
   describe("missing charge", () => {
-    it("returns handled:false when invoiceId is not in the charge store", async () => {
-      const result = await handleCryptoWebhook(deps, makePayload({ invoiceId: "inv-unknown-999" }));
+    it("returns handled:false when chargeId is not in the charge store", async () => {
+      const result = await handleCryptoWebhook(deps, makePayload({ chargeId: "chg-unknown-999" }));
 
       expect(result.handled).toBe(false);
       expect(result.tenant).toBeUndefined();
     });
   });
 
-  // ---------------------------------------------------------------------------
-  // Status mapping for all known event types
-  // ---------------------------------------------------------------------------
-
-  describe("status mapping", () => {
-    it.each([
-      ["InvoiceCreated", "New"],
-      ["InvoiceProcessing", "Processing"],
-      ["InvoiceReceivedPayment", "Processing"],
-      ["InvoiceSettled", "Settled"],
-      ["InvoicePaymentSettled", "Settled"],
-      ["InvoiceExpired", "Expired"],
-      ["InvoiceInvalid", "Invalid"],
-    ] as const)("maps %s event to %s status", async (eventType, expectedStatus) => {
-      const result = await handleCryptoWebhook(deps, makePayload({ type: eventType }));
-      expect(result.status).toBe(expectedStatus);
-    });
-
-    it("throws on unknown event types", async () => {
-      await expect(handleCryptoWebhook(deps, makePayload({ type: "InvoiceSomeUnknownEvent" }))).rejects.toThrow(
-        "Unknown BTCPay event type: InvoiceSomeUnknownEvent",
-      );
-    });
-  });
-
   // ---------------------------------------------------------------------------
   // Charge store status updates
   // ---------------------------------------------------------------------------
 
   describe("charge store updates", () => {
     it("updates charge status on every webhook call", async () => {
-      await handleCryptoWebhook(deps, makePayload({ type: "InvoiceProcessing" }));
+      await handleCryptoWebhook(deps, makePayload({ status: "partial" }));
 
-      const charge = await chargeStore.getByReferenceId("inv-test-001");
-      expect(charge?.status).toBe("Processing");
+      const charge = await chargeStore.getByReferenceId("chg-test-001");
+      expect(charge?.status).toBe("partial");
+    });
+
+    it("settles charge when status is confirmed", async () => {
+      await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
+
+      const charge = await chargeStore.getByReferenceId("chg-test-001");
+      expect(charge?.status).toBe("Settled");
     });
   });
 
@@ -212,16 +180,16 @@ describe("handleCryptoWebhook (monetization layer)", () => {
   // ---------------------------------------------------------------------------
 
   describe("replay guard", () => {
-    it("blocks duplicate invoiceId + event type combinations", async () => {
+    it("blocks duplicate chargeId via ks: dedupe key", async () => {
       const replayGuard = new DrizzleWebhookSeenRepository(db);
       const depsWithGuard: CryptoWebhookDeps = { ...deps, replayGuard };
 
-      const first = await handleCryptoWebhook(depsWithGuard, makePayload({ type: "InvoiceSettled" }));
+      const first = await handleCryptoWebhook(depsWithGuard, makePayload({ status: "confirmed" }));
       expect(first.handled).toBe(true);
       expect(first.creditedCents).toBe(2500);
       expect(first.duplicate).toBeUndefined();
 
-      const second = await handleCryptoWebhook(depsWithGuard, makePayload({ type: "InvoiceSettled" }));
+      const second = await handleCryptoWebhook(depsWithGuard, makePayload({ status: "confirmed" }));
       expect(second.handled).toBe(true);
       expect(second.duplicate).toBe(true);
       expect(second.creditedCents).toBeUndefined();
@@ -229,17 +197,6 @@ describe("handleCryptoWebhook (monetization layer)", () => {
       // Balance is still $25, not $50
       expect((await creditLedger.balance("tenant-a")).toCents()).toBe(2500);
     });
-
-    it("same invoice with a different event type is not blocked", async () => {
-      const replayGuard = new DrizzleWebhookSeenRepository(db);
-      const depsWithGuard: CryptoWebhookDeps = { ...deps, replayGuard };
-
-      await handleCryptoWebhook(depsWithGuard, makePayload({ type: "InvoiceProcessing" }));
-      const result = await handleCryptoWebhook(depsWithGuard, makePayload({ type: "InvoiceSettled" }));
-
-      expect(result.duplicate).toBeUndefined();
-      expect(result.creditedCents).toBe(2500);
-    });
   });
 
   // ---------------------------------------------------------------------------
@@ -247,13 +204,13 @@ describe("handleCryptoWebhook (monetization layer)", () => {
   // ---------------------------------------------------------------------------
 
   describe("BotBilling reactivation", () => {
-    it("calls botBilling.checkReactivation on InvoiceSettled and returns reactivatedBots", async () => {
+    it("calls botBilling.checkReactivation on confirmed and returns reactivatedBots", async () => {
       const mockBotBilling = {
         checkReactivation: vi.fn().mockResolvedValue(["bot-1", "bot-2"]),
       } as unknown as BotBilling;
       const depsWithBots: CryptoWebhookDeps = { ...deps, botBilling: mockBotBilling };
 
-      const result = await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+      const result = await handleCryptoWebhook(depsWithBots, makePayload({ status: "confirmed" }));
 
       expect(mockBotBilling.checkReactivation).toHaveBeenCalledWith("tenant-a", creditLedger);
       expect(result.reactivatedBots).toEqual(["bot-1", "bot-2"]);
@@ -265,18 +222,18 @@ describe("handleCryptoWebhook (monetization layer)", () => {
       } as unknown as BotBilling;
       const depsWithBots: CryptoWebhookDeps = { ...deps, botBilling: mockBotBilling };
 
-      const result = await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+      const result = await handleCryptoWebhook(depsWithBots, makePayload({ status: "confirmed" }));
 
       expect(result.reactivatedBots).toBeUndefined();
     });
 
-    it("does NOT call botBilling on non-settled events", async () => {
+    it("does NOT call botBilling on non-confirmed statuses", async () => {
       const mockBotBilling = {
         checkReactivation: vi.fn().mockResolvedValue(["bot-1"]),
       } as unknown as BotBilling;
       const depsWithBots: CryptoWebhookDeps = { ...deps, botBilling: mockBotBilling };
 
-      await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceProcessing" }));
+      await handleCryptoWebhook(depsWithBots, makePayload({ status: "pending" }));
 
       expect(mockBotBilling.checkReactivation).not.toHaveBeenCalled();
     });
@@ -287,18 +244,18 @@ describe("handleCryptoWebhook (monetization layer)", () => {
       } as unknown as BotBilling;
       const depsWithBots: CryptoWebhookDeps = { ...deps, botBilling: mockBotBilling };
 
-      // First settlement — should call reactivation
-      await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+      // First confirmation — should call reactivation
+      await handleCryptoWebhook(depsWithBots, makePayload({ status: "confirmed" }));
       expect(mockBotBilling.checkReactivation).toHaveBeenCalledTimes(1);
 
-      // Second settlement — charge already credited, should NOT call reactivation again
-      await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+      // Second confirmation — charge already credited, should NOT call reactivation again
+      await handleCryptoWebhook(depsWithBots, makePayload({ status: "confirmed" }));
       expect(mockBotBilling.checkReactivation).toHaveBeenCalledTimes(1);
     });
 
     it("operates correctly when botBilling is not provided", async () => {
       // No botBilling dependency — should complete without error
-      const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+      const result = await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));
 
       expect(result.handled).toBe(true);
       expect(result.creditedCents).toBe(2500);
@@ -311,16 +268,16 @@ describe("handleCryptoWebhook (monetization layer)", () => {
   // ---------------------------------------------------------------------------
 
   describe("multiple tenants", () => {
-    it("processes invoices for different tenants independently", async () => {
-      await chargeStore.create("inv-b-001", "tenant-b", 5000);
-      await chargeStore.create("inv-c-001", "tenant-c", 1500);
+    it("processes charges for different tenants independently", async () => {
+      await chargeStore.create("chg-b-001", "tenant-b", 5000);
+      await chargeStore.create("chg-c-001", "tenant-c", 1500);
 
-      await handleCryptoWebhook(deps, makePayload({ invoiceId: "inv-b-001", type: "InvoiceSettled" }));
-      await handleCryptoWebhook(deps, makePayload({ invoiceId: "inv-c-001", type: "InvoiceSettled" }));
+      await handleCryptoWebhook(deps, makePayload({ chargeId: "chg-b-001", status: "confirmed" }));
+      await handleCryptoWebhook(deps, makePayload({ chargeId: "chg-c-001", status: "confirmed" }));
 
       expect((await creditLedger.balance("tenant-b")).toCents()).toBe(5000);
       expect((await creditLedger.balance("tenant-c")).toCents()).toBe(1500);
-      // Original tenant-a was not settled in this test
+      // Original tenant-a was not confirmed in this test
       expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
     });
   });

package/src/monetization/crypto/index.ts

@@ -1,23 +1,21 @@
-// Re-export everything from the billing/crypto module.
+// Re-export from billing/crypto module.
 export type {
-  CryptoBillingConfig,
   CryptoChargeRecord,
-  CryptoCheckoutOpts,
   CryptoConfig,
   CryptoPaymentState,
+  CryptoWebhookDeps,
   CryptoWebhookPayload,
   CryptoWebhookResult,
   ICryptoChargeRepository,
-} from "@wopr-network/platform-core/billing";
+} from "../../billing/crypto/index.js";
 export {
-  BTCPayClient,
   CryptoChargeRepository,
-  createCryptoCheckout,
+  CryptoServiceClient,
   DrizzleCryptoChargeRepository,
+  handleCryptoWebhook,
+  handleKeyServerWebhook,
   loadCryptoConfig,
   MIN_PAYMENT_USD,
-  mapBtcPayEventToStatus,
-  verifyCryptoWebhookSignature,
-} from "@wopr-network/platform-core/billing";
-export type { CryptoWebhookDeps } from "./webhook.js";
-export { handleCryptoWebhook } from "./webhook.js";
+} from "../../billing/crypto/index.js";
+export type { CryptoWebhookDeps as WoprCryptoWebhookDeps } from "./webhook.js";
+export { handleCryptoWebhook as handleWoprCryptoWebhook } from "./webhook.js";

package/src/monetization/crypto/webhook.ts

@@ -1,12 +1,7 @@
-import type {
-  CryptoWebhookPayload,
-  CryptoWebhookResult,
-  ICryptoChargeRepository,
-  IWebhookSeenRepository,
-} from "@wopr-network/platform-core/billing";
-import { mapBtcPayEventToStatus } from "@wopr-network/platform-core/billing";
-import type { ILedger } from "@wopr-network/platform-core/credits";
-import { Credit } from "@wopr-network/platform-core/credits";
+import type { CryptoWebhookPayload, ICryptoChargeRepository } from "../../billing/crypto/index.js";
+import { handleKeyServerWebhook } from "../../billing/crypto/key-server-webhook.js";
+import type { IWebhookSeenRepository } from "../../billing/webhook-seen-repository.js";
+import type { ILedger } from "../../credits/ledger.js";
 import type { BotBilling } from "../credits/bot-billing.js";
 
 export interface CryptoWebhookDeps {
@@ -17,99 +12,30 @@ export interface CryptoWebhookDeps {
 }
 
 /**
- * Process a BTCPay Server webhook event (WOPR-specific version).
+ * Process a crypto payment webhook from the key server (WOPR-specific version).
  *
- * Only credits the ledger on InvoiceSettled.
- * Uses botBilling.checkReactivation for WOPR bot suspension recovery.
- *
- * Idempotency strategy (matches Stripe webhook pattern):
- *   Primary: `creditLedger.hasReferenceId("crypto:<invoiceId>")` — atomic,
- *   checked inside the ledger's serialized transaction.
- *   Secondary: `chargeStore.markCredited()` — advisory flag for queries.
- *
- * CRITICAL: charge.amountUsdCents is in USD cents (integer).
- * Credit.fromCents() converts cents → nanodollars for the ledger.
+ * Delegates to handleKeyServerWebhook() for charge lookup, ledger crediting,
+ * and idempotency. Adds WOPR-specific bot reactivation via botBilling.
  */
 export async function handleCryptoWebhook(
   deps: CryptoWebhookDeps,
   payload: CryptoWebhookPayload,
-): Promise<CryptoWebhookResult> {
-  const { chargeStore, creditLedger } = deps;
-
-  // Replay guard FIRST: deduplicate by invoiceId + event type.
-  // Must run before mapBtcPayEventToStatus() — unknown event types throw,
-  // and BTCPay retries webhooks on failure. Without this ordering, an unknown
-  // event type causes an infinite retry loop.
-  const dedupeKey = `${payload.invoiceId}:${payload.type}`;
-  if (await deps.replayGuard.isDuplicate(dedupeKey, "crypto")) {
-    return { handled: true, status: "New", duplicate: true };
-  }
-
-  // Map BTCPay event type to a CryptoPaymentState (throws on unknown types).
-  const status = mapBtcPayEventToStatus(payload.type);
-
-  // Look up the charge record to find the tenant.
-  const charge = await chargeStore.getByReferenceId(payload.invoiceId);
-  if (!charge) {
-    return { handled: false, status };
-  }
-
-  // Update charge status regardless of event type.
-  await chargeStore.updateStatus(payload.invoiceId, status);
-
-  let result: CryptoWebhookResult;
-
-  if (payload.type === "InvoiceSettled") {
-    // Idempotency: use ledger referenceId check (same pattern as Stripe webhook).
-    // This is atomic — the referenceId is checked inside the ledger's serialized
-    // transaction, eliminating the TOCTOU race of isCredited() + creditLedger().
-    const creditRef = `crypto:${payload.invoiceId}`;
-    if (await creditLedger.hasReferenceId(creditRef)) {
-      result = {
-        handled: true,
-        status,
-        tenant: charge.tenantId,
-        creditedCents: 0,
-      };
-    } else {
-      // Credit the original USD amount requested (not the crypto amount).
-      // charge.amountUsdCents is in USD cents (integer).
-      // Credit.fromCents() converts to nanodollars for the ledger.
-      const creditCents = charge.amountUsdCents;
-
-      await creditLedger.credit(charge.tenantId, Credit.fromCents(creditCents), "purchase", {
-        description: `Crypto credit purchase via BTCPay (invoice: ${payload.invoiceId})`,
-        referenceId: creditRef,
-        fundingSource: "crypto",
-      });
-
-      // Mark credited (advisory — primary idempotency is the ledger referenceId above).
-      await chargeStore.markCredited(payload.invoiceId);
-
-      // Reactivate suspended bots (same as Stripe webhook).
-      let reactivatedBots: string[] | undefined;
-      if (deps.botBilling) {
-        reactivatedBots = await deps.botBilling.checkReactivation(charge.tenantId, creditLedger);
-        if (reactivatedBots.length === 0) reactivatedBots = undefined;
-      }
-
-      result = {
-        handled: true,
-        status,
-        tenant: charge.tenantId,
-        creditedCents: creditCents,
-        reactivatedBots,
-      };
-    }
-  } else {
-    // New, Processing, Expired, Invalid — just track status.
-    result = {
-      handled: true,
-      status,
-      tenant: charge.tenantId,
-    };
-  }
-
-  await deps.replayGuard.markSeen(dedupeKey, "crypto");
-  return result;
+): Promise<{
+  handled: boolean;
+  duplicate?: boolean;
+  tenant?: string;
+  creditedCents?: number;
+  reactivatedBots?: string[];
+}> {
+  return handleKeyServerWebhook(
+    {
+      chargeStore: deps.chargeStore,
+      creditLedger: deps.creditLedger,
+      replayGuard: deps.replayGuard,
+      onCreditsPurchased: deps.botBilling
+        ? (tenantId, ledger) => deps.botBilling?.checkReactivation(tenantId, ledger) ?? Promise.resolve([])
+        : undefined,
+    },
+    payload,
+  );
 }

package/src/monetization/index.ts

@@ -158,10 +158,8 @@ export {
   SIGNUP_GRANT,
   SUSPENSION_GRACE_DAYS,
 } from "./credits/index.js";
-// Crypto payments (BTCPay Server)
+// Crypto payments (key server — native BTC/EVM watchers, no BTCPay)
 export type {
-  CryptoBillingConfig,
-  CryptoCheckoutOpts,
   CryptoConfig,
   CryptoPaymentState,
   CryptoWebhookDeps,
@@ -169,15 +167,13 @@ export type {
   CryptoWebhookResult,
 } from "./crypto/index.js";
 export {
-  BTCPayClient,
   CryptoChargeRepository,
-  createCryptoCheckout,
+  CryptoServiceClient,
   DrizzleCryptoChargeRepository,
   handleCryptoWebhook,
+  handleKeyServerWebhook,
   loadCryptoConfig,
   MIN_PAYMENT_USD,
-  mapBtcPayEventToStatus,
-  verifyCryptoWebhookSignature,
 } from "./crypto/index.js";
 // Feature gating middleware (WOP-384 — replaced tier gates with balance gates)
 export {

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

@@ -1,18 +0,0 @@
-import type { ICryptoChargeRepository } from "./charge-store.js";
-import type { BTCPayClient } from "./client.js";
-import type { CryptoCheckoutOpts } from "./types.js";
-/** Minimum payment amount in USD. */
-export declare const MIN_PAYMENT_USD = 10;
-/**
- * Create a BTCPay invoice and store the charge record.
- *
- * Returns the BTCPay-hosted checkout page URL and invoice ID.
- * The user is redirected to checkoutLink to complete the crypto payment.
- *
- * NOTE: amountUsd is converted to cents (integer) for the charge store.
- * The charge store holds USD cents, NOT nanodollars.
- */
-export declare function createCryptoCheckout(client: BTCPayClient, chargeStore: ICryptoChargeRepository, opts: CryptoCheckoutOpts): Promise<{
-    referenceId: string;
-    url: string;
-}>;

package/dist/billing/crypto/checkout.js

@@ -1,35 +0,0 @@
-import crypto from "node:crypto";
-import { Credit } from "../../credits/credit.js";
-/** Minimum payment amount in USD. */
-export const MIN_PAYMENT_USD = 10;
-/**
- * Create a BTCPay invoice and store the charge record.
- *
- * Returns the BTCPay-hosted checkout page URL and invoice ID.
- * The user is redirected to checkoutLink to complete the crypto payment.
- *
- * NOTE: amountUsd is converted to cents (integer) for the charge store.
- * The charge store holds USD cents, NOT nanodollars.
- */
-export async function createCryptoCheckout(client, chargeStore, opts) {
-    if (opts.amountUsd < MIN_PAYMENT_USD) {
-        throw new Error(`Minimum payment amount is $${MIN_PAYMENT_USD}`);
-    }
-    const orderId = `crypto:${opts.tenant}:${crypto.randomUUID()}`;
-    const invoice = await client.createInvoice({
-        amountUsd: opts.amountUsd,
-        orderId,
-        buyerEmail: `${opts.tenant}@${process.env.PLATFORM_DOMAIN ?? "wopr.bot"}`,
-    });
-    // Store the charge record for webhook correlation.
-    // amountUsdCents = USD * 100 (cents, NOT nanodollars).
-    // Credit.fromDollars() handles the float → integer boundary safely via Math.round
-    // on the nanodollar scale, then toCentsRounded() converts back to integer cents.
-    // This avoids direct floating-point multiplication for the cents conversion.
-    const amountUsdCents = Credit.fromDollars(opts.amountUsd).toCentsRounded();
-    await chargeStore.create(invoice.id, opts.tenant, amountUsdCents);
-    return {
-        referenceId: invoice.id,
-        url: invoice.checkoutLink,
-    };
-}