@wopr-network/platform-core 1.48.0 → 1.49.0

package/drizzle/migrations/meta/_journal.json

@@ -113,6 +113,13 @@
       "when": 1742918400000,
       "tag": "0015_callback_url",
       "breakpoints": true
+    },
+    {
+      "idx": 16,
+      "version": "7",
+      "when": 1743004800000,
+      "tag": "0016_charge_progress_columns",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.48.0",
+  "version": "1.49.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/billing/crypto/__tests__/unified-checkout.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from "vitest";
+import type { CryptoServiceClient } from "../client.js";
+import { createUnifiedCheckout, MIN_CHECKOUT_USD } from "../unified-checkout.js";
+
+function mockCryptoService(): CryptoServiceClient {
+  return {
+    createCharge: vi.fn().mockResolvedValue({
+      chargeId: "btc:bc1qtest",
+      address: "bc1qtest",
+      chain: "bitcoin",
+      token: "BTC",
+      amountUsd: 50,
+      displayAmount: "0.00076923 BTC",
+      derivationIndex: 7,
+      expiresAt: "2026-03-21T23:00:00Z",
+    }),
+    listChains: vi.fn(),
+    deriveAddress: vi.fn(),
+    getCharge: vi.fn(),
+  } as unknown as CryptoServiceClient;
+}
+
+describe("createUnifiedCheckout", () => {
+  it("delegates to CryptoServiceClient.createCharge", async () => {
+    const service = mockCryptoService();
+    const result = await createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: 50 });
+
+    expect(result.depositAddress).toBe("bc1qtest");
+    expect(result.displayAmount).toBe("0.00076923 BTC");
+    expect(result.amountUsd).toBe(50);
+    expect(result.token).toBe("BTC");
+    expect(result.chain).toBe("bitcoin");
+    expect(result.referenceId).toBe("btc:bc1qtest");
+
+    expect(service.createCharge).toHaveBeenCalledWith({
+      chain: "btc",
+      amountUsd: 50,
+      callbackUrl: undefined,
+    });
+  });
+
+  it("passes callbackUrl to createCharge", async () => {
+    const service = mockCryptoService();
+    await createUnifiedCheckout({ cryptoService: service }, "base-usdc", {
+      tenant: "t-1",
+      amountUsd: 25,
+      callbackUrl: "https://example.com/hook",
+    });
+
+    expect(service.createCharge).toHaveBeenCalledWith({
+      chain: "base-usdc",
+      amountUsd: 25,
+      callbackUrl: "https://example.com/hook",
+    });
+  });
+
+  it("rejects amount below minimum", async () => {
+    const service = mockCryptoService();
+    await expect(
+      createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: 5 }),
+    ).rejects.toThrow(`Minimum payment amount is $${MIN_CHECKOUT_USD}`);
+
+    expect(service.createCharge).not.toHaveBeenCalled();
+  });
+
+  it("rejects non-finite amount", async () => {
+    const service = mockCryptoService();
+    await expect(
+      createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: NaN }),
+    ).rejects.toThrow(`Minimum payment amount is $${MIN_CHECKOUT_USD}`);
+  });
+
+  it("propagates createCharge errors", async () => {
+    const service = mockCryptoService();
+    (service.createCharge as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error("CryptoService createCharge failed (500): Internal Server Error"),
+    );
+
+    await expect(
+      createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: 50 }),
+    ).rejects.toThrow("CryptoService createCharge failed (500)");
+  });
+});

package/src/billing/crypto/__tests__/watcher-service.test.ts

