@wopr-network/platform-core 1.14.7 → 1.15.0

package/dist/config/provider-endpoints.d.ts

@@ -2,5 +2,9 @@ import type { Provider } from "../security/types.js";
 /**
  * Base API URLs used to validate provider keys.
  * Centralised here so every consumer references one source of truth.
+ *
+ * Each URL can be overridden via env var for proxied / air-gapped / self-hosted deployments:
+ *   ANTHROPIC_API_URL, OPENAI_API_URL, GOOGLE_API_URL,
+ *   DISCORD_API_URL, ELEVENLABS_API_URL, DEEPGRAM_API_URL
  */
 export declare const PROVIDER_API_URLS: Record<Provider, string>;

package/dist/config/provider-endpoints.js

@@ -1,12 +1,16 @@
 /**
  * Base API URLs used to validate provider keys.
  * Centralised here so every consumer references one source of truth.
+ *
+ * Each URL can be overridden via env var for proxied / air-gapped / self-hosted deployments:
+ *   ANTHROPIC_API_URL, OPENAI_API_URL, GOOGLE_API_URL,
+ *   DISCORD_API_URL, ELEVENLABS_API_URL, DEEPGRAM_API_URL
  */
 export const PROVIDER_API_URLS = {
-    anthropic: "https://api.anthropic.com/v1/models",
-    openai: "https://api.openai.com/v1/models",
-    google: "https://generativelanguage.googleapis.com/v1/models",
-    discord: "https://discord.com/api/v10/users/@me",
-    elevenlabs: "https://api.elevenlabs.io/v1/user",
-    deepgram: "https://api.deepgram.com/v1/projects",
+    anthropic: process.env.ANTHROPIC_API_URL || "https://api.anthropic.com/v1/models",
+    openai: process.env.OPENAI_API_URL || "https://api.openai.com/v1/models",
+    google: process.env.GOOGLE_API_URL || "https://generativelanguage.googleapis.com/v1/models",
+    discord: process.env.DISCORD_API_URL || "https://discord.com/api/v10/users/@me",
+    elevenlabs: process.env.ELEVENLABS_API_URL || "https://api.elevenlabs.io/v1/user",
+    deepgram: process.env.DEEPGRAM_API_URL || "https://api.deepgram.com/v1/projects",
 };

package/dist/credits/credit-ledger.d.ts

@@ -2,16 +2,16 @@
  * NAMING CONVENTION — cents vs credits (WOP-1058)
  *
  * - `_cents` suffix = value denominated in USD cents.
- *   Used for: Stripe amounts, PayRam amounts, ledger balances, ledger transactions.
+ *   Used for: Stripe amounts, BTCPay amounts, ledger balances, ledger transactions.
  *   The platform credit unit IS the USD cent (1 credit = 1 cent = $0.01).
  *
  * - `_credits` suffix = platform credit count (used in DB columns and raw storage).
  *   Semantically identical to cents but signals "this is a platform concept stored
  *   as a Credit.toRaw() nanodollar value in the database."
  *
- * - NEVER rename a Stripe/PayRam-facing `_cents` field to `_credits`.
+ * - NEVER rename a Stripe/BTCPay-facing `_cents` field to `_credits`.
  *   Stripe's `amount` parameter and `amount_total` response are always USD cents.
- *   PayRam's `amountUsdCents` is always USD cents.
+ *   BTCPay's `amountUsdCents` is always USD cents.
  *
  * - When adding new fields: if it touches a payment processor API, use `_cents`.
  *   If it's a DB column storing Credit.toRaw() values, use `_credits`.

package/dist/credits/credit-ledger.js

@@ -2,16 +2,16 @@
  * NAMING CONVENTION — cents vs credits (WOP-1058)
  *
  * - `_cents` suffix = value denominated in USD cents.
- *   Used for: Stripe amounts, PayRam amounts, ledger balances, ledger transactions.
+ *   Used for: Stripe amounts, BTCPay amounts, ledger balances, ledger transactions.
  *   The platform credit unit IS the USD cent (1 credit = 1 cent = $0.01).
  *
  * - `_credits` suffix = platform credit count (used in DB columns and raw storage).
  *   Semantically identical to cents but signals "this is a platform concept stored
  *   as a Credit.toRaw() nanodollar value in the database."
  *
- * - NEVER rename a Stripe/PayRam-facing `_cents` field to `_credits`.
+ * - NEVER rename a Stripe/BTCPay-facing `_cents` field to `_credits`.
  *   Stripe's `amount` parameter and `amount_total` response are always USD cents.
- *   PayRam's `amountUsdCents` is always USD cents.
+ *   BTCPay's `amountUsdCents` is always USD cents.
  *
  * - When adding new fields: if it touches a payment processor API, use `_cents`.
  *   If it's a DB column storing Credit.toRaw() values, use `_credits`.

