@dvmkit/sdk 0.6.0-rc.1 → 0.7.0-rc.10

package/dist/chunk-UOCZXO2Z.js

@@ -1,1663 +0,0 @@
-import {
-  connectedTempoAccount,
-  tempoBalanceCheckHint,
-  tempoTokenReference
-} from "./chunk-GFY5FRX3.js";
-import {
-  fundingReachableAt,
-  listCredits,
-  maxAdvertisedMicro,
-  normalizeCreditEndpoint,
-  withinAdvertisedTolerance
-} from "./chunk-B2IROPQF.js";
-import {
-  costAnchor,
-  formatUsd,
-  formatUsdcMicrounits
-} from "./chunk-PAIM66YA.js";
-import {
-  IDENTITIES_FILE,
-  TEMPO_CHANNELS_FILE,
-  ensureConfigDir,
-  resolveRpcHttpTransportOptions,
-  resolveRpcOverride
-} from "./chunk-CZULM42S.js";
-import {
-  redactUrl,
-  redactUrlsInText
-} from "./chunk-FUJ36YDV.js";
-import {
-  DvmError
-} from "./chunk-LIRAHP7B.js";
-
-// src/lib/cli-identity-store.ts
-import { schnorr } from "@noble/curves/secp256k1.js";
-import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
-import lockfile from "proper-lockfile";
-var DEFAULT_LOCK_STALE_MS = 3e4;
-var DEFAULT_LOCK_RETRIES = 30;
-var DEFAULT_LOCK_RETRY_INTERVAL_MS = 1e3;
-var IDENTITIES_VERSION = 1;
-function identitiesFileExists() {
-  return existsSync(IDENTITIES_FILE);
-}
-function loadIdentities() {
-  if (!existsSync(IDENTITIES_FILE)) return null;
-  const raw = readFileSync(IDENTITIES_FILE, "utf-8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new DvmError(
-      "identities_corrupt",
-      `Identities file at ${IDENTITIES_FILE} is not valid JSON.`,
-      `Restore a backup or delete the file and run 'dvm init'. Underlying error: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) {
-    throw new DvmError(
-      "identities_corrupt",
-      `Identities file at ${IDENTITIES_FILE} is missing a version field.`,
-      "Restore a backup or delete the file and run 'dvm init'."
-    );
-  }
-  const version = parsed.version;
-  if (version !== IDENTITIES_VERSION) {
-    throw new DvmError(
-      "identities_unknown_version",
-      `Unknown identities file version ${String(version)} (this CLI understands version ${String(IDENTITIES_VERSION)}).`,
-      "Upgrade dvm CLI: a newer version wrote this file."
-    );
-  }
-  const identities = parsed.identities;
-  if (typeof identities !== "object" || identities === null || Array.isArray(identities)) {
-    throw new DvmError(
-      "identities_corrupt",
-      `Identities file at ${IDENTITIES_FILE} has a malformed identities map.`,
-      "Restore a backup or delete the file and run 'dvm init'."
-    );
-  }
-  return {
-    version: IDENTITIES_VERSION,
-    identities
-  };
-}
-function saveIdentities(file) {
-  ensureConfigDir();
-  const tmp = `${IDENTITIES_FILE}.tmp`;
-  const data = JSON.stringify(file, null, 2) + "\n";
-  writeFileSync(tmp, data, { mode: 384 });
-  try {
-    renameSync(tmp, IDENTITIES_FILE);
-  } catch (err) {
-    try {
-      unlinkSync(tmp);
-    } catch {
-    }
-    throw err;
-  }
-}
-async function withIdentitiesLock(fn, opts = {}) {
-  ensureConfigDir();
-  const lockPath = `${IDENTITIES_FILE}.lock`;
-  const stale = opts.stale ?? DEFAULT_LOCK_STALE_MS;
-  const retries = opts.retries ?? DEFAULT_LOCK_RETRIES;
-  const interval = opts.retryIntervalMs ?? DEFAULT_LOCK_RETRY_INTERVAL_MS;
-  let release;
-  try {
-    release = await lockfile.lock(IDENTITIES_FILE, {
-      lockfilePath: lockPath,
-      stale,
-      realpath: false,
-      retries: { retries, factor: 1, minTimeout: interval, maxTimeout: interval }
-    });
-  } catch (err) {
-    throw new DvmError(
-      "identities_locked",
-      `Could not acquire the identities lock at ${lockPath} within the retry budget.`,
-      `Another dvm CLI may be writing to ${IDENTITIES_FILE}. Wait a moment and retry. If no other dvm CLI is running, remove ${lockPath} and try again.`,
-      { lock_file: lockPath, underlying: err instanceof Error ? err.message : String(err) }
-    );
-  }
-  try {
-    return await fn();
-  } finally {
-    try {
-      await release();
-    } catch {
-    }
-  }
-}
-function generateIdentity(now = Date.now()) {
-  const { secretKey, publicKey } = schnorr.keygen();
-  return {
-    privkey: bytesToHex(secretKey),
-    pubkey: bytesToHex(publicKey),
-    createdAt: now
-  };
-}
-function deriveIdentityFromPrivkey(privkeyHex, now = Date.now()) {
-  if (!/^[0-9a-f]{64}$/.test(privkeyHex)) {
-    throw new DvmError(
-      "invalid_privkey",
-      "Private key must be 64 lowercase hex characters (32 bytes).",
-      "Generate a fresh one with 'dvm identity create <name>'."
-    );
-  }
-  const privkeyBytes = hexToBytes(privkeyHex);
-  const pubkeyBytes = schnorr.getPublicKey(privkeyBytes);
-  return {
-    privkey: privkeyHex,
-    pubkey: bytesToHex(pubkeyBytes),
-    createdAt: now
-  };
-}
-function bytesToHex(bytes) {
-  let s = "";
-  for (const b of bytes) s += b.toString(16).padStart(2, "0");
-  return s;
-}
-function hexToBytes(hex) {
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-
-// src/lib/cli-identity-resolve.ts
-function resolveSigningIdentity(opts) {
-  if (opts.as !== void 0) {
-    const file2 = loadIdentities();
-    const entry = file2?.identities[opts.as];
-    if (!entry) {
-      throw new DvmError(
-        "auth_required",
-        `No identity named '${opts.as}' is configured.`,
-        availableHint(file2?.identities, "create one with 'dvm identity create <name>'.")
-      );
-    }
-    return {
-      privkey: entry.privkey,
-      pubkey: entry.pubkey,
-      source: { kind: "flag", name: opts.as }
-    };
-  }
-  const envKey = process.env.DVM_IDENTITY_KEY;
-  if (envKey) {
-    const derived = deriveIdentityFromPrivkey(envKey.toLowerCase());
-    return { privkey: derived.privkey, pubkey: derived.pubkey, source: { kind: "env" } };
-  }
-  const file = loadIdentities();
-  const identities = file?.identities ?? {};
-  const names = Object.keys(identities);
-  const configuredDefault = opts.config?.defaultIdentity;
-  if (configuredDefault !== void 0) {
-    if (!Object.hasOwn(identities, configuredDefault)) {
-      throw new DvmError(
-        "auth_required",
-        `Configured default identity '${configuredDefault}' no longer exists.`,
-        availableHint(identities, "set a new default with 'dvm identity use <name>'.")
-      );
-    }
-    const entry = identities[configuredDefault];
-    return {
-      privkey: entry.privkey,
-      pubkey: entry.pubkey,
-      source: { kind: "default", name: configuredDefault }
-    };
-  }
-  if (names.length === 1) {
-    const onlyName = names[0];
-    const entry = identities[onlyName];
-    return {
-      privkey: entry.privkey,
-      pubkey: entry.pubkey,
-      source: { kind: "sole", name: onlyName }
-    };
-  }
-  if (names.length === 0) {
-    throw new DvmError(
-      "auth_required",
-      "This DVM requires a signed request but no caller identity is configured.",
-      "Run 'dvm identity create <name>' (or 'dvm init') to generate one, or pass DVM_IDENTITY_KEY=<hex>."
-    );
-  }
-  throw new DvmError(
-    "auth_required",
-    "Multiple identities are configured but none is selected.",
-    `Pass --as <name>, set a default with 'dvm identity use <name>', or export DVM_IDENTITY_KEY=<hex>. Available: ${names.join(", ")}.`
-  );
-}
-function findSigningIdentityByPubkey(pubkey) {
-  const wanted = pubkey.toLowerCase();
-  const envKey = process.env.DVM_IDENTITY_KEY;
-  if (envKey) {
-    try {
-      const derived = deriveIdentityFromPrivkey(envKey.toLowerCase());
-      if (derived.pubkey === wanted) {
-        return { privkey: derived.privkey, pubkey: derived.pubkey, source: { kind: "env" } };
-      }
-    } catch {
-    }
-  }
-  const identities = loadIdentities()?.identities ?? {};
-  for (const [name, entry] of Object.entries(identities)) {
-    if (entry.pubkey.toLowerCase() === wanted) {
-      return { privkey: entry.privkey, pubkey: entry.pubkey, source: { kind: "pubkey", name } };
-    }
-  }
-  return null;
-}
-function availableHint(identities, suffix) {
-  const names = identities ? Object.keys(identities) : [];
-  if (names.length === 0) return `No identities are configured \u2014 ${suffix}`;
-  return `Available identities: ${names.join(", ")}. ${suffix}`;
-}
-
-// src/lib/shell-quote.ts
-function shellQuoteArg(value) {
-  if (value === "") return "''";
-  if (SAFE_VALUE_RE.test(value)) return value;
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-var SAFE_VALUE_RE = /^[a-zA-Z0-9_\-./@:=,+%]+$/;
-
-// src/lib/payment-rails/tempo-channel-store.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "crypto";
-import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
-import { Session as TempoSession } from "mppx/tempo";
-import lockfile2 from "proper-lockfile";
-import { isAddress, zeroAddress } from "viem";
-var TEMPO_CHARGE_PENDING_STALE_MS = 24 * 60 * 60 * 1e3;
-var tempoLockOwner = new AsyncLocalStorage();
-async function withTempoChannelLock(operation) {
-  if (tempoLockOwner.getStore()?.active) return operation();
-  ensureTempoChannelFile();
-  const release = await lockfile2.lock(TEMPO_CHANNELS_FILE, {
-    realpath: false,
-    retries: { retries: 20, minTimeout: 25, maxTimeout: 250 }
-  });
-  const owner = { active: true };
-  try {
-    return await tempoLockOwner.run(owner, operation);
-  } finally {
-    owner.active = false;
-    await release();
-  }
-}
-function createTempoChannelStore(context) {
-  let operator = context.operator === void 0 ? void 0 : normalizeTempoChannelOperator(context.operator);
-  return TempoSession.Client.createJsonChannelStore({
-    get(key) {
-      if (operator === void 0) return void 0;
-      return loadFile().values[channelStorageKey(context.callerPubkey, operator, key)];
-    },
-    set(key, value) {
-      const file = loadFile();
-      const entry = JSON.parse(value);
-      const entryOperator = normalizeTempoChannelOperator(entry.descriptor?.operator);
-      if (operator !== void 0 && operator !== entryOperator) {
-        throw new DvmError(
-          "payment_invalid",
-          "The Tempo channel operator does not match the session challenge."
-        );
-      }
-      operator = entryOperator;
-      const storedKey = channelStorageKey(context.callerPubkey, operator, key);
-      if (Object.hasOwn(file.values, storedKey)) {
-        const occupiedValue = file.values[storedKey];
-        const occupied = JSON.parse(occupiedValue);
-        if (typeof occupied.channelId !== "string" || occupied.channelId.toLowerCase() !== entry.channelId.toLowerCase()) {
-          throw new DvmError(
-            "tempo_channel_scope_occupied",
-            "A different Tempo channel already occupies this payment scope.",
-            "Exit the existing Tempo channel before retrying this funding. Its local recovery descriptor was preserved.",
-            {
-              occupied_channel_id: typeof occupied.channelId === "string" ? occupied.channelId : void 0,
-              refused_channel_id: entry.channelId
-            },
-            "Funding stopped before broadcast because this Tempo payment scope still holds another recoverable channel."
-          );
-        }
-      }
-      file.values[storedKey] = value;
-      if (context.endpoint && context.creditId) {
-        const updatedAt = Date.now();
-        const association = {
-          endpoint: normalizeCreditEndpoint(context.endpoint),
-          callerPubkey: context.callerPubkey,
-          creditId: context.creditId,
-          channelKey: key.startsWith("chan:") ? key.slice(5) : key,
-          operator,
-          channelId: entry.channelId,
-          cumulativeAmount: entry.cumulativeAmount,
-          deposit: entry.deposit,
-          chainId: entry.chainId,
-          opened: entry.opened,
-          updatedAt
-        };
-        file.associations = file.associations.map(
-          (candidate) => candidate.callerPubkey === association.callerPubkey && candidate.operator === association.operator && candidate.channelKey === association.channelKey && candidate.channelId.toLowerCase() === association.channelId.toLowerCase() ? {
-            ...candidate,
-            cumulativeAmount: association.cumulativeAmount,
-            deposit: association.deposit,
-            chainId: association.chainId,
-            opened: association.opened,
-            updatedAt
-          } : candidate
-        );
-        const index = file.associations.findIndex(
-          (candidate) => sameCredit(
-            candidate,
-            association.endpoint,
-            association.callerPubkey,
-            association.creditId
-          )
-        );
-        if (index === -1) file.associations.push(association);
-        else file.associations[index] = association;
-      }
-      saveFile(file);
-    },
-    delete(key) {
-      if (operator === void 0) return;
-      const file = loadFile();
-      const removedKey = channelStorageKey(context.callerPubkey, operator, key);
-      const channelKey = key.startsWith("chan:") ? key.slice(5) : key;
-      const endpoint = context.endpoint ? normalizeCreditEndpoint(context.endpoint) : void 0;
-      file.associations = file.associations.filter((association) => {
-        if (association.callerPubkey !== context.callerPubkey || association.operator !== operator || association.channelKey !== channelKey) {
-          return true;
-        }
-        if (endpoint && context.creditId) {
-          return !sameCredit(association, endpoint, context.callerPubkey, context.creditId);
-        }
-        return false;
-      });
-      const shared = file.associations.some(
-        (association) => association.callerPubkey === context.callerPubkey && association.operator === operator && association.channelKey === channelKey
-      );
-      if (!shared) {
-        file.values = Object.fromEntries(
-          Object.entries(file.values).filter(([storedKey]) => storedKey !== removedKey)
-        );
-      }
-      saveFile(file);
-    }
-  });
-}
-function listTempoChannelAssociations() {
-  return [...loadFile().associations].sort((a, b) => b.updatedAt - a.updatedAt);
-}
-function loadTempoChannelAssociation(endpoint, callerPubkey, creditId) {
-  const normalized = normalizeCreditEndpoint(endpoint);
-  return loadFile().associations.find(
-    (candidate) => sameCredit(candidate, normalized, callerPubkey, creditId)
-  );
-}
-function loadTempoChannelAssociationByKey(callerPubkey, operator, channelKey) {
-  const normalizedOperator = normalizeTempoChannelOperator(operator);
-  return loadFile().associations.find(
-    (candidate) => candidate.callerPubkey === callerPubkey && candidate.operator === normalizedOperator && candidate.channelKey === channelKey
-  );
-}
-async function loadTempoChannelEntry(association) {
-  return createTempoChannelStore({
-    callerPubkey: association.callerPubkey,
-    endpoint: association.endpoint,
-    creditId: association.creditId,
-    operator: association.operator
-  }).get(association.channelKey);
-}
-async function loadTempoChannelController(association) {
-  const entry = await loadTempoChannelEntry(association);
-  return entry && tempoDescriptorController(entry.descriptor);
-}
-function tempoDescriptorController(descriptor) {
-  const payer = descriptor.payer;
-  if (typeof payer !== "string" || !isAddress(payer, { strict: false })) return void 0;
-  const signer = descriptor.authorizedSigner;
-  const authorizedSigner = TempoSession.Precompile.Channel.resolveAuthorizedSigner({
-    ...descriptor,
-    payer,
-    authorizedSigner: typeof signer === "string" && isAddress(signer, { strict: false }) ? signer : zeroAddress
-  });
-  return { payer: payer.toLowerCase(), authorizedSigner: authorizedSigner.toLowerCase() };
-}
-function tempoChannelControlledBy(controller, address) {
-  if (!controller) return true;
-  if (address === void 0) return false;
-  const candidate = address.toLowerCase();
-  return controller.payer.toLowerCase() === candidate || controller.authorizedSigner.toLowerCase() === candidate;
-}
-async function retireTempoChannel(association) {
-  await createTempoChannelStore({
-    callerPubkey: association.callerPubkey,
-    endpoint: association.endpoint,
-    creditId: association.creditId,
-    operator: association.operator
-  }).delete(association.channelKey);
-}
-async function retireTempoChannelScope(association) {
-  await createTempoChannelStore({
-    callerPubkey: association.callerPubkey,
-    operator: association.operator
-  }).delete(association.channelKey);
-}
-function tempoChargeFundingStale(pending, now = Date.now()) {
-  return now - pending.requestedAt >= TEMPO_CHARGE_PENDING_STALE_MS;
-}
-function tempoChargeCredentialSettleable(pending, now = Date.now()) {
-  return pending.credentialValidBefore !== void 0 && now < pending.credentialValidBefore * 1e3;
-}
-function recordPendingTempoChargeFunding(pending) {
-  const { file, credits } = loadChargeFile();
-  const entry = { ...pending, endpoint: normalizeCreditEndpoint(pending.endpoint) };
-  file.charges = [
-    ...file.charges.filter((candidate) => !sameChargeCredit(candidate, entry, credits)),
-    entry
-  ];
-  saveFile(file);
-}
-function loadResumableTempoChargeFunding(args) {
-  const key = {
-    endpoint: normalizeCreditEndpoint(args.endpoint),
-    callerPubkey: args.callerPubkey,
-    creditId: args.creditId
-  };
-  const { file, credits } = loadChargeFile();
-  return file.charges.find(
-    (entry) => sameChargeCredit(entry, key, credits) && !tempoChargeFundingStale(entry, args.now)
-  );
-}
-function listResumableTempoChargeFundings(filter = {}) {
-  const endpoint = filter.endpoint ? normalizeCreditEndpoint(filter.endpoint) : void 0;
-  const { file, credits } = loadChargeFile();
-  return file.charges.filter(
-    (entry) => (!endpoint || fundingReachableAt(entry, endpoint, credits)) && (!filter.callerPubkey || entry.callerPubkey === filter.callerPubkey) && !tempoChargeFundingStale(entry, filter.now)
-  ).sort((a, b) => a.requestedAt - b.requestedAt);
-}
-function clearPendingTempoChargeFunding(pending) {
-  const { file, credits } = loadChargeFile();
-  const key = { ...pending, endpoint: normalizeCreditEndpoint(pending.endpoint) };
-  const remaining = file.charges.filter(
-    (entry) => !sameChargeCredit(entry, key, credits) || entry.fundId !== pending.fundId
-  );
-  if (remaining.length === file.charges.length) return;
-  file.charges = remaining;
-  saveFile(file);
-}
-function sameCredit(association, endpoint, callerPubkey, creditId) {
-  return association.endpoint === endpoint && association.callerPubkey === callerPubkey && association.creditId === creditId;
-}
-function sameChargeCredit(entry, key, credits) {
-  return entry.callerPubkey === key.callerPubkey && entry.creditId === key.creditId && fundingReachableAt(entry, normalizeCreditEndpoint(key.endpoint), credits);
-}
-function loadChargeFile() {
-  const snapshot = collapseChargeFile();
-  if (!snapshot.changed) return snapshot;
-  const persisted = tryWithTempoChannelLockSync(() => {
-    const current = collapseChargeFile();
-    if (current.changed) saveFile(current.file);
-    return current;
-  });
-  return persisted ?? snapshot;
-}
-function collapseChargeFile() {
-  const file = loadFile();
-  const credits = listCredits();
-  const charges = [];
-  let changed = false;
-  for (const entry of file.charges) {
-    const index = charges.findIndex((candidate) => sameChargeCredit(candidate, entry, credits));
-    if (index === -1) {
-      charges.push(entry);
-      continue;
-    }
-    const seenAt = Number.isFinite(charges[index].requestedAt) ? charges[index].requestedAt : 0;
-    const entryAt = Number.isFinite(entry.requestedAt) ? entry.requestedAt : 0;
-    if (entryAt > seenAt) charges[index] = entry;
-    changed = true;
-  }
-  if (changed) file.charges = charges;
-  return { file, credits, changed };
-}
-function tryWithTempoChannelLockSync(operation) {
-  if (tempoLockOwner.getStore()?.active) return operation();
-  ensureTempoChannelFile();
-  let release;
-  try {
-    release = lockfile2.lockSync(TEMPO_CHANNELS_FILE, { realpath: false });
-  } catch (error) {
-    if (error.code === "ELOCKED") return void 0;
-    throw error;
-  }
-  const owner = { active: true };
-  try {
-    return tempoLockOwner.run(owner, operation);
-  } finally {
-    owner.active = false;
-    release();
-  }
-}
-function ensureTempoChannelFile() {
-  ensureConfigDir();
-  if (existsSync2(TEMPO_CHANNELS_FILE)) return;
-  try {
-    writeFileSync2(TEMPO_CHANNELS_FILE, `${JSON.stringify(emptyFile(), null, 2)}
-`, {
-      mode: 384,
-      flag: "wx"
-    });
-  } catch {
-  }
-}
-function loadFile() {
-  if (!existsSync2(TEMPO_CHANNELS_FILE)) return emptyFile();
-  try {
-    const parsed = JSON.parse(readFileSync2(TEMPO_CHANNELS_FILE, "utf8"));
-    if (parsed.version === 1) return migrateLegacyFile(parsed);
-    if (parsed.version !== 2 || !isStringRecord(parsed.values) || !Array.isArray(parsed.associations) || !parsed.associations.every(isTempoChannelAssociation)) {
-      throw new Error("unsupported Tempo channel store shape");
-    }
-    return {
-      version: 2,
-      values: parsed.values,
-      associations: parsed.associations,
-      // Tolerated rather than required, unlike its two siblings: every file
-      // written before lacks the key, and failing closed on it would
-      // read as a corrupt journal on a store that is perfectly intact.
-      charges: Array.isArray(parsed.charges) ? parsed.charges.filter(isPendingTempoCharge) : []
-    };
-  } catch (cause) {
-    throw new DvmError(
-      "tempo_channel_store_invalid",
-      "The saved Tempo channel journal cannot be read safely.",
-      `Do not delete ${TEMPO_CHANNELS_FILE}; restore or repair it before signing another channel credential.`,
-      { cause: cause instanceof Error ? cause.message : String(cause) }
-    );
-  }
-}
-function saveFile(file) {
-  ensureConfigDir();
-  const tmp = `${TEMPO_CHANNELS_FILE}.${randomUUID()}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(file, null, 2) + "\n", { mode: 384 });
-  renameSync2(tmp, TEMPO_CHANNELS_FILE);
-}
-function emptyFile() {
-  return { version: 2, values: {}, associations: [], charges: [] };
-}
-function migrateLegacyFile(parsed) {
-  if (!isStringRecord(parsed.values) || !Array.isArray(parsed.associations) || !parsed.associations.every(isLegacyTempoChannelAssociation)) {
-    throw new Error("unsupported Tempo channel store shape");
-  }
-  const values = { ...parsed.values };
-  const consumed = /* @__PURE__ */ new Set();
-  const associations = parsed.associations.map((association) => {
-    const legacyKey = `${association.callerPubkey}:chan:${association.channelKey}`;
-    const serialized = parsed.values?.[legacyKey];
-    if (serialized === void 0) {
-      throw new Error(`Tempo channel ${association.channelId} has no stored descriptor`);
-    }
-    const operator = serializedChannelOperator(serialized);
-    values[channelStorageKey(association.callerPubkey, operator, `chan:${association.channelKey}`)] = serialized;
-    consumed.add(legacyKey);
-    return { ...association, operator };
-  });
-  return {
-    version: 2,
-    values: Object.fromEntries(Object.entries(values).filter(([key]) => !consumed.has(key))),
-    associations,
-    charges: Array.isArray(parsed.charges) ? parsed.charges.filter(isPendingTempoCharge) : []
-  };
-}
-function channelStorageKey(callerPubkey, operator, key) {
-  return `${callerPubkey}:${operator}:${key}`;
-}
-function serializedChannelOperator(value) {
-  const parsed = JSON.parse(value);
-  return normalizeTempoChannelOperator(parsed.descriptor?.operator);
-}
-function normalizeTempoChannelOperator(value) {
-  if (value === void 0) return zeroAddress;
-  if (typeof value !== "string" || !isAddress(value, { strict: false })) {
-    throw new Error("invalid Tempo channel operator");
-  }
-  return value.toLowerCase();
-}
-function isStringRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
-}
-function isPendingTempoCharge(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const entry = value;
-  return typeof entry.endpoint === "string" && typeof entry.callerPubkey === "string" && typeof entry.creditId === "string" && typeof entry.fundId === "string" && typeof entry.amountMicro === "number" && typeof entry.targetMicro === "number" && typeof entry.credential === "string" && typeof entry.signedMicro === "number" && typeof entry.amountMsats === "number" && typeof entry.btcRate === "number" && typeof entry.requestedAt === "number" && (entry.credentialValidBefore === void 0 || typeof entry.credentialValidBefore === "number");
-}
-function isTempoChannelAssociation(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const association = value;
-  return typeof association.endpoint === "string" && typeof association.callerPubkey === "string" && typeof association.creditId === "string" && typeof association.channelKey === "string" && typeof association.operator === "string" && isAddress(association.operator, { strict: false }) && typeof association.channelId === "string" && typeof association.cumulativeAmount === "string" && typeof association.deposit === "string" && typeof association.chainId === "number" && typeof association.opened === "boolean" && typeof association.updatedAt === "number";
-}
-function isLegacyTempoChannelAssociation(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const association = value;
-  return typeof association.endpoint === "string" && typeof association.callerPubkey === "string" && typeof association.creditId === "string" && typeof association.channelKey === "string" && typeof association.channelId === "string" && typeof association.cumulativeAmount === "string" && typeof association.deposit === "string" && typeof association.chainId === "number" && typeof association.opened === "boolean" && typeof association.updatedAt === "number";
-}
-
-// src/lib/payment-rails/tempo-session.ts
-import { Credential } from "mppx";
-import { Mppx } from "mppx/client";
-import { Session as TempoSession2 } from "mppx/tempo";
-import { decodeFunctionData, formatUnits, isAddress as isAddress2, zeroAddress as zeroAddress2 } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-import { Transaction } from "viem/tempo";
-
-// src/lib/rail-labels.ts
-var PAYMENT_RAIL_KEYS = ["cashu", "cashu_p2pk", "x402", "tempo"];
-function isPaymentRailKey(value) {
-  return typeof value === "string" && PAYMENT_RAIL_KEYS.includes(value);
-}
-function fundingRailLabel(rail) {
-  switch (rail) {
-    case "cashu":
-      return "ecash";
-    case "lightning":
-      return "Lightning";
-    case "x402":
-      return "x402 stablecoin";
-    case "tempo":
-      return "Tempo stablecoin";
-  }
-}
-function paymentRailLabel(rail) {
-  switch (rail) {
-    case "cashu":
-    case "cashu_p2pk":
-      return "ecash";
-    case "x402":
-      return "x402 stablecoin";
-    case "tempo":
-      return "Tempo stablecoin";
-  }
-}
-function probeRailLabel(rail) {
-  return rail === "lightning" ? "Lightning float" : fundingRailLabel(rail);
-}
-function railLabelAtSentenceStart(label) {
-  return label === "ecash" ? "Ecash" : label;
-}
-
-// src/lib/wallet-rail-copy.ts
-function rpcEndpointSuffix(rail) {
-  const url = rail.details?.rpc_url;
-  return typeof url === "string" && url.length > 0 ? ` via ${url}` : "";
-}
-function rpcEndpointLine(rail) {
-  const url = rail.details?.rpc_url;
-  if (typeof url !== "string" || url.length === 0) return null;
-  const source = rail.details?.rpc_source === "override" ? rpcOverrideEnvVar(rail.rail) : null;
-  return `read from ${url} (${source ?? "bundled default"})`;
-}
-function unreachableRailDisplay(rail) {
-  if (rail.error?.code === "x402_unsupported_network") {
-    const network = rail.details?.network;
-    return typeof network === "string" ? `x402 rail is configured for ${network}, a chain it can't settle on.` : "x402 rail is configured for a chain it can't settle on.";
-  }
-  return nwcRejectionDisplay(rail) ?? `${railLabelAtSentenceStart(probeRailLabel(rail.rail))} rail is configured but not reachable.`;
-}
-function nwcRejectionDisplay(rail) {
-  switch (rail.error?.code) {
-    case "float_unauthorized":
-      return "The Lightning wallet no longer recognises this connection \u2014 it looks revoked or expired.";
-    case "float_connection_restricted":
-      return "The Lightning wallet recognises this connection but won't let it do what the agent needs.";
-    default:
-      return null;
-  }
-}
-function unreachableRailHint(rail) {
-  if (rail.error?.hint) return rail.error.hint;
-  switch (rail.rail) {
-    case "lightning":
-      return "Re-run 'dvm wallet connect' with the connection string piped in.";
-    case "cashu":
-      return "Check mint health with 'dvm wallet mint-health'.";
-    case "x402":
-      return "Check DVM_X402_RPC_URL, or ensure viem is installed.";
-    case "tempo":
-      return "Check DVM_TEMPO_RPC_URL, or ensure viem is installed.";
-  }
-}
-function tempoKeyImportRoutes(opts) {
-  const force = opts.replacingConnectedKey ? " --force" : "";
-  return `'dvm wallet tempo-connect --key-file <path>${force}', or DVM_TEMPO_KEY=<key> dvm wallet tempo-connect${force}`;
-}
-var TEMPO_EXIT_KEY_MISSING_HINT = `Reconnect that exact key (${tempoKeyImportRoutes({ replacingConnectedKey: false })}) before attempting an on-chain exit.`;
-function rpcOverrideEnvVar(rail) {
-  switch (rail) {
-    case "x402":
-      return "DVM_X402_RPC_URL";
-    case "tempo":
-      return "DVM_TEMPO_RPC_URL";
-    default:
-      return null;
-  }
-}
-
-// src/lib/payment-rails/tempo-session.ts
-function offersTempoCreditSession(menu) {
-  return menu?.tempo?.methods.some(
-    (candidate) => candidate.method === "tempo" && candidate.intent === "session"
-  ) === true;
-}
-function offersTempoCreditCharge(menu) {
-  return menu?.tempo?.methods.some(
-    (candidate) => candidate.method === "tempo" && candidate.intent === "charge"
-  ) === true;
-}
-function withholdsTempoCreditSession(menu) {
-  return menu?.tempo?.withheld?.some(
-    (candidate) => candidate.method === "tempo" && candidate.intent === "session"
-  ) === true;
-}
-function offersTempoCreditFunding(menu) {
-  return offersTempoCreditSession(menu) || offersTempoCreditCharge(menu);
-}
-function createTempoCreditSession(args) {
-  return TempoSession2.Client.session({
-    account: privateKeyToAccount(args.account.privateKey),
-    channelStore: createTempoChannelStore({
-      endpoint: args.endpoint,
-      callerPubkey: args.callerPubkey,
-      creditId: args.creditId,
-      operator: args.operator ?? zeroAddress2
-    }),
-    maxDeposit: formatUnits(BigInt(args.maxDepositMicro), 6),
-    topUpAmount: formatUnits(BigInt(args.topUpAmountMicro), 6),
-    ...args.getClient ? { getClient: args.getClient } : {}
-  });
-}
-function createTempoSessionPaymentFetch(method, fetch) {
-  return Mppx.create({
-    methods: [method],
-    fetch,
-    maxPaymentRetries: 5,
-    polyfill: false
-  }).fetch;
-}
-function tempoSessionChallengeChannelScope(challenge) {
-  if (!challenge) return void 0;
-  const request = challenge.request;
-  if (typeof request?.recipient !== "string" || !isAddress2(request.recipient, { strict: false }) || typeof request.currency !== "string" || !isAddress2(request.currency, { strict: false })) {
-    return void 0;
-  }
-  const methodDetails = request.methodDetails && typeof request.methodDetails === "object" ? request.methodDetails : void 0;
-  const chainId = methodDetails?.chainId;
-  if (typeof chainId !== "number" || !Number.isSafeInteger(chainId) || chainId <= 0) {
-    return void 0;
-  }
-  const challengeEscrow = [methodDetails?.escrowContract, methodDetails?.escrow].find(
-    (candidate) => typeof candidate === "string" && isAddress2(candidate, { strict: false })
-  );
-  const escrow = challengeEscrow ?? TempoSession2.Precompile.Constants.tip20ChannelEscrow;
-  const operator = methodDetails?.operator;
-  if (operator !== void 0 && (typeof operator !== "string" || !isAddress2(operator, { strict: false }))) {
-    return void 0;
-  }
-  return {
-    channelKey: `${request.recipient.toLowerCase()}:${request.currency.toLowerCase()}:${escrow.toLowerCase()}:${String(chainId)}`,
-    operator: operator?.toLowerCase() ?? zeroAddress2
-  };
-}
-function tempoSessionCredentialChannelScope(credential) {
-  try {
-    return tempoSessionChallengeChannelScope(
-      Credential.deserialize(credential).challenge
-    );
-  } catch {
-    return void 0;
-  }
-}
-function tempoSessionAssociationByKey(args) {
-  return args.channelScope ? loadTempoChannelAssociationByKey(
-    args.callerPubkey,
-    args.channelScope.operator,
-    args.channelScope.channelKey
-  ) : loadTempoChannelAssociation(args.endpoint, args.callerPubkey, args.creditId);
-}
-function tempoSessionPriorCumulativeMicro(args) {
-  const association = args.association ?? loadTempoChannelAssociation(args.endpoint, args.callerPubkey, args.creditId);
-  if (!association?.opened) return 0;
-  const prior = BigInt(association.cumulativeAmount);
-  if (prior < 0n || prior > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new DvmError("payment_invalid", "The Tempo channel's cumulative amount is out of range.");
-  }
-  return Number(prior);
-}
-function tempoSessionCumulativeCapMicro(args) {
-  const prior = BigInt(tempoSessionPriorCumulativeMicro(args));
-  const amount = BigInt(Math.max(0, args.amountMicro));
-  const explicitAllowance = BigInt(Math.max(args.allowanceMicro, args.amountMicro));
-  const allowance = explicitAllowance > amount ? explicitAllowance : maxAdvertisedMicro(amount);
-  const cap = prior + allowance;
-  if (cap > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new DvmError("payment_invalid", "The Tempo session deposit cap is out of range.");
-  }
-  return Number(cap);
-}
-function tempoSessionCredentialDepositMicro(credential) {
-  return readSessionDeposit(credential).depositMicro;
-}
-function assertTempoSessionDepositWithinCap(args) {
-  const { action, depositMicro } = readSessionDeposit(args.credential);
-  if (depositMicro === 0) return;
-  const priorMicro = action === "topUp" ? Number(
-    (args.channelScope ? loadTempoChannelAssociationByKey(
-      args.callerPubkey,
-      args.channelScope.operator,
-      args.channelScope.channelKey
-    ) : loadTempoChannelAssociation(args.endpoint, args.callerPubkey, args.creditId))?.deposit ?? 0
-  ) : 0;
-  const committedMicro = priorMicro + depositMicro;
-  if (committedMicro <= args.capMicro) return;
-  const committedUsd = committedMicro / 1e6;
-  const capUsd = args.capMicro / 1e6;
-  throw new DvmError(
-    "tempo_session_deposit_exceeds_limit",
-    `This Tempo session would lock $${formatUsd(committedUsd)} of channel collateral, above the $${formatUsd(capUsd)} this funding authorized.`,
-    "Nothing was sent and no collateral moved. Fund a smaller amount, or ask the DVM operator why its session asks for a deposit this size.",
-    {
-      committed_usdc_microunits: String(committedMicro),
-      max_usdc_microunits: String(args.capMicro),
-      anchor: costAnchor(committedUsd),
-      display: `Funding refused: the DVM's Tempo session would lock $${formatUsd(committedUsd)} of on-chain collateral, over the $${formatUsd(capUsd)} authorized for this funding.`
-    }
-  );
-}
-function assertTempoSessionChallengeWithinAsk(args) {
-  const local = BigInt(Math.max(0, Math.round(args.basisMicro)));
-  for (const challenge of args.challenges) {
-    if (challenge.method !== "tempo" || challenge.intent !== "session") continue;
-    const advertised = BigInt(tempoSessionChallengeMicro(challenge));
-    if (withinAdvertisedTolerance(advertised, local)) continue;
-    const advertisedUsd = Number(advertised) / 1e6;
-    const localUsd = Number(local) / 1e6;
-    throw new DvmError(
-      "tempo_session_amount_exceeds_limit",
-      `The DVM's Tempo session asks this funding to authorize $${formatUsd(advertisedUsd)}, more than 10% above the $${formatUsd(localUsd)} of credit it is buying.`,
-      "No voucher was signed, so this DVM gained no authority to capture anything. If the funding had already opened or topped up its channel, that collateral is still yours \u2014 'dvm wallet balance' shows it and 'dvm wallet tempo-exit <dvm>' recovers it on-chain. Fund an amount this DVM prices, or ask its operator to check its BTC/USD rate.",
-      {
-        advertised_usdc_microunits: advertised.toString(),
-        local_usdc_microunits: local.toString(),
-        max_usdc_microunits: maxAdvertisedMicro(local).toString(),
-        anchor: costAnchor(advertisedUsd),
-        display: `Funding refused: the DVM's Tempo session wants a $${formatUsd(advertisedUsd)} voucher for $${formatUsd(localUsd)} of credit, over the 10% safety margin.`
-      }
-    );
-  }
-}
-function tempoSessionCredentialCumulativeMicro(credential) {
-  let payload;
-  try {
-    payload = Credential.deserialize(credential).payload;
-  } catch {
-    return void 0;
-  }
-  const { cumulativeAmount } = payload;
-  if (typeof cumulativeAmount !== "string" || !/^\d+$/.test(cumulativeAmount)) return void 0;
-  const micro = BigInt(cumulativeAmount);
-  if (micro > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new DvmError("payment_invalid", "The Tempo session voucher amount is out of range.");
-  }
-  return Number(micro);
-}
-function assertTempoSessionVoucherWithinAsk(args) {
-  const local = BigInt(Math.max(0, Math.round(args.basisMicro)));
-  const authorized = BigInt(args.authorizedMicro);
-  if (authorized <= 0n || withinAdvertisedTolerance(authorized, local)) return;
-  const authorizedUsd = Number(authorized) / 1e6;
-  const localUsd = Number(local) / 1e6;
-  throw new DvmError(
-    "tempo_session_amount_exceeds_limit",
-    `This Tempo session voucher would let the DVM capture $${formatUsd(authorizedUsd)}, above the $${formatUsd(localUsd)} of credit this funding is buying.`,
-    "The voucher never left this machine, so this DVM can capture nothing against it. Any channel collateral the funding already locked is still yours \u2014 'dvm wallet balance' shows it and 'dvm wallet tempo-exit <dvm>' recovers it on-chain. Fund an amount this DVM prices, or ask its operator why its session charges more than it quoted.",
-    {
-      advertised_usdc_microunits: authorized.toString(),
-      local_usdc_microunits: local.toString(),
-      max_usdc_microunits: maxAdvertisedMicro(local).toString(),
-      anchor: costAnchor(authorizedUsd),
-      display: `Funding refused: the DVM's Tempo session voucher would capture $${formatUsd(authorizedUsd)} for $${formatUsd(localUsd)} of credit, over the 10% safety margin.`
-    }
-  );
-}
-async function persistTempoOpenCredential(args) {
-  try {
-    const parsed = Credential.deserialize(args.credential);
-    const payload = parsed.payload;
-    if (payload.action !== "open" || typeof payload.channelId !== "string" || typeof payload.cumulativeAmount !== "string" || !payload.descriptor || typeof payload.descriptor !== "object") {
-      return false;
-    }
-    const methodDetails = parsed.challenge.request.methodDetails;
-    if (typeof methodDetails?.chainId !== "number") return false;
-    const escrow = typeof methodDetails.escrowContract === "string" && isAddress2(methodDetails.escrowContract, { strict: false }) ? methodDetails.escrowContract : TempoSession2.Precompile.Constants.tip20ChannelEscrow;
-    const descriptor = payload.descriptor;
-    const channelId = TempoSession2.Precompile.Channel.computeId({
-      ...descriptor,
-      chainId: methodDetails.chainId,
-      escrow
-    });
-    if (channelId.toLowerCase() !== payload.channelId.toLowerCase()) return false;
-    const depositMicro = tempoSessionCredentialDepositMicro(args.credential);
-    const existingAssociation = loadTempoChannelAssociation(
-      args.endpoint,
-      args.callerPubkey,
-      args.creditId
-    );
-    const existing = existingAssociation ? await loadTempoChannelEntry(existingAssociation) : void 0;
-    await createTempoChannelStore({
-      endpoint: args.endpoint,
-      callerPubkey: args.callerPubkey,
-      creditId: args.creditId,
-      operator: descriptor.operator
-    }).set({
-      channelId,
-      cumulativeAmount: BigInt(payload.cumulativeAmount),
-      deposit: BigInt(depositMicro),
-      descriptor,
-      escrow,
-      chainId: methodDetails.chainId,
-      opened: args.opened || existing?.opened === true && existing.channelId.toLowerCase() === channelId.toLowerCase()
-    });
-    return true;
-  } catch (err) {
-    if (err instanceof DvmError && err.code === "tempo_channel_scope_occupied") throw err;
-    return false;
-  }
-}
-function tempoSessionChallenge(err) {
-  if (!(err instanceof DvmError) || !Array.isArray(err.data?.tempo_challenges)) return void 0;
-  const challenge = err.data.tempo_challenges.find(
-    (candidate) => candidate.method === "tempo" && candidate.intent === "session"
-  );
-  return challenge;
-}
-function tempoSessionChallengeMicro(challenge) {
-  const advertised = challenge.request?.amount;
-  if (typeof advertised !== "string" || !/^\d+$/.test(advertised)) {
-    throw new DvmError(
-      "payment_invalid",
-      `The DVM advertised an unreadable Tempo session amount: '${String(advertised)}'.`,
-      "Do not pay this. Ask the DVM operator to return a whole number of USDC micro-units."
-    );
-  }
-  const micro = BigInt(advertised);
-  if (micro > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new DvmError("payment_invalid", "The Tempo session challenge amount is out of range.");
-  }
-  return Number(micro);
-}
-async function createTempoCloseCredential(args) {
-  const entry = await loadTempoChannelEntry(args.association);
-  if (!entry) {
-    throw new DvmError(
-      "tempo_channel_not_found",
-      `The Tempo channel for credit ${args.association.creditId} is missing locally.`,
-      "Use 'dvm wallet tempo-exit <dvm>' only when the channel record is present; otherwise contact the DVM operator with the credit id."
-    );
-  }
-  if (BigInt(args.cumulativeAmountMicro) > entry.cumulativeAmount) {
-    throw new DvmError(
-      "tempo_close_amount_unauthorized",
-      `The DVM asked to close this Tempo channel at $${formatUsdcMicrounits(BigInt(args.cumulativeAmountMicro))}, above the $${formatUsdcMicrounits(entry.cumulativeAmount)} this wallet has authorized on it.`,
-      `No credential was signed and nothing is stranded: run 'dvm wallet tempo-exit <dvm>' to recover the channel's unsettled balance on-chain, and tell the DVM's operator that its close request exceeded the caller's authorization.`
-    );
-  }
-  const durableStore = createTempoChannelStore({
-    endpoint: args.association.endpoint,
-    callerPubkey: args.association.callerPubkey,
-    creditId: args.association.creditId,
-    operator: args.association.operator
-  });
-  const method = TempoSession2.Client.session({
-    account: privateKeyToAccount(args.account.privateKey),
-    // mppx normally deletes a channel as soon as it signs a manual close.
-    // The credential has not reached the DVM at that point, so keep the
-    // unilateral-exit record until wallet tempo-exit independently confirms the
-    // cooperative close on-chain and retires it.
-    channelStore: {
-      get: (key) => durableStore.get(key),
-      set: (next) => durableStore.set(next),
-      delete: () => void 0
-    },
-    ...args.getClient ? { getClient: args.getClient } : {}
-  });
-  return method.createCredential({
-    challenge: args.challenge,
-    context: {
-      action: "close",
-      descriptor: entry.descriptor,
-      cumulativeAmountRaw: String(args.cumulativeAmountMicro)
-    }
-  });
-}
-async function advanceTempoChannelExit(args) {
-  return withTempoChannelLock(() => advanceTempoChannelExitLocked(args));
-}
-async function reconcileTempoChannelOnChain(args) {
-  const { association } = args;
-  const unread = {
-    retired: false,
-    channelId: association.channelId,
-    depositMicro: Number(association.deposit),
-    settledMicro: 0
-  };
-  let entry;
-  let state;
-  try {
-    ({ entry, state } = await readTempoChannelState(args));
-  } catch (err) {
-    return { ...unread, status: "unreadable", error: asTempoReadError(err) };
-  }
-  const read = {
-    status: classifyTempoChannelState(entry, state),
-    channelId: entry.channelId,
-    depositMicro: Number(state.deposit),
-    settledMicro: Number(state.settled)
-  };
-  if (read.status !== "closed") return { ...read, retired: false };
-  if (args.observeOnly) return { ...read, retired: false };
-  try {
-    const retired = await withTempoChannelLock(async () => {
-      const current = loadTempoChannelAssociation(
-        association.endpoint,
-        association.callerPubkey,
-        association.creditId
-      );
-      if (!current) return true;
-      if (current.channelId.toLowerCase() !== association.channelId.toLowerCase()) return false;
-      await retireTempoChannelScope(current);
-      return true;
-    });
-    return { ...read, retired };
-  } catch (err) {
-    return { ...read, retired: false, error: asTempoReadError(err) };
-  }
-}
-async function advanceTempoChannelExitLocked(args) {
-  const association = loadTempoChannelAssociation(
-    args.association.endpoint,
-    args.association.callerPubkey,
-    args.association.creditId
-  );
-  if (association?.channelId.toLowerCase() !== args.association.channelId.toLowerCase()) {
-    throw new DvmError(
-      "tempo_channel_not_found",
-      `No local Tempo channel entry remains for credit ${args.association.creditId}.`
-    );
-  }
-  const entry = await loadTempoChannelEntry(association);
-  if (!entry) {
-    if (args.abandon) {
-      await retireTempoChannel(association);
-      return {
-        status: "abandoned",
-        descriptorMissing: true,
-        channelId: association.channelId
-      };
-    }
-    throw new DvmError(
-      "tempo_channel_not_found",
-      `The Tempo channel record for credit ${association.creditId} has no stored descriptor.`,
-      `Run 'dvm wallet tempo-exit ${association.endpoint} --abandon' to retire this unusable local record. Nothing will be broadcast, because there is no descriptor from which to address the escrow.`
-    );
-  }
-  const identity = { channelId: entry.channelId, channelToken: entry.descriptor.token };
-  const account = args.account;
-  const controller = tempoDescriptorController(entry.descriptor);
-  if (account && controller && !tempoChannelControlledBy(controller, account.address)) {
-    if (!args.abandon) throw foreignChannelExitError(association, controller, account);
-    await retireTempoChannelScope(association);
-    return {
-      status: "abandoned",
-      foreignPayer: controller.payer,
-      channelId: association.channelId
-    };
-  }
-  const rpc = await resolveTempoExitRpc(entry.chainId);
-  const client = args.client ?? (account ? await tempoWalletClient(account, rpc) : await tempoPublicClient(rpc));
-  const chain = redactingExitChain(
-    args.chain ?? TempoSession2.Precompile.Chain,
-    rpc,
-    entry.descriptor.token
-  );
-  let state = await chain.getChannelState(client, entry.channelId, entry.escrow);
-  const amounts = () => {
-    const authorized = entry.cumulativeAmount > state.settled ? entry.cumulativeAmount : state.settled;
-    return {
-      depositMicro: Number(state.deposit),
-      settledMicro: Number(state.settled),
-      guaranteedMicro: Number(state.deposit > authorized ? state.deposit - authorized : 0n),
-      // Clamped because the escrow zeroes a withdrawn channel's deposit while
-      // keeping its settled total, so a closed channel reads deposit 0 against
-      // a positive settled and the raw subtraction goes negative.
-      likelyMicro: Number(state.deposit > state.settled ? state.deposit - state.settled : 0n)
-    };
-  };
-  if (state.deposit === 0n) {
-    if (classifyTempoChannelState(entry, state) === "closed") {
-      await retireTempoChannelScope(association);
-      return { status: "already_closed", ...identity, ...amounts() };
-    }
-    if (args.abandon) {
-      await retireTempoChannel(association);
-      return { status: "abandoned", ...identity, ...amounts() };
-    }
-    return { status: "unconfirmed", ...identity, ...amounts() };
-  }
-  if (args.abandon) {
-    throw new DvmError(
-      "tempo_channel_on_chain",
-      `The Tempo channel for credit ${association.creditId} holds $${formatUsdcMicrounits(state.deposit)} on-chain, so its record cannot be abandoned.`,
-      account ? `Run 'dvm wallet tempo-exit' without --abandon to close it and recover the collateral.` : `No Tempo key is connected, so this record could not be checked against one. Reconnect the key that opened this channel (${tempoKeyImportRoutes({ replacingConnectedKey: false })}) and run 'dvm wallet tempo-exit' without --abandon to recover the collateral. Retiring the record is offered only once a connected key shows the channel is not this wallet's.`
-    );
-  }
-  if (!account) throw tempoExitKeyMissingError();
-  const exitAccount = privateKeyToAccount(account.privateKey);
-  const transactionOptions = {
-    account: exitAccount,
-    feePayer: exitAccount,
-    candidateFeeTokens: [entry.descriptor.token]
-  };
-  if (state.closeRequestedAt === 0) {
-    const hash2 = await chain.requestCloseOnChain(
-      client,
-      entry.descriptor,
-      entry.escrow,
-      transactionOptions
-    );
-    await chain.waitForSuccessfulReceipt(client, hash2);
-    state = await chain.getChannelState(client, entry.channelId, entry.escrow);
-    return {
-      status: "close_requested",
-      ...identity,
-      transactionHash: hash2,
-      withdrawAvailableAt: (state.closeRequestedAt + 900) * 1e3,
-      ...amounts()
-    };
-  }
-  const withdrawAvailableAt = state.closeRequestedAt + 900;
-  const now = args.nowSeconds ?? Math.floor(Date.now() / 1e3);
-  if (now < withdrawAvailableAt) {
-    return {
-      status: "waiting",
-      ...identity,
-      withdrawAvailableAt: withdrawAvailableAt * 1e3,
-      ...amounts()
-    };
-  }
-  const withdrawnAmounts = amounts();
-  const hash = await chain.withdrawOnChain(
-    client,
-    entry.descriptor,
-    entry.escrow,
-    transactionOptions
-  );
-  await chain.waitForSuccessfulReceipt(client, hash);
-  state = await chain.getChannelState(client, entry.channelId, entry.escrow);
-  await retireTempoChannelScope(association);
-  return {
-    status: "withdrawn",
-    ...identity,
-    transactionHash: hash,
-    ...withdrawnAmounts
-  };
-}
-function foreignChannelExitError(association, controller, account) {
-  const abandon = [
-    "dvm wallet tempo-exit",
-    shellQuoteArg(association.endpoint),
-    "--credit-id",
-    shellQuoteArg(association.creditId),
-    "--abandon"
-  ].join(" ");
-  return new DvmError(
-    "tempo_wallet_mismatch",
-    `The connected Tempo key ${account.address} is not the wallet recorded for the channel with ${association.endpoint} \u2014 that channel was opened by ${controller.payer}.`,
-    // `--force` is live here and only here among the exit refusals: reaching
-    // this error took a connected `account`, so the reconnect is a replacement
-    // the import refuses without it.
-    `Nothing was signed or broadcast, and the channel's collateral is untouched \u2014 only ${controller.payer} can move it. Reconnect that exact key (${tempoKeyImportRoutes({ replacingConnectedKey: true })}) and retry, or run '${abandon}' to retire the local record. Retiring it discards this machine's only descriptor for that channel, so restoring the key afterwards would no longer recover the collateral; the record blocks nothing while it stands.`,
-    {
-      anchor: "tempo_channel_payer_mismatch",
-      endpoint: association.endpoint,
-      credit_id: association.creditId,
-      channel_id: association.channelId,
-      recorded_payer: controller.payer,
-      recorded_authorized_signer: controller.authorizedSigner,
-      connected_payer: account.address
-    }
-  );
-}
-function tempoExitKeyMissingError() {
-  return new DvmError(
-    "tempo_wallet_missing",
-    "The Tempo key that controls this channel is not connected.",
-    TEMPO_EXIT_KEY_MISSING_HINT
-  );
-}
-async function readTempoChannelState(args) {
-  const entry = await loadTempoChannelEntry(args.association);
-  if (!entry) {
-    throw new DvmError(
-      "tempo_channel_not_found",
-      `The Tempo channel record for credit ${args.association.creditId} has no stored descriptor.`,
-      `That channel can no longer be read or closed from here. Run 'dvm wallet tempo-exit ${args.association.endpoint} --abandon' to retire the unusable local record without broadcasting anything, then retry the wallet change.`
-    );
-  }
-  const rpc = await resolveTempoExitRpc(entry.chainId);
-  const client = args.client ?? await tempoPublicClient(rpc);
-  const chain = args.chain ?? TempoSession2.Precompile.Chain;
-  const state = await guardTempoChannelRead(
-    rpc,
-    () => chain.getChannelState(client, entry.channelId, entry.escrow)
-  );
-  return { entry, state };
-}
-function asTempoReadError(err) {
-  if (err instanceof DvmError) return err;
-  return new DvmError(
-    "tempo_chain_read_failed",
-    `The Tempo channel state could not be read: ${redactUrlsInText(
-      err instanceof Error ? err.message : String(err)
-    )}`
-  );
-}
-function classifyTempoChannelState(entry, state) {
-  if (state.deposit > 0n) return state.closeRequestedAt === 0 ? "open" : "closing";
-  return entry.opened || state.settled > 0n || state.closeRequestedAt !== 0 ? "closed" : "unconfirmed";
-}
-async function guardTempoChannelRead(rpc, run) {
-  try {
-    return await run();
-  } catch (err) {
-    if (err instanceof DvmError) throw err;
-    const cause = redactUrlsInText(err instanceof Error ? err.message : String(err));
-    if (!isTransportFailure(err)) {
-      throw new DvmError(
-        "tempo_chain_read_failed",
-        `The Tempo channel state could not be read: ${cause}`,
-        "This failed on-chain rather than in transit, so changing DVM_TEMPO_RPC_URL will not help. The local channel record was kept; 'dvm wallet tempo-exit <dvm>' re-reads the chain and reports where the channel actually is."
-      );
-    }
-    throw new DvmError(
-      "tempo_rpc_error",
-      `The Tempo channel state could not be read: ${cause}`,
-      rpc.source === "override" ? `DVM_TEMPO_RPC_URL sent this read to ${redactUrl(rpc.url)}. Correct it, or unset it to fall back to Tempo's bundled endpoint, then re-run \u2014 the local channel record was kept until the chain can be read.` : `Verify connectivity to Tempo's bundled endpoint (${redactUrl(rpc.url)}), or send the read somewhere else with DVM_TEMPO_RPC_URL, then re-run \u2014 the local channel record was kept until the chain can be read.`
-    );
-  }
-}
-async function resolveTempoExitRpc(chainId) {
-  const { tempo, tempoModerato } = await import("viem/chains");
-  const chain = chainId === tempo.id ? tempo : chainId === tempoModerato.id ? tempoModerato : null;
-  if (!chain) {
-    throw new DvmError(
-      "tempo_chain_unsupported",
-      `The recorded Tempo channel uses unsupported chain ${String(chainId)}.`
-    );
-  }
-  const { url, source } = resolveRpcOverride(
-    process.env.DVM_TEMPO_RPC_URL,
-    chain.rpcUrls.default.http[0]
-  );
-  return { chain, url, source };
-}
-async function tempoPublicClient(rpc) {
-  const { createPublicClient, http } = await import("viem");
-  const transportOptions = resolveRpcHttpTransportOptions(
-    rpc.source,
-    process.env.DVM_TEMPO_RPC_HEADERS_JSON
-  );
-  return createPublicClient({
-    chain: rpc.chain,
-    transport: transportOptions ? http(rpc.url, transportOptions) : http(rpc.url)
-  });
-}
-async function tempoWalletClient(account, rpc) {
-  const { createWalletClient, http } = await import("viem");
-  const transportOptions = resolveRpcHttpTransportOptions(
-    rpc.source,
-    process.env.DVM_TEMPO_RPC_HEADERS_JSON
-  );
-  return createWalletClient({
-    account: privateKeyToAccount(account.privateKey),
-    chain: rpc.chain,
-    transport: transportOptions ? http(rpc.url, transportOptions) : http(rpc.url)
-  });
-}
-function readSessionDeposit(credential) {
-  let payload;
-  try {
-    payload = Credential.deserialize(credential).payload;
-  } catch {
-    return { depositMicro: 0 };
-  }
-  const action = typeof payload.action === "string" ? payload.action : void 0;
-  if (action === "topUp") {
-    if (typeof payload.additionalDeposit !== "string" || !/^\d+$/.test(payload.additionalDeposit)) {
-      throw unreadableDeposit("top-up");
-    }
-    return { action, depositMicro: depositAsMicro(BigInt(payload.additionalDeposit)) };
-  }
-  if (action !== "open") return { ...action ? { action } : {}, depositMicro: 0 };
-  if (typeof payload.transaction !== "string") throw unreadableDeposit("channel open");
-  let calls = [];
-  try {
-    const deserialized = Transaction.deserialize(payload.transaction);
-    if ("calls" in deserialized && Array.isArray(deserialized.calls)) calls = deserialized.calls;
-  } catch {
-    throw unreadableDeposit("channel open");
-  }
-  for (const call of calls) {
-    if (typeof call.data !== "string") continue;
-    try {
-      const decoded = decodeFunctionData({
-        abi: TempoSession2.Precompile.escrowAbi,
-        data: call.data
-      });
-      if (decoded.functionName !== "open") continue;
-      return { action, depositMicro: depositAsMicro(decoded.args[3]) };
-    } catch {
-      continue;
-    }
-  }
-  throw unreadableDeposit("channel open");
-}
-function unreadableDeposit(leg) {
-  return new DvmError(
-    "tempo_session_deposit_unreadable",
-    `The Tempo session ${leg} credential does not state the deposit it commits.`,
-    "Nothing was sent. Retry the funding; if it recurs, the DVM's session challenge is malformed and its operator should be told."
-  );
-}
-function depositAsMicro(deposit) {
-  if (deposit < 0n || deposit > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new DvmError("payment_invalid", "The Tempo session channel deposit is out of range.");
-  }
-  return Number(deposit);
-}
-var TRANSPORT_ERROR_NAMES = /* @__PURE__ */ new Set([
-  "HttpRequestError",
-  "ResponseBodyTooLargeError",
-  "RpcRequestError",
-  "SocketClosedError",
-  "TimeoutError",
-  "UrlRequiredError",
-  "WebSocketRequestError"
-]);
-var TRANSPORT_ERROR_CODES = /* @__PURE__ */ new Set([
-  "EAI_AGAIN",
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ENOTFOUND",
-  "EPIPE",
-  "ETIMEDOUT"
-]);
-var REVERT_ERROR_NAMES = /* @__PURE__ */ new Set(["ContractFunctionRevertedError", "ExecutionRevertedError"]);
-var EXECUTION_REVERTED_RPC_CODE = 3;
-function isRevertLink(err) {
-  if (REVERT_ERROR_NAMES.has(err.name)) return true;
-  const { code } = err;
-  return code === EXECUTION_REVERTED_RPC_CODE;
-}
-function isTransportLink(err) {
-  if (TRANSPORT_ERROR_NAMES.has(err.name)) return true;
-  const { code } = err;
-  return typeof code === "string" && TRANSPORT_ERROR_CODES.has(code);
-}
-function isTransportFailure(err) {
-  let transport = false;
-  let cursor = err;
-  for (let depth = 0; cursor instanceof Error && depth < 8; depth += 1) {
-    if (isRevertLink(cursor)) return false;
-    transport ||= isTransportLink(cursor);
-    cursor = cursor.cause;
-  }
-  return transport;
-}
-function redactingExitChain(chain, rpc, token) {
-  const guard = async (run) => {
-    try {
-      return await run();
-    } catch (err) {
-      if (err instanceof DvmError) throw err;
-      const cause = redactUrlsInText(err instanceof Error ? err.message : String(err));
-      if (!isTransportFailure(err)) {
-        throw new DvmError(
-          "tempo_exit_failed",
-          `Tempo channel exit failed: ${cause}`,
-          `This failed on-chain rather than in transit, so changing DVM_TEMPO_RPC_URL will not help \u2014 a transaction the escrow rejected reads like this, and so does one this wallet cannot pay for. The exit is caller-paid and Tempo charges its fees in a stablecoin rather than a separate gas token, so check that the wallet holds a spendable balance of ${tempoTokenReference(token)} outside the channel. ${tempoBalanceCheckHint(token)} Then re-run 'dvm wallet tempo-exit' \u2014 it re-reads the chain and resumes from wherever the channel actually is. If it fails the same way with the wallet funded, the escrow is refusing the exit and the channel needs a closer look.`
-        );
-      }
-      throw new DvmError(
-        "tempo_rpc_error",
-        `Tempo channel exit failed: ${cause}`,
-        // Which knob is the caller's to turn depends on whose endpoint this was.
-        rpc.source === "override" ? `DVM_TEMPO_RPC_URL sent this exit to ${redactUrl(rpc.url)}. Correct it, or unset it to fall back to Tempo's bundled endpoint, then re-run 'dvm wallet tempo-exit' \u2014 it re-reads the chain and resumes from wherever the channel actually is.` : `Verify connectivity to Tempo's bundled endpoint (${redactUrl(rpc.url)}), or send the exit somewhere else with DVM_TEMPO_RPC_URL, then re-run 'dvm wallet tempo-exit' \u2014 it re-reads the chain and resumes from wherever the channel actually is.`
-      );
-    }
-  };
-  return {
-    getChannelState: (...args) => guard(() => chain.getChannelState(...args)),
-    requestCloseOnChain: (...args) => guard(() => chain.requestCloseOnChain(...args)),
-    waitForSuccessfulReceipt: (...args) => guard(() => chain.waitForSuccessfulReceipt(...args)),
-    withdrawOnChain: (...args) => guard(() => chain.withdrawOnChain(...args))
-  };
-}
-
-// src/lib/payment-rails/tempo-lifecycle.ts
-async function assertTempoWalletIdle(intent) {
-  const connected = await connectedTempoAccount();
-  if (!connected) return;
-  const records = await ownedTempoChannelRecords(connected.address);
-  const verdicts = await Promise.all(
-    records.map(async (association) => ({
-      association,
-      chain: await reconcileTempoChannelOnChain({ association })
-    }))
-  );
-  let blocker;
-  for (const status of BLOCKING_ORDER) {
-    blocker = verdicts.find((verdict) => verdict.chain.status === status);
-    if (blocker) break;
-  }
-  if (!blocker) return;
-  const blocking = verdicts.filter((verdict) => verdict.chain.status !== "closed").length;
-  throw blocker.chain.status === "unreadable" ? blocker.chain.error?.code === "tempo_channel_not_found" ? descriptorlessChannelError(blocker.association, blocker.chain, intent, blocking) : unreadableChainError(blocker.association, blocker.chain, intent, blocking) : liveChannelError(blocker.association, blocker.chain, intent, blocking);
-}
-async function ownedTempoChannelRecords(address) {
-  const records = listTempoChannelAssociations();
-  const controlled = await Promise.all(
-    records.map(
-      async (association) => tempoChannelControlledBy(
-        await loadTempoChannelController(association).catch(() => void 0),
-        address
-      )
-    )
-  );
-  return records.filter((_, index) => controlled[index]);
-}
-var BLOCKING_ORDER = ["open", "closing", "unconfirmed", "unreadable"];
-function liveChannelError(association, chain, intent, blocking) {
-  const depositMicro = chain.status === "unconfirmed" ? Number(association.deposit) : chain.depositMicro;
-  const amount = `$${formatUsdcMicrounits(BigInt(depositMicro))}`;
-  const message = chain.status === "open" ? `The connected Tempo key still holds ${amount} of collateral in an open channel with ${association.endpoint}.` : chain.status === "closing" ? `The connected Tempo key has ${amount} still escrowed on its channel with ${association.endpoint}, where a close has been requested on-chain and is in its 15-minute grace period.` : `The connected Tempo key signed an open committing ${amount} to a channel with ${association.endpoint} that the escrow has no record of, so that collateral may or may not be locked.`;
-  const caller = findSigningIdentityByPubkey(association.callerPubkey);
-  if (!caller) {
-    return new DvmError(
-      "tempo_channels_active",
-      message,
-      `Only this key can close that channel, but its caller identity (${association.callerPubkey}) is no longer configured. Restore that identity first, then retry the wallet ${intent === "replace" ? "replacement" : "disconnect"}; the key and channel record were left untouched.${remainingClause(blocking)}`,
-      channelData(association, chain, depositMicro, blocking)
-    );
-  }
-  const identityName = caller.source.kind === "env" ? void 0 : caller.source.name;
-  const selectors = { creditId: association.creditId, identityName };
-  const exit = tempoExitCommand(association.endpoint, selectors);
-  const abandon = tempoExitCommand(association.endpoint, selectors, true);
-  const fund = creditCommand("fund", association.endpoint, selectors);
-  const remedy = chain.status === "open" ? (
-    // The endpoint can hold several credits and caller identities. Both
-    // selectors keep every remedy pointed at the channel just named.
-    `Empty the channel first \u2014 '${creditCommand("drain", association.endpoint, selectors)}' for the cooperative exit, or '${exit}' if the DVM is unavailable`
-  ) : chain.status === "closing" ? `'${exit}' withdraws what remains once the grace period ends` : `'${exit}' reads the chain and says which it is, and '${fund}' resumes a funding still pending for it. Once that open is known never to have landed, '${abandon}' retires the record`;
-  return new DvmError(
-    "tempo_channels_active",
-    message,
-    `Only this key can close that channel. ${remedy} \u2014 and ${intentClause(intent)}.${remainingClause(blocking)}`,
-    channelData(association, chain, depositMicro, blocking)
-  );
-}
-function tempoExitCommand(endpoint, selectors, abandon = false) {
-  const parts = [
-    "dvm wallet tempo-exit",
-    shellQuoteArg(endpoint),
-    "--credit-id",
-    shellQuoteArg(selectors.creditId)
-  ];
-  if (selectors.identityName !== void 0) {
-    parts.push("--as", shellQuoteArg(selectors.identityName));
-  }
-  if (abandon) parts.push("--abandon");
-  return parts.join(" ");
-}
-function creditCommand(verb, endpoint, selectors) {
-  const parts = [
-    `dvm credit ${verb}`,
-    shellQuoteArg(endpoint),
-    "--credit-id",
-    shellQuoteArg(selectors.creditId)
-  ];
-  if (selectors.identityName !== void 0) {
-    parts.push("--as", shellQuoteArg(selectors.identityName));
-  }
-  return parts.join(" ");
-}
-function unreadableChainError(association, chain, intent, blocking) {
-  const cause = chain.error;
-  return new DvmError(
-    cause?.code ?? "tempo_chain_read_failed",
-    `The Tempo channel with ${association.endpoint} could not be read, so there is no way to show it is empty: ${cause?.message ?? "the chain read failed"}`,
-    `The Tempo key is untouched, and the local channel record was kept \u2014 it is the only route back to any collateral the escrow does hold. ${cause?.hint ? `${cause.hint} Then ${intentClause(intent)}.` : `Restore the chain read, then ${intentClause(intent)}.`}${remainingClause(blocking)}`,
-    channelData(association, chain, Number(association.deposit), blocking)
-  );
-}
-function descriptorlessChannelError(association, chain, intent, blocking) {
-  const message = `The saved Tempo channel with ${association.endpoint} has no stored descriptor, so its escrow state cannot be read or closed from this machine.`;
-  const data = {
-    ...channelData(association, chain, Number(association.deposit), blocking),
-    anchor: "tempo_channel_descriptor_missing"
-  };
-  const caller = findSigningIdentityByPubkey(association.callerPubkey);
-  if (!caller) {
-    return new DvmError(
-      "tempo_channel_not_found",
-      message,
-      `The caller identity that owns this record (${association.callerPubkey}) is no longer configured. Restore that identity first, then retire the descriptor-less record; the Tempo key and record were left untouched.${remainingClause(blocking)}`,
-      data
-    );
-  }
-  const identityName = caller.source.kind === "env" ? void 0 : caller.source.name;
-  const abandon = tempoExitCommand(
-    association.endpoint,
-    { creditId: association.creditId, identityName },
-    true
-  );
-  return new DvmError(
-    "tempo_channel_not_found",
-    message,
-    `Run '${abandon}' to retire this unusable local record without broadcasting anything, then ${intentClause(intent)}.${remainingClause(blocking)}`,
-    data
-  );
-}
-function channelData(association, chain, depositMicro, blocking) {
-  return {
-    anchor: "tempo_channel_live",
-    endpoint: association.endpoint,
-    credit_id: association.creditId,
-    channel_id: association.channelId,
-    chain_id: association.chainId,
-    chain_status: chain.status,
-    deposit_micro: depositMicro,
-    ...chain.status === "unreadable" ? {} : { settled_micro: chain.settledMicro },
-    // How many records are still in the way, so an agent knows whether clearing
-    // the one named above is the whole job.
-    blocking_channels: blocking
-  };
-}
-function remainingClause(blocking) {
-  return blocking > 1 ? ` ${blocking - 1} other recorded channel${blocking > 2 ? "s" : ""} still ${blocking > 2 ? "block" : "blocks"} this too \u2014 'dvm wallet balance' lists them all with what the escrow says about each.` : "";
-}
-function intentClause(intent) {
-  return intent === "replace" ? "retry the replacement" : "retry 'dvm wallet tempo-disconnect'";
-}
-
-export {
-  TEMPO_CHARGE_PENDING_STALE_MS,
-  withTempoChannelLock,
-  listTempoChannelAssociations,
-  loadTempoChannelAssociation,
-  loadTempoChannelEntry,
-  loadTempoChannelController,
-  tempoChannelControlledBy,
-  tempoChargeCredentialSettleable,
-  recordPendingTempoChargeFunding,
-  loadResumableTempoChargeFunding,
-  listResumableTempoChargeFundings,
-  clearPendingTempoChargeFunding,
-  shellQuoteArg,
-  isPaymentRailKey,
-  fundingRailLabel,
-  paymentRailLabel,
-  probeRailLabel,
-  railLabelAtSentenceStart,
-  rpcEndpointSuffix,
-  rpcEndpointLine,
-  unreachableRailDisplay,
-  nwcRejectionDisplay,
-  unreachableRailHint,
-  tempoKeyImportRoutes,
-  TEMPO_EXIT_KEY_MISSING_HINT,
-  IDENTITIES_VERSION,
-  identitiesFileExists,
-  loadIdentities,
-  saveIdentities,
-  withIdentitiesLock,
-  generateIdentity,
-  deriveIdentityFromPrivkey,
-  resolveSigningIdentity,
-  findSigningIdentityByPubkey,
-  assertTempoWalletIdle,
-  offersTempoCreditSession,
-  offersTempoCreditCharge,
-  withholdsTempoCreditSession,
-  offersTempoCreditFunding,
-  createTempoCreditSession,
-  createTempoSessionPaymentFetch,
-  tempoSessionChallengeChannelScope,
-  tempoSessionCredentialChannelScope,
-  tempoSessionAssociationByKey,
-  tempoSessionPriorCumulativeMicro,
-  tempoSessionCumulativeCapMicro,
-  assertTempoSessionDepositWithinCap,
-  assertTempoSessionChallengeWithinAsk,
-  tempoSessionCredentialCumulativeMicro,
-  assertTempoSessionVoucherWithinAsk,
-  persistTempoOpenCredential,
-  tempoSessionChallenge,
-  tempoSessionChallengeMicro,
-  createTempoCloseCredential,
-  advanceTempoChannelExit,
-  reconcileTempoChannelOnChain
-};