@@ -0,0 +1,242 @@
+import { describe, expect, it, vi } from "vitest";
+import { handlePayment } from "../watcher-service.js";
+
+function mockChargeStore(overrides: Record<string, unknown> = {}) {
+  return {
+    getByDepositAddress: vi.fn().mockResolvedValue({
+      referenceId: "btc:test",
+      tenantId: "t1",
+      amountUsdCents: 5000,
+      creditedAt: null,
+      chain: "bitcoin",
+      depositAddress: "bc1qtest",
+      token: "BTC",
+      callbackUrl: "https://example.com/hook",
+      expectedAmount: "50000",
+      receivedAmount: "0",
+      confirmations: 0,
+      confirmationsRequired: 6,
+      ...overrides,
+    }),
+    updateProgress: vi.fn().mockResolvedValue(undefined),
+    updateStatus: vi.fn().mockResolvedValue(undefined),
+    markCredited: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+function mockDb() {
+  return {
+    insert: vi.fn().mockReturnValue({ values: vi.fn().mockResolvedValue(undefined) }),
+    update: vi.fn().mockReturnValue({
+      set: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(undefined) }),
+    }),
+  };
+}
+
+const noop = () => {};
+
+describe("handlePayment", () => {
+  it("fires webhook with confirmations: 0 on first tx detection", async () => {
+    const chargeStore = mockChargeStore();
+    const db = mockDb();
+    const enqueuedPayloads: Record<string, unknown>[] = [];
+    db.insert = vi.fn().mockReturnValue({
+      values: vi.fn().mockImplementation((val: Record<string, unknown>) => {
+        if (val.payload) enqueuedPayloads.push(JSON.parse(val.payload as string));
+        return Promise.resolve(undefined);
+      }),
+    });
+
+    await handlePayment(
+      db as never,
+      chargeStore as never,
+      "bc1qtest",
+      "50000",
+      {
+        txHash: "abc123",
+        confirmations: 0,
+        confirmationsRequired: 6,
+        amountReceivedCents: 5000,
+      },
+      noop,
+    );
+
+    expect(enqueuedPayloads).toHaveLength(1);
+    expect(enqueuedPayloads[0]).toMatchObject({
+      chargeId: "btc:test",
+      status: "partial",
+      confirmations: 0,
+      confirmationsRequired: 6,
+    });
+  });
+
+  it("fires webhook on each confirmation increment", async () => {
+    const chargeStore = mockChargeStore({ confirmations: 2 });
+    const db = mockDb();
+    const enqueuedPayloads: Record<string, unknown>[] = [];
+    db.insert = vi.fn().mockReturnValue({
+      values: vi.fn().mockImplementation((val: Record<string, unknown>) => {
+        if (val.payload) enqueuedPayloads.push(JSON.parse(val.payload as string));
+        return Promise.resolve(undefined);
+      }),
+    });
+
+    await handlePayment(
+      db as never,
+      chargeStore as never,
+      "bc1qtest",
+      "0", // no additional payment, just confirmation update
+      {
+        txHash: "abc123",
+        confirmations: 3,
+        confirmationsRequired: 6,
+        amountReceivedCents: 5000,
+      },
+      noop,
+    );
+
+    expect(enqueuedPayloads).toHaveLength(1);
+    expect(enqueuedPayloads[0]).toMatchObject({
+      status: "partial",
+      confirmations: 3,
+      confirmationsRequired: 6,
+    });
+  });
+
+  it("fires final webhook with status confirmed at threshold", async () => {
+    const chargeStore = mockChargeStore({
+      receivedAmount: "50000",
+      confirmations: 5,
+    });
+    const db = mockDb();
+    const enqueuedPayloads: Record<string, unknown>[] = [];
+    db.insert = vi.fn().mockReturnValue({
+      values: vi.fn().mockImplementation((val: Record<string, unknown>) => {
+        if (val.payload) enqueuedPayloads.push(JSON.parse(val.payload as string));
+        return Promise.resolve(undefined);
+      }),
+    });
+
+    await handlePayment(
+      db as never,
+      chargeStore as never,
+      "bc1qtest",
+      "0",
+      {
+        txHash: "abc123",
+        confirmations: 6,
+        confirmationsRequired: 6,
+        amountReceivedCents: 5000,
+      },
+      noop,
+    );
+
+    expect(enqueuedPayloads).toHaveLength(1);
+    expect(enqueuedPayloads[0]).toMatchObject({
+      status: "confirmed",
+      confirmations: 6,
+      confirmationsRequired: 6,
+    });
+    expect(chargeStore.markCredited).toHaveBeenCalledOnce();
+  });
+
+  it("all webhooks use canonical status values only", async () => {
+    const chargeStore = mockChargeStore();
+    const db = mockDb();
+    const enqueuedPayloads: Record<string, unknown>[] = [];
+    db.insert = vi.fn().mockReturnValue({
+      values: vi.fn().mockImplementation((val: Record<string, unknown>) => {
+        if (val.payload) enqueuedPayloads.push(JSON.parse(val.payload as string));
+        return Promise.resolve(undefined);
+      }),
+    });
+
+    await handlePayment(
+      db as never,
+      chargeStore as never,
+      "bc1qtest",
+      "50000",
+      {
+        txHash: "abc123",
+        confirmations: 0,
+        confirmationsRequired: 6,
+        amountReceivedCents: 5000,
+      },
+      noop,
+    );
+
+    const validStatuses = ["pending", "partial", "confirmed", "expired", "failed"];
+    for (const payload of enqueuedPayloads) {
+      expect(validStatuses).toContain(payload.status);
+    }
+    // Must NEVER contain legacy statuses
+    for (const payload of enqueuedPayloads) {
+      expect(payload.status).not.toBe("Settled");
+      expect(payload.status).not.toBe("Processing");
+      expect(payload.status).not.toBe("New");
+    }
+  });
+
+  it("updates charge progress via updateProgress()", async () => {
+    const chargeStore = mockChargeStore();
+    const db = mockDb();
+    db.insert = vi.fn().mockReturnValue({
+      values: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await handlePayment(
+      db as never,
+      chargeStore as never,
+      "bc1qtest",
+      "25000",
+      {
+        txHash: "abc123",
+        confirmations: 2,
+        confirmationsRequired: 6,
+        amountReceivedCents: 2500,
+      },
+      noop,
+    );
+
+    expect(chargeStore.updateProgress).toHaveBeenCalledWith("btc:test", {
+      status: "partial",
+      amountReceivedCents: 2500,
+      confirmations: 2,
+      confirmationsRequired: 6,
+      txHash: "abc123",
+    });
+  });
+
+  it("skips already-credited charges", async () => {
+    const chargeStore = mockChargeStore({ creditedAt: "2026-01-01" });
+    const db = mockDb();
+
+    await handlePayment(
+      db as never,
+      chargeStore as never,
+      "bc1qtest",
+      "50000",
+      { txHash: "abc123", confirmations: 6, confirmationsRequired: 6, amountReceivedCents: 5000 },
+      noop,
+    );
+
+    expect(chargeStore.updateProgress).not.toHaveBeenCalled();
+  });
+
+  it("skips unknown addresses", async () => {
+    const chargeStore = mockChargeStore();
+    chargeStore.getByDepositAddress.mockResolvedValue(null);
+    const db = mockDb();
+
+    await handlePayment(
+      db as never,
+      chargeStore as never,
+      "bc1qunknown",
+      "50000",
+      { txHash: "abc123", confirmations: 0, confirmationsRequired: 6, amountReceivedCents: 5000 },
+      noop,
+    );
+
+    expect(chargeStore.updateProgress).not.toHaveBeenCalled();
+  });
+});