@wopr-network/platform-core 1.43.0 → 1.44.1

package/dist/monetization/crypto/__tests__/webhook.test.js

@@ -7,15 +7,12 @@ import { createTestDb, truncateAllTables } from "../../../test/db.js";
 import { handleCryptoWebhook } from "../webhook.js";
 function makePayload(overrides = {}) {
     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,
     };
 }
@@ -38,160 +35,128 @@ describe("handleCryptoWebhook (monetization layer)", () => {
         await creditLedger.seedSystemAccounts();
         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);
             const balance = await creditLedger.balance("tenant-a");
             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");
             expect(balance.toCents()).toBe(2500);
         });
     });
     // ---------------------------------------------------------------------------
-    // 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");
             expect(result.creditedCents).toBeUndefined();
             expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
         });
     });
-    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();
             expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
         });
     });
-    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();
             expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
         });
     });
     // ---------------------------------------------------------------------------
-    // 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"],
-        ])("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" }));
-            const charge = await chargeStore.getByReferenceId("inv-test-001");
-            expect(charge?.status).toBe("Processing");
+            await handleCryptoWebhook(deps, makePayload({ status: "partial" }));
+            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");
         });
     });
     // ---------------------------------------------------------------------------
     // Replay guard / idempotency
     // ---------------------------------------------------------------------------
     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 = { ...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();
             // 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 = { ...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);
-        });
     });
     // ---------------------------------------------------------------------------
     // BotBilling reactivation — WOPR-specific behaviour
     // ---------------------------------------------------------------------------
     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"]),
             };
             const depsWithBots = { ...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"]);
         });
