@wopr-network/platform-core 1.14.8 → 1.16.0

package/src/billing/payram/types.ts

@@ -1,44 +0,0 @@
-/** PayRam payment states (from PayRam API docs). */
-export type PayRamPaymentState = "OPEN" | "VERIFYING" | "FILLED" | "OVER_FILLED" | "PARTIALLY_FILLED" | "CANCELLED";
-
-/** Options for creating a PayRam payment session. */
-export interface PayRamCheckoutOpts {
-  /** Internal tenant ID. */
-  tenant: string;
-  /** Amount in USD (minimum $10). */
-  amountUsd: number;
-}
-
-/** Webhook payload received from PayRam. */
-export interface PayRamWebhookPayload {
-  /** Unique payment reference from session creation. */
-  reference_id: string;
-  /** Merchant invoice ID (echoed back if sent). */
-  invoice_id?: string;
-  /** Payment status. */
-  status: PayRamPaymentState;
-  /** Amount filled in this update. */
-  amount: string;
-  /** Currency symbol (ETH, USDC, USDT, etc.). */
-  currency: string;
-  /** Cumulative total filled so far. */
-  filled_amount: string;
-}
-
-/** Configuration for PayRam billing integration. */
-export interface PayRamBillingConfig {
-  /** PayRam API key (from dashboard). */
-  apiKey: string;
-  /** PayRam self-hosted server base URL. */
-  baseUrl: string;
-}
-
-/** Result of processing a PayRam webhook event. */
-export interface PayRamWebhookResult {
-  handled: boolean;
-  status: string;
-  tenant?: string;
-  creditedCents?: number;
-  reactivatedBots?: string[];
-  duplicate?: boolean;
-}

package/src/billing/payram/webhook.test.ts

