@dvmkit/sdk 0.1.0-rc.2 → 0.1.0-rc.3

package/dist/chunk-YD3TZNXV.js

@@ -0,0 +1,1042 @@
+import {
+  fundingReachableAt,
+  isValidEvmPrivateKey,
+  listCredits,
+  loadConfig,
+  maxAdvertisedMicro,
+  normalizeCreditEndpoint,
+  withinAdvertisedTolerance
+} from "./chunk-FT7IM66W.js";
+import {
+  DvmError,
+  IDENTITIES_FILE,
+  TEMPO_CHANNELS_FILE,
+  costAnchor,
+  ensureConfigDir,
+  formatUsd,
+  resolveRpcHttpTransportOptions,
+  resolveRpcOverride
+} from "./chunk-5SO7ZVOH.js";
+import {
+  redactUrl,
+  redactUrlsInText
+} from "./chunk-FUJ36YDV.js";
+
+// src/lib/payment-rails/tempo-channel-store.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { Session as TempoSession } from "mppx/tempo";
+import lockfile 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 lockfile.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 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 = lockfile.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 (existsSync(TEMPO_CHANNELS_FILE)) return;
+  try {
+    writeFileSync(TEMPO_CHANNELS_FILE, `${JSON.stringify(emptyFile(), null, 2)}
+`, {
+      mode: 384,
+      flag: "wx"
+    });
+  } catch {
+  }
+}
+function loadFile() {
+  if (!existsSync(TEMPO_CHANNELS_FILE)) return emptyFile();
+  try {
+    const parsed = JSON.parse(readFileSync(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 internal-review 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`;
+  writeFileSync(tmp, JSON.stringify(file, null, 2) + "\n", { mode: 384 });
+  renameSync(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/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/cli-identity-store.ts
+import { schnorr } from "@noble/curves/secp256k1.js";
+import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import lockfile2 from "proper-lockfile";
+var IDENTITIES_VERSION = 1;
+function loadIdentities() {
+  if (!existsSync2(IDENTITIES_FILE)) return null;
+  const raw = readFileSync2(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 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 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;
+}
+
+// src/lib/payment-rails/tempo-wallet.ts
+var TEMPO_CHAIN_ID = 4217;
+async function connectedTempoAccount() {
+  const config = loadConfig();
+  return tempoAccountFromConfig(config);
+}
+async function deriveTempoAddress(privateKey) {
+  if (!isValidEvmPrivateKey(privateKey)) throw invalidTempoPrivateKey();
+  const { privateKeyToAccount: privateKeyToAccount2 } = await import("viem/accounts");
+  return privateKeyToAccount2(privateKey).address.toLowerCase();
+}
+async function tempoAccountFromConfig(config) {
+  if (config?.tempo?.method !== "tempo") return null;
+  const apiKey = config.tempo.apiKey;
+  if (!apiKey || !isValidEvmPrivateKey(apiKey)) return null;
+  const privateKey = apiKey;
+  const address = await deriveTempoAddress(privateKey);
+  return { privateKey, address };
+}
+function invalidTempoPrivateKey() {
+  return new DvmError(
+    "invalid_api_key",
+    "A Tempo private key must be a valid 0x-prefixed 32-byte hex secp256k1 private key.",
+    "Generate one with `cast wallet new` or `openssl rand -hex 32` (and prepend 0x)."
+  );
+}
+
+// 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/wallet-rail-copy.ts
+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.`;
+
+// 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 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 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)
+  });
+}
+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;
+}
+
+export {
+  TEMPO_CHARGE_PENDING_STALE_MS,
+  withTempoChannelLock,
+  listTempoChannelAssociations,
+  loadTempoChannelAssociation,
+  loadTempoChannelEntry,
+  loadTempoChannelController,
+  tempoChannelControlledBy,
+  tempoChargeCredentialSettleable,
+  recordPendingTempoChargeFunding,
+  loadResumableTempoChargeFunding,
+  listResumableTempoChargeFundings,
+  clearPendingTempoChargeFunding,
+  shellQuoteArg,
+  findSigningIdentityByPubkey,
+  TEMPO_CHAIN_ID,
+  connectedTempoAccount,
+  offersTempoCreditSession,
+  offersTempoCreditCharge,
+  withholdsTempoCreditSession,
+  offersTempoCreditFunding,
+  createTempoCreditSession,
+  createTempoSessionPaymentFetch,
+  tempoSessionChallengeChannelScope,
+  tempoSessionCredentialChannelScope,
+  tempoSessionAssociationByKey,
+  tempoSessionPriorCumulativeMicro,
+  tempoSessionCumulativeCapMicro,
+  assertTempoSessionDepositWithinCap,
+  assertTempoSessionChallengeWithinAsk,
+  tempoSessionCredentialCumulativeMicro,
+  assertTempoSessionVoucherWithinAsk,
+  persistTempoOpenCredential,
+  tempoSessionChallenge,
+  reconcileTempoChannelOnChain
+};