@wopr-network/platform-core 1.14.8 → 1.15.0

package/dist/billing/payram/webhook.test.js

@@ -1,249 +0,0 @@
-/**
- * Unit tests for PayRam webhook handler (WOP-407).
- *
- * Covers FILLED/OVER_FILLED crediting the ledger, PARTIALLY_FILLED/CANCELLED
- * no-op status, idempotency, replay guard, and bot reactivation.
- */
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { DrizzleLedger } from "../../credits/ledger.js";
-import { createTestDb, truncateAllTables } from "../../test/db.js";
-import { DrizzleWebhookSeenRepository } from "../drizzle-webhook-seen-repository.js";
-import { noOpReplayGuard } from "../webhook-seen-repository.js";
-import { PayRamChargeRepository } from "./charge-store.js";
-import { handlePayRamWebhook } from "./webhook.js";
-function makePayload(overrides = {}) {
-    return {
-        reference_id: "ref-test-001",
-        status: "FILLED",
-        amount: "25.00",
-        currency: "USDC",
-        filled_amount: "25.00",
-        ...overrides,
-    };
-}
-// TOP OF FILE - shared across ALL describes
-let pool;
-let db;
-beforeAll(async () => {
-    ({ db, pool } = await createTestDb());
-});
-afterAll(async () => {
-    await pool.close();
-});
-describe("handlePayRamWebhook", () => {
-    let chargeStore;
-    let creditLedger;
-    let deps;
-    beforeEach(async () => {
-        await truncateAllTables(pool);
-        chargeStore = new PayRamChargeRepository(db);
-        creditLedger = new DrizzleLedger(db);
-        await creditLedger.seedSystemAccounts();
-        deps = { chargeStore, creditLedger, replayGuard: noOpReplayGuard };
-        // Create a default test charge
-        await chargeStore.create("ref-test-001", "tenant-a", 2500);
-    });
-    // ---------------------------------------------------------------------------
-    // FILLED / OVER_FILLED — should credit ledger
-    // ---------------------------------------------------------------------------
-    describe("FILLED status", () => {
-        it("credits the ledger with the requested USD amount", async () => {
-            const result = await handlePayRamWebhook(deps, makePayload({ status: "FILLED" }));
-            expect(result.handled).toBe(true);
-            expect(result.status).toBe("FILLED");
-            expect(result.tenant).toBe("tenant-a");
-            expect(result.creditedCents).toBe(2500);
-            const balance = await creditLedger.balance("tenant-a");
-            expect(balance.toCents()).toBe(2500);
-        });
-        it("uses payram: prefix on reference ID in credit transaction", async () => {
-            await handlePayRamWebhook(deps, makePayload({ status: "FILLED" }));
-            const history = await creditLedger.history("tenant-a");
-            expect(history).toHaveLength(1);
-            expect(history[0].referenceId).toBe("payram:ref-test-001");
-            expect(history[0].entryType).toBe("purchase");
-        });
-        it("records fundingSource as payram", async () => {
-            await handlePayRamWebhook(deps, makePayload({ status: "FILLED" }));
-            const history = await creditLedger.history("tenant-a");
-            expect(history[0].metadata?.fundingSource).toBe("payram");
-        });
-        it("marks the charge as credited after FILLED", async () => {
-            await handlePayRamWebhook(deps, makePayload({ status: "FILLED" }));
-            expect(await chargeStore.isCredited("ref-test-001")).toBe(true);
-        });
-        it("is idempotent — duplicate FILLED webhook does not double-credit", async () => {
-            await handlePayRamWebhook(deps, makePayload({ status: "FILLED" }));
-            const result2 = await handlePayRamWebhook(deps, makePayload({ status: "FILLED" }));
-            expect(result2.handled).toBe(true);
-            expect(result2.creditedCents).toBe(0);
-            const balance = await creditLedger.balance("tenant-a");
-            expect(balance.toCents()).toBe(2500); // Only credited once
-        });
-    });
-    describe("OVER_FILLED status", () => {
-        it("credits the requested USD amount (not the overpayment)", async () => {
-            await chargeStore.create("ref-over-001", "tenant-b", 1000);
-            const result = await handlePayRamWebhook(deps, makePayload({
-                reference_id: "ref-over-001",
-                status: "OVER_FILLED",
-                filled_amount: "12.50", // Overpaid by $2.50
-                currency: "ETH",
-            }));
-            expect(result.handled).toBe(true);
-            expect(result.creditedCents).toBe(1000); // Only the requested amount
-            expect((await creditLedger.balance("tenant-b")).toCents()).toBe(1000);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Statuses that should NOT credit the ledger
-    // ---------------------------------------------------------------------------
-    describe("PARTIALLY_FILLED status", () => {
-        it("does NOT credit the ledger", async () => {
-            const result = await handlePayRamWebhook(deps, makePayload({ status: "PARTIALLY_FILLED" }));
-            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("VERIFYING status", () => {
-        it("does NOT credit the ledger", async () => {
-            const result = await handlePayRamWebhook(deps, makePayload({ status: "VERIFYING" }));
-            expect(result.handled).toBe(true);
-            expect(result.creditedCents).toBeUndefined();
-            expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
-        });
-    });
-    describe("OPEN status", () => {
-        it("does NOT credit the ledger", async () => {
-            const result = await handlePayRamWebhook(deps, makePayload({ status: "OPEN" }));
-            expect(result.handled).toBe(true);
-            expect(result.creditedCents).toBeUndefined();
-            expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
-        });
-    });
-    describe("CANCELLED status", () => {
-        it("does NOT credit the ledger", async () => {
-            const result = await handlePayRamWebhook(deps, makePayload({ status: "CANCELLED" }));
-            expect(result.handled).toBe(true);
-            expect(result.creditedCents).toBeUndefined();
-            expect((await creditLedger.balance("tenant-a")).toCents()).toBe(0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Unknown reference ID
-    // ---------------------------------------------------------------------------
-    describe("unknown reference_id", () => {
-        it("returns handled:false when charge not found", async () => {
-            const result = await handlePayRamWebhook(deps, makePayload({ reference_id: "ref-unknown-999" }));
-            expect(result.handled).toBe(false);
-            expect(result.tenant).toBeUndefined();
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Charge store updates
-    // ---------------------------------------------------------------------------
-    describe("charge store updates", () => {
-        it("updates charge status on every webhook call", async () => {
-            await handlePayRamWebhook(deps, makePayload({ status: "VERIFYING" }));
-            const charge = await chargeStore.getByReferenceId("ref-test-001");
-            expect(charge?.status).toBe("VERIFYING");
-        });
-        it("updates currency and filled_amount on FILLED", async () => {
-            await handlePayRamWebhook(deps, makePayload({ status: "FILLED", currency: "USDT", filled_amount: "25.00" }));
-            const charge = await chargeStore.getByReferenceId("ref-test-001");
-            expect(charge?.currency).toBe("USDT");
-            expect(charge?.filledAmount).toBe("25.00");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Multiple tenants / reference IDs
-    // ---------------------------------------------------------------------------
-    describe("different reference IDs", () => {
-        it("processes multiple reference IDs independently", async () => {
-            await chargeStore.create("ref-b-001", "tenant-b", 5000);
-            await chargeStore.create("ref-c-001", "tenant-c", 1500);
-            await handlePayRamWebhook(deps, makePayload({ reference_id: "ref-b-001", status: "FILLED" }));
-            await handlePayRamWebhook(deps, makePayload({ reference_id: "ref-c-001", status: "FILLED" }));
-            expect((await creditLedger.balance("tenant-b")).toCents()).toBe(5000);
-            expect((await creditLedger.balance("tenant-c")).toCents()).toBe(1500);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Replay guard
-    // ---------------------------------------------------------------------------
-    describe("replay guard", () => {
-        it("blocks duplicate reference_id + status combos", async () => {
-            const replayGuard = new DrizzleWebhookSeenRepository(db);
-            const depsWithGuard = { ...deps, replayGuard };
-            const first = await handlePayRamWebhook(depsWithGuard, makePayload({ status: "FILLED" }));
-            expect(first.handled).toBe(true);
-            expect(first.creditedCents).toBe(2500);
-            expect(first.duplicate).toBeUndefined();
-            const second = await handlePayRamWebhook(depsWithGuard, makePayload({ status: "FILLED" }));
-            expect(second.handled).toBe(true);
-            expect(second.duplicate).toBe(true);
-            expect(second.creditedCents).toBeUndefined();
-            // Only credited once
-            expect((await creditLedger.balance("tenant-a")).toCents()).toBe(2500);
-        });
-        it("same reference_id with different status is not blocked by replay guard", async () => {
-            const replayGuard = new DrizzleWebhookSeenRepository(db);
-            const depsWithGuard = { ...deps, replayGuard };
-            await handlePayRamWebhook(depsWithGuard, makePayload({ status: "VERIFYING" }));
-            const result = await handlePayRamWebhook(depsWithGuard, makePayload({ status: "FILLED" }));
-            expect(result.duplicate).toBeUndefined();
-            expect(result.creditedCents).toBe(2500);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Bot reactivation
-    // ---------------------------------------------------------------------------
-    describe("resource reactivation via onCreditsPurchased", () => {
-        it("calls onCreditsPurchased on FILLED and includes reactivatedBots in result", async () => {
-            const mockOnCreditsPurchased = vi.fn().mockResolvedValue(["bot-1", "bot-2"]);
-            const depsWithCallback = {
-                ...deps,
-                onCreditsPurchased: mockOnCreditsPurchased,
-            };
-            const result = await handlePayRamWebhook(depsWithCallback, makePayload({ status: "FILLED" }));
-            expect(mockOnCreditsPurchased).toHaveBeenCalledWith("tenant-a", creditLedger);
-            expect(result.reactivatedBots).toEqual(["bot-1", "bot-2"]);
-        });
-        it("does not include reactivatedBots when no resources reactivated", async () => {
-            const mockOnCreditsPurchased = vi.fn().mockResolvedValue([]);
-            const depsWithCallback = {
-                ...deps,
-                onCreditsPurchased: mockOnCreditsPurchased,
-            };
-            const result = await handlePayRamWebhook(depsWithCallback, makePayload({ status: "FILLED" }));
-            expect(result.reactivatedBots).toBeUndefined();
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// DrizzleWebhookSeenRepository unit tests (replaces PayRamReplayGuard)
-// ---------------------------------------------------------------------------
-describe("DrizzleWebhookSeenRepository (payram replay guard)", () => {
-    beforeEach(async () => {
-        await truncateAllTables(pool);
-    });
-    it("reports unseen keys as not duplicate", async () => {
-        const guard = new DrizzleWebhookSeenRepository(db);
-        expect(await guard.isDuplicate("ref-001:FILLED", "payram")).toBe(false);
-    });
-    it("reports seen keys as duplicate", async () => {
-        const guard = new DrizzleWebhookSeenRepository(db);
-        await guard.markSeen("ref-001:FILLED", "payram");
-        expect(await guard.isDuplicate("ref-001:FILLED", "payram")).toBe(true);
-    });
-    it("purges expired entries via purgeExpired", async () => {
-        const guard = new DrizzleWebhookSeenRepository(db);
-        await guard.markSeen("ref-expire:FILLED", "payram");
-        expect(await guard.isDuplicate("ref-expire:FILLED", "payram")).toBe(true);
-        // Negative TTL pushes cutoff into the future — entry is expired
-        await guard.purgeExpired(-24 * 60 * 60 * 1000);
-        expect(await guard.isDuplicate("ref-expire:FILLED", "payram")).toBe(false);
-    });
-});

package/dist/db/schema/payram.js

@@ -1,21 +0,0 @@
-import { sql } from "drizzle-orm";
-import { index, integer, pgTable, text } from "drizzle-orm/pg-core";
-/**
- * PayRam payment sessions — tracks the lifecycle of each crypto payment.
- * reference_id is the PayRam-assigned unique identifier.
- */
-export const payramCharges = pgTable("payram_charges", {
-    referenceId: text("reference_id").primaryKey(),
-    tenantId: text("tenant_id").notNull(),
-    amountUsdCents: integer("amount_usd_cents").notNull(),
-    status: text("status").notNull().default("OPEN"),
-    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_payram_charges_tenant").on(table.tenantId),
-    index("idx_payram_charges_status").on(table.status),
-    index("idx_payram_charges_created").on(table.createdAt),
-]);

package/dist/monetization/payram/charge-store.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/monetization/payram/charge-store.test.js

@@ -1,64 +0,0 @@
-import { PayRamChargeRepository } from "@wopr-network/platform-core/billing";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
-describe("PayRamChargeRepository", () => {
-    let pool;
-    let db;
-    let store;
-    beforeAll(async () => {
-        ({ db, pool } = await createTestDb());
-        await beginTestTransaction(pool);
-    });
-    afterAll(async () => {
-        await endTestTransaction(pool);
-        await pool.close();
-    });
-    beforeEach(async () => {
-        await rollbackTestTransaction(pool);
-        store = new PayRamChargeRepository(db);
-    });
-    it("create() stores a charge", async () => {
-        await store.create("ref-001", "tenant-1", 2500);
-        const charge = await store.getByReferenceId("ref-001");
-        expect(charge).not.toBeNull();
-        expect(charge?.referenceId).toBe("ref-001");
-        expect(charge?.tenantId).toBe("tenant-1");
-        expect(charge?.amountUsdCents).toBe(2500);
-        expect(charge?.status).toBe("OPEN");
-        expect(charge?.creditedAt).toBeNull();
-    });
-    it("getByReferenceId() returns null when not found", async () => {
-        const charge = await store.getByReferenceId("ref-nonexistent");
-        expect(charge).toBeNull();
-    });
-    it("updateStatus() updates status, currency and filled_amount", async () => {
-        await store.create("ref-002", "tenant-2", 5000);
-        await store.updateStatus("ref-002", "FILLED", "USDC", "50.00");
-        const charge = await store.getByReferenceId("ref-002");
-        expect(charge?.status).toBe("FILLED");
-        expect(charge?.currency).toBe("USDC");
-        expect(charge?.filledAmount).toBe("50.00");
-    });
-    it("updateStatus() handles partial updates (no currency)", async () => {
-        await store.create("ref-003", "tenant-3", 1000);
-        await store.updateStatus("ref-003", "VERIFYING");
-        const charge = await store.getByReferenceId("ref-003");
-        expect(charge?.status).toBe("VERIFYING");
-        expect(charge?.currency).toBeNull();
-    });
-    it("isCredited() returns false before markCredited", async () => {
-        await store.create("ref-004", "tenant-4", 1500);
-        expect(await store.isCredited("ref-004")).toBe(false);
-    });
-    it("markCredited() sets creditedAt", async () => {
-        await store.create("ref-005", "tenant-5", 3000);
-        await store.markCredited("ref-005");
-        const charge = await store.getByReferenceId("ref-005");
-        expect(charge?.creditedAt).not.toBeNull();
-    });
-    it("isCredited() returns true after markCredited", async () => {
-        await store.create("ref-006", "tenant-6", 2000);
-        await store.markCredited("ref-006");
-        expect(await store.isCredited("ref-006")).toBe(true);
-    });
-});

package/dist/monetization/payram/checkout.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/monetization/payram/checkout.test.js

@@ -1,73 +0,0 @@
-import { createPayRamCheckout, MIN_PAYMENT_USD, PayRamChargeRepository } from "@wopr-network/platform-core/billing";
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
-function createMockPayram(overrides = {}) {
-    return {
-        payments: {
-            initiatePayment: overrides.initiatePayment ??
-                vi.fn().mockResolvedValue({
-                    reference_id: "ref-mock-001",
-                    url: "https://payram.example.com/pay/ref-mock-001",
-                }),
-        },
-    };
-}
-describe("createPayRamCheckout", () => {
-    let pool;
-    let db;
-    let chargeStore;
-    let payram;
-    beforeAll(async () => {
-        ({ db, pool } = await createTestDb());
-        await beginTestTransaction(pool);
-    });
-    afterAll(async () => {
-        await endTestTransaction(pool);
-        await pool.close();
-    });
-    beforeEach(async () => {
-        await rollbackTestTransaction(pool);
-        chargeStore = new PayRamChargeRepository(db);
-        payram = createMockPayram();
-    });
-    it("rejects amounts below $10 minimum", async () => {
-        await expect(createPayRamCheckout(payram, chargeStore, { tenant: "t-1", amountUsd: 5 })).rejects.toThrow(`Minimum payment amount is $${MIN_PAYMENT_USD}`);
-    });
-    it("rejects amounts of exactly $0", async () => {
-        await expect(createPayRamCheckout(payram, chargeStore, { tenant: "t-1", amountUsd: 0 })).rejects.toThrow();
-    });
-    it("calls payram.payments.initiatePayment with correct params", async () => {
-        const initiatePayment = vi.fn().mockResolvedValue({
-            reference_id: "ref-abc",
-            url: "https://payram.example.com/pay/ref-abc",
-        });
-        const mockPayram = createMockPayram({ initiatePayment });
-        await createPayRamCheckout(mockPayram, chargeStore, { tenant: "t-test", amountUsd: 25 });
-        expect(initiatePayment).toHaveBeenCalledWith({
-            customerEmail: "t-test@wopr.bot",
-            customerId: "t-test",
-            amountInUSD: 25,
-        });
-    });
-    it("stores the charge with correct amountUsdCents (converts from USD)", async () => {
-        const initiatePayment = vi.fn().mockResolvedValue({
-            reference_id: "ref-store-test",
-            url: "https://payram.example.com/pay/ref-store-test",
-        });
-        const mockPayram = createMockPayram({ initiatePayment });
-        await createPayRamCheckout(mockPayram, chargeStore, { tenant: "t-2", amountUsd: 25 });
-        const charge = await chargeStore.getByReferenceId("ref-store-test");
-        expect(charge).not.toBeNull();
-        expect(charge?.tenantId).toBe("t-2");
-        expect(charge?.amountUsdCents).toBe(2500); // $25.00 = 2500 cents
-        expect(charge?.status).toBe("OPEN");
-    });
-    it("returns referenceId and url from PayRam response", async () => {
-        const result = await createPayRamCheckout(payram, chargeStore, { tenant: "t-3", amountUsd: 10 });
-        expect(result.referenceId).toBe("ref-mock-001");
-        expect(result.url).toBe("https://payram.example.com/pay/ref-mock-001");
-    });
-    it("accepts exactly $10 (minimum boundary)", async () => {
-        await expect(createPayRamCheckout(payram, chargeStore, { tenant: "t-4", amountUsd: 10 })).resolves.not.toBeNull();
-    });
-});

package/dist/monetization/payram/client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/monetization/payram/client.test.js

@@ -1,52 +0,0 @@
-import { createPayRamClient, loadPayRamConfig } from "@wopr-network/platform-core/billing";
-import { Payram } from "payram";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-describe("createPayRamClient", () => {
-    it("returns a Payram instance", () => {
-        const client = createPayRamClient({ apiKey: "test-key", baseUrl: "https://api.payram.test" });
-        expect(client).toBeInstanceOf(Payram);
-    });
-    it("passes config through to the Payram constructor", () => {
-        const client = createPayRamClient({ apiKey: "pk_live_123", baseUrl: "https://api.payram.io" });
-        expect(client).toBeInstanceOf(Payram);
-    });
-});
-describe("loadPayRamConfig", () => {
-    beforeEach(() => {
-        delete process.env.PAYRAM_API_KEY;
-        delete process.env.PAYRAM_BASE_URL;
-    });
-    afterEach(() => {
-        vi.unstubAllEnvs();
-    });
-    it("returns null when PAYRAM_API_KEY is missing", () => {
-        vi.stubEnv("PAYRAM_BASE_URL", "https://api.payram.test");
-        expect(loadPayRamConfig()).toBeNull();
-    });
-    it("returns null when PAYRAM_BASE_URL is missing", () => {
-        vi.stubEnv("PAYRAM_API_KEY", "pk_test_123");
-        expect(loadPayRamConfig()).toBeNull();
-    });
-    it("returns null when PAYRAM_API_KEY is an empty string", () => {
-        vi.stubEnv("PAYRAM_API_KEY", "");
-        vi.stubEnv("PAYRAM_BASE_URL", "https://api.payram.test");
-        expect(loadPayRamConfig()).toBeNull();
-    });
-    it("returns null when PAYRAM_BASE_URL is an empty string", () => {
-        vi.stubEnv("PAYRAM_API_KEY", "pk_test_123");
-        vi.stubEnv("PAYRAM_BASE_URL", "");
-        expect(loadPayRamConfig()).toBeNull();
-    });
-    it("returns config when both env vars are set", () => {
-        vi.stubEnv("PAYRAM_API_KEY", "pk_test_123");
-        vi.stubEnv("PAYRAM_BASE_URL", "https://api.payram.test");
-        const config = loadPayRamConfig();
-        expect(config).toEqual({
-            apiKey: "pk_test_123",
-            baseUrl: "https://api.payram.test",
-        });
-    });
-    it("returns null when both env vars are missing", () => {
-        expect(loadPayRamConfig()).toBeNull();
-    });
-});

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

@@ -1,4 +0,0 @@
-export type { IPayRamChargeRepository, PayRamBillingConfig, PayRamChargeRecord, PayRamCheckoutOpts, PayRamConfig, PayRamPaymentState, PayRamWebhookPayload, PayRamWebhookResult, } from "@wopr-network/platform-core/billing";
-export { createPayRamCheckout, createPayRamClient, DrizzlePayRamChargeRepository, loadPayRamConfig, MIN_PAYMENT_USD, PayRamChargeRepository, } from "@wopr-network/platform-core/billing";
-export type { PayRamWebhookDeps } from "./webhook.js";
-export { handlePayRamWebhook } from "./webhook.js";

package/dist/monetization/payram/index.js

@@ -1,2 +0,0 @@
-export { createPayRamCheckout, createPayRamClient, DrizzlePayRamChargeRepository, loadPayRamConfig, MIN_PAYMENT_USD, PayRamChargeRepository, } from "@wopr-network/platform-core/billing";
-export { handlePayRamWebhook } from "./webhook.js";

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

@@ -1,17 +0,0 @@
-import type { IWebhookSeenRepository, PayRamChargeRepository, PayRamWebhookPayload, PayRamWebhookResult } 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 PayRamWebhookDeps {
-    chargeStore: PayRamChargeRepository;
-    creditLedger: ILedger;
-    botBilling?: BotBilling;
-    replayGuard: IWebhookSeenRepository;
-}
-/**
- * Process a PayRam webhook event.
- *
- * Only credits the ledger on FILLED or OVER_FILLED status.
- * Uses the PayRam reference_id mapped to the stored charge record
- * for tenant resolution and idempotency.
- */
-export declare function handlePayRamWebhook(deps: PayRamWebhookDeps, payload: PayRamWebhookPayload): Promise<PayRamWebhookResult>;

package/dist/monetization/payram/webhook.js

@@ -1,71 +0,0 @@
-import { Credit } from "@wopr-network/platform-core/credits";
-/**
- * Process a PayRam webhook event.
- *
- * Only credits the ledger on FILLED or OVER_FILLED status.
- * Uses the PayRam reference_id mapped to the stored charge record
- * for tenant resolution and idempotency.
- */
-export async function handlePayRamWebhook(deps, payload) {
-    const { chargeStore, creditLedger } = deps;
-    // Replay guard: deduplicate by reference_id + status combination.
-    const dedupeKey = `${payload.reference_id}:${payload.status}`;
-    if (await deps.replayGuard.isDuplicate(dedupeKey, "payram")) {
-        return { handled: true, status: payload.status, duplicate: true };
-    }
-    // Look up the charge record to find the tenant.
-    const charge = await chargeStore.getByReferenceId(payload.reference_id);
-    if (!charge) {
-        return { handled: false, status: payload.status };
-    }
-    // Update charge status regardless of payment state.
-    await chargeStore.updateStatus(payload.reference_id, payload.status, payload.currency, payload.filled_amount);
-    let result;
-    if (payload.status === "FILLED" || payload.status === "OVER_FILLED") {
-        // Idempotency: skip if already credited.
-        if (await chargeStore.isCredited(payload.reference_id)) {
-            result = {
-                handled: true,
-                status: payload.status,
-                tenant: charge.tenantId,
-                creditedCents: 0,
-            };
-        }
-        else {
-            // Credit the original USD amount requested (not the crypto amount).
-            // For OVER_FILLED, we still credit the requested amount — the
-            // overpayment stays in the PayRam wallet as a buffer.
-            const creditCents = charge.amountUsdCents;
-            await creditLedger.credit(charge.tenantId, Credit.fromCents(creditCents), "purchase", {
-                description: `Crypto credit purchase via PayRam (ref: ${payload.reference_id}, ${payload.currency ?? "crypto"})`,
-                referenceId: `payram:${payload.reference_id}`,
-                fundingSource: "payram",
-            });
-            await chargeStore.markCredited(payload.reference_id);
-            // Reactivate suspended bots (same as Stripe webhook, WOP-447).
-            let reactivatedBots;
-            if (deps.botBilling) {
-                reactivatedBots = await deps.botBilling.checkReactivation(charge.tenantId, creditLedger);
-                if (reactivatedBots.length === 0)
-                    reactivatedBots = undefined;
-            }
-            result = {
-                handled: true,
-                status: payload.status,
-                tenant: charge.tenantId,
-                creditedCents: creditCents,
-                reactivatedBots,
-            };
-        }
-    }
-    else {
-        // OPEN, VERIFYING, PARTIALLY_FILLED, CANCELLED — just track status.
-        result = {
-            handled: true,
-            status: payload.status,
-            tenant: charge.tenantId,
-        };
-    }
-    await deps.replayGuard.markSeen(dedupeKey, "payram");
-    return result;
-}

package/dist/monetization/payram/webhook.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Unit tests for PayRam webhook handler (WOP-407).
- *
- * Covers FILLED/OVER_FILLED crediting the ledger, PARTIALLY_FILLED/CANCELLED
- * no-op status, idempotency, replay guard, and bot reactivation.
- */
-export {};