package/dist/db/index.d.ts

@@ -14,10 +14,10 @@ export type DrizzleDb = PgDatabase<PgQueryResultHKT, PlatformSchema>;
 export type PlatformDb = DrizzleDb;
 /** Create a Drizzle database instance wrapping the given pg.Pool. */
 export declare function createDb(pool: Pool): PlatformDb;
-export { schema };
 export type { SQL } from "drizzle-orm";
 export { and, asc, count, desc, eq, gt, gte, ilike, inArray, isNull, like, lt, lte, ne, or, sql } from "drizzle-orm";
 export { pgTable, text } from "drizzle-orm/pg-core";
 export type { AuthUser, IAuthUserRepository } from "./auth-user-repository.js";
 export { BetterAuthUserRepository } from "./auth-user-repository.js";
 export { creditColumn } from "./credit-column.js";
+export { schema };

package/dist/db/index.js

@@ -4,7 +4,6 @@ import * as schema from "./schema/index.js";
 export function createDb(pool) {
     return drizzle(pool, { schema });
 }
-export { schema };
 // Re-export commonly used drizzle-orm operators so consumers using pnpm link
 // resolve them from the same drizzle-orm instance as the schema tables.
 export { and, asc, count, desc, eq, gt, gte, ilike, inArray, isNull, like, lt, lte, ne, or, sql } from "drizzle-orm";
