@dvmkit/sdk 0.0.0 → 0.1.0-rc.2

package/dist/payout-reporter-4TNWRS5F.js

@@ -0,0 +1,753 @@
+import {
+  withSdkInitLock
+} from "./chunk-S3XAHZQY.js";
+
+// src/sdk/server/payout-reporter.ts
+import { createHash, randomUUID } from "crypto";
+var MemoryX402BatchStore = class {
+  batches = /* @__PURE__ */ new Map();
+  get(scope) {
+    return Promise.resolve(this.batches.get(scope));
+  }
+  put(batch) {
+    this.batches.set(batch.scope, { ...batch });
+    return Promise.resolve();
+  }
+  delete(scope) {
+    this.batches.delete(scope);
+    return Promise.resolve();
+  }
+  async settle(scope, batchId, enqueue) {
+    const open = this.batches.get(scope);
+    if (open?.batchId !== batchId) return false;
+    this.batches.delete(scope);
+    try {
+      await enqueue();
+    } catch (err) {
+      this.batches.set(scope, open);
+      throw err;
+    }
+    return true;
+  }
+};
+var PostgresX402BatchStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /** Create the table (idempotent), under the SDK init lock like every other boot DDL. */
+  async init() {
+    await withSdkInitLock(this.db, async () => {
+      await this.db.query(`
+        CREATE TABLE IF NOT EXISTS payout_x402_batches (
+          scope           TEXT PRIMARY KEY,
+          batch_id        TEXT NOT NULL,
+          claimed_native  NUMERIC(78, 0) NOT NULL DEFAULT 0,
+          voucher_count   INTEGER NOT NULL DEFAULT 0,
+          claims          INTEGER NOT NULL DEFAULT 0,
+          opened_at       BIGINT NOT NULL,
+          attempts        INTEGER NOT NULL DEFAULT 0,
+          first_failed_at BIGINT,
+          last_error      TEXT,
+          next_retry_at   BIGINT,
+          updated_at      BIGINT NOT NULL
+        )
+      `);
+    });
+  }
+  async get(scope) {
+    const { rows } = await this.db.query("SELECT * FROM payout_x402_batches WHERE scope = $1", [scope]);
+    const row = rows.at(0);
+    if (!row) return void 0;
+    return {
+      scope: row.scope,
+      batchId: row.batch_id,
+      claimedNative: BigInt(row.claimed_native),
+      voucherCount: row.voucher_count,
+      claims: row.claims,
+      openedAt: Number(row.opened_at),
+      attempts: row.attempts,
+      firstFailedAt: row.first_failed_at === null ? null : Number(row.first_failed_at),
+      lastError: row.last_error,
+      nextRetryAt: row.next_retry_at === null ? null : Number(row.next_retry_at)
+    };
+  }
+  async put(batch) {
+    await this.db.query(
+      `INSERT INTO payout_x402_batches (
+         scope, batch_id, claimed_native, voucher_count, claims, opened_at,
+         attempts, first_failed_at, last_error, next_retry_at, updated_at
+       ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT (scope) DO UPDATE SET
+         batch_id = EXCLUDED.batch_id,
+         claimed_native = EXCLUDED.claimed_native,
+         voucher_count = EXCLUDED.voucher_count,
+         claims = EXCLUDED.claims,
+         opened_at = EXCLUDED.opened_at,
+         attempts = EXCLUDED.attempts,
+         first_failed_at = EXCLUDED.first_failed_at,
+         last_error = EXCLUDED.last_error,
+         next_retry_at = EXCLUDED.next_retry_at,
+         updated_at = EXCLUDED.updated_at`,
+      [
+        batch.scope,
+        batch.batchId,
+        batch.claimedNative.toString(),
+        batch.voucherCount,
+        batch.claims,
+        batch.openedAt,
+        batch.attempts,
+        batch.firstFailedAt,
+        batch.lastError,
+        batch.nextRetryAt,
+        Date.now()
+      ]
+    );
+  }
+  async delete(scope) {
+    await this.db.query("DELETE FROM payout_x402_batches WHERE scope = $1", [scope]);
+  }
+  async settle(scope, batchId, enqueue) {
+    const client = await this.db.connect();
+    try {
+      await client.query("BEGIN");
+      const { rowCount } = await client.query(
+        "DELETE FROM payout_x402_batches WHERE scope = $1 AND batch_id = $2",
+        [scope, batchId]
+      );
+      if (!rowCount) {
+        await client.query("ROLLBACK");
+        return false;
+      }
+      await enqueue(client);
+      await client.query("COMMIT");
+      return true;
+    } catch (err) {
+      await client.query("ROLLBACK").catch(() => void 0);
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+};
+var PAYOUT_SNAPSHOT_INTERVAL_MS = 5 * 6e4;
+var PayoutReporter = class {
+  dvmId;
+  transport;
+  db;
+  cashu;
+  batches;
+  ownsBatchStore;
+  intervalMs;
+  now;
+  x402;
+  tempo;
+  timer = null;
+  warmup = null;
+  constructor(opts) {
+    this.dvmId = opts.dvmId;
+    this.transport = opts.transport;
+    this.db = opts.db;
+    this.cashu = opts.cashu ?? false;
+    this.ownsBatchStore = !opts.batchStore;
+    this.batches = opts.batchStore ?? (opts.db ? new PostgresX402BatchStore(opts.db) : new MemoryX402BatchStore());
+    this.intervalMs = opts.snapshotIntervalMs ?? PAYOUT_SNAPSHOT_INTERVAL_MS;
+    this.now = opts.now ?? Date.now;
+  }
+  /** Boot DDL for the durable batch store, when this reporter owns one. */
+  async init() {
+    if (this.ownsBatchStore && this.batches instanceof PostgresX402BatchStore) {
+      await this.batches.init();
+    }
+  }
+  /**
+   * Start the snapshot loop. Unref'd, so it never keeps a scale-to-zero
+   * machine awake; a first snapshot runs shortly after boot so a fresh process
+   * reports without waiting a whole interval.
+   */
+  start() {
+    if (this.timer) return;
+    this.warmup = setTimeout(() => {
+      void this.snapshot();
+    }, WARMUP_MS);
+    this.warmup.unref();
+    this.timer = setInterval(() => {
+      void this.snapshot();
+    }, this.intervalMs);
+    this.timer.unref();
+  }
+  stop() {
+    if (this.warmup) clearTimeout(this.warmup);
+    this.warmup = null;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+  enqueuePayout(payload, tx) {
+    return this.transport.enqueuePayout(payload, tx);
+  }
+  reportPayout(payload) {
+    return this.transport.reportPayout(payload);
+  }
+  reportPayoutPending(payload) {
+    return this.transport.reportPayoutPending(payload);
+  }
+  /** Deliver what is queued now; a transport without the seam waits for its retry loop. */
+  async flush() {
+    try {
+      await this.transport.drainPending?.();
+    } catch (err) {
+      warn("payout_flush_failed", { error: message(err) });
+    }
+  }
+  // ── cashu ─────────────────────────────────────────────────────────────
+  /** The hook `mark-melted` runs inside its transaction: the mark and its payout commit together. */
+  meltHook() {
+    return {
+      enqueue: (event, tx) => this.cashuMelted(event, tx),
+      committed: () => {
+        void this.flush();
+        void this.snapshotCashu();
+      }
+    };
+  }
+  /**
+   * A melt completed: the accumulator rows are SPENT at the mint and the
+   * Lightning payment reached the builder's destination. One payout per mint
+   * in the call — a `mark-melted` normally names one, since a melt quote
+   * belongs to one mint. The amount is the face value melted; the mint's fee
+   * and the Lightning amount received are builder-machine facts this DVM does
+   * not see.
+   *
+   * Queued through `tx` when the caller is inside the transaction that marks
+   * the rows, and a failure is thrown rather than swallowed so that mark rolls
+   * back with it — see {@link TransactionalPayoutHook}. Without `tx` the rows
+   * are queued on their own and delivered at once.
+   */
+  async cashuMelted(event, tx) {
+    const byMint = /* @__PURE__ */ new Map();
+    for (const row of event.rows) {
+      const group = byMint.get(row.mintUrl) ?? { sats: 0, proofs: 0 };
+      group.sats += row.proofAmount;
+      group.proofs += 1;
+      byMint.set(row.mintUrl, group);
+    }
+    const preimageHash = createHash("sha256").update(event.paymentPreimage).digest("hex");
+    const landedAt = this.now();
+    const mints = [...byMint.entries()];
+    for (const [index, [mint, group]] of mints.entries()) {
+      if (group.sats <= 0) continue;
+      await this.enqueuePayout(
+        {
+          dvmId: this.dvmId,
+          payoutId: mints.length === 1 ? `cashu:melt:${event.meltQuoteId}` : `cashu:melt:${event.meltQuoteId}:${index}`,
+          rail: "cashu",
+          kind: "melt",
+          nativeAmount: group.sats,
+          nativeAsset: "sats",
+          recipient: null,
+          refs: {
+            mint,
+            meltQuoteId: event.meltQuoteId,
+            preimageHash,
+            proofCount: group.proofs
+          },
+          landedAt
+        },
+        tx
+      );
+    }
+    if (!tx) {
+      void this.flush();
+      void this.snapshotCashu();
+    }
+  }
+  // ── tempo ─────────────────────────────────────────────────────────────
+  /** The host attaches the session store and ledger readers once they exist. */
+  attachTempo(reader) {
+    this.tempo = reader;
+  }
+  /**
+   * A Tempo channel settled or closed on chain. `delta` is what this
+   * transaction newly paid the recipient; a transaction that paid nothing new
+   * (a close of a fully settled channel) is no payout.
+   */
+  async tempoSettled(event) {
+    try {
+      if (event.delta <= 0n) return;
+      await this.reportPayout({
+        dvmId: this.dvmId,
+        payoutId: `tempo:${event.txHash}`,
+        rail: "tempo",
+        kind: event.trigger === "close" ? "close" : "settle",
+        nativeAmount: Number(event.delta),
+        nativeAsset: "usdc",
+        recipient: this.tempo?.recipient ?? null,
+        refs: {
+          channelId: event.channelId,
+          txHash: event.txHash,
+          trigger: event.trigger,
+          ...this.tempo?.network ? { network: this.tempo.network } : {}
+        },
+        landedAt: this.now()
+      });
+    } catch (err) {
+      warn("payout_report_failed", { rail: "tempo", kind: event.trigger, error: message(err) });
+    }
+    void this.snapshotTempo();
+  }
+  /** The hook `reconcile-tempo-drain` runs inside its transaction: the booking and its payout commit together. */
+  tempoRepairHook() {
+    return {
+      enqueue: (event, tx) => this.tempoCloseReconciled(event, tx),
+      committed: () => {
+        void this.flush();
+        void this.snapshotTempo();
+      }
+    };
+  }
+  /**
+   * The operator repaired a wedged cooperative close (internal-review). The close's
+   * payee side landed on chain when the close did; if the live hook reported
+   * it, this upgrades that row to `repair`, otherwise it is the row. The
+   * figure is the receipt's payee total for the channel.
+   *
+   * Queued through `tx` when the caller is inside the transaction that books
+   * the drain, and thrown rather than swallowed so that booking rolls back
+   * with it — see {@link TransactionalPayoutHook}.
+   */
+  async tempoCloseReconciled(event, tx) {
+    const settled = BigInt(event.settledToPayee);
+    if (settled <= 0n) return;
+    await this.enqueuePayout(
+      {
+        dvmId: this.dvmId,
+        payoutId: `tempo:${event.txHash}`,
+        rail: "tempo",
+        kind: "close",
+        nativeAmount: Number(settled),
+        nativeAsset: "usdc",
+        recipient: this.tempo?.recipient ?? null,
+        refs: {
+          channelId: event.channelId,
+          txHash: event.txHash,
+          trigger: "close",
+          ...this.tempo?.network ? { network: this.tempo.network } : {}
+        },
+        landedAt: this.now(),
+        repaired: true,
+        repairKind: "tempo_close_reconciled"
+      },
+      tx
+    );
+    if (!tx) {
+      void this.flush();
+      void this.snapshotTempo();
+    }
+  }
+  // ── x402 ──────────────────────────────────────────────────────────────
+  /** The observer the batch-settlement server attaches to and routes its manager through. */
+  x402Observer() {
+    return {
+      attach: (ctx) => {
+        this.x402 = ctx;
+      },
+      trackManager: (manager) => this.trackX402Manager(manager),
+      recordSettle: async (transaction) => {
+        const ctx = this.x402;
+        if (ctx) await this.recordX402Settle(ctx, transaction);
+        void this.snapshotX402();
+      },
+      recordSettleFailure: async (error) => {
+        const ctx = this.x402;
+        if (ctx) await this.recordX402SettleFailure(ctx, error);
+        void this.snapshotX402();
+      }
+    };
+  }
+  /**
+   * Wrap the upstream channel manager so every claim grows the open batch and
+   * every settle closes it. The claim delta is read off storage rather than
+   * off upstream's result, which carries only a voucher count; under the
+   * fleet lock the before/after read is consistent. A channel the claim
+   * removed on its way through — a refund's claim-then-delete (internal-review) —
+   * moved whatever it still owed before it went, and that value reaches
+   * `pay_to` in this batch too, so it counts at its pre-claim figure.
+   */
+  trackX402Manager(manager) {
+    const claim = async (...args) => {
+      const ctx = this.x402;
+      const before = ctx ? await claimedByChannel(ctx.storage) : /* @__PURE__ */ new Map();
+      const results = await manager.claim(...args);
+      if (ctx && results.length > 0) {
+        const after = await claimedByChannel(ctx.storage);
+        let delta = 0n;
+        for (const [channelId, now] of after) {
+          const prior = before.get(channelId)?.claimed ?? 0n;
+          if (now.claimed > prior) delta += now.claimed - prior;
+        }
+        for (const [channelId, prior] of before) {
+          if (!after.has(channelId) && prior.charged > prior.claimed) {
+            delta += prior.charged - prior.claimed;
+          }
+        }
+        await this.recordX402Claim(ctx, {
+          delta,
+          vouchers: results.reduce((sum, r) => sum + r.vouchers, 0)
+        });
+        void this.snapshotX402();
+      }
+      return results;
+    };
+    const settle = async () => {
+      const ctx = this.x402;
+      try {
+        const result = await manager.settle();
+        if (ctx) await this.recordX402Settle(ctx, result.transaction);
+        void this.snapshotX402();
+        return result;
+      } catch (err) {
+        if (ctx) await this.recordX402SettleFailure(ctx, err);
+        void this.snapshotX402();
+        throw err;
+      }
+    };
+    return new Proxy(manager, {
+      get(target, prop, receiver) {
+        if (prop === "claim") return claim;
+        if (prop === "settle") return settle;
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+  }
+  async recordX402Claim(ctx, claim) {
+    try {
+      const now = this.now();
+      const open = await this.batches.get(ctx.scope) ?? {
+        scope: ctx.scope,
+        batchId: randomUUID(),
+        claimedNative: 0n,
+        voucherCount: 0,
+        claims: 0,
+        openedAt: now,
+        attempts: 0,
+        firstFailedAt: null,
+        lastError: null,
+        nextRetryAt: null
+      };
+      open.claimedNative += claim.delta;
+      open.voucherCount += claim.vouchers;
+      open.claims += 1;
+      await this.batches.put(open);
+    } catch (err) {
+      warn("payout_batch_track_failed", { scope: ctx.scope, error: message(err) });
+    }
+  }
+  async recordX402Settle(ctx, transaction) {
+    try {
+      const open = await this.batches.get(ctx.scope);
+      if (!open) {
+        warn("payout_batch_untracked", { scope: ctx.scope, transaction });
+        return;
+      }
+      if (open.claimedNative <= 0n) {
+        await this.batches.delete(ctx.scope);
+        warn("payout_batch_empty", { scope: ctx.scope, transaction, batchId: open.batchId });
+        return;
+      }
+      const payload = {
+        dvmId: this.dvmId,
+        payoutId: `x402:batch:${open.batchId}`,
+        rail: "x402",
+        kind: "batch",
+        nativeAmount: Number(open.claimedNative),
+        nativeAsset: "usdc",
+        recipient: ctx.payTo,
+        refs: {
+          batchId: open.batchId,
+          txHash: transaction,
+          voucherCount: open.voucherCount,
+          claims: open.claims,
+          network: ctx.network
+        },
+        landedAt: this.now()
+      };
+      const closed = await this.batches.settle(
+        ctx.scope,
+        open.batchId,
+        (tx) => this.enqueuePayout(payload, tx)
+      );
+      if (!closed) {
+        warn("payout_batch_raced", { scope: ctx.scope, transaction, batchId: open.batchId });
+        return;
+      }
+    } catch (err) {
+      warn("payout_report_failed", { rail: "x402", kind: "batch", error: message(err) });
+      return;
+    }
+    void this.flush();
+  }
+  async recordX402SettleFailure(ctx, err) {
+    try {
+      const open = await this.batches.get(ctx.scope);
+      if (!open) return;
+      const now = this.now();
+      open.attempts += 1;
+      open.firstFailedAt ??= now;
+      open.lastError = settleErrorReason(err);
+      open.nextRetryAt = now + ctx.settleIntervalMs;
+      await this.batches.put(open);
+    } catch (trackErr) {
+      warn("payout_batch_track_failed", { scope: ctx.scope, error: message(trackErr) });
+    }
+  }
+  // ── snapshots ─────────────────────────────────────────────────────────
+  /** Every rail this reporter can read, each on its own failure boundary. */
+  async snapshot() {
+    await this.snapshotCashu();
+    await this.snapshotX402();
+    await this.snapshotTempo();
+  }
+  /**
+   * Cashu: every unmelted proof in the accumulator, per mint. Rows whose
+   * builder-side melt failed are still in the pool (they are still at the
+   * mint) and listed as wedged until `restart-failed` clears them.
+   */
+  async snapshotCashu() {
+    if (!this.db || !this.cashu) return;
+    try {
+      const { rows } = await this.db.query(
+        `SELECT mint_url, melt_status, SUM(proof_amount)::text AS sats,
+                COUNT(*)::int AS proofs, MIN(received_at)::text AS since
+           FROM wallet_accumulator
+          WHERE dvm_id = $1 AND melted_at IS NULL
+          GROUP BY mint_url, melt_status`,
+        [this.dvmId]
+      );
+      const byMint = /* @__PURE__ */ new Map();
+      const wedged = [];
+      let poolNative = 0;
+      for (const row of rows) {
+        const sats = Number(row.sats);
+        poolNative += sats;
+        const pool = byMint.get(row.mint_url) ?? { native: 0, proofs: 0 };
+        pool.native += sats;
+        pool.proofs += row.proofs;
+        byMint.set(row.mint_url, pool);
+        if (row.melt_status === "failed") {
+          wedged.push({
+            id: `cashu:melt-failed:${row.mint_url}`,
+            kind: "melt",
+            since: Number(row.since),
+            attempts: null,
+            nextRetry: null,
+            lastError: "melt_failed",
+            native: sats
+          });
+        }
+      }
+      await this.reportPayoutPending({
+        dvmId: this.dvmId,
+        rail: "cashu",
+        poolNative,
+        nativeAsset: "sats",
+        items: byMint.size,
+        pools: [...byMint.entries()].map(([mint, pool]) => ({
+          id: mint,
+          native: pool.native,
+          label: `${pool.proofs} proofs`
+        })),
+        wedged,
+        snapshotAt: this.now()
+      });
+    } catch (err) {
+      warn("payout_pending_snapshot_failed", { rail: "cashu", error: message(err) });
+    }
+  }
+  /**
+   * x402: the open batch (claimed, not yet transferred) plus every channel's
+   * unclaimed voucher value; wedged when the settle keeps failing, and the
+   * refund settlements stuck between chain and ledger beside it.
+   */
+  async snapshotX402() {
+    const ctx = this.x402;
+    if (!ctx) return;
+    try {
+      const pools = [];
+      const wedged = [];
+      const open = await this.batches.get(ctx.scope);
+      if (open && open.claimedNative > 0n) {
+        pools.push({
+          id: open.batchId,
+          native: Number(open.claimedNative),
+          label: "claimed, awaiting settle"
+        });
+        if (open.attempts > 0) {
+          wedged.push({
+            id: open.batchId,
+            kind: "settle",
+            since: open.firstFailedAt ?? open.openedAt,
+            attempts: open.attempts,
+            nextRetry: open.nextRetryAt,
+            lastError: open.lastError,
+            native: Number(open.claimedNative)
+          });
+        }
+      }
+      const unclaimed = [];
+      for (const channel of await ctx.storage.list()) {
+        const owed = BigInt(channel.chargedCumulativeAmount) - BigInt(channel.totalClaimed);
+        if (owed > 0n) {
+          unclaimed.push({
+            id: channel.channelId,
+            native: Number(owed),
+            label: "unclaimed vouchers"
+          });
+        }
+      }
+      pools.push(...capPools(unclaimed, MAX_POOLS - pools.length));
+      if (ctx.listWedgedRefunds) {
+        for (const refund of await ctx.listWedgedRefunds()) {
+          wedged.push({
+            id: refund.settlementId,
+            kind: "refund",
+            since: refund.createdAt,
+            attempts: null,
+            nextRetry: null,
+            lastError: null,
+            ...refund.native !== void 0 ? { native: refund.native } : {}
+          });
+        }
+      }
+      await this.reportPayoutPending({
+        dvmId: this.dvmId,
+        rail: "x402",
+        poolNative: pools.reduce((sum, pool) => sum + pool.native, 0),
+        nativeAsset: "usdc",
+        items: pools.length,
+        pools,
+        wedged,
+        snapshotAt: this.now()
+      });
+    } catch (err) {
+      warn("payout_pending_snapshot_failed", { rail: "x402", error: message(err) });
+    }
+  }
+  /**
+   * Tempo: each active channel's spent-but-unsettled balance — earned, not
+   * yet paid to the recipient — and the cooperative closes wedged between
+   * chain and ledger (internal-review), aged past the same floor the repair queue
+   * uses so an in-flight close is not reported as stuck.
+   */
+  async snapshotTempo() {
+    const reader = this.tempo;
+    if (!reader?.listActive) return;
+    try {
+      const pools = [];
+      let cursor;
+      for (let page = 0; page < MAX_TEMPO_PAGES; page++) {
+        const rows = await reader.listActive(100, cursor);
+        for (const row of rows) {
+          const state = row.state;
+          if (state.finalized === true) continue;
+          const spent = asBigInt(state.spent);
+          const settled = asBigInt(state.settledOnChain);
+          if (spent === void 0 || settled === void 0 || spent <= settled) continue;
+          pools.push({
+            id: typeof state.channelId === "string" ? state.channelId : row.key,
+            native: Number(spent - settled),
+            label: "earned, awaiting settlement"
+          });
+        }
+        if (rows.length < 100) break;
+        const last = rows[rows.length - 1];
+        cursor = { updatedAt: last.updatedAt, key: last.key };
+      }
+      const wedged = [];
+      if (reader.listChannelDrains) {
+        const drains = await reader.listChannelDrains({
+          limit: 50,
+          createdBeforeMs: this.now() - WEDGE_MIN_AGE_MS,
+          rail: "tempo"
+        });
+        for (const drain of drains) {
+          wedged.push({
+            id: `${drain.creditId}:${drain.drainId}`,
+            kind: "close",
+            since: drain.createdAt,
+            attempts: null,
+            nextRetry: null,
+            lastError: null,
+            ...drain.drainedNative !== null ? { native: drain.drainedNative } : {}
+          });
+        }
+      }
+      const capped = capPools(pools);
+      await this.reportPayoutPending({
+        dvmId: this.dvmId,
+        rail: "tempo",
+        poolNative: capped.reduce((sum, pool) => sum + pool.native, 0),
+        nativeAsset: "usdc",
+        items: capped.length,
+        pools: capped,
+        wedged,
+        snapshotAt: this.now()
+      });
+    } catch (err) {
+      warn("payout_pending_snapshot_failed", { rail: "tempo", error: message(err) });
+    }
+  }
+};
+var WARMUP_MS = 5e3;
+var WEDGE_MIN_AGE_MS = 5 * 6e4;
+var MAX_POOLS = 50;
+var MAX_TEMPO_PAGES = 20;
+async function claimedByChannel(storage) {
+  const view = /* @__PURE__ */ new Map();
+  for (const channel of await storage.list()) {
+    view.set(channel.channelId.toLowerCase(), {
+      claimed: BigInt(channel.totalClaimed),
+      charged: BigInt(channel.chargedCumulativeAmount)
+    });
+  }
+  return view;
+}
+function capPools(pools, limit = MAX_POOLS) {
+  const keep = Math.max(1, limit);
+  if (pools.length <= keep) return pools;
+  const sorted = [...pools].sort((a, b) => b.native - a.native);
+  const head = sorted.slice(0, keep - 1);
+  const tail = sorted.slice(keep - 1);
+  head.push({
+    id: "other",
+    native: tail.reduce((sum, pool) => sum + pool.native, 0),
+    label: `${tail.length} more`
+  });
+  return head;
+}
+function asBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+  if (typeof value === "string" && /^\d+$/.test(value)) return BigInt(value);
+  return void 0;
+}
+function settleErrorReason(err) {
+  if (err && typeof err === "object" && typeof err.errorReason === "string") {
+    return err.errorReason;
+  }
+  const name = err instanceof Error ? err.name : "Error";
+  const text = message(err).replace(/https?:\/\/\S+/g, "<url>").slice(0, 160);
+  return text ? `${name}: ${text}` : name;
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function warn(level, fields) {
+  console.warn(JSON.stringify({ level, ...fields }));
+}
+export {
+  MemoryX402BatchStore,
+  PAYOUT_SNAPSHOT_INTERVAL_MS,
+  PayoutReporter,
+  PostgresX402BatchStore
+};