@wopr-network/platform-core 1.13.2 → 1.14.0

package/src/monetization/credits/credit-expiry-cron.test.ts

@@ -1,16 +1,16 @@
 import type { PGlite } from "@electric-sql/pglite";
-import { Credit, DrizzleCreditLedger, runCreditExpiryCron } from "@wopr-network/platform-core/credits";
+import { Credit, DrizzleLedger, runCreditExpiryCron } from "@wopr-network/platform-core/credits";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import { createTestDb, truncateAllTables } from "../../test/db.js";
 
 describe("runCreditExpiryCron", () => {
   let pool: PGlite;
-  let ledger: DrizzleCreditLedger;
+  let ledger: DrizzleLedger;
 
   beforeAll(async () => {
     const { db, pool: p } = await createTestDb();
     pool = p;
-    ledger = new DrizzleCreditLedger(db);
+    ledger = new DrizzleLedger(db);
   });
 
   afterAll(async () => {
@@ -19,6 +19,7 @@ describe("runCreditExpiryCron", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
+    await ledger.seedSystemAccounts();
   });
 
   // All tests pass an explicit `now` parameter — hardcoded dates are time-independent
@@ -31,16 +32,11 @@ describe("runCreditExpiryCron", () => {
   });
 
   it("debits expired promotional credit grant", async () => {
-    await ledger.credit(
-      "tenant-1",
-      Credit.fromCents(500),
-      "promo",
-      "New user bonus",
-      "promo:tenant-1",
-      undefined,
-      undefined,
-      "2026-01-10T00:00:00Z",
-    );
+    await ledger.credit("tenant-1", Credit.fromCents(500), "promo", {
+      description: "New user bonus",
+      referenceId: "promo:tenant-1",
+      expiresAt: "2026-01-10T00:00:00Z",
+    });
 
     const result = await runCreditExpiryCron({ ledger, now: "2026-01-15T00:00:00Z" });
     expect(result.processed).toBe(1);
@@ -51,16 +47,11 @@ describe("runCreditExpiryCron", () => {
   });
 
   it("does not debit non-expired credits", async () => {
-    await ledger.credit(
-      "tenant-1",
-      Credit.fromCents(500),
-      "promo",
-      "Future bonus",
-      "promo:tenant-1-future",
-      undefined,
-      undefined,
-      "2026-02-01T00:00:00Z",
-    );
+    await ledger.credit("tenant-1", Credit.fromCents(500), "promo", {
+      description: "Future bonus",
+      referenceId: "promo:tenant-1-future",
+      expiresAt: "2026-02-01T00:00:00Z",
+    });
 
     const result = await runCreditExpiryCron({ ledger, now: "2026-01-15T00:00:00Z" });
     expect(result.processed).toBe(0);
@@ -70,7 +61,7 @@ describe("runCreditExpiryCron", () => {
   });
 
   it("does not debit credits without expires_at", async () => {
-    await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", "Top-up");
+    await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", { description: "Top-up" });
 
     const result = await runCreditExpiryCron({ ledger, now: "2026-01-15T00:00:00Z" });
     expect(result.processed).toBe(0);
@@ -80,17 +71,12 @@ describe("runCreditExpiryCron", () => {
   });
 
   it("only debits up to available balance when partially consumed", async () => {
-    await ledger.credit(
-      "tenant-1",
-      Credit.fromCents(500),
-      "promo",
-      "Promo",
-      "promo:partial",
-      undefined,
-      undefined,
-      "2026-01-10T00:00:00Z",
-    );
-    await ledger.debit("tenant-1", Credit.fromCents(300), "bot_runtime", "Runtime");
+    await ledger.credit("tenant-1", Credit.fromCents(500), "promo", {
+      description: "Promo",
+      referenceId: "promo:partial",
+      expiresAt: "2026-01-10T00:00:00Z",
+    });
+    await ledger.debit("tenant-1", Credit.fromCents(300), "bot_runtime", { description: "Runtime" });
 
     const result = await runCreditExpiryCron({ ledger, now: "2026-01-15T00:00:00Z" });
     expect(result.processed).toBe(1);
@@ -100,16 +86,11 @@ describe("runCreditExpiryCron", () => {
   });
 
   it("is idempotent -- does not double-debit on second run", async () => {
-    await ledger.credit(
-      "tenant-1",
-      Credit.fromCents(500),
-      "promo",
-      "Promo",
-      "promo:idemp",
-      undefined,
-      undefined,
-      "2026-01-10T00:00:00Z",
-    );
+    await ledger.credit("tenant-1", Credit.fromCents(500), "promo", {
+      description: "Promo",
+      referenceId: "promo:idemp",
+      expiresAt: "2026-01-10T00:00:00Z",
+    });
 
     await runCreditExpiryCron({ ledger, now: "2026-01-15T00:00:00Z" });
     const balanceAfterFirst = await ledger.balance("tenant-1");

package/src/monetization/credits/dividend-cron.test.ts

@@ -1,43 +1,34 @@
 import type { PGlite } from "@electric-sql/pglite";
-import { Credit, CreditLedger } from "@wopr-network/platform-core/credits";
+import { CREDIT_TYPE_ACCOUNT, 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 { creditBalances, creditTransactions } from "../../db/schema/credits.js";
+import type { PlatformDb } from "../../db/index.js";
 import { createTestDb, truncateAllTables } from "../../test/db.js";
-import { DrizzleCreditTransactionRepository } from "./credit-transaction-repository.js";
 import { type DividendCronConfig, runDividendCron } from "./dividend-cron.js";
 
-async function insertPurchase(db: DrizzleDb, tenantId: string, amountCents: number, createdAt: string): Promise<void> {
-  const id = `test-${tenantId}-${Date.now()}-${Math.random()}`;
+async function insertPurchase(
+  ledger: DrizzleLedger,
+  tenantId: string,
+  amountCents: number,
+  postedAt: string,
+): Promise<void> {
   const amount = Credit.fromCents(amountCents);
-  await db.insert(creditTransactions).values({
-    id,
+  await ledger.post({
+    entryType: "purchase",
     tenantId,
-    amount,
-    balanceAfter: amount,
-    type: "purchase",
-    createdAt,
+    description: `Test purchase ${amountCents}¢`,
+    referenceId: `test-purchase:${tenantId}:${postedAt}:${Math.random()}`,
+    postedAt,
+    lines: [
+      { accountCode: CREDIT_TYPE_ACCOUNT.purchase, amount, side: "debit" },
+      { accountCode: `2000:${tenantId}`, amount, side: "credit" },
+    ],
   });
-  // Upsert credit_balances
-  const existing = await db
-    .select()
-    .from(creditBalances)
-    .where((await import("drizzle-orm")).eq(creditBalances.tenantId, tenantId));
-  if (existing.length > 0) {
-    await db
-      .update(creditBalances)
-      .set({ balance: existing[0].balance.add(amount) })
-      .where((await import("drizzle-orm")).eq(creditBalances.tenantId, tenantId));
-  } else {
-    await db.insert(creditBalances).values({ tenantId, balance: amount });
-  }
 }
 
 describe("runDividendCron", () => {
   let pool: PGlite;
-  let db: DrizzleDb;
-  let ledger: CreditLedger;
-  let creditTransactionRepo: DrizzleCreditTransactionRepository;
+  let db: PlatformDb;
+  let ledger: DrizzleLedger;
 
   beforeAll(async () => {
     ({ db, pool } = await createTestDb());
@@ -49,13 +40,12 @@ describe("runDividendCron", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
-    ledger = new CreditLedger(db);
-    creditTransactionRepo = new DrizzleCreditTransactionRepository(db);
+    ledger = new DrizzleLedger(db);
+    await ledger.seedSystemAccounts();
   });
 
   function makeConfig(overrides?: Partial<DividendCronConfig>): DividendCronConfig {
     return {
-      creditTransactionRepo,
       ledger,
       matchRate: 1.0,
       targetDate: "2026-02-20",
@@ -64,7 +54,7 @@ describe("runDividendCron", () => {
   }
 
   it("distributes dividend to eligible tenants", async () => {
-    await insertPurchase(db, "t1", 1000, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t1", 1000, "2026-02-20 12:00:00");
 
     const result = await runDividendCron(makeConfig());
 
@@ -75,7 +65,7 @@ describe("runDividendCron", () => {
   });
 
   it("is idempotent — skips if already ran for the date", async () => {
-    await insertPurchase(db, "t1", 1000, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t1", 1000, "2026-02-20 12:00:00");
 
     const result1 = await runDividendCron(makeConfig());
     expect(result1.distributed).toBe(1);
@@ -91,23 +81,22 @@ describe("runDividendCron", () => {
   });
 
   it("handles floor rounding — remainder is not distributed", async () => {
-    await insertPurchase(db, "t1", 50, "2026-02-20 12:00:00");
-    await insertPurchase(db, "t2", 30, "2026-02-20 12:00:00");
-    await insertPurchase(db, "t3", 20, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t1", 50, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t2", 30, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t3", 20, "2026-02-20 12:00:00");
 
     const result = await runDividendCron(makeConfig());
 
     expect(result.pool.toCents()).toBe(100);
     expect(result.activeCount).toBe(3);
     // Nanodollar precision: floor(1_000_000_000 raw / 3) = 333_333_333 raw each
-    // Remainder = 1 nanodollar (not 1 cent — far less wasted with higher scale)
     expect(result.perUser.toRaw()).toBe(333_333_333);
     expect(result.distributed).toBe(3);
   });
 
   it("skips distribution when pool is zero", async () => {
     // Tenant purchased within 7 days but NOT on target date -> pool = 0
-    await insertPurchase(db, "t1", 500, "2026-02-18 12:00:00");
+    await insertPurchase(ledger, "t1", 500, "2026-02-18 12:00:00");
 
     const result = await runDividendCron(makeConfig());
 
@@ -118,11 +107,9 @@ describe("runDividendCron", () => {
   });
 
   it("distributes sub-cent amounts at nanodollar precision", async () => {
-    // 1 cent purchase, 3 active users: pool = 10_000_000 raw
-    // floor(10_000_000 / 3) = 3_333_333 raw each — non-zero, gets distributed
-    await insertPurchase(db, "t1", 1, "2026-02-20 12:00:00");
-    await insertPurchase(db, "t2", 500, "2026-02-18 12:00:00");
-    await insertPurchase(db, "t3", 500, "2026-02-17 12:00:00");
+    await insertPurchase(ledger, "t1", 1, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t2", 500, "2026-02-18 12:00:00");
+    await insertPurchase(ledger, "t3", 500, "2026-02-17 12:00:00");
 
     const result = await runDividendCron(makeConfig({ matchRate: 1.0 }));
 
@@ -133,21 +120,20 @@ describe("runDividendCron", () => {
   });
 
   it("records transactions with correct type and referenceId", async () => {
-    await insertPurchase(db, "t1", 1000, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t1", 1000, "2026-02-20 12:00:00");
 
     await runDividendCron(makeConfig());
 
     const history = await ledger.history("t1", { type: "community_dividend" });
     expect(history).toHaveLength(1);
-    expect(history[0].type).toBe("community_dividend");
+    expect(history[0].entryType).toBe("community_dividend");
     expect(history[0].referenceId).toBe("dividend:2026-02-20:t1");
-    expect(history[0].amount.toCents()).toBe(1000);
     expect(history[0].description).toContain("Community dividend");
   });
 
   it("collects errors without stopping distribution to other tenants", async () => {
-    await insertPurchase(db, "t1", 500, "2026-02-20 12:00:00");
-    await insertPurchase(db, "t2", 500, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t1", 500, "2026-02-20 12:00:00");
+    await insertPurchase(ledger, "t2", 500, "2026-02-20 12:00:00");
 
     const result = await runDividendCron(makeConfig());
 

package/src/monetization/credits/dividend-cron.ts

@@ -1,11 +1,9 @@
-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 { logger } from "../../config/logger.js";
-import type { ICreditTransactionRepository } from "./credit-transaction-repository.js";
 
 export interface DividendCronConfig {
-  creditTransactionRepo: ICreditTransactionRepository;
-  ledger: ICreditLedger;
+  ledger: ILedger;
   /** Fraction of daily purchases matched as dividend pool. Default 1.0 (100%). */
   matchRate: number;
   /** The date to compute dividend for, as YYYY-MM-DD string. Typically yesterday. */
@@ -43,7 +41,7 @@ export async function runDividendCron(cfg: DividendCronConfig): Promise<Dividend
   // Idempotency: check if any per-tenant dividend was already distributed for this date.
   // We look for any referenceId matching "dividend:YYYY-MM-DD:*".
   const sentinelPrefix = `dividend:${cfg.targetDate}:`;
-  const alreadyRan = await cfg.creditTransactionRepo.existsByReferenceIdLike(`${sentinelPrefix}%`);
+  const alreadyRan = await cfg.ledger.existsByReferenceIdLike(`${sentinelPrefix}%`);
 
   if (alreadyRan) {
     result.skippedAlreadyRun = true;
@@ -55,7 +53,7 @@ export async function runDividendCron(cfg: DividendCronConfig): Promise<Dividend
   const dayStart = `${cfg.targetDate} 00:00:00`;
   const dayEnd = `${cfg.targetDate} 24:00:00`;
 
-  const dailyPurchaseTotalCredit = await cfg.creditTransactionRepo.sumPurchasesForPeriod(dayStart, dayEnd);
+  const dailyPurchaseTotalCredit = await cfg.ledger.sumPurchasesForPeriod(dayStart, dayEnd);
   result.pool = dailyPurchaseTotalCredit.multiply(cfg.matchRate);
 
   // Step 2: Find all active tenants (purchased in last 7 days from target date).
@@ -64,7 +62,7 @@ export async function runDividendCron(cfg: DividendCronConfig): Promise<Dividend
   const windowStart = subtractDays(cfg.targetDate, 6);
   const windowStartTs = `${windowStart} 00:00:00`;
 
-  const activeTenantIds = await cfg.creditTransactionRepo.getActiveTenantIdsInWindow(windowStartTs, dayEnd);
+  const activeTenantIds = await cfg.ledger.getActiveTenantIdsInWindow(windowStartTs, dayEnd);
   result.activeCount = activeTenantIds.length;
 
   // Step 3: Compute per-user share.
@@ -92,13 +90,10 @@ export async function runDividendCron(cfg: DividendCronConfig): Promise<Dividend
   for (const tenantId of activeTenantIds) {
     const perUserRef = `dividend:${cfg.targetDate}:${tenantId}`;
     try {
-      await cfg.ledger.credit(
-        tenantId,
-        result.perUser,
-        "community_dividend",
-        `Community dividend for ${cfg.targetDate}: pool ${result.pool.toCents()}c / ${result.activeCount} users`,
-        perUserRef,
-      );
+      await cfg.ledger.credit(tenantId, result.perUser, "community_dividend", {
+        description: `Community dividend for ${cfg.targetDate}: pool ${result.pool.toCents()}c / ${result.activeCount} users`,
+        referenceId: perUserRef,
+      });
       result.distributed++;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);

package/src/monetization/credits/dividend-repository.test.ts

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 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 { adminUsers } from "../../db/schema/admin-users.js";
@@ -54,6 +54,7 @@ describe("DrizzleDividendRepository", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
+    await new DrizzleLedger(db).seedSystemAccounts();
     repo = new DrizzleDividendRepository(db);
   });
 
@@ -194,8 +195,8 @@ describe("DrizzleDividendRepository", () => {
     });
 
     it("marks user as eligible when they have a recent purchase", async () => {
-      const ledger = new CreditLedger(db);
-      await ledger.credit("t1", Credit.fromCents(100), "purchase", "recent buy");
+      const ledger = new DrizzleLedger(db);
+      await ledger.credit("t1", Credit.fromCents(100), "purchase", { description: "recent buy" });
 
       const stats = await repo.getStats("t1");
       expect(stats.userEligible).toBe(true);

package/src/monetization/credits/dividend-repository.ts

@@ -2,8 +2,8 @@ import { Credit } from "@wopr-network/platform-core/credits";
 import { and, desc, eq, gte, lt, sql } from "drizzle-orm";
 import type { DrizzleDb } from "../../db/index.js";
 import { adminUsers } from "../../db/schema/admin-users.js";
-import { creditTransactions } from "../../db/schema/credits.js";
 import { dividendDistributions } from "../../db/schema/dividend-distributions.js";
+import { journalEntries, journalLines } from "../../db/schema/ledger.js";
 import type { DividendHistoryEntry, DividendStats } from "../repository-types.js";
 
 export type { DividendHistoryEntry, DividendStats };
@@ -30,35 +30,32 @@ export class DrizzleDividendRepository implements IDividendRepository {
   constructor(private readonly db: DrizzleDb) {}
 
   async getStats(tenantId: string): Promise<DividendStats> {
-    // 1. Pool = sum of purchase amounts from yesterday UTC
+    // 1. Pool = sum of purchase credit amounts from yesterday UTC
     const poolRow = (
       await this.db
-        // raw SQL: Drizzle cannot express COALESCE(SUM(...), 0) aggregate
-        .select({ total: sql<number>`COALESCE(SUM(${creditTransactions.amount}), 0)` })
-        .from(creditTransactions)
+        .select({ total: sql<string>`COALESCE(SUM(${journalLines.amount}), 0)` })
+        .from(journalLines)
+        .innerJoin(journalEntries, eq(journalEntries.id, journalLines.journalEntryId))
         .where(
           and(
-            eq(creditTransactions.type, "purchase"),
-            // raw SQL: Drizzle cannot express date_trunc with interval arithmetic
-            sql`${creditTransactions.createdAt}::timestamp >= date_trunc('day', timezone('UTC', now())) - INTERVAL '1 day'`,
-            sql`${creditTransactions.createdAt}::timestamp < date_trunc('day', timezone('UTC', now()))`,
+            eq(journalEntries.entryType, "purchase"),
+            eq(journalLines.side, "credit"),
+            sql`${journalEntries.postedAt}::timestamp >= date_trunc('day', timezone('UTC', now())) - INTERVAL '1 day'`,
+            sql`${journalEntries.postedAt}::timestamp < date_trunc('day', timezone('UTC', now()))`,
           ),
         )
     )[0];
-    const poolCents = poolRow?.total ?? 0;
-    const pool = Credit.fromCents(poolCents);
+    const pool = Credit.fromRaw(Number(poolRow?.total ?? 0));
 
     // 2. Active users = distinct tenants with a purchase in the last 7 days
     const activeRow = (
       await this.db
-        // raw SQL: Drizzle cannot express COUNT(DISTINCT col)
-        .select({ count: sql<number>`COUNT(DISTINCT ${creditTransactions.tenantId})` })
-        .from(creditTransactions)
+        .select({ count: sql<number>`COUNT(DISTINCT ${journalEntries.tenantId})` })
+        .from(journalEntries)
         .where(
           and(
-            eq(creditTransactions.type, "purchase"),
-            // raw SQL: Drizzle cannot express timestamp comparison with interval arithmetic
-            sql`${creditTransactions.createdAt}::timestamp >= timezone('UTC', now()) - INTERVAL '7 days'`,
+            eq(journalEntries.entryType, "purchase"),
+            sql`${journalEntries.postedAt}::timestamp >= timezone('UTC', now()) - INTERVAL '7 days'`,
           ),
         )
     )[0];
@@ -75,10 +72,10 @@ export class DrizzleDividendRepository implements IDividendRepository {
     // 5. User eligibility — last purchase within 7 days
     const userPurchaseRow = (
       await this.db
-        .select({ createdAt: creditTransactions.createdAt })
-        .from(creditTransactions)
-        .where(and(eq(creditTransactions.tenantId, tenantId), eq(creditTransactions.type, "purchase")))
-        .orderBy(desc(creditTransactions.createdAt))
+        .select({ postedAt: journalEntries.postedAt })
+        .from(journalEntries)
+        .where(and(eq(journalEntries.tenantId, tenantId), eq(journalEntries.entryType, "purchase")))
+        .orderBy(desc(journalEntries.postedAt))
         .limit(1)
     )[0];
 
@@ -87,10 +84,7 @@ export class DrizzleDividendRepository implements IDividendRepository {
     let userWindowExpiresAt: string | null = null;
 
     if (userPurchaseRow) {
-      const rawTs = userPurchaseRow.createdAt;
-      // Parse the timestamp directly. PGlite may return ISO strings with or without
-      // timezone suffix. JavaScript's Date constructor handles ISO 8601 strings natively.
-      const lastPurchase = new Date(rawTs);
+      const lastPurchase = new Date(userPurchaseRow.postedAt);
       userLastPurchaseAt = lastPurchase.toISOString();
 
       const windowExpiry = new Date(lastPurchase.getTime() + 7 * 24 * 60 * 60 * 1000);

package/src/monetization/credits/index.ts

@@ -2,24 +2,24 @@ export type {
   AutoTopupSettings,
   CreditExpiryCronConfig,
   CreditExpiryCronResult,
-  CreditTransaction,
   CreditType,
   DebitType,
   HistoryOptions,
   IAutoTopupSettingsRepository,
-  ICreditLedger,
+  ILedger,
+  JournalEntry,
   TransactionType,
 } from "@wopr-network/platform-core/credits";
 export {
   ALLOWED_SCHEDULE_INTERVALS,
   ALLOWED_THRESHOLDS,
   ALLOWED_TOPUP_AMOUNTS,
-  CreditLedger,
   computeNextScheduleAt,
   DrizzleAutoTopupSettingsRepository,
-  DrizzleCreditLedger,
+  DrizzleLedger,
   grantSignupCredits,
   InsufficientBalanceError,
+  Ledger,
   runCreditExpiryCron,
   SIGNUP_GRANT,
 } from "@wopr-network/platform-core/credits";

package/src/monetization/credits/member-usage.test.ts

@@ -1,13 +1,13 @@
 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";
 
-describe("DrizzleCreditLedger.memberUsage", () => {
+describe("DrizzleDrizzleLedger.memberUsage", () => {
   let pool: PGlite;
   let db: DrizzleDb;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
 
   beforeAll(async () => {
     ({ db, pool } = await createTestDb());
@@ -19,14 +19,25 @@ describe("DrizzleCreditLedger.memberUsage", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
+
+    await ledger.seedSystemAccounts();
   });
 
   it("should aggregate debit totals per attributed user", async () => {
-    await ledger.credit("org-1", Credit.fromCents(10000), "purchase", "Seed");
-    await ledger.debit("org-1", Credit.fromCents(100), "adapter_usage", "Chat", undefined, false, "user-a");
-    await ledger.debit("org-1", Credit.fromCents(200), "adapter_usage", "Chat", undefined, false, "user-a");
-    await ledger.debit("org-1", Credit.fromCents(300), "adapter_usage", "Chat", undefined, false, "user-b");
+    await ledger.credit("org-1", Credit.fromCents(10000), "purchase", { description: "Seed" });
+    await ledger.debit("org-1", Credit.fromCents(100), "adapter_usage", {
+      description: "Chat",
+      attributedUserId: "user-a",
+    });
+    await ledger.debit("org-1", Credit.fromCents(200), "adapter_usage", {
+      description: "Chat",
+      attributedUserId: "user-a",
+    });
+    await ledger.debit("org-1", Credit.fromCents(300), "adapter_usage", {
+      description: "Chat",
+      attributedUserId: "user-b",
+    });
 
     const result = await ledger.memberUsage("org-1");
     expect(result).toHaveLength(2);
@@ -41,9 +52,12 @@ describe("DrizzleCreditLedger.memberUsage", () => {
   });
 
   it("should exclude transactions with null attributedUserId", async () => {
-    await ledger.credit("org-1", Credit.fromCents(10000), "purchase", "Seed");
-    await ledger.debit("org-1", Credit.fromCents(100), "bot_runtime", "Cron"); // no attributedUserId
-    await ledger.debit("org-1", Credit.fromCents(200), "adapter_usage", "Chat", undefined, false, "user-a");
+    await ledger.credit("org-1", Credit.fromCents(10000), "purchase", { description: "Seed" });
+    await ledger.debit("org-1", Credit.fromCents(100), "bot_runtime", { description: "Cron" }); // no attributedUserId
+    await ledger.debit("org-1", Credit.fromCents(200), "adapter_usage", {
+      description: "Chat",
+      attributedUserId: "user-a",
+    });
 
     const result = await ledger.memberUsage("org-1");
     expect(result).toHaveLength(1);