@@ -200,15 +165,15 @@ describe("handleCryptoWebhook (monetization layer)", () => {
                 checkReactivation: vi.fn().mockResolvedValue([]),
             };
             const depsWithBots = { ...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"]),
             };
             const depsWithBots = { ...deps, botBilling: mockBotBilling };
-            await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceProcessing" }));
+            await handleCryptoWebhook(depsWithBots, makePayload({ status: "pending" }));
             expect(mockBotBilling.checkReactivation).not.toHaveBeenCalled();
         });
         it("does NOT call botBilling when charge is already credited (idempotency path)", async () => {
@@ -216,16 +181,16 @@ describe("handleCryptoWebhook (monetization layer)", () => {
                 checkReactivation: vi.fn().mockResolvedValue(["bot-1"]),
             };
             const depsWithBots = { ...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);
             expect(result.reactivatedBots).toBeUndefined();
@@ -235,14 +200,14 @@ describe("handleCryptoWebhook (monetization layer)", () => {
     // Multiple tenants — independent processing
     // ---------------------------------------------------------------------------
     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);
-            await handleCryptoWebhook(deps, makePayload({ invoiceId: "inv-b-001", type: "InvoiceSettled" }));
-            await handleCryptoWebhook(deps, makePayload({ invoiceId: "inv-c-001", type: "InvoiceSettled" }));
+        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({ 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/dist/monetization/crypto/index.d.ts

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

package/dist/monetization/crypto/index.js

@@ -1,2 +1,2 @@
-export { BTCPayClient, CryptoChargeRepository, createCryptoCheckout, DrizzleCryptoChargeRepository, loadCryptoConfig, MIN_PAYMENT_USD, mapBtcPayEventToStatus, verifyCryptoWebhookSignature, } from "@wopr-network/platform-core/billing";
-export { handleCryptoWebhook } from "./webhook.js";
+export { CryptoChargeRepository, CryptoServiceClient, DrizzleCryptoChargeRepository, handleCryptoWebhook, handleKeyServerWebhook, loadCryptoConfig, MIN_PAYMENT_USD, } from "../../billing/crypto/index.js";
+export { handleCryptoWebhook as handleWoprCryptoWebhook } from "./webhook.js";

package/dist/monetization/crypto/webhook.d.ts

@@ -1,5 +1,6 @@
-import type { CryptoWebhookPayload, CryptoWebhookResult, ICryptoChargeRepository, IWebhookSeenRepository } from "@wopr-network/platform-core/billing";
-import type { ILedger } from "@wopr-network/platform-core/credits";
+import type { CryptoWebhookPayload, ICryptoChargeRepository } from "../../billing/crypto/index.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 {
     chargeStore: ICryptoChargeRepository;
@@ -8,17 +9,15 @@ export interface CryptoWebhookDeps {
     replayGuard: IWebhookSeenRepository;
 }
 /**
- * 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 declare function handleCryptoWebhook(deps: CryptoWebhookDeps, payload: CryptoWebhookPayload): Promise<CryptoWebhookResult>;
+export declare function handleCryptoWebhook(deps: CryptoWebhookDeps, payload: CryptoWebhookPayload): Promise<{
+    handled: boolean;
+    duplicate?: boolean;
+    tenant?: string;
+    creditedCents?: number;
+    reactivatedBots?: string[];
+}>;

package/dist/monetization/crypto/webhook.js

@@ -1,88 +1,17 @@
-import { mapBtcPayEventToStatus } from "@wopr-network/platform-core/billing";
-import { Credit } from "@wopr-network/platform-core/credits";
+import { handleKeyServerWebhook } from "../../billing/crypto/key-server-webhook.js";
 /**
- * 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, payload) {
-    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;
-    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;
-            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;
+    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/dist/monetization/index.d.ts

@@ -41,8 +41,8 @@ export type { BudgetCheckerConfig, BudgetCheckResult, SpendLimits } from "./budg
 export { BudgetChecker, DrizzleBudgetChecker } from "./budget/index.js";
 export type { BillingState, CreditType, DebitType, GetActiveBotCount, HistoryOptions, ILedger, JournalEntry, OnSuspend, RuntimeCronConfig, RuntimeCronResult, TransactionType, } from "./credits/index.js";
 export { BotBilling, buildResourceTierCosts, DAILY_BOT_COST, DrizzleBotBilling, DrizzleLedger, grantSignupCredits, InsufficientBalanceError, Ledger, runRuntimeDeductions, SIGNUP_GRANT, SUSPENSION_GRACE_DAYS, } from "./credits/index.js";
-export type { CryptoBillingConfig, CryptoCheckoutOpts, CryptoConfig, CryptoPaymentState, CryptoWebhookDeps, CryptoWebhookPayload, CryptoWebhookResult, } from "./crypto/index.js";
-export { BTCPayClient, CryptoChargeRepository, createCryptoCheckout, DrizzleCryptoChargeRepository, handleCryptoWebhook, loadCryptoConfig, MIN_PAYMENT_USD, mapBtcPayEventToStatus, verifyCryptoWebhookSignature, } from "./crypto/index.js";
+export type { CryptoConfig, CryptoPaymentState, CryptoWebhookDeps, CryptoWebhookPayload, CryptoWebhookResult, } from "./crypto/index.js";
+export { CryptoChargeRepository, CryptoServiceClient, DrizzleCryptoChargeRepository, handleCryptoWebhook, handleKeyServerWebhook, loadCryptoConfig, MIN_PAYMENT_USD, } from "./crypto/index.js";
 export { type CreditGateConfig, createBalanceGate, createCreditGate, createFeatureGate, type FeatureGateConfig, type GetUserBalance, type ResolveTenantId, } from "./feature-gate.js";
 export type { BillingPeriod, BillingPeriodSummary, MeterEventRow, UsageSummary, } from "./metering/index.js";
 export { DrizzleMeterAggregator, DrizzleMeterEmitter, MeterAggregator, MeterEmitter, } from "./metering/index.js";

package/dist/monetization/index.js

@@ -50,7 +50,7 @@ export { withMargin, } from "./adapters/types.js";
 export { ArbitrageRouter, NoProviderAvailableError, ProviderRegistry, } from "./arbitrage/index.js";
 export { BudgetChecker, DrizzleBudgetChecker } from "./budget/index.js";
 export { BotBilling, buildResourceTierCosts, DAILY_BOT_COST, DrizzleBotBilling, DrizzleLedger, grantSignupCredits, InsufficientBalanceError, Ledger, runRuntimeDeductions, SIGNUP_GRANT, SUSPENSION_GRACE_DAYS, } from "./credits/index.js";
-export { BTCPayClient, CryptoChargeRepository, createCryptoCheckout, DrizzleCryptoChargeRepository, handleCryptoWebhook, loadCryptoConfig, MIN_PAYMENT_USD, mapBtcPayEventToStatus, verifyCryptoWebhookSignature, } from "./crypto/index.js";
+export { CryptoChargeRepository, CryptoServiceClient, DrizzleCryptoChargeRepository, handleCryptoWebhook, handleKeyServerWebhook, loadCryptoConfig, MIN_PAYMENT_USD, } from "./crypto/index.js";
 // Feature gating middleware (WOP-384 — replaced tier gates with balance gates)
 export { createBalanceGate, createCreditGate, createFeatureGate, } from "./feature-gate.js";
 export { DrizzleMeterAggregator, DrizzleMeterEmitter, MeterAggregator, MeterEmitter, } from "./metering/index.js";

package/drizzle/migrations/0015_callback_url.sql

@@ -0,0 +1,32 @@
+-- Watcher service schema additions: webhook outbox + charge amount tracking.
+
+-- 1. callback_url for webhook delivery
+ALTER TABLE "crypto_charges" ADD COLUMN "callback_url" text;
+--> statement-breakpoint
+
+-- 2. Expected crypto amount in native base units (locked at charge creation)
+ALTER TABLE "crypto_charges" ADD COLUMN "expected_amount" text;
+--> statement-breakpoint
+
+-- 3. Running total of received crypto in native base units (partial payments)
+ALTER TABLE "crypto_charges" ADD COLUMN "received_amount" text;
+--> statement-breakpoint
+
+-- 4. Webhook delivery outbox — durable retry for payment callbacks
+CREATE TABLE IF NOT EXISTS "webhook_deliveries" (
+  "id" integer PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  "charge_id" text NOT NULL,
+  "callback_url" text NOT NULL,
+  "payload" text NOT NULL,
+  "status" text NOT NULL DEFAULT 'pending',
+  "attempts" integer NOT NULL DEFAULT 0,
+  "next_retry_at" text,
+  "last_error" text,
+  "created_at" text NOT NULL DEFAULT (now())
+);
+--> statement-breakpoint
+
+CREATE INDEX IF NOT EXISTS "idx_webhook_deliveries_status" ON "webhook_deliveries" ("status");
+--> statement-breakpoint
+
+CREATE INDEX IF NOT EXISTS "idx_webhook_deliveries_charge" ON "webhook_deliveries" ("charge_id");

package/drizzle/migrations/meta/_journal.json

@@ -106,6 +106,13 @@
       "when": 1742832000000,
       "tag": "0014_crypto_key_server",
       "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "7",
+      "when": 1742918400000,
+      "tag": "0015_callback_url",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.43.0",
+  "version": "1.44.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -87,7 +87,21 @@ function mockDeps(): KeyServerDeps & {
       },
     ]),
     listAll: vi.fn(),
-    getById: vi.fn(),
+    getById: vi.fn().mockResolvedValue({
+      id: "btc",
+      type: "native",
+      token: "BTC",
+      chain: "bitcoin",
+      decimals: 8,
+      displayName: "Bitcoin",
+      contractAddress: null,
+      confirmations: 6,
+      oracleAddress: "0x64c911996D3c6aC71f9b455B1E8E7266BcbD848F",
+      xpub: null,
+      displayOrder: 0,
+      enabled: true,
+      rpcUrl: null,
+    }),
     listByType: vi.fn(),
     upsert: vi.fn().mockResolvedValue(undefined),
     setEnabled: vi.fn().mockResolvedValue(undefined),
@@ -96,6 +110,7 @@ function mockDeps(): KeyServerDeps & {
     db: createMockDb() as never,
     chargeStore: chargeStore as never,
     methodStore: methodStore as never,
+    oracle: { getPrice: vi.fn().mockResolvedValue({ priceCents: 6_500_000, updatedAt: new Date() }) } as never,
   };
 }
 

package/src/billing/crypto/btc/watcher.ts

@@ -14,6 +14,8 @@ export interface BtcWatcherOpts {
   oracle: IPriceOracle;
   /** Required — BTC has no block cursor, so txid dedup must be persisted. */
   cursorStore: IWatcherCursorStore;
+  /** Override chain identity for cursor namespace (default: config.network). Prevents txid collisions across BTC/LTC/DOGE. */
+  chainId?: string;
 }
 
 interface ReceivedByAddress {
@@ -39,7 +41,7 @@ export class BtcWatcher {
     this.minConfirmations = opts.config.confirmations;
     this.oracle = opts.oracle;
     this.cursorStore = opts.cursorStore;
-    this.watcherId = `btc:${opts.config.network}`;
+    this.watcherId = `btc:${opts.chainId ?? opts.config.network}`;
   }
 
   /** Update the set of watched addresses. */

package/src/billing/crypto/charge-store.ts

@@ -17,6 +17,9 @@ export interface CryptoChargeRecord {
   token: string | null;
   depositAddress: string | null;
   derivationIndex: number | null;
+  callbackUrl: string | null;
+  expectedAmount: string | null;
+  receivedAmount: string | null;
 }
 
 export interface CryptoDepositChargeInput {
@@ -27,6 +30,9 @@ export interface CryptoDepositChargeInput {
   token: string;
   depositAddress: string;
   derivationIndex: number;
+  callbackUrl?: string;
+  /** Expected crypto amount in native base units (sats for BTC, base units for ERC20). */
+  expectedAmount?: string;
 }
 
 export interface ICryptoChargeRepository {
@@ -50,7 +56,7 @@ export interface ICryptoChargeRepository {
 /**
  * Manages crypto charge records in PostgreSQL.
  *
- * Each charge maps a BTCPay invoice ID to a tenant and tracks
+ * Each charge maps a deposit address to a tenant and tracks
  * the payment lifecycle (New → Processing → Settled/Expired/Invalid).
  *
  * amountUsdCents stores the requested amount in USD cents (integer).
@@ -92,6 +98,9 @@ export class DrizzleCryptoChargeRepository implements ICryptoChargeRepository {
       token: row.token ?? null,
       depositAddress: row.depositAddress ?? null,
       derivationIndex: row.derivationIndex ?? null,
+      callbackUrl: row.callbackUrl ?? null,
+      expectedAmount: row.expectedAmount ?? null,
+      receivedAmount: row.receivedAmount ?? null,
     };
   }
 
@@ -146,6 +155,9 @@ export class DrizzleCryptoChargeRepository implements ICryptoChargeRepository {
       token: input.token,
       depositAddress: input.depositAddress.toLowerCase(),
       derivationIndex: input.derivationIndex,
+      callbackUrl: input.callbackUrl,
+      expectedAmount: input.expectedAmount,
+      receivedAmount: "0",
     });
   }