@wopr-network/platform-core 1.13.3 → 1.14.0

package/src/metering/reconciliation-cron.test.ts

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import type { PGlite } from "@electric-sql/pglite";
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { Credit } from "../credits/credit.js";
-import { CreditLedger } from "../credits/credit-ledger.js";
+import { DrizzleLedger } from "../credits/ledger.js";
 import type { PlatformDb } from "../db/index.js";
 import { usageSummaries } from "../db/schema/meter-events.js";
 import { createTestDb, truncateAllTables } from "../test/db.js";
@@ -18,7 +18,7 @@ const DAY_END = DAY_START + 24 * 60 * 60 * 1000;
 describe("runReconciliation", () => {
   let pool: PGlite;
   let db: PlatformDb;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
   let usageSummaryRepo: DrizzleUsageSummaryRepository;
   let adapterUsageRepo: DrizzleAdapterUsageRepository;
 
@@ -26,7 +26,7 @@ describe("runReconciliation", () => {
     const t = await createTestDb();
     pool = t.pool;
     db = t.db;
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
     usageSummaryRepo = new DrizzleUsageSummaryRepository(db);
     adapterUsageRepo = new DrizzleAdapterUsageRepository(db);
   });
@@ -37,6 +37,7 @@ describe("runReconciliation", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
+    await ledger.seedSystemAccounts();
   });
 
   /** Insert a usage_summaries row directly. */
@@ -75,7 +76,7 @@ describe("runReconciliation", () => {
     await insertSummary({ tenant: "t1", totalCharge: charge.toRaw() });
 
     await ledger.credit("t1", Credit.fromCents(500), "purchase");
-    await ledger.debit("t1", charge, "adapter_usage", "chat usage");
+    await ledger.debit("t1", charge, "adapter_usage", { description: "chat usage" });
 
     const result = await runReconciliation({ usageSummaryRepo, adapterUsageRepo, targetDate: TODAY });
     expect(result.tenantsChecked).toBe(1);
@@ -86,7 +87,7 @@ describe("runReconciliation", () => {
     await insertSummary({ tenant: "t1", totalCharge: Credit.fromCents(100).toRaw() });
 
     await ledger.credit("t1", Credit.fromCents(500), "purchase");
-    await ledger.debit("t1", Credit.fromCents(80), "adapter_usage", "chat usage");
+    await ledger.debit("t1", Credit.fromCents(80), "adapter_usage", { description: "chat usage" });
 
     const result = await runReconciliation({ usageSummaryRepo, adapterUsageRepo, targetDate: TODAY });
     expect(result.tenantsChecked).toBe(1);
@@ -118,7 +119,7 @@ describe("runReconciliation", () => {
 
     await ledger.credit("t1", Credit.fromCents(500), "purchase");
     // Debit as bot_runtime — should NOT count toward reconciliation
-    await ledger.debit("t1", Credit.fromCents(20), "bot_runtime", "daily runtime");
+    await ledger.debit("t1", Credit.fromCents(20), "bot_runtime", { description: "daily runtime" });
 
     const result = await runReconciliation({ usageSummaryRepo, adapterUsageRepo, targetDate: TODAY });
     // Metered 20c, ledger adapter_usage = 0 => drift = 20c
@@ -150,12 +151,12 @@ describe("runReconciliation", () => {
     // t1: balanced
     await insertSummary({ tenant: "t1", totalCharge: Credit.fromCents(50).toRaw() });
     await ledger.credit("t1", Credit.fromCents(500), "purchase");
-    await ledger.debit("t1", Credit.fromCents(50), "adapter_usage", "chat");
+    await ledger.debit("t1", Credit.fromCents(50), "adapter_usage", { description: "chat" });
 
     // t2: drifted
     await insertSummary({ tenant: "t2", totalCharge: Credit.fromCents(100).toRaw() });
     await ledger.credit("t2", Credit.fromCents(500), "purchase");
-    await ledger.debit("t2", Credit.fromCents(60), "adapter_usage", "chat");
+    await ledger.debit("t2", Credit.fromCents(60), "adapter_usage", { description: "chat" });
 
     const result = await runReconciliation({ usageSummaryRepo, adapterUsageRepo, targetDate: TODAY });
     expect(result.tenantsChecked).toBe(2);
@@ -193,7 +194,7 @@ describe("runReconciliation", () => {
     await insertSummary({ tenant: "t1", totalCharge: Credit.fromCents(50).toRaw() });
 
     await ledger.credit("t1", Credit.fromCents(500), "purchase");
-    await ledger.debit("t1", Credit.fromCents(80), "adapter_usage", "chat usage");
+    await ledger.debit("t1", Credit.fromCents(80), "adapter_usage", { description: "chat usage" });
 
     const result = await runReconciliation({ usageSummaryRepo, adapterUsageRepo, targetDate: TODAY });
     expect(result.discrepancies).toHaveLength(1);

package/src/metering/reconciliation-repository.test.ts

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import type { PGlite } from "@electric-sql/pglite";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import { Credit } from "../credits/credit.js";
-import { CreditLedger } from "../credits/credit-ledger.js";
+import { DrizzleLedger } from "../credits/ledger.js";
 import type { PlatformDb } from "../db/index.js";
 import { createTestDb, seedUsageSummary, truncateAllTables } from "../test/db.js";
 import { DrizzleAdapterUsageRepository, DrizzleUsageSummaryRepository } from "./reconciliation-repository.js";
@@ -126,12 +126,13 @@ describe("DrizzleUsageSummaryRepository", () => {
 
 describe("DrizzleAdapterUsageRepository", () => {
   let repo: DrizzleAdapterUsageRepository;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
 
   beforeEach(async () => {
     await truncateAllTables(pool);
     repo = new DrizzleAdapterUsageRepository(db);
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
+    await ledger.seedSystemAccounts();
   });
 
   it("returns empty array when no adapter_usage debits exist", async () => {
@@ -147,9 +148,9 @@ describe("DrizzleAdapterUsageRepository", () => {
     await ledger.credit("t1", Credit.fromCents(1000), "purchase");
     await ledger.credit("t2", Credit.fromCents(1000), "purchase");
 
-    await ledger.debit("t1", Credit.fromCents(30), "adapter_usage", "t1-debit-1");
-    await ledger.debit("t1", Credit.fromCents(20), "adapter_usage", "t1-debit-2");
-    await ledger.debit("t2", Credit.fromCents(50), "adapter_usage", "t2-debit-1");
+    await ledger.debit("t1", Credit.fromCents(30), "adapter_usage", { description: "t1-debit-1" });
+    await ledger.debit("t1", Credit.fromCents(20), "adapter_usage", { description: "t1-debit-2" });
+    await ledger.debit("t2", Credit.fromCents(50), "adapter_usage", { description: "t2-debit-1" });
 
     // Query window covering today
     const today = new Date().toISOString().slice(0, 10);
@@ -168,8 +169,8 @@ describe("DrizzleAdapterUsageRepository", () => {
 
   it("excludes non-adapter_usage debit types", async () => {
     await ledger.credit("t1", Credit.fromCents(1000), "purchase");
-    await ledger.debit("t1", Credit.fromCents(30), "adapter_usage", "adapter debit");
-    await ledger.debit("t1", Credit.fromCents(20), "bot_runtime", "runtime debit");
+    await ledger.debit("t1", Credit.fromCents(30), "adapter_usage", { description: "adapter debit" });
+    await ledger.debit("t1", Credit.fromCents(20), "bot_runtime", { description: "runtime debit" });
 
     const today = new Date().toISOString().slice(0, 10);
     const startIso = `${today}T00:00:00Z`;
@@ -182,7 +183,7 @@ describe("DrizzleAdapterUsageRepository", () => {
 
   it("excludes credit transactions (positive amounts are not debits)", async () => {
     await ledger.credit("t1", Credit.fromCents(1000), "purchase");
-    await ledger.debit("t1", Credit.fromCents(10), "adapter_usage", "real debit");
+    await ledger.debit("t1", Credit.fromCents(10), "adapter_usage", { description: "real debit" });
 
     const today = new Date().toISOString().slice(0, 10);
     const startIso = `${today}T00:00:00Z`;

package/src/metering/reconciliation-repository.ts

@@ -1,6 +1,6 @@
 import { and, eq, gte, lt, ne, sql } from "drizzle-orm";
 import type { PlatformDb } from "../db/index.js";
-import { creditTransactions } from "../db/schema/credits.js";
+import { journalEntries, journalLines } from "../db/schema/ledger.js";
 import { usageSummaries } from "../db/schema/meter-events.js";
 
 // ---------------------------------------------------------------------------
@@ -59,24 +59,27 @@ export class DrizzleAdapterUsageRepository implements IAdapterUsageRepository {
   constructor(private readonly db: PlatformDb) {}
 
   async getAggregatedAdapterUsageDebits(startIso: string, endIso: string): Promise<AggregatedDebit[]> {
+    // Sum the debit-side journal line amounts for adapter_usage entries.
+    // In double-entry: DR tenant liability (2000:<tenantId>), CR revenue:adapter_usage (4010).
+    // The debit line on the tenant account represents the charge amount.
     const rows = await this.db
       .select({
-        tenantId: creditTransactions.tenantId,
-        // amount_credits stores negative values for debits; ABS gives the raw positive debit amount.
-        // Use the raw column name in sql to bypass the custom creditColumn type serializer.
-        // raw SQL: Drizzle cannot express ABS with COALESCE and SUM
-        totalDebitRaw: sql<number>`COALESCE(SUM(ABS(amount_credits)), 0)`,
+        tenantId: journalEntries.tenantId,
+        // raw SQL: Drizzle cannot express COALESCE with SUM aggregation
+        totalDebitRaw: sql<number>`COALESCE(SUM(${journalLines.amount}), 0)`,
       })
-      .from(creditTransactions)
+      .from(journalLines)
+      .innerJoin(journalEntries, eq(journalEntries.id, journalLines.journalEntryId))
       .where(
         and(
-          eq(creditTransactions.type, "adapter_usage"),
+          eq(journalEntries.entryType, "adapter_usage"),
+          eq(journalLines.side, "debit"),
           // raw SQL: Drizzle cannot express timestamptz cast for text column date comparison
-          sql`${creditTransactions.createdAt}::timestamptz >= ${startIso}::timestamptz`,
-          sql`${creditTransactions.createdAt}::timestamptz < ${endIso}::timestamptz`,
+          sql`${journalEntries.postedAt}::timestamptz >= ${startIso}::timestamptz`,
+          sql`${journalEntries.postedAt}::timestamptz < ${endIso}::timestamptz`,
         ),
       )
-      .groupBy(creditTransactions.tenantId);
+      .groupBy(journalEntries.tenantId);
 
     return rows.map((r) => ({ tenantId: r.tenantId, totalDebitRaw: Number(r.totalDebitRaw) }));
   }

package/src/monetization/affiliate/affiliate-admin-repository.test.ts

@@ -1,10 +1,10 @@
 import type { PGlite } from "@electric-sql/pglite";
-import { sql } from "drizzle-orm";
+import { Credit, DrizzleLedger } from "@wopr-network/platform-core/credits";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import type { DrizzleDb } from "../../db/index.js";
 import { affiliateReferrals } from "../../db/schema/affiliate.js";
 import { affiliateFraudEvents } from "../../db/schema/affiliate-fraud.js";
-import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
+import { createTestDb, truncateAllTables } from "../../test/db.js";
 import { ADMIN_BLOCK_SENTINEL, DrizzleAffiliateFraudAdminRepository } from "./affiliate-admin-repository.js";
 
 describe("DrizzleAffiliateFraudAdminRepository", () => {
@@ -14,16 +14,15 @@ describe("DrizzleAffiliateFraudAdminRepository", () => {
 
   beforeAll(async () => {
     ({ db, pool } = await createTestDb());
-    await beginTestTransaction(pool);
   });
 
   afterAll(async () => {
-    await endTestTransaction(pool);
     await pool.close();
   });
 
   beforeEach(async () => {
-    await rollbackTestTransaction(pool);
+    await truncateAllTables(pool);
+    await new DrizzleLedger(db).seedSystemAccounts();
     repo = new DrizzleAffiliateFraudAdminRepository(db);
   });
 
@@ -162,11 +161,17 @@ describe("DrizzleAffiliateFraudAdminRepository", () => {
 
   describe("blockFingerprint", () => {
     it("should insert fraud events with ADMIN_BLOCK as referredTenantId", async () => {
-      await db.execute(
-        sql`INSERT INTO credit_transactions (id, tenant_id, amount_credits, balance_after_credits, type, created_at, stripe_fingerprint)
-            VALUES ('ct-1', 't-alice', 0, 0, 'purchase', now(), 'fp_abc123'),
-                   ('ct-2', 't-bob', 0, 0, 'purchase', now(), 'fp_abc123')`,
-      );
+      const ledger = new DrizzleLedger(db);
+      await ledger.credit("t-alice", Credit.fromCents(1), "purchase", {
+        description: "test purchase",
+        referenceId: "ref-alice-fp_abc123",
+        stripeFingerprint: "fp_abc123",
+      });
+      await ledger.credit("t-bob", Credit.fromCents(1), "purchase", {
+        description: "test purchase",
+        referenceId: "ref-bob-fp_abc123",
+        stripeFingerprint: "fp_abc123",
+      });
 
       await repo.blockFingerprint("fp_abc123", "admin-user-1");
 
@@ -185,11 +190,17 @@ describe("DrizzleAffiliateFraudAdminRepository", () => {
     });
 
     it("should use unique referralId per tenant to avoid unique constraint conflicts", async () => {
-      await db.execute(
-        sql`INSERT INTO credit_transactions (id, tenant_id, amount_credits, balance_after_credits, type, created_at, stripe_fingerprint)
-            VALUES ('ct-3', 't-carol', 0, 0, 'purchase', now(), 'fp_def456'),
-                   ('ct-4', 't-dave', 0, 0, 'purchase', now(), 'fp_def456')`,
-      );
+      const ledger = new DrizzleLedger(db);
+      await ledger.credit("t-carol", Credit.fromCents(1), "purchase", {
+        description: "test purchase",
+        referenceId: "ref-carol-fp_def456",
+        stripeFingerprint: "fp_def456",
+      });
+      await ledger.credit("t-dave", Credit.fromCents(1), "purchase", {
+        description: "test purchase",
+        referenceId: "ref-dave-fp_def456",
+        stripeFingerprint: "fp_def456",
+      });
 
       await repo.blockFingerprint("fp_def456", "admin-user-2");
 
@@ -204,10 +215,12 @@ describe("DrizzleAffiliateFraudAdminRepository", () => {
     });
 
     it("should be idempotent via onConflictDoNothing", async () => {
-      await db.execute(
-        sql`INSERT INTO credit_transactions (id, tenant_id, amount_credits, balance_after_credits, type, created_at, stripe_fingerprint)
-            VALUES ('ct-5', 't-eve', 0, 0, 'purchase', now(), 'fp_ghi789')`,
-      );
+      const ledger = new DrizzleLedger(db);
+      await ledger.credit("t-eve", Credit.fromCents(1), "purchase", {
+        description: "test purchase",
+        referenceId: "ref-eve-fp_ghi789",
+        stripeFingerprint: "fp_ghi789",
+      });
 
       await repo.blockFingerprint("fp_ghi789", "admin-user-3");
       await repo.blockFingerprint("fp_ghi789", "admin-user-3");

package/src/monetization/affiliate/affiliate-admin-repository.ts

@@ -4,7 +4,7 @@ import { logger } from "../../config/logger.js";
 import type { DrizzleDb } from "../../db/index.js";
 import { affiliateReferrals } from "../../db/schema/affiliate.js";
 import { affiliateFraudEvents } from "../../db/schema/affiliate-fraud.js";
-import { creditTransactions } from "../../db/schema/credits.js";
+import { journalEntries } from "../../db/schema/ledger.js";
 
 function parseSignals(raw: string): string[] {
   try {
@@ -119,13 +119,16 @@ export class DrizzleAffiliateFraudAdminRepository implements IAffiliateFraudAdmi
   }
 
   async listFingerprintClusters(): Promise<FingerprintCluster[]> {
+    // Query journal_entries.metadata->>'stripeFingerprint' for purchase entries
     // raw SQL: Drizzle cannot express HAVING COUNT(DISTINCT ...) with array_agg in a single query
     type ClusterRow = { stripe_fingerprint: string; tenant_ids: string[] };
     const rows = (await this.db.execute(sql`
-      SELECT stripe_fingerprint, array_agg(DISTINCT tenant_id ORDER BY tenant_id) AS tenant_ids
-      FROM credit_transactions
-      WHERE stripe_fingerprint IS NOT NULL
-      GROUP BY stripe_fingerprint
+      SELECT metadata->>'stripeFingerprint' AS stripe_fingerprint,
+             array_agg(DISTINCT tenant_id ORDER BY tenant_id) AS tenant_ids
+      FROM journal_entries
+      WHERE metadata->>'stripeFingerprint' IS NOT NULL
+        AND entry_type = 'purchase'
+      GROUP BY metadata->>'stripeFingerprint'
       HAVING COUNT(DISTINCT tenant_id) > 1
       ORDER BY COUNT(DISTINCT tenant_id) DESC
     `)) as unknown as { rows: ClusterRow[] };
@@ -138,9 +141,14 @@ export class DrizzleAffiliateFraudAdminRepository implements IAffiliateFraudAdmi
 
   async blockFingerprint(fingerprint: string, adminUserId: string): Promise<void> {
     const rows = await this.db
-      .selectDistinct({ tenantId: creditTransactions.tenantId })
-      .from(creditTransactions)
-      .where(eq(creditTransactions.stripeFingerprint, fingerprint));
+      .selectDistinct({ tenantId: journalEntries.tenantId })
+      .from(journalEntries)
+      .where(
+        and(
+          eq(journalEntries.entryType, "purchase"),
+          sql`${journalEntries.metadata}->>'stripeFingerprint' = ${fingerprint}`,
+        ),
+      );
     const tenantIds = rows.map((r) => r.tenantId);
 
     const now = new Date().toISOString();

package/src/monetization/affiliate/credit-match.test.ts

@@ -1,5 +1,5 @@
 import type { PGlite } from "@electric-sql/pglite";
-import { Credit, CreditLedger } from "@wopr-network/platform-core/credits";
+import { Credit, DrizzleLedger } from "@wopr-network/platform-core/credits";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import type { DrizzleDb } from "../../db/index.js";
 import { createTestDb, truncateAllTables } from "../../test/db.js";
@@ -10,7 +10,7 @@ import { DrizzleAffiliateRepository } from "./drizzle-affiliate-repository.js";
 describe("processAffiliateCreditMatch", () => {
   let pool: PGlite;
   let db: DrizzleDb;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
   let affiliateRepo: DrizzleAffiliateRepository;
   let fraudRepo: DrizzleAffiliateFraudRepository;
 
@@ -24,13 +24,19 @@ describe("processAffiliateCreditMatch", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
+
+    await ledger.seedSystemAccounts();
     affiliateRepo = new DrizzleAffiliateRepository(db);
     fraudRepo = new DrizzleAffiliateFraudRepository(db);
   });
 
   it("does nothing when tenant has no referral", async () => {
-    await ledger.credit("buyer", Credit.fromCents(1000), "purchase", "first buy", "session-1", "stripe");
+    await ledger.credit("buyer", Credit.fromCents(1000), "purchase", {
+      description: "first buy",
+      referenceId: "session-1",
+      fundingSource: "stripe",
+    });
 
     const result = await processAffiliateCreditMatch({
       tenantId: "buyer",
@@ -45,8 +51,16 @@ describe("processAffiliateCreditMatch", () => {
   it("does nothing when tenant already has prior purchases", async () => {
     await affiliateRepo.recordReferral("referrer", "buyer", "abc123");
 
-    await ledger.credit("buyer", Credit.fromCents(500), "purchase", "old buy", "session-0", "stripe");
-    await ledger.credit("buyer", Credit.fromCents(1000), "purchase", "new buy", "session-1", "stripe");
+    await ledger.credit("buyer", Credit.fromCents(500), "purchase", {
+      description: "old buy",
+      referenceId: "session-0",
+      fundingSource: "stripe",
+    });
+    await ledger.credit("buyer", Credit.fromCents(1000), "purchase", {
+      description: "new buy",
+      referenceId: "session-1",
+      fundingSource: "stripe",
+    });
 
     const result = await processAffiliateCreditMatch({
       tenantId: "buyer",
@@ -60,7 +74,11 @@ describe("processAffiliateCreditMatch", () => {
 
   it("credits referrer on first purchase with 100% match", async () => {
     await affiliateRepo.recordReferral("referrer", "buyer", "abc123");
-    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", "first buy", "session-1", "stripe");
+    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", {
+      description: "first buy",
+      referenceId: "session-1",
+      fundingSource: "stripe",
+    });
 
     const result = await processAffiliateCreditMatch({
       tenantId: "buyer",
@@ -83,7 +101,11 @@ describe("processAffiliateCreditMatch", () => {
 
   it("respects custom match rate", async () => {
     await affiliateRepo.recordReferral("referrer", "buyer", "abc123");
-    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", "first buy", "session-1", "stripe");
+    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", {
+      description: "first buy",
+      referenceId: "session-1",
+      fundingSource: "stripe",
+    });
 
     const result = await processAffiliateCreditMatch({
       tenantId: "buyer",
@@ -99,7 +121,11 @@ describe("processAffiliateCreditMatch", () => {
 
   it("is idempotent — second call returns null", async () => {
     await affiliateRepo.recordReferral("referrer", "buyer", "abc123");
-    await ledger.credit("buyer", Credit.fromCents(1000), "purchase", "first buy", "session-1", "stripe");
+    await ledger.credit("buyer", Credit.fromCents(1000), "purchase", {
+      description: "first buy",
+      referenceId: "session-1",
+      fundingSource: "stripe",
+    });
 
     const first = await processAffiliateCreditMatch({
       tenantId: "buyer",
@@ -123,7 +149,11 @@ describe("processAffiliateCreditMatch", () => {
       signupIp: "1.2.3.4",
       signupEmail: "alice+ref@gmail.com",
     });
-    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", "first buy", "session-1", "stripe");
+    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", {
+      description: "first buy",
+      referenceId: "session-1",
+      fundingSource: "stripe",
+    });
 
     const result = await processAffiliateCreditMatch({
       tenantId: "buyer",
@@ -156,7 +186,11 @@ describe("processAffiliateCreditMatch", () => {
 
       // New referral
       await affiliateRepo.recordReferral("referrer", "buyer", "abc123");
-      await ledger.credit("buyer", Credit.fromCents(1000), "purchase", "first buy", "session-1", "stripe");
+      await ledger.credit("buyer", Credit.fromCents(1000), "purchase", {
+        description: "first buy",
+        referenceId: "session-1",
+        fundingSource: "stripe",
+      });
 
       const result = await processAffiliateCreditMatch({
         tenantId: "buyer",
@@ -184,7 +218,11 @@ describe("processAffiliateCreditMatch", () => {
 
       // New referral
       await affiliateRepo.recordReferral("referrer", "buyer", "abc123");
-      await ledger.credit("buyer", Credit.fromCents(1000), "purchase", "first buy", "session-1", "stripe");
+      await ledger.credit("buyer", Credit.fromCents(1000), "purchase", {
+        description: "first buy",
+        referenceId: "session-1",
+        fundingSource: "stripe",
+      });
 
       const result = await processAffiliateCreditMatch({
         tenantId: "buyer",
@@ -203,7 +241,11 @@ describe("processAffiliateCreditMatch", () => {
 
     it("allows payout when under both caps", async () => {
       await affiliateRepo.recordReferral("referrer", "buyer", "abc123");
-      await ledger.credit("buyer", Credit.fromCents(2000), "purchase", "first buy", "session-1", "stripe");
+      await ledger.credit("buyer", Credit.fromCents(2000), "purchase", {
+        description: "first buy",
+        referenceId: "session-1",
+        fundingSource: "stripe",
+      });
 
       const result = await processAffiliateCreditMatch({
         tenantId: "buyer",
@@ -223,7 +265,11 @@ describe("processAffiliateCreditMatch", () => {
     await affiliateRepo.recordReferral("referrer", "buyer", "abc123", {
       signupIp: "1.2.3.4",
     });
-    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", "first buy", "session-1", "stripe");
+    await ledger.credit("buyer", Credit.fromCents(2000), "purchase", {
+      description: "first buy",
+      referenceId: "session-1",
+      fundingSource: "stripe",
+    });
 
     const result = await processAffiliateCreditMatch({
       tenantId: "buyer",

package/src/monetization/affiliate/credit-match.ts

@@ -1,4 +1,4 @@
-import type { Credit, ICreditLedger } from "@wopr-network/platform-core/credits";
+import type { Credit, ILedger } from "@wopr-network/platform-core/credits";
 import { config } from "../../config/index.js";
 import type { IAffiliateFraudRepository } from "./affiliate-fraud-repository.js";
 import type { IAffiliateRepository } from "./drizzle-affiliate-repository.js";
@@ -11,7 +11,7 @@ const DEFAULT_MAX_MATCH_CREDITS_30D = config.billing.affiliateMaxMatchCredits30d
 export interface AffiliateCreditMatchDeps {
   tenantId: string;
   purchaseAmount: Credit;
-  ledger: ICreditLedger;
+  ledger: ILedger;
   affiliateRepo: IAffiliateRepository;
   matchRate?: number;
   fraudRepo?: IAffiliateFraudRepository;
@@ -122,13 +122,10 @@ export async function processAffiliateCreditMatch(
   if (matchAmount.isZero() || matchAmount.isNegative()) return null;
 
   // 6. Credit the referrer
-  await ledger.credit(
-    referral.referrerTenantId,
-    matchAmount,
-    "affiliate_match",
-    `Affiliate match for referred tenant ${tenantId}`,
-    refId,
-  );
+  await ledger.credit(referral.referrerTenantId, matchAmount, "affiliate_match", {
+    description: `Affiliate match for referred tenant ${tenantId}`,
+    referenceId: refId,
+  });
 
   // 7. Update referral record
   await affiliateRepo.markFirstPurchase(tenantId);

package/src/monetization/affiliate/new-user-bonus.test.ts

@@ -1,5 +1,5 @@
 import type { PGlite } from "@electric-sql/pglite";
-import { Credit, CreditLedger } from "@wopr-network/platform-core/credits";
+import { Credit, DrizzleLedger } from "@wopr-network/platform-core/credits";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import type { DrizzleDb } from "../../db/index.js";
 import { createTestDb, truncateAllTables } from "../../test/db.js";
@@ -9,7 +9,7 @@ import { DEFAULT_BONUS_RATE, grantNewUserBonus } from "./new-user-bonus.js";
 describe("grantNewUserBonus", () => {
   let pool: PGlite;
   let db: DrizzleDb;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
   let affiliateRepo: DrizzleAffiliateRepository;
 
   beforeAll(async () => {
@@ -22,7 +22,9 @@ describe("grantNewUserBonus", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
+
+    await ledger.seedSystemAccounts();
     affiliateRepo = new DrizzleAffiliateRepository(db);
   });
 
@@ -48,7 +50,7 @@ describe("grantNewUserBonus", () => {
 
     const txns = await ledger.history("referred-1");
     expect(txns).toHaveLength(1);
-    expect(txns[0].type).toBe("affiliate_bonus");
+    expect(txns[0].entryType).toBe("affiliate_bonus");
     expect(txns[0].referenceId).toBe("affiliate-bonus:referred-1");
     expect(txns[0].description).toContain("first-purchase bonus");
   });

package/src/monetization/affiliate/new-user-bonus.ts

@@ -1,4 +1,4 @@
-import type { ICreditLedger } from "@wopr-network/platform-core/credits";
+import type { ILedger } from "@wopr-network/platform-core/credits";
 import { Credit } from "@wopr-network/platform-core/credits";
 import { config } from "../../config/index.js";
 import type { IAffiliateRepository } from "./drizzle-affiliate-repository.js";
@@ -7,7 +7,7 @@ import type { IAffiliateRepository } from "./drizzle-affiliate-repository.js";
 export const DEFAULT_BONUS_RATE = config.billing.affiliateNewUserBonusRate;
 
 export interface NewUserBonusParams {
-  ledger: ICreditLedger;
+  ledger: ILedger;
   affiliateRepo: IAffiliateRepository;
   referredTenantId: string;
   purchaseAmount: Credit;
@@ -57,13 +57,10 @@ export async function grantNewUserBonus(params: NewUserBonusParams): Promise<New
   await affiliateRepo.markFirstPurchase(referredTenantId);
 
   // 6. Credit the bonus
-  await ledger.credit(
-    referredTenantId,
-    bonus,
-    "affiliate_bonus",
-    `New user first-purchase bonus (${Math.round(rate * 100)}%)`,
-    refId,
-  );
+  await ledger.credit(referredTenantId, bonus, "affiliate_bonus", {
+    description: `New user first-purchase bonus (${Math.round(rate * 100)}%)`,
+    referenceId: refId,
+  });
 
   return { granted: true, bonus };
 }

package/src/monetization/credits/auto-topup-charge.test.ts

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
 import type { PGlite } from "@electric-sql/pglite";
 import type { ITenantCustomerRepository } from "@wopr-network/platform-core/billing";
-import { Credit, CreditLedger } from "@wopr-network/platform-core/credits";
+import { Credit, DrizzleLedger } from "@wopr-network/platform-core/credits";
 import Stripe from "stripe";
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import type { DrizzleDb } from "../../db/index.js";
@@ -48,7 +48,7 @@ function mockTenantStore(stripeCustomerId = "cus_123") {
 describe("chargeAutoTopup", () => {
   let pool: PGlite;
   let db: DrizzleDb;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
 
   beforeAll(async () => {
     ({ db, pool } = await createTestDb());
@@ -60,7 +60,9 @@ describe("chargeAutoTopup", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
+
+    await ledger.seedSystemAccounts();
   });
 
   it("charges Stripe and credits ledger on success", async () => {
@@ -79,8 +81,8 @@ describe("chargeAutoTopup", () => {
     expect(result.paymentReference).toEqual(expect.any(String));
     expect((await ledger.balance("t1")).toCents()).toBe(500);
     const history = await ledger.history("t1");
-    expect(history[0].type).toBe("purchase");
-    expect(history[0].fundingSource).toBe("stripe");
+    expect(history[0].entryType).toBe("purchase");
+    expect(history[0].metadata?.fundingSource).toBe("stripe");
   });
 
   it("writes success event to credit_auto_topup log", async () => {