@@ -1,320 +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 { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { DrizzleLedger } from "../../credits/ledger.js";
-import type { PlatformDb } from "../../db/index.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 type { PayRamWebhookDeps, PayRamWebhookPayload } from "./index.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: PlatformDb;
-
-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("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: PayRamWebhookDeps = {
-        ...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: PayRamWebhookDeps = {
-        ...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/src/billing/payram/webhook.ts

@@ -1,94 +0,0 @@
-import { Credit } from "../../credits/credit.js";
-import type { ILedger } from "../../credits/ledger.js";
-import type { IWebhookSeenRepository } from "../webhook-seen-repository.js";
-import type { PayRamChargeRepository } from "./charge-store.js";
-import type { PayRamWebhookPayload, PayRamWebhookResult } from "./types.js";
-
-export interface PayRamWebhookDeps {
-  chargeStore: PayRamChargeRepository;
-  creditLedger: ILedger;
-  replayGuard: IWebhookSeenRepository;
-  /** Called after credits are purchased — consumer can reactivate suspended resources. Returns reactivated resource IDs. */
-  onCreditsPurchased?: (tenantId: string, ledger: ILedger) => Promise<string[]>;
-}
-
-/**
- * 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 resources after credit purchase.
-      let reactivatedBots: string[] | undefined;
-      if (deps.onCreditsPurchased) {
-        reactivatedBots = await deps.onCreditsPurchased(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/src/db/schema/payram.ts

@@ -1,26 +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/src/monetization/payram/cents-credits-boundary.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-/**
- * Regression tests for PayRam cents/credits boundary (WOP-1058).
- *
- * Verifies that the USD-to-cents conversion in checkout and
- * the cents-to-credits flow in the webhook maintain correct units.
- *
- * If any of these tests fail after a rename/refactor, a _cents field was
- * incorrectly changed to store Credit raw units (nanodollars) instead of
- * USD cents. See src/monetization/credits/credit-ledger.ts for naming convention.
- */
-describe("WOP-1058: PayRam cents/credits boundary", () => {
-  it("USD to cents conversion is correct (mirrors checkout.ts pattern)", () => {
-    // This mirrors the conversion in payram/checkout.ts: Math.round(opts.amountUsd * 100)
-    const amountUsd = 25;
-    const amountUsdCents = Math.round(amountUsd * 100);
-    expect(amountUsdCents).toBe(2500);
-    // Must NOT be nanodollar scale
-    expect(amountUsdCents).toBeLessThan(1_000_000);
-  });
-
-  it("minimum payment amount converts to valid cents", () => {
-    const MIN_PAYMENT_USD = 10;
-    const cents = Math.round(MIN_PAYMENT_USD * 100);
-    expect(cents).toBe(1000);
-    expect(Number.isInteger(cents)).toBe(true);
-    // Sanity: $10 is 1000 cents, NOT 10_000_000_000 nanodollars
-    expect(cents).toBeLessThan(1_000_000);
-  });
-
-  it("fractional USD amounts round correctly to cents", () => {
-    // Edge case: floating point conversion
-    const amountUsd = 10.99;
-    const cents = Math.round(amountUsd * 100);
-    expect(cents).toBe(1099);
-    expect(cents).toBeLessThan(1_000_000);
-  });
-
-  it("amountUsdCents stored in charge record equals USD * 100 (not nanodollars)", () => {
-    // The core invariant: payram/checkout.ts stores Math.round(amountUsd * 100)
-    // as amountUsdCents. This test proves the conversion stays at cent scale.
-    const testCases: Array<{ usd: number; expectedCents: number }> = [
-      { usd: 10, expectedCents: 1000 },
-      { usd: 25, expectedCents: 2500 },
-      { usd: 50, expectedCents: 5000 },
-      { usd: 100, expectedCents: 10000 },
-    ];
-
-    for (const { usd, expectedCents } of testCases) {
-      const amountUsdCents = Math.round(usd * 100);
-      expect(amountUsdCents).toBe(expectedCents);
-      // CREDIT SCALE = 1_000_000_000. If this value approaches that, unit confusion occurred.
-      expect(amountUsdCents).toBeLessThan(1_000_000);
-    }
-  });
-
-  it("creditedCents in webhook equals amountUsdCents from charge store (1:1 for PayRam)", () => {
-    // payram/webhook.ts: const creditCents = charge.amountUsdCents;
-    // The credited amount always equals the stored USD cents — no bonus tiers for PayRam.
-    const chargeAmountUsdCents = 2500; // $25.00
-    const creditCents = chargeAmountUsdCents; // 1:1 for PayRam
-    expect(creditCents).toBe(2500);
-    // creditedCents must be 2500 (cents), not 25_000_000_000 (nanodollars)
-    expect(creditCents).toBeLessThan(1_000_000);
-  });
-
-  it("cents-to-nanodollar scale difference is preserved as a sanity constant", () => {
-    // Credit.SCALE = 1_000_000_000 nanodollars per dollar
-    // 1 USD cent = 10_000_000 nanodollars (SCALE / 100)
-    // This test documents the relationship so future developers understand the gap.
-    const CREDIT_SCALE = 1_000_000_000;
-    const CENTS_PER_DOLLAR = 100;
-    const NANODOLLARS_PER_CENT = CREDIT_SCALE / CENTS_PER_DOLLAR;
-
-    expect(NANODOLLARS_PER_CENT).toBe(10_000_000);
-
-    // $25 in cents = 2500. $25 in nanodollars = 25_000_000_000.
-    // These are 10_000_000x apart — confirming that mixing the two is catastrophic.
-    const twentyFiveDollarsInCents = 2500;
-    const twentyFiveDollarsInNanodollars = 25 * CREDIT_SCALE;
-    expect(twentyFiveDollarsInNanodollars / twentyFiveDollarsInCents).toBe(NANODOLLARS_PER_CENT);
-  });
-});

package/src/monetization/payram/charge-store.test.ts

@@ -1,84 +0,0 @@
-/**
- * Unit tests for PayRamChargeRepository (WOP-407).
- */
-import type { PGlite } from "@electric-sql/pglite";
-import { PayRamChargeRepository } from "@wopr-network/platform-core/billing";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import type { DrizzleDb } from "../../db/index.js";
-import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
-
-describe("PayRamChargeRepository", () => {
-  let pool: PGlite;
-  let db: DrizzleDb;
-  let store: PayRamChargeRepository;
-
-  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);
-  });
-});