@dvmkit/sdk 0.0.0 → 0.1.0-rc.1

package/dist/chunk-NTK5DJ6R.js

@@ -0,0 +1,1256 @@
+import {
+  CreditLedgerError,
+  DRAIN_DELIVERY_RESERVE_SATS,
+  X402_SPEND_BLOCKING_SETTLEMENT_STATUSES,
+  X402_WEDGED_SETTLEMENT_STATUSES,
+  allocateDrawValue,
+  assertFundingBasis,
+  clipEarmark,
+  depleteLots,
+  fifoOrder,
+  growthRailValue,
+  inKindDrawMsats,
+  isInKindDepletion,
+  isNonChannelBitcoinRail,
+  lotOwedSats,
+  netOwedSats,
+  x402SettlementPending
+} from "./chunk-RPXHKMYE.js";
+
+// src/sdk/server/memory-credit-ledger.ts
+import { randomUUID } from "crypto";
+var MemoryCreditLedger = class {
+  /**
+   * Per-process and lost on restart, so a DVM backed by this ledger never
+   * advertises the funding menu outside devMode (internal-review) — funding on one
+   * machine and drawing on another would `credit_not_found`.
+   */
+  durable = false;
+  credits = /* @__PURE__ */ new Map();
+  fundings = /* @__PURE__ */ new Map();
+  invoices = /* @__PURE__ */ new Map();
+  tempoLosses = /* @__PURE__ */ new Map();
+  x402Losses = /* @__PURE__ */ new Map();
+  x402Settlements;
+  /** See {@link CreditLedger.useX402SettlementGate} — same contract (internal-review). */
+  useX402SettlementGate(gate) {
+    this.x402Settlements = gate;
+  }
+  async fund(args) {
+    const basis = args.basis;
+    const wedged = await this.blockingX402Refund(
+      basis?.x402Channel?.channelId,
+      X402_SPEND_BLOCKING_SETTLEMENT_STATUSES
+    );
+    if (wedged) throw x402SettlementPending(args.creditId ?? randomUUID(), wedged);
+    return run(() => this.fundSync(args));
+  }
+  async draw(args) {
+    const blocking = await this.blockingRefundForCredit(
+      args.creditId,
+      X402_SPEND_BLOCKING_SETTLEMENT_STATUSES
+    );
+    return run(() => this.drawSync(args, blocking));
+  }
+  /** See {@link CreditLedger.blockingX402Refund} — same contract (internal-review). */
+  async blockingX402Refund(channelId, statuses) {
+    if (!channelId || !this.x402Settlements) return void 0;
+    return this.x402Settlements.pendingRefundSettlement(channelId, statuses);
+  }
+  /** The unresolved x402 refund that must stop an effect on `creditId` (internal-review). */
+  blockingRefundForCredit(creditId, statuses) {
+    return this.blockingX402Refund(this.credits.get(creditId)?.x402ChannelId, statuses);
+  }
+  growDraw(args) {
+    return run(() => this.growDrawSync(args));
+  }
+  settle(args) {
+    return run(() => {
+      const credit = this.requireCredit(args.creditId);
+      const draw = credit.draws.get(args.drawId);
+      const to = draw?.status === "settled" ? "settled" : credit.status === "unbacked" ? "released" : "settled";
+      return this.resolve({ ...args, to });
+    });
+  }
+  release(args) {
+    return run(() => this.resolve({ ...args, to: "released" }));
+  }
+  recordFunding(args) {
+    return run(() => {
+      assertAmount(args.amountMicro, { min: 1 });
+      const key = fundingKey(args.creditId, args.fundId);
+      if (this.fundings.has(key)) {
+        throw new CreditLedgerError(
+          "funding_replayed",
+          `funding ${args.fundId} on credit ${args.creditId} was already recorded`
+        );
+      }
+      const record = {
+        creditId: args.creditId,
+        fundId: args.fundId,
+        amountMicro: args.amountMicro,
+        rail: args.rail ?? null,
+        createdAt: args.nowMs ?? Date.now(),
+        callerPubkey: null,
+        balanceAfterMicro: null,
+        ledgerSeq: null,
+        receipt: null
+      };
+      this.fundings.set(key, record);
+      return record;
+    });
+  }
+  getFunding(args) {
+    return run(() => this.fundings.get(fundingKey(args.creditId, args.fundId)));
+  }
+  completeFunding(args) {
+    return run(() => {
+      const key = fundingKey(args.creditId, args.fundId);
+      const record = this.fundings.get(key);
+      if (!record) {
+        throw new CreditLedgerError(
+          "credit_not_found",
+          `funding ${args.fundId} on credit ${args.creditId} was not recorded`
+        );
+      }
+      record.callerPubkey ??= args.callerPubkey;
+      record.balanceAfterMicro ??= args.balanceAfterMicro;
+      record.ledgerSeq ??= args.ledgerSeq;
+      return record;
+    });
+  }
+  saveFundingReceipt(args) {
+    return run(() => {
+      const record = this.fundings.get(fundingKey(args.creditId, args.fundId));
+      if (!record) {
+        throw new CreditLedgerError(
+          "credit_not_found",
+          `funding ${args.fundId} on credit ${args.creditId} was not recorded`
+        );
+      }
+      record.receipt ??= args.receipt;
+      return record.receipt;
+    });
+  }
+  recordInvoice(args) {
+    return run(() => {
+      assertAmount(args.amountMicro, { min: 1 });
+      const key = fundingKey(args.creditId, args.fundId);
+      const existing = this.invoices.get(key);
+      if (existing) return existing;
+      for (const invoice of this.invoices.values()) {
+        if (invoice.paymentHash === args.paymentHash) {
+          throw new CreditLedgerError(
+            "invoice_conflict",
+            `payment hash ${args.paymentHash} is already bound to another funding`
+          );
+        }
+      }
+      const record = {
+        creditId: args.creditId,
+        fundId: args.fundId,
+        callerPubkey: args.callerPubkey,
+        currency: args.currency,
+        amountMicro: args.amountMicro,
+        amountMsats: args.amountMsats,
+        paymentHash: args.paymentHash,
+        bolt11: args.bolt11,
+        status: "pending",
+        blockedReason: null,
+        reconciledCreditId: null,
+        reconciledFundId: null,
+        resolvedAt: null,
+        writeOffNote: null,
+        expiresAt: args.expiresAt,
+        createdAt: args.nowMs ?? Date.now(),
+        settledAt: null
+      };
+      this.invoices.set(key, record);
+      return record;
+    });
+  }
+  getInvoice(args) {
+    return run(() => this.invoices.get(fundingKey(args.creditId, args.fundId)));
+  }
+  listPendingInvoices(args) {
+    return run(
+      () => [...this.invoices.values()].filter(
+        (invoice) => invoice.status === "pending" && invoice.callerPubkey === args.callerPubkey && (args.creditId === void 0 || invoice.creditId === args.creditId)
+      ).sort((a, b) => a.createdAt - b.createdAt || (a.fundId < b.fundId ? -1 : 1)).slice(0, args.limit)
+    );
+  }
+  settleInvoice(args) {
+    return run(() => {
+      assertFundingBasis(args.basis);
+      const key = fundingKey(args.creditId, args.fundId);
+      const invoice = this.invoices.get(key);
+      if (!invoice) {
+        throw new CreditLedgerError(
+          "invoice_not_found",
+          `no invoice for funding ${args.fundId} on credit ${args.creditId}`
+        );
+      }
+      const nowMs = args.nowMs ?? Date.now();
+      if (invoice.status === "settled") {
+        const existing = this.credits.get(args.creditId);
+        return {
+          invoice,
+          funding: this.fundings.get(key),
+          credit: existing ? this.snapshot(existing, nowMs) : void 0,
+          replayed: true
+        };
+      }
+      if (this.fundings.has(key)) {
+        throw new CreditLedgerError(
+          "funding_replayed",
+          `funding ${args.fundId} on credit ${args.creditId} was already recorded`
+        );
+      }
+      const funding = {
+        creditId: invoice.creditId,
+        fundId: invoice.fundId,
+        amountMicro: invoice.amountMicro,
+        rail: "lightning",
+        createdAt: nowMs,
+        callerPubkey: null,
+        balanceAfterMicro: null,
+        ledgerSeq: null,
+        receipt: null
+      };
+      this.fundings.set(key, funding);
+      const credit = this.fundSync({
+        creditId: invoice.creditId,
+        callerPubkey: invoice.callerPubkey,
+        currency: invoice.currency,
+        amountMicro: invoice.amountMicro,
+        expiryMs: args.expiryMs,
+        basis: args.basis,
+        nowMs
+      });
+      funding.callerPubkey = invoice.callerPubkey;
+      funding.balanceAfterMicro = credit.availableMicro;
+      funding.ledgerSeq = credit.lastLedgerSeq;
+      const settled = {
+        ...invoice,
+        status: "settled",
+        settledAt: args.settledAtMs ?? nowMs
+      };
+      this.invoices.set(key, settled);
+      return { invoice: settled, funding, credit, replayed: false };
+    });
+  }
+  markInvoiceExpired(args) {
+    return run(() => {
+      const key = fundingKey(args.creditId, args.fundId);
+      const invoice = this.invoices.get(key);
+      if (invoice?.status !== "pending") return invoice;
+      const expired = { ...invoice, status: "expired" };
+      this.invoices.set(key, expired);
+      return expired;
+    });
+  }
+  markInvoiceBlocked(args) {
+    return run(() => {
+      const key = fundingKey(args.creditId, args.fundId);
+      const invoice = this.invoices.get(key);
+      if (invoice?.status !== "pending") return invoice;
+      const blocked = {
+        ...invoice,
+        status: "blocked",
+        blockedReason: args.reason
+      };
+      this.invoices.set(key, blocked);
+      return blocked;
+    });
+  }
+  getInvoiceByPaymentHash(paymentHash) {
+    return run(() => this.findByPaymentHash(paymentHash)?.invoice);
+  }
+  listBlockedInvoices(args) {
+    const statuses = args.includeResolved ? ["blocked", "reconciled", "written_off"] : ["blocked"];
+    return run(
+      () => [...this.invoices.values()].filter((invoice) => statuses.includes(invoice.status)).sort(compareInvoiceKeyset).filter((invoice) => args.after === void 0 || compareToCursor(invoice, args.after) > 0).slice(0, args.limit)
+    );
+  }
+  reconcileBlockedInvoice(args) {
+    return run(() => {
+      assertFundingBasis(args.basis);
+      const found = this.findByPaymentHash(args.paymentHash);
+      if (!found) {
+        throw new CreditLedgerError(
+          "invoice_not_found",
+          `no invoice for payment hash ${args.paymentHash}`
+        );
+      }
+      const { key, invoice } = found;
+      const nowMs = args.nowMs ?? Date.now();
+      if (invoice.status === "reconciled") {
+        const targetKey2 = invoice.reconciledCreditId && invoice.reconciledFundId ? fundingKey(invoice.reconciledCreditId, invoice.reconciledFundId) : void 0;
+        const existing = invoice.reconciledCreditId ? this.credits.get(invoice.reconciledCreditId) : void 0;
+        return {
+          invoice,
+          funding: targetKey2 ? this.fundings.get(targetKey2) : void 0,
+          credit: existing ? this.snapshot(existing, nowMs) : void 0,
+          replayed: true
+        };
+      }
+      if (invoice.status !== "blocked" && invoice.status !== "written_off") {
+        throw new CreditLedgerError(
+          "invoice_not_blocked",
+          `invoice ${args.paymentHash} is ${invoice.status}; only a blocked or written-off invoice can be reconciled`
+        );
+      }
+      const targetKey = fundingKey(args.targetCreditId, invoice.paymentHash);
+      if (this.fundings.has(targetKey)) {
+        throw new CreditLedgerError(
+          "funding_replayed",
+          `funding ${invoice.paymentHash} on credit ${args.targetCreditId} was already recorded`
+        );
+      }
+      const funding = {
+        creditId: args.targetCreditId,
+        fundId: invoice.paymentHash,
+        amountMicro: invoice.amountMicro,
+        rail: "lightning",
+        createdAt: nowMs,
+        callerPubkey: null,
+        balanceAfterMicro: null,
+        ledgerSeq: null,
+        receipt: null
+      };
+      this.fundings.set(targetKey, funding);
+      const credit = this.fundSync({
+        creditId: args.targetCreditId,
+        callerPubkey: invoice.callerPubkey,
+        currency: invoice.currency,
+        amountMicro: invoice.amountMicro,
+        expiryMs: args.expiryMs,
+        basis: args.basis,
+        nowMs
+      });
+      funding.callerPubkey = invoice.callerPubkey;
+      funding.balanceAfterMicro = credit.availableMicro;
+      funding.ledgerSeq = credit.lastLedgerSeq;
+      const reconciled = {
+        ...invoice,
+        status: "reconciled",
+        reconciledCreditId: args.targetCreditId,
+        reconciledFundId: invoice.paymentHash,
+        resolvedAt: nowMs,
+        settledAt: args.settledAtMs ?? invoice.settledAt
+      };
+      this.invoices.set(key, reconciled);
+      return { invoice: reconciled, funding, credit, replayed: false };
+    });
+  }
+  writeOffBlockedInvoice(args) {
+    return run(() => {
+      const found = this.findByPaymentHash(args.paymentHash);
+      if (!found) return void 0;
+      if (found.invoice.status !== "blocked") return { invoice: found.invoice, written: false };
+      const written = {
+        ...found.invoice,
+        status: "written_off",
+        writeOffNote: args.note ?? null,
+        resolvedAt: args.nowMs ?? Date.now()
+      };
+      this.invoices.set(found.key, written);
+      return { invoice: written, written: true };
+    });
+  }
+  findByPaymentHash(paymentHash) {
+    for (const [key, invoice] of this.invoices) {
+      if (invoice.paymentHash === paymentHash) return { key, invoice };
+    }
+    return void 0;
+  }
+  fundSync(args) {
+    assertAmount(args.amountMicro, { min: 1 });
+    if (!Number.isSafeInteger(args.expiryMs) || args.expiryMs <= 0) {
+      throw new CreditLedgerError(
+        "invalid_expiry",
+        `expiryMs must be a positive safe integer (got ${args.expiryMs})`
+      );
+    }
+    const b = assertFundingBasis(args.basis);
+    const nowMs = args.nowMs ?? Date.now();
+    const creditId = args.creditId ?? randomUUID();
+    const existing = this.credits.get(creditId);
+    if (existing) {
+      if (existing.callerPubkey !== args.callerPubkey) {
+        throw new CreditLedgerError(
+          "caller_mismatch",
+          `credit ${creditId} belongs to a different caller pubkey`
+        );
+      }
+      if (existing.currency !== args.currency) {
+        throw new CreditLedgerError(
+          "currency_mismatch",
+          `credit ${creditId} is denominated in ${existing.currency}, not ${args.currency}`
+        );
+      }
+      if (existing.status !== "active") throw terminalCreditError(creditId);
+      if (existing.rail !== null && existing.rail !== b.rail) {
+        throw new CreditLedgerError(
+          "rail_mismatch",
+          `credit ${creditId} was funded on the ${existing.rail} rail, not ${b.rail}`,
+          { expectedRail: existing.rail }
+        );
+      }
+      const incomingTempoChannel = b.tempoSession?.channelId.toLowerCase() ?? null;
+      if (existing.tempoChannelId !== incomingTempoChannel) {
+        throw new CreditLedgerError(
+          "rail_mismatch",
+          existing.tempoChannelId ? `credit ${creditId} belongs to Tempo session channel ${existing.tempoChannelId}` : existing.rail === "tempo" ? `credit ${creditId} was funded by a one-shot Tempo charge and cannot accept a Tempo session voucher` : `credit ${creditId} is not bound to a Tempo session channel and cannot adopt one`,
+          {
+            expectedRail: existing.rail,
+            ...existing.tempoChannelId || existing.rail === "tempo" ? { expectedInstrument: existing.tempoChannelId ? "tempo_session" : "tempo_charge" } : {},
+            expectedChannelId: existing.tempoChannelId
+          }
+        );
+      }
+      if (existing.x402ChannelId !== (b.x402Channel?.channelId ?? null)) {
+        throw new CreditLedgerError(
+          "rail_mismatch",
+          existing.x402ChannelId ? `credit ${creditId} is bound to x402 settlement channel ${existing.x402ChannelId}` : existing.rail === "x402" ? `credit ${creditId} was funded by a one-shot x402 exact payment and cannot accept an x402 batch-settlement channel deposit` : `credit ${creditId} is not bound to an x402 batch-settlement channel and cannot adopt one`,
+          {
+            expectedRail: existing.rail,
+            ...existing.x402ChannelId || existing.rail === "x402" ? { expectedInstrument: existing.x402ChannelId ? "x402_channel" : "x402_exact" } : {},
+            expectedChannelId: existing.x402ChannelId
+          }
+        );
+      }
+      existing.balanceMicro += args.amountMicro;
+      existing.expiryMs = args.expiryMs;
+      applyBasis(existing, b);
+      recordLot(existing, args.amountMicro, b, nowMs);
+      return this.snapshot(existing, nowMs);
+    }
+    if (b.x402Channel) {
+      for (const candidate of this.credits.values()) {
+        if (candidate.x402ChannelId === b.x402Channel.channelId) {
+          throw new CreditLedgerError(
+            "rail_mismatch",
+            `x402 channel ${b.x402Channel.channelId} is already bound to credit ${candidate.creditId}`,
+            {
+              expectedRail: candidate.rail,
+              expectedInstrument: "x402_channel",
+              expectedChannelId: b.x402Channel.channelId,
+              boundCreditId: candidate.creditId
+            }
+          );
+        }
+      }
+    }
+    const credit = {
+      creditId,
+      callerPubkey: args.callerPubkey,
+      currency: args.currency,
+      balanceMicro: args.amountMicro,
+      expiryMs: args.expiryMs,
+      status: "active",
+      lastLedgerSeq: 0,
+      createdAt: nowMs,
+      draws: /* @__PURE__ */ new Map(),
+      rail: null,
+      nativeAsset: null,
+      mint: null,
+      fundingRef: null,
+      tempoChannelId: null,
+      msatsRemaining: 0,
+      nativeRemaining: null,
+      x402ChannelId: null,
+      drains: /* @__PURE__ */ new Map(),
+      lots: []
+    };
+    applyBasis(credit, b);
+    recordLot(credit, args.amountMicro, b, nowMs);
+    this.credits.set(creditId, credit);
+    return this.snapshot(credit, nowMs);
+  }
+  drawSync(args, x402Refund) {
+    assertAmount(args.amountMicro, { min: 0 });
+    const nowMs = args.nowMs ?? Date.now();
+    const jobId = args.jobId ?? null;
+    const credit = this.requireCredit(args.creditId);
+    const existing = credit.draws.get(args.drawId);
+    if (existing) {
+      if (existing.amountMicro !== args.amountMicro || existing.jobId !== jobId) {
+        throw new CreditLedgerError(
+          "draw_conflict",
+          `draw ${args.drawId} on credit ${args.creditId} was recorded with different parameters`,
+          { expectedAmountMicro: existing.amountMicro, expectedJobId: existing.jobId }
+        );
+      }
+      return { ...drawResult(existing, credit), replayed: true };
+    }
+    if (credit.status !== "active") throw terminalCreditError(args.creditId);
+    if (x402Refund) throw x402SettlementPending(args.creditId, x402Refund);
+    if (credit.expiryMs <= nowMs) {
+      throw new CreditLedgerError("credit_expired", `credit ${args.creditId} expired`, {
+        expiryMs: credit.expiryMs,
+        balanceMicro: credit.balanceMicro
+      });
+    }
+    const pending = pendingSums(credit);
+    const available = credit.balanceMicro - pending.micro;
+    if (args.amountMicro > available) {
+      throw new CreditLedgerError(
+        "insufficient_credit",
+        `draw of ${args.amountMicro} exceeds available balance ${available}`,
+        {
+          availableMicro: available,
+          balanceMicro: credit.balanceMicro,
+          requestedMicro: args.amountMicro
+        }
+      );
+    }
+    const alloc = allocateDrawValue({
+      amountMicro: args.amountMicro,
+      availableMicro: available,
+      availableMsats: Math.max(0, credit.msatsRemaining - pending.msats),
+      availableNative: credit.nativeRemaining === null ? null : Math.max(0, credit.nativeRemaining - pending.native)
+    });
+    const ledgerSeq = credit.lastLedgerSeq + 1;
+    credit.lastLedgerSeq = ledgerSeq;
+    const draw = {
+      creditId: args.creditId,
+      drawId: args.drawId,
+      amountMicro: args.amountMicro,
+      jobId,
+      ledgerSeq,
+      status: "pending",
+      balanceAfterMicro: available - args.amountMicro,
+      createdAt: nowMs,
+      resolvedAt: null,
+      drawMsats: alloc.drawMsats,
+      drawNative: alloc.drawNative,
+      grownMicro: 0
+    };
+    credit.draws.set(args.drawId, draw);
+    return { ...drawResult(draw, credit), replayed: false };
+  }
+  /** Mid-job top-up growth (internal-review) — see `CreditLedger.growDraw` for the semantics. */
+  growDrawSync(args) {
+    assertAmount(args.addAmountMicro, { min: 1 });
+    const credit = this.requireCredit(args.creditId);
+    const draw = credit.draws.get(args.drawId);
+    if (!draw) {
+      throw new CreditLedgerError(
+        "draw_not_found",
+        `draw ${args.drawId} not found on credit ${args.creditId}`
+      );
+    }
+    if (draw.status !== "pending") {
+      throw new CreditLedgerError(
+        "invalid_draw_state",
+        `cannot grow draw ${args.drawId}: status is ${draw.status}`,
+        { currentStatus: draw.status }
+      );
+    }
+    if (credit.status !== "active") throw terminalCreditError(args.creditId);
+    if (args.jobId !== void 0 && draw.jobId !== args.jobId) {
+      throw new CreditLedgerError(
+        "draw_conflict",
+        `draw ${args.drawId} on credit ${args.creditId} belongs to a different job`,
+        { expectedJobId: draw.jobId }
+      );
+    }
+    const pending = pendingSums(credit);
+    const available = credit.balanceMicro - pending.micro;
+    const headroom = args.capMicro === void 0 ? args.addAmountMicro : Math.max(0, args.capMicro - draw.grownMicro);
+    const grantMicro = Math.min(args.addAmountMicro, headroom);
+    if (grantMicro <= 0) {
+      return {
+        ...drawResult(draw, credit),
+        replayed: false,
+        addedRailValue: { drawMsats: 0, drawNative: null },
+        addedAmountMicro: 0,
+        cappedMicro: args.addAmountMicro
+      };
+    }
+    if (grantMicro > available) {
+      throw new CreditLedgerError(
+        "insufficient_credit",
+        `top-up draw of ${grantMicro} exceeds available balance ${available}`,
+        {
+          availableMicro: available,
+          balanceMicro: credit.balanceMicro,
+          requestedMicro: grantMicro
+        }
+      );
+    }
+    const added = growthRailValue({
+      earmark: clipEarmark(args.addRailValue, grantMicro, args.addAmountMicro),
+      amountMicro: grantMicro,
+      availableMicro: available,
+      availableMsats: Math.max(0, credit.msatsRemaining - pending.msats),
+      availableNative: credit.nativeRemaining === null ? null : Math.max(0, credit.nativeRemaining - pending.native)
+    });
+    draw.amountMicro += grantMicro;
+    draw.grownMicro += grantMicro;
+    draw.balanceAfterMicro = available - grantMicro;
+    draw.drawMsats += added.drawMsats;
+    if (added.drawNative !== null) draw.drawNative = (draw.drawNative ?? 0) + added.drawNative;
+    return {
+      ...drawResult(draw, credit),
+      replayed: false,
+      addedRailValue: added,
+      addedAmountMicro: grantMicro,
+      cappedMicro: args.addAmountMicro - grantMicro
+    };
+  }
+  get(creditId, opts) {
+    const credit = this.credits.get(creditId);
+    return Promise.resolve(credit ? this.snapshot(credit, opts?.nowMs ?? Date.now()) : void 0);
+  }
+  getForCaller(callerPubkey, opts) {
+    const nowMs = opts?.nowMs ?? Date.now();
+    return Promise.resolve(
+      [...this.credits.values()].filter((c) => c.callerPubkey === callerPubkey).sort((a, b) => a.createdAt - b.createdAt || a.creditId.localeCompare(b.creditId)).map((c) => this.snapshot(c, nowMs))
+    );
+  }
+  getDraw(args) {
+    const credit = this.credits.get(args.creditId);
+    const draw = credit?.draws.get(args.drawId);
+    return Promise.resolve(draw && credit ? drawRecord(draw, credit) : void 0);
+  }
+  getDrawByJobId(jobId) {
+    const matches = [];
+    for (const credit of this.credits.values()) {
+      for (const draw of credit.draws.values()) {
+        if (draw.jobId === jobId) matches.push(drawRecord(draw, credit));
+      }
+    }
+    return Promise.resolve(matches.length === 1 ? matches[0] : void 0);
+  }
+  listPendingDraws(creditId) {
+    const credit = this.credits.get(creditId);
+    if (!credit) return Promise.resolve([]);
+    return Promise.resolve(
+      [...credit.draws.values()].filter((d) => d.status === "pending").sort((a, b) => a.ledgerSeq - b.ledgerSeq).map((d) => drawRecord(d, credit))
+    );
+  }
+  listStalePendingDraws(args) {
+    const out = [];
+    for (const credit of this.credits.values()) {
+      for (const draw of credit.draws.values()) {
+        if (draw.status !== "pending") continue;
+        if (draw.createdAt >= args.createdBeforeMs) continue;
+        out.push(drawRecord(draw, credit));
+      }
+    }
+    out.sort(compareStaleDrawKey);
+    const after = args.after;
+    const page = after ? out.filter((d) => compareStaleDrawKey(d, after) > 0) : out;
+    return Promise.resolve(page.slice(0, args.limit));
+  }
+  /** Settled draws' native value for the credit an x402 channel funded (internal-review). */
+  earnedNativeForX402Channel(channelId) {
+    for (const credit of this.credits.values()) {
+      if (credit.x402ChannelId !== channelId) continue;
+      let earned = 0;
+      for (const draw of credit.draws.values()) {
+        if (draw.status !== "settled" || draw.drawNative === null) continue;
+        earned += draw.drawNative;
+      }
+      return Promise.resolve(earned);
+    }
+    return Promise.resolve(void 0);
+  }
+  getCreditByX402Channel(channelId) {
+    for (const credit of this.credits.values()) {
+      if (credit.x402ChannelId === channelId) {
+        return Promise.resolve(this.snapshot(credit, Date.now()));
+      }
+    }
+    return Promise.resolve(void 0);
+  }
+  terminalizeTempoCredits(evidence, _tx) {
+    return run(() => {
+      const channelId = evidence.channelId.toLowerCase();
+      const observedAt = evidence.observedAt ?? Date.now();
+      for (const credit of this.credits.values()) {
+        if (credit.tempoChannelId !== channelId) continue;
+        if (credit.status === "unbacked") continue;
+        const consumedServiceMicro = [...credit.draws.values()].filter((draw) => draw.status === "settled").reduce((sum, draw) => sum + draw.amountMicro, 0);
+        this.tempoLosses.set(credit.creditId, {
+          creditId: credit.creditId,
+          channelId,
+          callerPubkey: credit.callerPubkey,
+          currency: credit.currency,
+          formerBalanceMicro: credit.balanceMicro,
+          settledOnChainNative: evidence.settledOnChainNative,
+          highestVoucherNative: evidence.highestVoucherNative,
+          consumedServiceMicro,
+          consumedNative: evidence.consumedNative,
+          observedAt
+        });
+        credit.status = "unbacked";
+      }
+      return [...this.tempoLosses.values()].filter((loss) => loss.channelId === channelId);
+    });
+  }
+  listTempoCreditLosses(args) {
+    return Promise.resolve(
+      [...this.tempoLosses.values()].sort((a, b) => b.observedAt - a.observedAt || a.creditId.localeCompare(b.creditId)).slice(0, args?.limit ?? 50)
+    );
+  }
+  terminalizeX402Credit(evidence, _tx) {
+    return run(() => {
+      const channelId = evidence.channelId.toLowerCase();
+      const observedAt = evidence.observedAt ?? Date.now();
+      for (const credit of this.credits.values()) {
+        if (credit.x402ChannelId !== channelId) continue;
+        if (credit.status === "unbacked") continue;
+        const consumedServiceMicro = [...credit.draws.values()].filter((draw) => draw.status === "settled").reduce((sum, draw) => sum + draw.amountMicro, 0);
+        this.x402Losses.set(credit.creditId, {
+          creditId: credit.creditId,
+          channelId,
+          callerPubkey: credit.callerPubkey,
+          currency: credit.currency,
+          formerBalanceMicro: credit.balanceMicro,
+          channelBalanceNative: evidence.channelBalanceNative,
+          totalClaimedNative: evidence.totalClaimedNative,
+          consumedServiceMicro,
+          observedAt
+        });
+        credit.status = "unbacked";
+      }
+      return [...this.x402Losses.values()].filter((loss) => loss.channelId === channelId);
+    });
+  }
+  listX402CreditLosses(args) {
+    return Promise.resolve(
+      [...this.x402Losses.values()].sort((a, b) => b.observedAt - a.observedAt || a.creditId.localeCompare(b.creditId)).slice(0, args?.limit ?? 50)
+    );
+  }
+  // ── Drains (internal-review) — semantics mirror the Postgres ledger ─────────
+  async requestDrain(args) {
+    const wedged = await this.blockingRefundForCredit(
+      args.creditId,
+      X402_WEDGED_SETTLEMENT_STATUSES
+    );
+    const x402Refund = wedged?.effectId === `${args.creditId}:${args.drainId}` ? void 0 : wedged;
+    return run(() => {
+      const nowMs = args.nowMs ?? Date.now();
+      const credit = this.requireCredit(args.creditId);
+      if (credit.callerPubkey !== args.callerPubkey) {
+        throw new CreditLedgerError(
+          "caller_mismatch",
+          `credit ${args.creditId} belongs to a different caller pubkey`
+        );
+      }
+      const existing = credit.drains.get(args.drainId);
+      if (existing) {
+        if (existing.method !== args.method || JSON.stringify(existing.payout) !== JSON.stringify(args.payout)) {
+          throw new CreditLedgerError(
+            "drain_conflict",
+            `drain ${args.drainId} on credit ${args.creditId} was recorded with a different method or payout`
+          );
+        }
+        return {
+          drain: drainRecord(existing, credit),
+          credit: this.snapshot(credit, nowMs),
+          replayed: true
+        };
+      }
+      if (credit.status !== "active") throw terminalCreditError(args.creditId);
+      if (x402Refund) throw x402SettlementPending(args.creditId, x402Refund);
+      const pending = pendingSums(credit);
+      const availableMicro = credit.balanceMicro - pending.micro;
+      if (args.requireNoPending && pending.micro > 0) {
+        throw new CreditLedgerError(
+          "drain_conflict",
+          `credit ${args.creditId} has pending draws that must finish before it can drain`,
+          { drainConflict: "pending_draws" }
+        );
+      }
+      if (availableMicro <= 0) {
+        throw new CreditLedgerError(
+          "nothing_to_drain",
+          `credit ${args.creditId} has no available balance to drain`,
+          { availableMicro, balanceMicro: credit.balanceMicro }
+        );
+      }
+      const depletion = isNonChannelBitcoinRail(credit.rail) ? depleteLots(openLots(credit), availableMicro) : void 0;
+      const inKind = depletion !== void 0 && isInKindDepletion(depletion, availableMicro);
+      const grossSats = inKind ? depletion.satsOwed : null;
+      const owedSats = grossSats === null ? null : netOwedSats(grossSats);
+      if (owedSats === 0) {
+        throw new CreditLedgerError(
+          "drain_below_dust",
+          `credit ${args.creditId} holds ${availableMicro} micro, worth ${grossSats ?? 0} sats at the rate it was funded \u2014 no more than the ${DRAIN_DELIVERY_RESERVE_SATS} sats it costs to hand back`,
+          { availableMicro, balanceMicro: credit.balanceMicro }
+        );
+      }
+      const ledgerSeq = credit.lastLedgerSeq + 1;
+      const drainedMsats = Math.max(0, credit.msatsRemaining - pending.msats);
+      const drainedNative = credit.nativeRemaining === null ? null : Math.max(0, credit.nativeRemaining - pending.native);
+      credit.lastLedgerSeq = ledgerSeq;
+      credit.balanceMicro -= availableMicro;
+      credit.msatsRemaining = Math.min(credit.msatsRemaining, pending.msats);
+      if (credit.nativeRemaining !== null) {
+        credit.nativeRemaining = Math.min(credit.nativeRemaining, pending.native);
+      }
+      const drain = {
+        drainId: args.drainId,
+        method: args.method,
+        payout: { ...args.payout },
+        amountMicro: availableMicro,
+        balanceAfterMicro: credit.balanceMicro,
+        drainedMsats,
+        drainedNative,
+        owedSats,
+        lotDebits: depletion?.debits ?? [],
+        ledgerSeq,
+        status: "pending",
+        token: null,
+        sentRef: null,
+        fulfilment: null,
+        receipts: [],
+        createdAt: nowMs,
+        parkedAt: null,
+        pickedUpAt: null,
+        sentAt: null,
+        releasedAt: null,
+        writeOffNote: null,
+        writtenOffAt: null
+      };
+      applyLotDebits(credit, drain.lotDebits, -1);
+      credit.drains.set(args.drainId, drain);
+      return {
+        drain: drainRecord(drain, credit),
+        credit: this.snapshot(credit, nowMs),
+        replayed: false
+      };
+    });
+  }
+  bitcoinDepositLiability() {
+    const byRail = /* @__PURE__ */ new Map();
+    const byCurrency = /* @__PURE__ */ new Map();
+    const liability = {
+      depositSats: 0,
+      credits: 0,
+      byRail: [],
+      byCurrency: [],
+      uncoveredCredits: 0,
+      uncoveredMicro: 0,
+      unbackedCredits: 0,
+      unbackedMicro: 0
+    };
+    for (const credit of this.credits.values()) {
+      if (!isNonChannelBitcoinRail(credit.rail)) continue;
+      if (credit.tempoChannelId !== null || credit.x402ChannelId !== null) continue;
+      if (credit.balanceMicro <= 0) continue;
+      const lots = openLots(credit);
+      const covered = lots.reduce((sum, lot) => sum + lot.remainingMicro, 0);
+      const basisless = lots.reduce(
+        (sum, lot) => sum + (lot.satsFunded === 0 ? lot.remainingMicro : 0),
+        0
+      );
+      const inKind = covered >= credit.balanceMicro && basisless === 0;
+      const owed = inKind ? lotOwedSats(lots) : 0;
+      liability.depositSats += owed;
+      liability.credits++;
+      if (covered < credit.balanceMicro) {
+        liability.uncoveredCredits++;
+        liability.uncoveredMicro += credit.balanceMicro;
+      } else if (basisless > 0) {
+        liability.unbackedCredits++;
+        liability.unbackedMicro += credit.balanceMicro;
+      }
+      const rail = byRail.get(credit.rail) ?? { rail: credit.rail, sats: 0, credits: 0 };
+      rail.sats += owed;
+      rail.credits++;
+      byRail.set(credit.rail, rail);
+      const currency = byCurrency.get(credit.currency) ?? {
+        currency: credit.currency,
+        micro: 0,
+        credits: 0
+      };
+      currency.micro += credit.balanceMicro;
+      currency.credits++;
+      byCurrency.set(credit.currency, currency);
+    }
+    liability.byRail = [...byRail.values()];
+    liability.byCurrency = [...byCurrency.values()];
+    return Promise.resolve(liability);
+  }
+  listFundingLots(creditId) {
+    const credit = this.credits.get(creditId);
+    return Promise.resolve(credit ? openLots(credit).map((lot) => ({ ...lot })) : []);
+  }
+  getDrain(args) {
+    const credit = this.credits.get(args.creditId);
+    const drain = credit?.drains.get(args.drainId);
+    return Promise.resolve(drain && credit ? drainRecord(drain, credit) : void 0);
+  }
+  listPendingDrains() {
+    const out = [];
+    for (const credit of this.credits.values()) {
+      for (const drain of credit.drains.values()) {
+        if (drain.status === "pending") out.push(drainRecord(drain, credit));
+      }
+    }
+    out.sort((a, b) => a.createdAt - b.createdAt || a.creditId.localeCompare(b.creditId));
+    return Promise.resolve(out);
+  }
+  listChannelDrains(args) {
+    const out = [];
+    for (const credit of this.credits.values()) {
+      if (credit.tempoChannelId === null) continue;
+      for (const drain of credit.drains.values()) {
+        if (drain.status !== "pending" || drain.method !== "tempo") continue;
+        if (drain.createdAt > args.createdBeforeMs) continue;
+        if (!args.includeResolved && drain.writtenOffAt !== null) continue;
+        out.push(drainRecord(drain, credit));
+      }
+    }
+    out.sort(
+      (a, b) => a.createdAt - b.createdAt || a.creditId.localeCompare(b.creditId) || a.drainId.localeCompare(b.drainId)
+    );
+    const after = args.after;
+    const page = after ? out.filter(
+      (row) => row.createdAt > after.createdAt || row.createdAt === after.createdAt && (row.creditId > after.creditId || row.creditId === after.creditId && row.drainId > after.drainId)
+    ) : out;
+    return Promise.resolve(page.slice(0, args.limit));
+  }
+  writeOffDrain(args) {
+    const credit = this.credits.get(args.creditId);
+    const drain = credit?.drains.get(args.drainId);
+    if (!credit || !drain) return Promise.resolve(void 0);
+    if (drain.status !== "pending" || drain.writtenOffAt !== null) {
+      return Promise.resolve({ drain: drainRecord(drain, credit), written: false });
+    }
+    drain.writeOffNote = args.note ?? null;
+    drain.writtenOffAt = args.nowMs ?? Date.now();
+    return Promise.resolve({ drain: drainRecord(drain, credit), written: true });
+  }
+  clearDrainWriteOff(args) {
+    const drain = this.credits.get(args.creditId)?.drains.get(args.drainId);
+    if (drain) {
+      drain.writeOffNote = null;
+      drain.writtenOffAt = null;
+    }
+    return Promise.resolve();
+  }
+  releaseDrain(args) {
+    return run(() => {
+      const { credit, drain } = this.requireDrain(args.creditId, args.drainId);
+      if (drain.status === "released") {
+        return {
+          drain: drainRecord(drain, credit),
+          credit: this.snapshot(credit, args.nowMs ?? Date.now()),
+          replayed: true
+        };
+      }
+      if (drain.status !== "pending") {
+        throw new CreditLedgerError(
+          "invalid_drain_state",
+          `cannot release ${drain.method} drain ${args.drainId} from status ${drain.status}`
+        );
+      }
+      drain.status = "released";
+      drain.releasedAt = args.nowMs ?? Date.now();
+      credit.balanceMicro += drain.amountMicro;
+      credit.msatsRemaining += drain.drainedMsats;
+      if (credit.nativeRemaining !== null && drain.drainedNative !== null) {
+        credit.nativeRemaining += drain.drainedNative;
+      }
+      applyLotDebits(credit, drain.lotDebits, 1);
+      return {
+        drain: drainRecord(drain, credit),
+        credit: this.snapshot(credit, args.nowMs ?? Date.now()),
+        replayed: false
+      };
+    });
+  }
+  parkDrain(args) {
+    return run(() => {
+      const { credit, drain } = this.requireDrain(args.creditId, args.drainId);
+      if (drain.status === "pending" && drain.method === "cashu") {
+        drain.status = "parked";
+        drain.token = args.token;
+        if (args.fulfilment) drain.fulfilment = args.fulfilment;
+        drain.parkedAt = args.nowMs ?? Date.now();
+        return drainRecord(drain, credit);
+      }
+      if ((drain.status === "parked" || drain.status === "picked_up") && drain.token === args.token) {
+        return drainRecord(drain, credit);
+      }
+      throw this.transitionRefusal(drain, "park");
+    });
+  }
+  markDrainPickedUp(args) {
+    return run(() => {
+      const { credit, drain } = this.requireDrain(args.creditId, args.drainId);
+      if (drain.status === "parked") {
+        drain.status = "picked_up";
+        drain.pickedUpAt = args.nowMs ?? Date.now();
+        return { drain: drainRecord(drain, credit), replayed: false };
+      }
+      if (drain.status === "picked_up")
+        return { drain: drainRecord(drain, credit), replayed: true };
+      throw this.transitionRefusal(drain, "mark picked up");
+    });
+  }
+  markDrainSent(args) {
+    return run(() => {
+      const { credit, drain } = this.requireDrain(args.creditId, args.drainId);
+      if (drain.status === "pending" && drain.method !== "cashu") {
+        drain.status = "sent";
+        drain.sentRef = { ...args.sentRef };
+        drain.sentAt = args.nowMs ?? Date.now();
+        return { drain: drainRecord(drain, credit), replayed: false };
+      }
+      if (drain.status === "sent") return { drain: drainRecord(drain, credit), replayed: true };
+      throw this.transitionRefusal(drain, "mark sent");
+    });
+  }
+  appendDrainReceipt(args) {
+    return run(() => {
+      const drain = this.credits.get(args.creditId)?.drains.get(args.drainId);
+      if (drain) drain.receipts.push(args.receipt);
+    });
+  }
+  // ── Internals ─────────────────────────────────────────────────────────
+  requireDrain(creditId, drainId) {
+    const credit = this.credits.get(creditId);
+    const drain = credit?.drains.get(drainId);
+    if (!credit || !drain) {
+      throw new CreditLedgerError(
+        "drain_not_found",
+        `drain ${drainId} not found on credit ${creditId}`
+      );
+    }
+    return { credit, drain };
+  }
+  transitionRefusal(drain, verb) {
+    return new CreditLedgerError(
+      drain.status === "parked" || drain.status === "picked_up" || drain.status === "sent" ? "drain_conflict" : "invalid_drain_state",
+      `cannot ${verb} drain ${drain.drainId}: status is ${drain.status} (method ${drain.method})`
+    );
+  }
+  resolve(args) {
+    const nowMs = args.nowMs ?? Date.now();
+    const credit = this.requireCredit(args.creditId);
+    const draw = credit.draws.get(args.drawId);
+    if (!draw) {
+      throw new CreditLedgerError(
+        "draw_not_found",
+        `draw ${args.drawId} not found on credit ${args.creditId}`
+      );
+    }
+    let replayed = false;
+    if (draw.status === args.to) {
+      replayed = true;
+    } else if (draw.status !== "pending") {
+      throw new CreditLedgerError(
+        "invalid_draw_state",
+        `cannot ${args.to === "settled" ? "settle" : "release"} draw ${args.drawId}: status is ${draw.status}`,
+        { currentStatus: draw.status }
+      );
+    } else {
+      draw.status = args.to;
+      draw.resolvedAt = nowMs;
+      if (args.to === "settled") {
+        credit.balanceMicro -= draw.amountMicro;
+        if (isNonChannelBitcoinRail(credit.rail)) {
+          const depletion = depleteLots(openLots(credit), draw.amountMicro);
+          const settledMsats = inKindDrawMsats(depletion, draw.amountMicro);
+          if (settledMsats !== null && settledMsats !== draw.drawMsats) {
+            draw.allocatedMsats = draw.drawMsats;
+            draw.drawMsats = settledMsats;
+          }
+          applyLotDebits(credit, depletion.debits, -1);
+        }
+        credit.msatsRemaining = Math.max(0, credit.msatsRemaining - draw.drawMsats);
+        if (credit.nativeRemaining !== null) {
+          credit.nativeRemaining = Math.max(0, credit.nativeRemaining - (draw.drawNative ?? 0));
+        }
+      }
+    }
+    return {
+      ...drawResult(draw, credit),
+      status: args.to,
+      replayed,
+      availableMicro: credit.status === "unbacked" ? 0 : credit.balanceMicro - pendingSums(credit).micro,
+      resolvedAt: draw.resolvedAt ?? nowMs
+    };
+  }
+  requireCredit(creditId) {
+    const credit = this.credits.get(creditId);
+    if (!credit) {
+      throw new CreditLedgerError("credit_not_found", `credit ${creditId} not found`);
+    }
+    return credit;
+  }
+  snapshot(credit, nowMs) {
+    const pending = pendingSums(credit);
+    const live = credit.status === "active";
+    return {
+      creditId: credit.creditId,
+      callerPubkey: credit.callerPubkey,
+      currency: credit.currency,
+      balanceMicro: credit.balanceMicro,
+      availableMicro: live ? credit.balanceMicro - pending.micro : 0,
+      nativeAvailable: credit.nativeRemaining === null ? null : live ? Math.max(0, credit.nativeRemaining - pending.native) : 0,
+      expiryMs: credit.expiryMs,
+      expired: credit.expiryMs <= nowMs,
+      status: credit.status,
+      lastLedgerSeq: credit.lastLedgerSeq,
+      createdAt: credit.createdAt,
+      rail: credit.rail,
+      tempoChannelId: credit.tempoChannelId,
+      x402ChannelId: credit.x402ChannelId
+    };
+  }
+};
+function terminalCreditError(creditId) {
+  return new CreditLedgerError(
+    "credit_unbacked",
+    `credit ${creditId} is terminal; its Tempo backing finalized before the DVM was protected`
+  );
+}
+function applyBasis(credit, basis) {
+  credit.rail ??= basis.rail;
+  if (basis.nativeAsset !== void 0) credit.nativeAsset = basis.nativeAsset;
+  if (basis.mint !== void 0) credit.mint = basis.mint;
+  if (basis.fundingRef !== void 0) credit.fundingRef = basis.fundingRef;
+  if (basis.tempoSession) credit.tempoChannelId ??= basis.tempoSession.channelId.toLowerCase();
+  credit.x402ChannelId ??= basis.x402Channel?.channelId ?? null;
+  credit.msatsRemaining += basis.paidMsats;
+  if (basis.nativeAmount !== void 0) {
+    credit.nativeRemaining = (credit.nativeRemaining ?? 0) + basis.nativeAmount;
+  }
+}
+function recordLot(credit, amountMicro, basis, nowMs) {
+  if (!isNonChannelBitcoinRail(basis.rail)) return;
+  if (basis.tempoSession || basis.x402Channel) return;
+  credit.lots.push({
+    lotId: `lot:${randomUUID()}`,
+    creditId: credit.creditId,
+    rail: basis.rail,
+    satsFunded: Math.floor(basis.paidMsats / 1e3),
+    creditedMicro: amountMicro,
+    remainingMicro: amountMicro,
+    fundingRef: basis.fundingRef ?? null,
+    createdAt: nowMs
+  });
+}
+function applyLotDebits(credit, debits, sign) {
+  for (const debit of debits) {
+    const lot = credit.lots.find((candidate) => candidate.lotId === debit.lotId);
+    if (!lot) continue;
+    lot.remainingMicro = Math.max(
+      0,
+      Math.min(lot.remainingMicro + sign * debit.micro, lot.creditedMicro)
+    );
+  }
+}
+function openLots(credit) {
+  return credit.lots.filter((lot) => lot.remainingMicro > 0).sort(fifoOrder);
+}
+function run(fn) {
+  try {
+    return Promise.resolve(fn());
+  } catch (err) {
+    return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+  }
+}
+function fundingKey(creditId, fundId) {
+  return JSON.stringify([creditId, fundId]);
+}
+function pendingSums(credit) {
+  const sums = { micro: 0, msats: 0, native: 0 };
+  for (const d of credit.draws.values()) {
+    if (d.status !== "pending") continue;
+    sums.micro += d.amountMicro;
+    sums.msats += d.drawMsats;
+    sums.native += d.drawNative ?? 0;
+  }
+  return sums;
+}
+function railValue(draw, credit) {
+  return {
+    drawMsats: draw.drawMsats,
+    drawNative: draw.drawNative,
+    rail: credit.rail,
+    nativeAsset: credit.nativeAsset,
+    mint: credit.mint,
+    fundingRef: credit.fundingRef,
+    creditCurrency: credit.currency
+  };
+}
+function drawResult(draw, credit) {
+  return {
+    creditId: draw.creditId,
+    drawId: draw.drawId,
+    amountMicro: draw.amountMicro,
+    balanceAfterMicro: draw.balanceAfterMicro,
+    ledgerSeq: draw.ledgerSeq,
+    status: draw.status,
+    replayed: false,
+    railValue: railValue(draw, credit),
+    resolvedAt: draw.resolvedAt
+  };
+}
+function drawRecord(draw, credit) {
+  const { replayed: _replayed, ...rest } = drawResult(draw, credit);
+  return {
+    ...rest,
+    jobId: draw.jobId,
+    createdAt: draw.createdAt,
+    allocatedMsats: draw.allocatedMsats ?? draw.drawMsats
+  };
+}
+function compareStaleDrawKey(a, b) {
+  return a.createdAt - b.createdAt || a.creditId.localeCompare(b.creditId) || a.ledgerSeq - b.ledgerSeq;
+}
+function compareInvoiceKeyset(a, b) {
+  return a.createdAt - b.createdAt || a.creditId.localeCompare(b.creditId) || a.fundId.localeCompare(b.fundId);
+}
+function compareToCursor(invoice, cursor) {
+  return invoice.createdAt - cursor.createdAt || invoice.creditId.localeCompare(cursor.creditId) || invoice.fundId.localeCompare(cursor.fundId);
+}
+function drainRecord(drain, credit) {
+  return {
+    creditId: credit.creditId,
+    drainId: drain.drainId,
+    callerPubkey: credit.callerPubkey,
+    currency: credit.currency,
+    method: drain.method,
+    channelId: credit.tempoChannelId ?? credit.x402ChannelId,
+    payout: { ...drain.payout },
+    amountMicro: drain.amountMicro,
+    drainedNative: drain.drainedNative,
+    owedSats: drain.owedSats,
+    balanceAfterMicro: drain.balanceAfterMicro,
+    ledgerSeq: drain.ledgerSeq,
+    status: drain.status,
+    token: drain.token,
+    sentRef: drain.sentRef ? { ...drain.sentRef } : null,
+    fulfilment: drain.fulfilment ? { ...drain.fulfilment } : null,
+    receipts: [...drain.receipts],
+    createdAt: drain.createdAt,
+    parkedAt: drain.parkedAt,
+    pickedUpAt: drain.pickedUpAt,
+    sentAt: drain.sentAt,
+    releasedAt: drain.releasedAt,
+    writeOffNote: drain.writeOffNote,
+    writtenOffAt: drain.writtenOffAt
+  };
+}
+function assertAmount(amountMicro, opts) {
+  if (!Number.isSafeInteger(amountMicro) || amountMicro < opts.min) {
+    throw new CreditLedgerError(
+      "invalid_amount",
+      `amountMicro must be a safe integer \u2265 ${opts.min} (got ${amountMicro})`
+    );
+  }
+}
+
+export {
+  MemoryCreditLedger
+};