@wopr-network/platform-core 1.13.3 → 1.14.0

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

@@ -1,5 +1,5 @@
 import type { ITenantCustomerRepository } from "@wopr-network/platform-core/billing";
-import type { Credit, ICreditLedger } from "@wopr-network/platform-core/credits";
+import type { Credit, ILedger } from "@wopr-network/platform-core/credits";
 import Stripe from "stripe";
 import { logger } from "../../config/logger.js";
 import type { IAutoTopupEventLogRepository } from "./auto-topup-event-log-repository.js";
@@ -10,7 +10,7 @@ export const MAX_CONSECUTIVE_FAILURES = 3;
 export interface AutoTopupChargeDeps {
   stripe: Stripe;
   tenantRepo: ITenantCustomerRepository;
-  creditLedger: ICreditLedger;
+  creditLedger: ILedger;
   eventLogRepo: IAutoTopupEventLogRepository;
 }
 
@@ -136,14 +136,11 @@ export async function chargeAutoTopup(
   // 5. Credit the ledger (idempotent via referenceId = PI ID)
   try {
     if (!(await deps.creditLedger.hasReferenceId(paymentIntent.id))) {
-      await deps.creditLedger.credit(
-        tenantId,
-        amount,
-        "purchase",
-        `Auto-topup (${source})`,
-        paymentIntent.id,
-        "stripe",
-      );
+      await deps.creditLedger.credit(tenantId, amount, "purchase", {
+        description: `Auto-topup (${source})`,
+        referenceId: paymentIntent.id,
+        fundingSource: "stripe",
+      });
     }
   } catch (err) {
     const message = `Stripe charge ${paymentIntent.id} succeeded but credit grant failed: ${err instanceof Error ? err.message : String(err)}`;

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

@@ -1,5 +1,5 @@
 import type { PGlite } from "@electric-sql/pglite";
-import { Credit, CreditLedger, DrizzleAutoTopupSettingsRepository } from "@wopr-network/platform-core/credits";
+import { Credit, DrizzleAutoTopupSettingsRepository, 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";
@@ -8,7 +8,7 @@ import { maybeTriggerUsageTopup, type UsageTopupDeps } from "./auto-topup-usage.
 describe("maybeTriggerUsageTopup", () => {
   let pool: PGlite;
   let db: DrizzleDb;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
   let settingsRepo: DrizzleAutoTopupSettingsRepository;
 
   beforeAll(async () => {
@@ -21,7 +21,9 @@ describe("maybeTriggerUsageTopup", () => {
 
   beforeEach(async () => {
     await truncateAllTables(pool);
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
+
+    await ledger.seedSystemAccounts();
     settingsRepo = new DrizzleAutoTopupSettingsRepository(db);
   });
 
@@ -35,7 +37,11 @@ describe("maybeTriggerUsageTopup", () => {
 
   it("does nothing when usage_enabled is false", async () => {
     await settingsRepo.upsert("t1", { usageEnabled: false });
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn();
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 
@@ -49,7 +55,11 @@ describe("maybeTriggerUsageTopup", () => {
       usageThreshold: Credit.fromCents(100),
       usageTopup: Credit.fromCents(500),
     });
-    await ledger.credit("t1", Credit.fromCents(200), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(200), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn();
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 
@@ -63,7 +73,11 @@ describe("maybeTriggerUsageTopup", () => {
       usageThreshold: Credit.fromCents(100),
       usageTopup: Credit.fromCents(500),
     });
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn().mockResolvedValue({ success: true, paymentReference: "pi_123" });
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 
@@ -74,7 +88,11 @@ describe("maybeTriggerUsageTopup", () => {
   it("skips when charge is already in-flight", async () => {
     await settingsRepo.upsert("t1", { usageEnabled: true, usageThreshold: Credit.fromCents(100) });
     await settingsRepo.setUsageChargeInFlight("t1", true);
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn();
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 
@@ -89,7 +107,11 @@ describe("maybeTriggerUsageTopup", () => {
       usageThreshold: Credit.fromCents(500),
       usageTopup: Credit.fromCents(2000),
     });
-    await ledger.credit("t1", Credit.fromCents(100), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(100), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
 
     const mockCharge = vi.fn().mockResolvedValue({ success: true, paymentReference: "pi_race" });
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
@@ -113,7 +135,11 @@ describe("maybeTriggerUsageTopup", () => {
       usageThreshold: Credit.fromCents(100),
       usageTopup: Credit.fromCents(500),
     });
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn().mockResolvedValue({ success: true, paymentReference: "pi_123" });
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 
@@ -135,7 +161,11 @@ describe("maybeTriggerUsageTopup", () => {
       usageThreshold: Credit.fromCents(100),
       usageTopup: Credit.fromCents(500),
     });
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi
       .fn()
       .mockRejectedValueOnce(new Error("Stripe network error"))
@@ -162,7 +192,11 @@ describe("maybeTriggerUsageTopup", () => {
     });
     await settingsRepo.incrementUsageFailures("t1");
     await settingsRepo.incrementUsageFailures("t1");
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn().mockResolvedValue({ success: true });
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 
@@ -176,7 +210,11 @@ describe("maybeTriggerUsageTopup", () => {
       usageThreshold: Credit.fromCents(100),
       usageTopup: Credit.fromCents(500),
     });
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn().mockResolvedValue({ success: false, error: "declined" });
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 
@@ -208,7 +246,11 @@ describe("maybeTriggerUsageTopup", () => {
     });
     await settingsRepo.incrementUsageFailures("t1");
     await settingsRepo.incrementUsageFailures("t1");
-    await ledger.credit("t1", Credit.fromCents(50), "purchase", "buy", "ref-1", "stripe");
+    await ledger.credit("t1", Credit.fromCents(50), "purchase", {
+      description: "buy",
+      referenceId: "ref-1",
+      fundingSource: "stripe",
+    });
     const mockCharge = vi.fn().mockResolvedValue({ success: false, error: "declined" });
     const deps: UsageTopupDeps = { settingsRepo, creditLedger: ledger, chargeAutoTopup: mockCharge };
 

package/src/monetization/credits/auto-topup-usage.ts

@@ -1,11 +1,11 @@
-import type { Credit, IAutoTopupSettingsRepository, ICreditLedger } from "@wopr-network/platform-core/credits";
+import type { Credit, IAutoTopupSettingsRepository, ILedger } from "@wopr-network/platform-core/credits";
 import { logger } from "../../config/logger.js";
 import type { AutoTopupChargeResult } from "./auto-topup-charge.js";
 import { MAX_CONSECUTIVE_FAILURES } from "./auto-topup-charge.js";
 
 export interface UsageTopupDeps {
   settingsRepo: IAutoTopupSettingsRepository;
-  creditLedger: ICreditLedger;
+  creditLedger: ILedger;
   /** Injected charge function (allows mocking in tests). */
   chargeAutoTopup: (tenantId: string, amount: Credit, source: string) => Promise<AutoTopupChargeResult>;
   /** Optional tenant status check. If provided and returns non-null, skip the charge. */

package/src/monetization/credits/bot-billing.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 { sql } from "drizzle-orm";
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import type { DrizzleDb } from "../../db/index.js";
@@ -57,7 +57,7 @@ describe("BotBilling", () => {
   let pool: PGlite;
   let db: DrizzleDb;
   let billing: BotBilling;
-  let ledger: CreditLedger;
+  let ledger: DrizzleLedger;
 
   beforeAll(async () => {
     ({ db, pool } = await createTestDb());
@@ -70,7 +70,9 @@ describe("BotBilling", () => {
   beforeEach(async () => {
     await truncateAllTables(pool);
     billing = new BotBilling(new DrizzleBotInstanceRepository(db));
-    ledger = new CreditLedger(db);
+    ledger = new DrizzleLedger(db);
+
+    await ledger.seedSystemAccounts();
   });
 
   describe("registerBot", () => {
@@ -211,7 +213,11 @@ describe("BotBilling", () => {
       await billing.suspendBot("bot-1");
       await billing.suspendBot("bot-2");
 
-      await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", "test credit", "ref-1", "stripe");
+      await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", {
+        description: "test credit",
+        referenceId: "ref-1",
+        fundingSource: "stripe",
+      });
       const reactivated = await billing.checkReactivation("tenant-1", ledger);
 
       expect(reactivated.sort()).toEqual(["bot-1", "bot-2"]);
@@ -231,14 +237,22 @@ describe("BotBilling", () => {
       await billing.registerBot("bot-1", "tenant-1", "bot-a");
       await billing.destroyBot("bot-1");
 
-      await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", "test credit", "ref-1", "stripe");
+      await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", {
+        description: "test credit",
+        referenceId: "ref-1",
+        fundingSource: "stripe",
+      });
       const reactivated = await billing.checkReactivation("tenant-1", ledger);
 
       expect(reactivated).toEqual([]);
     });
 
     it("returns empty array for tenant with no bots", async () => {
-      await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", "test credit", "ref-1", "stripe");
+      await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", {
+        description: "test credit",
+        referenceId: "ref-1",
+        fundingSource: "stripe",
+      });
       const reactivated = await billing.checkReactivation("tenant-1", ledger);
       expect(reactivated).toEqual([]);
     });

package/src/monetization/credits/bot-billing.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 { logger } from "../../config/logger.js";
 import type { IBotInstanceRepository } from "../../fleet/bot-instance-repository.js";
@@ -16,7 +16,7 @@ export interface IBotBilling {
   suspendBot(botId: string): Promise<void>;
   suspendAllForTenant(tenantId: string): Promise<string[]>;
   reactivateBot(botId: string): Promise<void>;
-  checkReactivation(tenantId: string, ledger: ICreditLedger): Promise<string[]>;
+  checkReactivation(tenantId: string, ledger: ILedger): Promise<string[]>;
   destroyBot(botId: string): Promise<void>;
   destroyExpiredBots(): Promise<string[]>;
   getBotBilling(botId: string): Promise<unknown>;
@@ -98,7 +98,7 @@ export class DrizzleBotBilling implements IBotBilling {
    *
    * @returns IDs of reactivated bots.
    */
-  async checkReactivation(tenantId: string, ledger: ICreditLedger): Promise<string[]> {
+  async checkReactivation(tenantId: string, ledger: ILedger): Promise<string[]> {
     const balance = await ledger.balance(tenantId);
     if (balance.isNegative() || balance.isZero()) return [];
 

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);