@dvmkit/sdk 0.8.0 → 0.9.0

package/dist/{chunk-2I3OHMTY.js → chunk-BAQRUYRL.js}

@@ -1,9 +1,9 @@
-import {
-  diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-OIP44KBB.js";
 
 // src/sdk/server/postgres-replay-store.ts
 var DEFAULT_TABLE_NAME = "signed_request_replays";

package/dist/{chunk-ATXDKX6F.js → chunk-GAZBBMAA.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-66HGCPBU.js";
 import {
   diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
+} from "./chunk-OIP44KBB.js";
 
 // src/observability/payment-diagnostics.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-QPXI7YPH.js → chunk-GODOH2AF.js}

@@ -2,12 +2,12 @@ import {
   ContentHoldError,
   applyContentHoldMutation
 } from "./chunk-AFV77S4C.js";
-import {
-  diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-OIP44KBB.js";
 
 // src/sdk/server/postgres-job-store.ts
 import { createHash } from "crypto";

package/dist/{chunk-5CQKSLAU.js → chunk-HC4I7LAV.js}

@@ -1,6 +1,6 @@
 import {
   diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
+} from "./chunk-OIP44KBB.js";
 
 // src/sdk/pricing/currency.ts
 var InvalidCurrencyError = class extends Error {

package/dist/{chunk-6FEHRZO7.js → chunk-IBX2ORBV.js}

@@ -1,6 +1,6 @@
 import {
   diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
+} from "./chunk-OIP44KBB.js";
 
 // src/lib/pg-retry.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-TFYY5APM.js → chunk-IYQQXEHV.js}

@@ -2,12 +2,12 @@ import {
   parseStoreValue,
   stringifyStoreValue
 } from "./chunk-YG7G4DPZ.js";
-import {
-  diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-OIP44KBB.js";
 
 // src/sdk/server/tempo-charge-store.ts
 import { Credential } from "mppx";

package/dist/{chunk-X3JEME6P.js → chunk-K2MSIKMM.js}

@@ -1,9 +1,9 @@
-import {
-  diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-OIP44KBB.js";
 
 // src/sdk/server/payout-reporter.ts
 import { createHash, randomUUID } from "crypto";

package/dist/{chunk-55NKZQOC.js → chunk-KGL3YMZA.js}

@@ -4,7 +4,7 @@ import {
 import {
   diagnosticConsole,
   projectSpanRow
-} from "./chunk-DZQYQN2X.js";
+} from "./chunk-OIP44KBB.js";
 
 // src/lib/x402/env.ts
 import { isAddress } from "viem";

package/dist/{chunk-YPSJU3OH.js → chunk-LCCG5HQM.js}

@@ -2,7 +2,7 @@ import {
   createX402FacilitatorAuthHeaders,
   settleWithFacilitator,
   verifyWithFacilitator
-} from "./chunk-ATXDKX6F.js";
+} from "./chunk-GAZBBMAA.js";
 import {
   buildPaymentRequirements,
   decodePayment,
@@ -15,7 +15,7 @@ import {
 } from "./chunk-66HGCPBU.js";
 import {
   diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
+} from "./chunk-OIP44KBB.js";
 
 // src/lib/x402/verify.ts
 async function verifyX402Payment(paymentHeader, config, requiredUsdcMicro, resource, btcUsdRate, exactVersions = { v1: true, v2: true }) {

package/dist/{chunk-GB5XPAA5.js → chunk-LFVIZH2G.js}

@@ -1,9 +1,9 @@
 import {
   loggers
-} from "./chunk-BL6LRWXD.js";
+} from "./chunk-QSZW2I5Y.js";
 import {
   diagnosticConsole
-} from "./chunk-DZQYQN2X.js";
+} from "./chunk-OIP44KBB.js";
 
 // src/sdk/server/mpp-setup.ts
 import { createHash, randomUUID } from "crypto";
@@ -313,6 +313,15 @@ function logStateFailure(_error) {
 }
 
 // src/sdk/server/mpp-setup.ts
+var TempoDrainRefundUnprovenError = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+  reason;
+};
+var TempoCloseDescriptorError = class extends MppxErrors.VerificationFailedError {
+};
 var MPPX_HMAC_MISMATCH_REASON = "challenge was not issued by this server";
 var TEMPO_SETTLEMENT_LEASE_FIELD = "settlementLeaseUntil";
 var TEMPO_SETTLEMENT_LEASE_OWNER_FIELD = "settlementLeaseOwner";
@@ -557,7 +566,7 @@ function buildMppMethods(opts, env) {
           chainId: opts.tempoSession.chainId ?? chainId,
           ...opts.tempoSession.getClient && { getClient: opts.tempoSession.getClient },
           ...opts.tempoSession.onSessionSettlement && {
-            onSessionSettlement: opts.tempoSession.onSessionSettlement
+            onSessionSettlement: claimingCloseSettlement(opts.tempoSession)
           }
         })
       ));
@@ -566,6 +575,29 @@ function buildMppMethods(opts, env) {
   if (methods.length === 0 || !tempoConfiguration) return void 0;
   return { methods, tempoConfiguration };
 }
+function claimingCloseSettlement(session) {
+  const callback = session.onSessionSettlement;
+  const store = session.store;
+  if (session.hostedObligations || !store.getClose || !store.claimCloseReference) return callback;
+  return async (context) => {
+    if (context.trigger === "close") {
+      const intent = await store.getClose(context.channelId);
+      if (intent) {
+        let claimed = true;
+        try {
+          claimed = (await store.claimCloseReference(
+            context.channelId,
+            intent.drainId,
+            context.txHash
+          )).claimed;
+        } catch {
+        }
+        if (!claimed) return;
+      }
+    }
+    await callback(context);
+  };
+}
 function withAuthenticationOnlyValidation(method) {
   if (method.validate) return method;
   const validate = async ({ credential, request }) => ({
@@ -641,37 +673,64 @@ var DEFAULT_TEMPO_SESSION_CHAIN_OPS = {
       channelId
     )
   ),
-  findChannelClose: async (client, channelId, escrowContract, notBeforeMs) => {
-    const { getBlock, getBlockNumber, getLogs } = await import("viem/actions");
-    const event = TempoSession.Precompile.escrowAbi.find(
-      (item) => item.type === "event" && item.name === "ChannelClosed"
-    );
-    if (!event || event.type !== "event") throw new Error("Tempo escrow ABI has no ChannelClosed event");
-    let toBlock = await getBlockNumber(client);
+  findChannelClose: async (client, channelId, escrowContract, notBeforeMs, startBlock) => {
+    const { getBlock, getBlockNumber, getLogs, getTransaction } = await import("viem/actions");
+    const eventNamed = (name) => {
+      const event = TempoSession.Precompile.escrowAbi.find(
+        (item) => item.type === "event" && item.name === name
+      );
+      if (!event || event.type !== "event") throw new Error(`Tempo escrow ABI has no ${name} event`);
+      return event;
+    };
+    const closedEvent = eventNamed("ChannelClosed");
+    const requestedEvent = eventNamed("CloseRequested");
+    const cancelledEvent = eventNamed("CloseRequestCancelled");
+    const beforeBound = async (blockNumber) => Number((await getBlock(client, { blockNumber })).timestamp) * 1e3 < notBeforeMs - TEMPO_CLOSE_LOG_SLACK_MS;
+    if (startBlock !== void 0 && await beforeBound(startBlock)) {
+      return { outcome: "none", stoppedAt: startBlock };
+    }
+    let toBlock = startBlock ?? await getBlockNumber(client);
     for (let window = 0; window < TEMPO_CLOSE_LOG_MAX_WINDOWS; window += 1) {
       const fromBlock = toBlock >= TEMPO_CLOSE_LOG_WINDOW ? toBlock - TEMPO_CLOSE_LOG_WINDOW + 1n : 0n;
-      const logs = await getLogs(client, {
-        address: escrowContract,
-        event,
-        args: { channelId },
-        fromBlock,
-        toBlock
-      });
-      const closed = logs.find((log) => log.transactionHash);
-      if (closed?.transactionHash) return closed.transactionHash;
-      if (fromBlock === 0n) return null;
-      const start = await getBlock(client, { blockNumber: fromBlock });
-      if (Number(start.timestamp) * 1e3 < notBeforeMs - TEMPO_CLOSE_LOG_SLACK_MS) return null;
+      const range = { address: escrowContract, args: { channelId }, fromBlock, toBlock };
+      const [closed, requested, cancelled] = await Promise.all([
+        getLogs(client, { ...range, event: closedEvent }),
+        getLogs(client, { ...range, event: requestedEvent }),
+        getLogs(client, { ...range, event: cancelledEvent })
+      ]);
+      const newest = [
+        ...closed.map((log) => ({ log, kind: "closed" })),
+        ...requested.map((log) => ({ log, kind: "requested" })),
+        ...cancelled.map((log) => ({ log, kind: "cancelled" }))
+      ].filter(({ log }) => log.transactionHash && log.blockNumber !== null).sort((left, right) => left.log.blockNumber === right.log.blockNumber ? Number(right.log.logIndex ?? 0) - Number(left.log.logIndex ?? 0) : right.log.blockNumber > left.log.blockNumber ? 1 : -1)[0];
+      if (newest?.kind === "closed") {
+        const transaction = await getTransaction(client, {
+          hash: newest.log.transactionHash
+        });
+        return { outcome: "closed", txHash: newest.log.transactionHash, sender: transaction.from };
+      }
+      if (newest?.kind === "requested") {
+        const graceEnd = newest.log.args.closeGraceEnd;
+        const head = await getBlock(client, { blockTag: "latest" });
+        if (graceEnd === void 0 || head.timestamp < graceEnd) return { outcome: "none" };
+        return { outcome: "exit_requested" };
+      }
+      if (newest) return { outcome: "none", stoppedAt: 0n };
+      if (fromBlock === 0n || await beforeBound(fromBlock)) {
+        return { outcome: "none", stoppedAt: fromBlock };
+      }
       toBlock = fromBlock - 1n;
     }
-    throw new Error(`Tempo close search for channel ${channelId} exceeded its block budget`);
+    return { outcome: "paused", resumeAt: toBlock };
   }
 };
 function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
   let creditLedger;
+  let finalizeDrain;
   Object.assign(mppx, {
-    useTempoCreditLedger: (ledger) => {
+    useTempoCreditLedger: (ledger, finalizer) => {
       creditLedger = ledger;
+      finalizeDrain = finalizer;
     }
   });
   const chainOps = {
@@ -689,7 +748,7 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
       assertTempoSessionCloseVoucher: async (voucher) => {
         const descriptor = readChannelDescriptor(voucher.descriptor);
         if (!descriptor) {
-          throw new MppxErrors.VerificationFailedError({
+          throw new TempoCloseDescriptorError({
             reason: "descriptor required for TIP-1034 session action"
           });
         }
@@ -707,22 +766,22 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
           escrow
         });
         if (computed.toLowerCase() !== voucher.channelId.toLowerCase()) {
-          throw new MppxErrors.VerificationFailedError({
+          throw new TempoCloseDescriptorError({
             reason: "channel descriptor does not match channelId"
           });
         }
         if (!sameHex(descriptor.payee, voucher.request.recipient)) {
-          throw new MppxErrors.VerificationFailedError({
+          throw new TempoCloseDescriptorError({
             reason: "channel descriptor payee does not match server destination"
           });
         }
         if (!sameHex(descriptor.token, voucher.request.currency)) {
-          throw new MppxErrors.VerificationFailedError({
+          throw new TempoCloseDescriptorError({
             reason: "channel descriptor token does not match server token"
           });
         }
         if (!sameHex(descriptor.operator, details.operator ?? ZERO_ADDRESS)) {
-          throw new MppxErrors.VerificationFailedError({
+          throw new TempoCloseDescriptorError({
             reason: "channel descriptor operator does not match server operator"
           });
         }
@@ -736,7 +795,7 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
         }
         const storedDescriptor = readChannelDescriptor(stored.descriptor);
         if (!storedDescriptor || !sameDescriptor(descriptor, storedDescriptor)) {
-          throw new MppxErrors.VerificationFailedError({
+          throw new TempoCloseDescriptorError({
             reason: "credential descriptor does not match stored channel"
           });
         }
@@ -838,6 +897,9 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
         value: {
           ...value,
           finalized: active.finalized || chainFinalized,
+          ...chainFinalized && !active.finalized && {
+            depositBeforeFinalization: active.deposit
+          },
           closeRequestedAt: chainFinalized ? 0n : BigInt(chainState.closeRequestedAt),
           deposit: chainFinalized ? 0n : maxBigInt(active.deposit, chainState.deposit),
           settledOnChain: maxBigInt(active.settledOnChain, chainState.settled)
@@ -866,6 +928,9 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
         value: {
           ...current,
           finalized: active.finalized || chainFinalized,
+          ...chainFinalized && !active.finalized && {
+            depositBeforeFinalization: active.deposit
+          },
           closeRequestedAt: chainFinalized ? 0n : BigInt(chainState.closeRequestedAt),
           deposit: chainFinalized ? 0n : maxBigInt(active.deposit, chainState.deposit),
           settledOnChain: maxBigInt(active.settledOnChain, chainState.settled)
@@ -1103,6 +1168,7 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
         }
       }
     }
+    await reconcileTempoSessionCloses();
     return { scanned: rows.length, closeRequested, settled, inFlight };
   };
   const recoverTempoSessionClose = async (channelId, drainId) => {
@@ -1110,7 +1176,8 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
     const intent = await store.getClose(channelId);
     if (intent?.drainId !== drainId) return null;
     if (intent.reference) return intent.reference;
-    const current = readTempoSessionState(await store.get(channelId));
+    const stored = await store.get(channelId);
+    const current = readTempoSessionState(stored);
     if (!current) throw new Error(`Tempo session channel ${channelId} not found`);
     let finalized = current.finalized;
     if (!finalized) {
@@ -1125,23 +1192,35 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
     }
     if (!finalized) return null;
     const pending = await config.hostedObligations?.pendingTempoClose(channelId, drainId);
+    const selfHostedReport = !config.hostedObligations && !!config.onSessionSettlement && !!store.claimCloseReference && !!store.getCloseRecovery;
     let reference = pending?.txHash ?? void 0;
-    if (pending && !reference) {
-      const client = await getClient({ chainId: current.chainId });
-      const txHash = await chainOps.findChannelClose(
-        client,
-        current.channelId,
-        current.escrowContract,
-        pending.reservedAtMs
-      );
-      if (txHash) {
-        await config.hostedObligations.recordSubmitted(pending.id, txHash);
-        reference = txHash;
-      } else {
+    if (pending && pending.state !== "unmatched" && !reference || selfHostedReport) {
+      const recovery = await store.getCloseRecovery?.(channelId);
+      const notBeforeMs = pending?.reservedAtMs ?? recovery?.updatedAtMs;
+      if (notBeforeMs === void 0) throw new Error(`Tempo session close intent ${channelId} not found`);
+      const obligations = config.hostedObligations;
+      const found = await findFinalizedClose(current, stored, drainId, notBeforeMs, pending ? {
+        from: pending.searchBefore,
+        save: (resumeAt) => obligations.recordTempoCloseSearch(pending.id, resumeAt)
+      } : {
+        from: recovery?.searchBefore ?? null,
+        save: (resumeAt) => store.recordCloseSearch?.(channelId, drainId, resumeAt)
+      });
+      if (pending) {
+        reference = await settleUnsubmittedClose(current.channelId, drainId, pending.id, found);
+      } else if (found.outcome === "ours") {
+        const client = await getClient({ chainId: current.chainId });
+        const { settledToPayee } = await chainOps.readChannelClose(client, current.channelId, found.txHash);
+        const claimed = await store.claimCloseReference(channelId, drainId, found.txHash);
+        if (claimed.claimed) {
+          await reportRecoveredClose(current, found.txHash, recovery?.settledBeforeClose ?? null, settledToPayee);
+        }
+        return claimed.reference;
+      } else if (found.outcome === "none") {
         loggers.tempo.warn("tempo_session_close_recovery_unmatched", {
           channel_id: current.channelId,
           drain_id: drainId,
-          obligation_id: pending.id
+          amount_at_stake_native: (current.highestVoucherAmount - (recovery?.settledBeforeClose ?? current.settledOnChain)).toString()
         });
       }
     }
@@ -1152,6 +1231,234 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
     );
     return recovered.reference;
   };
+  const findFinalizedClose = async (current, stored, drainId, notBeforeMs, cursor) => {
+    const client = await getClient({ chainId: current.chainId });
+    const search = await chainOps.findChannelClose(
+      client,
+      current.channelId,
+      current.escrowContract,
+      notBeforeMs,
+      cursor.from ?? void 0
+    );
+    if (search.outcome === "paused") {
+      await cursor.save(search.resumeAt);
+      loggers.tempo.warn("tempo_session_close_recovery_search_paused", {
+        channel_id: current.channelId,
+        drain_id: drainId,
+        resume_block: search.resumeAt.toString()
+      });
+      throw new Error(`Tempo close search for channel ${current.channelId} continues on the next poll`);
+    }
+    if (search.outcome === "closed") {
+      return cooperativeCloseSenders(stored, config.account.address).has(search.sender.toLowerCase()) ? { outcome: "ours", txHash: search.txHash } : { outcome: "exit" };
+    }
+    if (search.outcome === "exit_requested") return { outcome: "exit" };
+    if (search.stoppedAt !== void 0) await cursor.save(search.stoppedAt);
+    return { outcome: "none", terminal: search.stoppedAt !== void 0 };
+  };
+  const settleUnsubmittedClose = async (channelId, drainId, obligationId, found) => {
+    const obligations = config.hostedObligations;
+    if (found.outcome === "ours") {
+      await obligations.recordSubmitted(obligationId, found.txHash);
+      return found.txHash;
+    }
+    if (found.outcome === "exit") {
+      if (await obligations.resolveTempoCloseExit(obligationId)) {
+        loggers.tempo.warn("tempo_session_close_exit_resolved", {
+          channel_id: channelId,
+          drain_id: drainId,
+          obligation_id: obligationId,
+          amount_at_stake_native: await obligations.tempoCloseAmountAtStake(obligationId)
+        });
+      }
+      return void 0;
+    }
+    if (found.terminal && await obligations.markTempoCloseUnmatched(obligationId)) {
+      loggers.tempo.warn("tempo_session_close_recovery_unmatched", {
+        channel_id: channelId,
+        drain_id: drainId,
+        obligation_id: obligationId,
+        amount_at_stake_native: await obligations.tempoCloseAmountAtStake(obligationId)
+      });
+    }
+    return void 0;
+  };
+  const reconcileUnsubmittedCloses = async () => {
+    const obligations = config.hostedObligations;
+    if (!obligations) return;
+    for (const row of await obligations.unsubmittedTempoCloses()) {
+      try {
+        const stored = await store.get(row.channelId);
+        const current = readTempoSessionState(stored);
+        if (!current) continue;
+        if (!current.finalized) {
+          const client = await getClient({ chainId: current.chainId });
+          const [chainState] = await chainOps.getChannelStatesBatch(
+            client,
+            [current.channelId],
+            current.escrowContract
+          );
+          await terminalizeLostBacking(current, chainState);
+          if (!await writeBackChainState(current, chainState)) continue;
+        }
+        const found = await findFinalizedClose(current, stored, row.drainId, row.reservedAtMs, {
+          from: row.searchBefore,
+          save: (resumeAt) => obligations.recordTempoCloseSearch(row.id, resumeAt)
+        });
+        await settleUnsubmittedClose(current.channelId, row.drainId, row.id, found);
+      } catch (error) {
+        loggers.tempo.warn("tempo_session_close_reconcile_failed", {
+          channel_id: row.channelId,
+          drain_id: row.drainId,
+          obligation_id: row.id,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+  const reconcileFinalizedDrains = async () => {
+    const ledger = creditLedger;
+    if (!ledger || !finalizeDrain) return;
+    let after;
+    do {
+      const page = await ledger.listChannelDrains({
+        limit: 100,
+        after,
+        createdBeforeMs: Date.now(),
+        rail: "tempo",
+        includeResolved: true
+      });
+      for (const drain of page) {
+        if (drain.status !== "exit_required" || !drain.channelId) continue;
+        try {
+          const stored = await store.get(drain.channelId);
+          const current = readTempoSessionState(stored);
+          if (!current) throw new Error("Channel history is unavailable");
+          const client = await getClient({ chainId: current.chainId });
+          const [chainState] = await chainOps.getChannelStatesBatch(client, [current.channelId], current.escrowContract);
+          if (!chainState || chainState.deposit !== 0n) continue;
+          await terminalizeLostBacking(current, chainState);
+          await writeBackChainState(current, chainState);
+          const pending = await config.hostedObligations?.pendingTempoClose(drain.channelId, drain.drainId);
+          if (pending && !pending.txHash) {
+            if (pending.state === "unmatched") throw new TempoDrainRefundUnprovenError("close_history_unmatched", "Close history requires an operator retry");
+            continue;
+          }
+          const recovery = await store.getCloseRecovery?.(drain.channelId);
+          const found = pending?.txHash ? { outcome: "ours", txHash: pending.txHash } : await findFinalizedClose(current, stored, drain.drainId, drain.createdAt, {
+            from: recovery?.searchBefore ?? null,
+            save: (resumeAt) => store.recordCloseSearch?.(drain.channelId, drain.drainId, resumeAt)
+          });
+          let refundedNative;
+          let reference;
+          if (found.outcome === "ours") {
+            reference = found.txHash;
+            const receipt = await chainOps.readChannelClose(client, current.channelId, found.txHash);
+            refundedNative = receipt.refundedToPayer;
+            if (!config.hostedObligations && config.onSessionSettlement && store.claimCloseReference) {
+              const claimed = await store.claimCloseReference(drain.channelId, drain.drainId, found.txHash);
+              if (claimed.claimed) {
+                await reportRecoveredClose(current, found.txHash, recovery?.settledBeforeClose ?? null, receipt.settledToPayee);
+              }
+            }
+          } else if (found.outcome === "exit") {
+            const snapshot = stored;
+            const deposit = typeof snapshot.depositBeforeFinalization === "bigint" ? snapshot.depositBeforeFinalization : current.deposit;
+            if (deposit <= 0n) throw new TempoDrainRefundUnprovenError("collateral_missing", "The pre-exit collateral is unavailable");
+            refundedNative = deposit - maxBigInt(current.settledOnChain, chainState.settled);
+            reference = `channel:${current.channelId}`;
+          } else {
+            throw new TempoDrainRefundUnprovenError("close_evidence_missing", "Channel finalization has no matching refund evidence");
+          }
+          if (drain.drainedNative === null || refundedNative < BigInt(drain.drainedNative)) {
+            throw new TempoDrainRefundUnprovenError("refund_short", "Proven refund is below the drain debit");
+          }
+          const creditUnbacked = (await ledger.get(drain.creditId))?.status === "unbacked";
+          await store.confirmClose?.(drain.channelId, drain.drainId, reference);
+          const changed = await finalizeDrain(drain, {
+            reference,
+            refundedNative,
+            outcome: found.outcome === "ours" ? "cooperative_close" : "payer_exit",
+            creditUnbacked
+          });
+          if (changed) {
+            loggers.tempo.warn(creditUnbacked ? "tempo_session_drain_unbacked_resolved" : "tempo_session_drain_finalized", {
+              channel_id: drain.channelId,
+              credit_id: drain.creditId,
+              drain_id: drain.drainId,
+              amount_at_stake_native: drain.drainedNative.toString(),
+              refund_native: refundedNative.toString(),
+              builder_loss_native: (current.highestVoucherAmount > maxBigInt(current.settledOnChain, chainState.settled) ? current.highestVoucherAmount - maxBigInt(current.settledOnChain, chainState.settled) : 0n).toString()
+            });
+          }
+        } catch (error) {
+          let failure = error;
+          if (error instanceof TempoDrainRefundUnprovenError) {
+            try {
+              await store.update(drain.channelId, (current) => {
+                if (!isStateRecord(current)) throw new Error("Channel history is unavailable");
+                const key = JSON.stringify([drain.creditId, drain.drainId, error.reason]);
+                const seen = Array.isArray(current.drainRefundWarnings) ? current.drainRefundWarnings : [];
+                if (seen.includes(key)) return { op: "noop", result: false };
+                loggers.tempo.warn("tempo_session_drain_refund_unproven", {
+                  channel_id: drain.channelId,
+                  credit_id: drain.creditId,
+                  drain_id: drain.drainId,
+                  amount_at_stake_native: drain.drainedNative?.toString() ?? null,
+                  amount_at_stake_micro: drain.amountMicro,
+                  currency: drain.currency,
+                  reason: error.reason,
+                  error: error.message
+                });
+                return { op: "set", value: { ...current, drainRefundWarnings: [...seen, key] }, result: true };
+              });
+              continue;
+            } catch (claimError) {
+              failure = claimError;
+            }
+          }
+          loggers.tempo.warn("tempo_session_close_reconcile_failed", {
+            channel_id: drain.channelId,
+            credit_id: drain.creditId,
+            drain_id: drain.drainId,
+            error: failure instanceof Error ? failure.message : String(failure)
+          });
+        }
+      }
+      const last = page.at(-1);
+      after = page.length === 100 && last ? { createdAt: last.createdAt, creditId: last.creditId, drainId: last.drainId } : void 0;
+    } while (after);
+  };
+  const reconcileTempoSessionCloses = async () => {
+    await reconcileUnsubmittedCloses();
+    await reconcileFinalizedDrains();
+  };
+  const reportRecoveredClose = async (channel, txHash, settledBeforeClose, settledToPayee) => {
+    if (settledBeforeClose === null || settledToPayee < settledBeforeClose) {
+      loggers.tempo.warn("tempo_session_close_settlement_unreported", {
+        channel_id: channel.channelId,
+        tx_hash: txHash,
+        amount_at_stake_native: settledToPayee.toString()
+      });
+      return;
+    }
+    try {
+      await config.onSessionSettlement({
+        txHash,
+        channelId: channel.channelId,
+        trigger: "close",
+        amount: settledToPayee,
+        delta: settledToPayee - settledBeforeClose
+      });
+    } catch (error) {
+      loggers.tempo.warn("tempo_session_close_settlement_callback_failed", {
+        channel_id: channel.channelId,
+        tx_hash: txHash,
+        amount_at_stake_native: (settledToPayee - settledBeforeClose).toString(),
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
   const getClose = store.getClose?.bind(store) ?? (() => Promise.resolve(null));
   const beginClose = store.beginClose?.bind(store);
   const withCloseIntent = store.withCloseIntent?.bind(store);
@@ -1160,6 +1467,7 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
   const confirmClose = store.confirmClose?.bind(store);
   return Object.assign(mppx, {
     sweepTempoSessions,
+    ...config?.hostedObligations && { reconcileTempoSessionCloses },
     ...beginClose && {
       beginTempoSessionClose: async (channelId, drainId) => {
         await beginClose(channelId, drainId);
@@ -1179,6 +1487,14 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
     }
   });
 }
+function cooperativeCloseSenders(stored, fallback) {
+  const record = stored && typeof stored === "object" ? stored : {};
+  const descriptor = record.descriptor && typeof record.descriptor === "object" ? record.descriptor : {};
+  const senders = new Set(
+    [record.operator, record.payee, descriptor.operator, descriptor.payee].filter((value) => typeof value === "string" && HEX_ADDRESS_RE.test(value)).map((value) => value.toLowerCase())
+  );
+  return senders.size > 0 ? senders : /* @__PURE__ */ new Set([fallback.toLowerCase()]);
+}
 function readTempoSessionState(value) {
   if (!value || typeof value !== "object") return void 0;
   const state = value;
@@ -1242,6 +1558,7 @@ export {
   TEMPO_SETTLEMENT_DEFAULT_LOW_BALANCE_MICRO,
   TempoSettlementReadiness,
   isTempoInsufficientFundsError,
+  TempoCloseDescriptorError,
   MPPX_HMAC_MISMATCH_REASON,
   TEMPO_SETTLEMENT_LEASE_FIELD,
   TEMPO_SETTLEMENT_LEASE_OWNER_FIELD,