@wopr-network/platform-core 1.14.8 → 1.16.0

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>;

package/dist/monetization/crypto/webhook.js

@@ -0,0 +1,88 @@
+import { mapBtcPayEventToStatus } from "@wopr-network/platform-core/billing";
+import { Credit } from "@wopr-network/platform-core/credits";
+/**
+ * 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 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;
+}

package/dist/monetization/index.d.ts

@@ -41,14 +41,14 @@ 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 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";
-export type { PayRamBillingConfig, PayRamCheckoutOpts, PayRamConfig, PayRamPaymentState, PayRamWebhookDeps, PayRamWebhookPayload, PayRamWebhookResult, } from "./payram/index.js";
-export { createPayRamCheckout, createPayRamClient, DrizzlePayRamChargeRepository, handlePayRamWebhook, loadPayRamConfig, MIN_PAYMENT_USD, PayRamChargeRepository, } from "./payram/index.js";
 export { checkInstanceQuota, DEFAULT_INSTANCE_LIMITS, type InstanceLimits, type QuotaCheckResult, } from "./quotas/quota-check.js";
 export { buildResourceLimits, type ContainerResourceLimits, DEFAULT_RESOURCE_CONFIG, type ResourceConfig, } from "./quotas/resource-limits.js";
-export type { IBotBilling, IBudgetChecker, IMeterAggregator, IMeterEmitter, IPayRamChargeRepository, ITenantCustomerRepository, PayRamChargeRecord, } from "./repository-types.js";
+export type { CryptoChargeRecord, IBotBilling, IBudgetChecker, ICryptoChargeRepository, IMeterAggregator, IMeterEmitter, ITenantCustomerRepository, } from "./repository-types.js";
 export { AdapterSocket, type SocketConfig, type SocketRequest } from "./socket/socket.js";
 export type { CreditCheckoutOpts, CreditPriceMap, CreditPricePoint, PortalSessionOpts, StripeBillingConfig, TenantCustomerRow, WebhookDeps, WebhookResult, } from "./stripe/index.js";
 export { CREDIT_PRICE_POINTS, createCreditCheckoutSession, createPortalSession, createStripeClient, DrizzleTenantCustomerRepository, getConfiguredPriceIds, getCreditAmountForPurchase, handleWebhookEvent, loadCreditPriceMap, loadStripeConfig, lookupCreditPrice, TenantCustomerRepository, } from "./stripe/index.js";

package/dist/monetization/index.js

@@ -50,10 +50,10 @@ 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";
 // 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";
-export { createPayRamCheckout, createPayRamClient, DrizzlePayRamChargeRepository, handlePayRamWebhook, loadPayRamConfig, MIN_PAYMENT_USD, PayRamChargeRepository, } from "./payram/index.js";
 export { checkInstanceQuota, DEFAULT_INSTANCE_LIMITS, } from "./quotas/quota-check.js";
 export { buildResourceLimits, DEFAULT_RESOURCE_CONFIG, } from "./quotas/resource-limits.js";
 // Socket layer — adapter orchestrator (WOP-376)

package/dist/monetization/repository-types.d.ts

@@ -1,4 +1,4 @@
-export type { IPayRamChargeRepository, ITenantCustomerRepository, PayRamChargeRecord, } from "@wopr-network/platform-core/billing";
+export type { CryptoChargeRecord, ICryptoChargeRepository, ITenantCustomerRepository, } from "@wopr-network/platform-core/billing";
 export type { IAutoTopupSettingsRepository, ILedger } from "@wopr-network/platform-core/credits";
 export type { IMeterAggregator, IMeterEmitter } from "@wopr-network/platform-core/metering";
 export type { FraudEvent, FraudEventInput, IAffiliateFraudRepository } from "./affiliate/affiliate-fraud-repository.js";

package/dist/observability/pagerduty.test.js

@@ -5,6 +5,7 @@ describe("PagerDutyNotifier", () => {
         vi.stubGlobal("fetch", vi.fn());
     });
     afterEach(() => {
+        vi.useRealTimers();
         vi.restoreAllMocks();
     });
     it("no-ops when disabled", async () => {