@wopr-network/platform-core 1.14.8 → 1.16.0

package/src/monetization/payram/checkout.test.ts

@@ -1,98 +0,0 @@
-/**
- * Unit tests for createPayRamCheckout (WOP-407).
- */
-import type { PGlite } from "@electric-sql/pglite";
-import { createPayRamCheckout, MIN_PAYMENT_USD, PayRamChargeRepository } from "@wopr-network/platform-core/billing";
-import type { Payram } from "payram";
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import type { DrizzleDb } from "../../db/index.js";
-import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
-
-function createMockPayram(overrides: { initiatePayment?: ReturnType<typeof vi.fn> } = {}): Payram {
-  return {
-    payments: {
-      initiatePayment:
-        overrides.initiatePayment ??
-        vi.fn().mockResolvedValue({
-          reference_id: "ref-mock-001",
-          url: "https://payram.example.com/pay/ref-mock-001",
-        }),
-    },
-  } as unknown as Payram;
-}
-
-describe("createPayRamCheckout", () => {
-  let pool: PGlite;
-  let db: DrizzleDb;
-  let chargeStore: PayRamChargeRepository;
-  let payram: 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/src/monetization/payram/client.test.ts

@@ -1,62 +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/src/monetization/payram/index.ts

@@ -1,20 +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/src/monetization/payram/webhook.test.ts

@@ -1,327 +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 type { PGlite } from "@electric-sql/pglite";
-import type { PayRamWebhookPayload } from "@wopr-network/platform-core/billing";
-import {
-  DrizzleWebhookSeenRepository,
-  noOpReplayGuard,
-  PayRamChargeRepository,
-} from "@wopr-network/platform-core/billing";
-import { DrizzleLedger } from "@wopr-network/platform-core/credits";
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import type { DrizzleDb } from "../../db/index.js";
-import { createTestDb, truncateAllTables } from "../../test/db.js";
-import type { PayRamWebhookDeps } from "./webhook.js";
-import { handlePayRamWebhook } from "./webhook.js";
-
-function makePayload(overrides: Partial<PayRamWebhookPayload> = {}): PayRamWebhookPayload {
-  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: PGlite;
-let db: DrizzleDb;
-
-beforeAll(async () => {
-  ({ db, pool } = await createTestDb());
-});
-
-afterAll(async () => {
-  await pool.close();
-});
-
-describe("handlePayRamWebhook", () => {
-  let chargeStore: PayRamChargeRepository;
-  let creditLedger: DrizzleLedger;
-  let deps: PayRamWebhookDeps;
-
-  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: PayRamWebhookDeps = { ...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: PayRamWebhookDeps = { ...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("bot reactivation", () => {
-    it("calls botBilling.checkReactivation on FILLED and includes reactivatedBots in result", async () => {
-      const mockCheckReactivation = vi.fn().mockReturnValue(["bot-1", "bot-2"]);
-      const depsWithBotBilling: PayRamWebhookDeps = {
-        ...deps,
-        botBilling: { checkReactivation: mockCheckReactivation } as unknown as Parameters<
-          typeof handlePayRamWebhook
-        >[0]["botBilling"],
-      };
-
-      const result = await handlePayRamWebhook(depsWithBotBilling, makePayload({ status: "FILLED" }));
-
-      expect(mockCheckReactivation).toHaveBeenCalledWith("tenant-a", creditLedger);
-      expect(result.reactivatedBots).toEqual(["bot-1", "bot-2"]);
-    });
-
-    it("does not include reactivatedBots when no bots reactivated", async () => {
-      const mockCheckReactivation = vi.fn().mockReturnValue([]);
-      const depsWithBotBilling: PayRamWebhookDeps = {
-        ...deps,
-        botBilling: { checkReactivation: mockCheckReactivation } as unknown as Parameters<
-          typeof handlePayRamWebhook
-        >[0]["botBilling"],
-      };
-
-      const result = await handlePayRamWebhook(depsWithBotBilling, 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/src/monetization/payram/webhook.ts

@@ -1,97 +0,0 @@
-import type {
-  IWebhookSeenRepository,
-  PayRamChargeRepository,
-  PayRamWebhookPayload,
-  PayRamWebhookResult,
-} from "@wopr-network/platform-core/billing";
-import type { ILedger } from "@wopr-network/platform-core/credits";
-import { Credit } from "@wopr-network/platform-core/credits";
-import type { 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 async function handlePayRamWebhook(
-  deps: PayRamWebhookDeps,
-  payload: PayRamWebhookPayload,
-): Promise<PayRamWebhookResult> {
-  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: PayRamWebhookResult;
-
-  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: string[] | undefined;
-      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;
-}