@@ -12,3 +11,4 @@ export { and, asc, count, desc, eq, gt, gte, ilike, inArray, isNull, like, lt, l
 export { pgTable, text } from "drizzle-orm/pg-core";
 export { BetterAuthUserRepository } from "./auth-user-repository.js";
 export { creditColumn } from "./credit-column.js";
+export { schema };

package/dist/db/schema/credits.js

@@ -13,7 +13,7 @@ export const creditTransactions = pgTable("credit_transactions", {
     type: text("type").notNull(), // signup_grant | purchase | bounty | referral | promo | community_dividend | bot_runtime | adapter_usage | addon | refund | correction
     description: text("description"),
     referenceId: text("reference_id").unique(),
-    fundingSource: text("funding_source"), // "stripe" | "payram" | null (null = legacy/signup)
+    fundingSource: text("funding_source"), // "stripe" | "crypto" | null (null = legacy/signup)
     attributedUserId: text("attributed_user_id"), // nullable — null for system/bot charges
     createdAt: text("created_at").notNull().default(sql `(now())`),
     expiresAt: text("expires_at"), // nullable — null means never expires

package/dist/db/schema/{payram.d.ts → crypto.d.ts}

@@ -1,14 +1,18 @@
 /**
- * PayRam payment sessions — tracks the lifecycle of each crypto payment.
- * reference_id is the PayRam-assigned unique identifier.
+ * Crypto payment charges — tracks the lifecycle of each BTCPay invoice.
+ * reference_id is the BTCPay invoice ID.
+ *
+ * amountUsdCents stores the requested amount in USD cents (integer).
+ * This is NOT nanodollars — Credit.fromCents() handles the conversion
+ * when crediting the ledger in the webhook handler.
  */
-export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithColumns<{
-    name: "payram_charges";
+export declare const cryptoCharges: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "crypto_charges";
     schema: undefined;
     columns: {
         referenceId: import("drizzle-orm/pg-core").PgColumn<{
             name: "reference_id";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -25,7 +29,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         tenantId: import("drizzle-orm/pg-core").PgColumn<{
             name: "tenant_id";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -42,7 +46,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         amountUsdCents: import("drizzle-orm/pg-core").PgColumn<{
             name: "amount_usd_cents";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "number";
             columnType: "PgInteger";
             data: number;
@@ -59,7 +63,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         status: import("drizzle-orm/pg-core").PgColumn<{
             name: "status";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -76,7 +80,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         currency: import("drizzle-orm/pg-core").PgColumn<{
             name: "currency";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -93,7 +97,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         filledAmount: import("drizzle-orm/pg-core").PgColumn<{
             name: "filled_amount";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -110,7 +114,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -127,7 +131,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         updatedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "updated_at";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -144,7 +148,7 @@ export declare const payramCharges: import("drizzle-orm/pg-core").PgTableWithCol
         }, {}, {}>;
         creditedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "credited_at";
-            tableName: "payram_charges";
+            tableName: "crypto_charges";
             dataType: "string";
             columnType: "PgText";
             data: string;

package/dist/db/schema/crypto.js

@@ -0,0 +1,25 @@
+import { sql } from "drizzle-orm";
+import { index, integer, pgTable, text } from "drizzle-orm/pg-core";
+/**
+ * Crypto payment charges — tracks the lifecycle of each BTCPay invoice.
+ * reference_id is the BTCPay invoice ID.
+ *
+ * amountUsdCents stores the requested amount in USD cents (integer).
+ * This is NOT nanodollars — Credit.fromCents() handles the conversion
+ * when crediting the ledger in the webhook handler.
+ */
+export const cryptoCharges = pgTable("crypto_charges", {
+    referenceId: text("reference_id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    amountUsdCents: integer("amount_usd_cents").notNull(),
+    status: text("status").notNull().default("New"),
+    currency: text("currency"),
+    filledAmount: text("filled_amount"),
+    createdAt: text("created_at").notNull().default(sql `(now())`),
+    updatedAt: text("updated_at").notNull().default(sql `(now())`),
+    creditedAt: text("credited_at"),
+}, (table) => [
+    index("idx_crypto_charges_tenant").on(table.tenantId),
+    index("idx_crypto_charges_status").on(table.status),
+    index("idx_crypto_charges_created").on(table.createdAt),
+]);

package/dist/db/schema/index.d.ts

@@ -16,6 +16,7 @@ export * from "./coupon-codes.js";
 export * from "./credit-auto-topup.js";
 export * from "./credit-auto-topup-settings.js";
 export * from "./credits.js";
+export * from "./crypto.js";
 export * from "./dividend-distributions.js";
 export * from "./email-notifications.js";
 export * from "./fleet-event-history.js";
@@ -39,7 +40,6 @@ export * from "./onboarding-sessions.js";
 export * from "./org-memberships.js";
 export * from "./organization-members.js";
 export * from "./page-contexts.js";
-export * from "./payram.js";
 export * from "./platform-api-keys.js";
 export * from "./plugin-configs.js";
 export * from "./plugin-marketplace-content.js";

package/dist/db/schema/index.js

@@ -16,6 +16,7 @@ export * from "./coupon-codes.js";
 export * from "./credit-auto-topup.js";
 export * from "./credit-auto-topup-settings.js";
 export * from "./credits.js";
+export * from "./crypto.js";
 export * from "./dividend-distributions.js";
 export * from "./email-notifications.js";
 export * from "./fleet-event-history.js";
@@ -39,7 +40,6 @@ export * from "./onboarding-sessions.js";
 export * from "./org-memberships.js";
 export * from "./organization-members.js";
 export * from "./page-contexts.js";
-export * from "./payram.js";
 export * from "./platform-api-keys.js";
 export * from "./plugin-configs.js";
 export * from "./plugin-marketplace-content.js";

package/dist/fleet/node-repository.d.ts

@@ -1,8 +1,6 @@
 import type { NodeStatus } from "./node-state-machine.js";
 import type { NewProvisioningNode, Node, NodeRegistration, NodeTransition, ProvisionDataUpdate, SelfHostedNodeRegistration } from "./repository-types.js";
-export type { Node, NodeTransition };
-export type { NodeRegistration, SelfHostedNodeRegistration };
-export type { NewProvisioningNode, ProvisionDataUpdate };
+export type { NewProvisioningNode, Node, NodeRegistration, NodeTransition, ProvisionDataUpdate, SelfHostedNodeRegistration, };
 export interface INodeRepository {
     getById(id: string): Promise<Node | null>;
     getBySecret(secret: string): Promise<Node | null>;

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

@@ -0,0 +1,249 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { CryptoChargeRepository } from "../../../billing/crypto/charge-store.js";
+import { DrizzleWebhookSeenRepository } from "../../../billing/drizzle-webhook-seen-repository.js";
+import { noOpReplayGuard } from "../../../billing/webhook-seen-repository.js";
+import { DrizzleLedger } from "../../../credits/ledger.js";
+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" },
+        ...overrides,
+    };
+}
+let pool;
+let db;
+beforeAll(async () => {
+    ({ db, pool } = await createTestDb());
+});
+afterAll(async () => {
+    await pool.close();
+});
+describe("handleCryptoWebhook (monetization layer)", () => {
+    let chargeStore;
+    let creditLedger;
+    let deps;
+    beforeEach(async () => {
+        await truncateAllTables(pool);
+        chargeStore = new CryptoChargeRepository(db);
+        creditLedger = new DrizzleLedger(db);
+        await creditLedger.seedSystemAccounts();
+        deps = { chargeStore, creditLedger, replayGuard: noOpReplayGuard };
+        // Default test charge: $25 = 2500 cents
+        await chargeStore.create("inv-test-001", "tenant-a", 2500);
+    });
+    // ---------------------------------------------------------------------------
+    // InvoiceSettled — credits ledger
+    // ---------------------------------------------------------------------------
+    describe("InvoiceSettled", () => {
+        it("credits the ledger with the USD amount in cents", async () => {
+            const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+            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("uses crypto: prefix on reference ID in ledger entry", async () => {
+            await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+            const history = await creditLedger.history("tenant-a");
+            expect(history).toHaveLength(1);
+            expect(history[0].referenceId).toBe("crypto:inv-test-001");
+            expect(history[0].entryType).toBe("purchase");
+        });
+        it("records fundingSource as crypto", async () => {
+            await handleCryptoWebhook(deps, makePayload({ type: "InvoiceSettled" }));
+            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" }));
+            expect(result2.handled).toBe(true);
+            expect(result2.creditedCents).toBe(0);
+            // 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
+    // ---------------------------------------------------------------------------
+    describe("InvoiceProcessing", () => {
+        it("does NOT credit the ledger", async () => {
+            const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceProcessing" }));
+            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", () => {
+        it("does NOT credit the ledger", async () => {
+            const result = await handleCryptoWebhook(deps, makePayload({ type: "InvoiceCreated" }));
+            expect(result.handled).toBe(true);
+            expect(result.creditedCents).toBeUndefined();
+            expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
+        });
+    });
+    describe("InvoiceExpired", () => {
+        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" }));
+            expect(result.handled).toBe(true);
+            expect(result.creditedCents).toBeUndefined();
+            expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Unknown invoiceId — 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" }));
+            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");
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Replay guard / idempotency
+    // ---------------------------------------------------------------------------
+    describe("replay guard", () => {
+        it("blocks duplicate invoiceId + event type combinations", async () => {
+            const replayGuard = new DrizzleWebhookSeenRepository(db);
+            const depsWithGuard = { ...deps, replayGuard };
+            const first = await handleCryptoWebhook(depsWithGuard, makePayload({ type: "InvoiceSettled" }));
+            expect(first.handled).toBe(true);
+            expect(first.creditedCents).toBe(2500);
+            expect(first.duplicate).toBeUndefined();
+            const second = await handleCryptoWebhook(depsWithGuard, makePayload({ type: "InvoiceSettled" }));
+            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 () => {
+            const mockBotBilling = {
+                checkReactivation: vi.fn().mockResolvedValue(["bot-1", "bot-2"]),
+            };
+            const depsWithBots = { ...deps, botBilling: mockBotBilling };
+            const result = await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+            expect(mockBotBilling.checkReactivation).toHaveBeenCalledWith("tenant-a", creditLedger);
+            expect(result.reactivatedBots).toEqual(["bot-1", "bot-2"]);
+        });
+        it("omits reactivatedBots when no bots are reactivated", async () => {
+            const mockBotBilling = {
+                checkReactivation: vi.fn().mockResolvedValue([]),
+            };
+            const depsWithBots = { ...deps, botBilling: mockBotBilling };
+            const result = await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+            expect(result.reactivatedBots).toBeUndefined();
+        });
+        it("does NOT call botBilling on non-settled events", async () => {
+            const mockBotBilling = {
+                checkReactivation: vi.fn().mockResolvedValue(["bot-1"]),
+            };
+            const depsWithBots = { ...deps, botBilling: mockBotBilling };
+            await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceProcessing" }));
+            expect(mockBotBilling.checkReactivation).not.toHaveBeenCalled();
+        });
+        it("does NOT call botBilling when charge is already credited (idempotency path)", async () => {
+            const mockBotBilling = {
+                checkReactivation: vi.fn().mockResolvedValue(["bot-1"]),
+            };
+            const depsWithBots = { ...deps, botBilling: mockBotBilling };
+            // First settlement — should call reactivation
+            await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+            expect(mockBotBilling.checkReactivation).toHaveBeenCalledTimes(1);
+            // Second settlement — charge already credited, should NOT call reactivation again
+            await handleCryptoWebhook(depsWithBots, makePayload({ type: "InvoiceSettled" }));
+            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" }));
+            expect(result.handled).toBe(true);
+            expect(result.creditedCents).toBe(2500);
+            expect(result.reactivatedBots).toBeUndefined();
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // 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" }));
+            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
+            expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
+        });
+    });
+});

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

@@ -0,0 +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";

package/dist/monetization/crypto/index.js

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

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

@@ -0,0 +1,24 @@
+import type { CryptoWebhookPayload, CryptoWebhookResult, ICryptoChargeRepository, IWebhookSeenRepository } from "@wopr-network/platform-core/billing";
+import type { ILedger } from "@wopr-network/platform-core/credits";
+import type { BotBilling } from "../credits/bot-billing.js";
+export interface CryptoWebhookDeps {
+    chargeStore: ICryptoChargeRepository;
+    creditLedger: ILedger;
+    botBilling?: BotBilling;
+    replayGuard: IWebhookSeenRepository;
+}
+/**
+ * Process a BTCPay Server webhook event (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.
+ */
+export declare function handleCryptoWebhook(deps: CryptoWebhookDeps, payload: CryptoWebhookPayload): Promise<CryptoWebhookResult>;