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

package/dist/{chunk-OQA7IHI4.js → chunk-OBBVDKLE.js}

@@ -1,34 +1,15 @@
-import {
-  computeResultHash,
-  costAnchor,
-  formatUsd,
-  isDrainReceipt,
-  isFundingReceipt,
-  msatsToUsd,
-  verifyDrainReceipt,
-  verifyFundingReceipt,
-  verifyReceipt
-} from "./chunk-PAIM66YA.js";
-import {
-  AGENT_MNEMONIC_FILE,
-  BUILDER_CONFIG_DIR,
-  BUILDER_FILE,
-  BUILDER_KEY_FILE,
-  WALLET_FILE,
-  ensureConfigDir
-} from "./chunk-CZULM42S.js";
 import {
   canonicaliseForSigning
-} from "./chunk-OFVV37XC.js";
+} from "./chunk-UKD3R2KU.js";
 import {
   callerLoggers
 } from "./chunk-66HGCPBU.js";
 import {
   DvmError
-} from "./chunk-LIRAHP7B.js";
+} from "./chunk-BPYMEMQX.js";
 import {
   diagnosticConsole
-} from "./chunk-ETXDTUJO.js";
+} from "./chunk-ZCNPIILZ.js";
 
 // src/lib/cashu/lock-pubkey.ts
 function toLockPubkey(raw) {
@@ -40,45 +21,257 @@ function isX402SettlementReconciliationReason(value) {
   return value === "settlement_not_on_chain" || value === "chain_unreachable" || value === "settlement_unbookmarked" || value === "facilitator_channel_state_unavailable";
 }
 
-// src/lib/mints.ts
-var RECOMMENDED_MINTS = [
-  {
-    name: "Coinos",
-    description: "Primary Cashu mint accepted by dvmkit DVMs",
-    url: "https://mint.coinos.io"
-  },
-  {
-    name: "Voltz Mint",
-    description: "Fallback Cashu mint accepted by dvmkit DVMs",
-    url: "https://mint.lnvoltz.com"
+// src/lib/credit-implicit.ts
+var IMPLICIT_CREDIT_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// src/lib/payment-rails/tempo-wire.ts
+var TEMPO_SESSION_UPDATED_REASON = "Tempo session updated; attach the next voucher to fund this credit.";
+
+// src/defaults.ts
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = process.env.DVM_CONFIG_DIR ?? join(homedir(), ".dvm");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var CONFIG_BACKUP_FILE = join(CONFIG_DIR, "config.json.bak");
+var CONFIG_AUDIT_FILE = join(CONFIG_DIR, "config-audit.jsonl");
+var CONFIG_PINNED_FILE = join(CONFIG_DIR, "config.json.pinned");
+var JOBS_FILE = join(CONFIG_DIR, "jobs.json");
+var REQUEST_INTENTS_DIR = join(CONFIG_DIR, "request-intents");
+var FAVORITES_FILE = join(CONFIG_DIR, "favorites.json");
+var MESSAGES_DIR = join(CONFIG_DIR, "messages");
+var RECEIPTS_FILE = join(CONFIG_DIR, "receipts.jsonl");
+var CREDITS_FILE = join(CONFIG_DIR, "credits.json");
+var X402_CHANNELS_FILE = join(CONFIG_DIR, "x402-channels.json");
+var TEMPO_CHANNELS_FILE = join(CONFIG_DIR, "tempo-channels.json");
+var FEEDBACK_NUDGES_FILE = join(CONFIG_DIR, "feedback-nudges.json");
+var RECOVERY_MNEMONIC_FILE = join(CONFIG_DIR, "recovery.mnemonic");
+var WALLET_FILE = join(CONFIG_DIR, "wallet.json");
+var AGENT_MNEMONIC_FILE = join(CONFIG_DIR, "wallet.mnemonic");
+var IDENTITIES_FILE = join(CONFIG_DIR, "identities.json");
+var PAIRINGS_DIR = join(CONFIG_DIR, "pairings");
+var BUDGET_FILE = join(CONFIG_DIR, "budget.json");
+var BTC_RATE_FILE = join(CONFIG_DIR, "btc-rate.json");
+var ADMIN_DIR = join(CONFIG_DIR, "admin");
+var PROXY_STATE_FILE = join(ADMIN_DIR, "proxy.json");
+var BUILDER_CONFIG_DIR = process.env.DVMKIT_CONFIG_DIR ?? join(homedir(), ".dvmkit");
+var BUILDER_FILE = join(BUILDER_CONFIG_DIR, "builder.json");
+var BUILDER_MNEMONIC_FILE = join(BUILDER_CONFIG_DIR, "recovery.mnemonic");
+var BUILDER_KEY_FILE = join(BUILDER_CONFIG_DIR, "builder.key");
+var MELT_PENDING_LOG_FILE = join(BUILDER_CONFIG_DIR, "melt-pending.log");
+var DRAIN_PARK_LOG_FILE = join(BUILDER_CONFIG_DIR, "drain-park.log");
+var DRAIN_HOLD_STATE_FILE = join(BUILDER_CONFIG_DIR, "drain-hold.json");
+var MELT_SUCCESS_FILE = join(BUILDER_CONFIG_DIR, "melt-success.json");
+
+// src/lib/config-dir.ts
+import { chmodSync, mkdirSync, statSync } from "fs";
+var CONFIG_DIR_MODE = 448;
+function ensureConfigDir() {
+  ensureConfigSubdir(CONFIG_DIR);
+}
+function ensureConfigSubdir(path) {
+  mkdirSync(path, { recursive: true, mode: CONFIG_DIR_MODE });
+}
+function repairConfigDirMode() {
+  const base = {
+    path: CONFIG_DIR,
+    exists: false,
+    modeOctal: null,
+    repaired: false,
+    skippedNonPosix: process.platform === "win32"
+  };
+  if (base.skippedNonPosix) return base;
+  let mode;
+  try {
+    mode = statSync(CONFIG_DIR).mode & 511;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const missing = err.code === "ENOENT";
+    return missing ? base : { ...base, error: message };
   }
-];
-function isTestMintUrl(url) {
-  let host;
+  if ((mode & 63) === 0) {
+    return { ...base, exists: true, modeOctal: toOctal(mode) };
+  }
+  try {
+    chmodSync(CONFIG_DIR, CONFIG_DIR_MODE);
+  } catch (err) {
+    return {
+      ...base,
+      exists: true,
+      modeOctal: toOctal(mode),
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return {
+    ...base,
+    exists: true,
+    modeOctal: toOctal(CONFIG_DIR_MODE),
+    previousModeOctal: toOctal(mode),
+    repaired: true
+  };
+}
+function toOctal(mode) {
+  return "0" + mode.toString(8).padStart(3, "0");
+}
+
+// src/lib/fx-coingecko.ts
+var COINGECKO_SIMPLE_PRICE_URL = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,usd-coin&vs_currencies=usd";
+var COINGECKO_BTC_USD_URL = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_USER_AGENT = "dvmkit-platform/1.0 (+https://dvmkit.com)";
+async function fetchCoinGeckoSpot(opts) {
+  const body = await fetchCoinGeckoBody(opts, COINGECKO_SIMPLE_PRICE_URL);
+  const btc = body.bitcoin?.usd;
+  const usdc = body["usd-coin"]?.usd;
+  if (!isPositiveNumber(btc)) {
+    throw new Error("coingecko response missing bitcoin.usd");
+  }
+  if (!isPositiveNumber(usdc)) {
+    throw new Error("coingecko response missing usd-coin.usd");
+  }
+  return { btc_usd: btc, usdc_usd: usdc, as_of: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function fetchCoinGeckoBtcUsd(opts) {
+  const body = await fetchCoinGeckoBody(opts, COINGECKO_BTC_USD_URL);
+  const btc = body.bitcoin?.usd;
+  if (!isPositiveNumber(btc)) {
+    throw new Error("coingecko response missing bitcoin.usd");
+  }
+  return { btc_usd: btc, as_of: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function fetchCoinGeckoBody(opts, defaultUrl) {
+  const url = opts?.url ?? defaultUrl;
+  const fetchImpl = opts?.fetchImpl ?? fetch;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const userAgent = opts?.userAgent ?? DEFAULT_USER_AGENT;
+  const res = await fetchImpl(url, {
+    headers: { "User-Agent": userAgent, Accept: "application/json" },
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    throw new Error(`coingecko returned HTTP ${res.status.toString()}`);
+  }
+  return await res.json();
+}
+function isPositiveNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+
+// src/lib/currency.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var COST_ANCHOR_BANDS = {
+  usd: [0.01, 0.1, 1, 10],
+  eur: [0.01, 0.1, 1, 10],
+  gbp: [0.01, 0.1, 1, 10],
+  jpy: [1, 10, 100, 1500]
+};
+function costAnchor(amount, currency = "usd") {
+  const bands = COST_ANCHOR_BANDS[currency] ?? COST_ANCHOR_BANDS.usd;
+  if (amount < bands[0]) return "fraction of a cent";
+  if (amount <= bands[1]) return "comparable to an API call";
+  if (amount <= bands[2]) return "comparable to a ChatGPT query";
+  if (amount <= bands[3]) return "comparable to a coffee";
+  return "significant purchase \u2014 review carefully";
+}
+function formatUsd(usd) {
+  if (usd === 0) return "0.00";
+  if (usd >= 0.01) return usd.toFixed(2);
+  const digits = Math.max(2, -Math.floor(Math.log10(usd)) + 1);
+  return usd.toFixed(digits);
+}
+function formatUsdcMicrounits(microunits) {
+  const value = typeof microunits === "bigint" ? microunits : BigInt(microunits);
+  const whole = value / 1000000n;
+  const fraction = (value % 1000000n).toString().padStart(6, "0").replace(/0+$/, "");
+  return `${whole}.${fraction.padEnd(2, "0") || "00"}`;
+}
+async function fetchBtcUsdRate() {
+  if (memRate && Date.now() - memTime < CACHE_TTL) {
+    return memRate;
+  }
+  const disk = readDiskCache();
+  if (disk) {
+    memRate = disk;
+    memTime = Date.now();
+    return disk;
+  }
+  const rate = await fetchFromApi();
+  memRate = rate;
+  memTime = Date.now();
+  writeDiskCache(rate);
+  return rate;
+}
+function getLastKnownBtcRate() {
+  if (memRate && memTime > 0) return { rate: memRate, cachedAt: memTime };
+  return readDiskCacheStale();
+}
+function formatStaleness(cachedAt, now = Date.now()) {
+  const ageMs = Math.max(0, now - cachedAt);
+  const seconds = Math.floor(ageMs / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const days = Math.floor(hours / 24);
+  return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+var CACHE_TTL = 5 * 60 * 1e3;
+var CACHE_FILE = BTC_RATE_FILE;
+var memRate = null;
+var memTime = 0;
+function readDiskCache() {
   try {
-    host = new URL(url).hostname.toLowerCase();
+    if (!existsSync(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    if (Date.now() - data.timestamp >= CACHE_TTL) return null;
+    if (!isPlausibleBtcUsdRate(data.rate)) return null;
+    return data.rate;
   } catch {
-    return false;
+    return null;
+  }
+}
+function readDiskCacheStale() {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    if (!isPlausibleBtcUsdRate(data.rate)) return null;
+    return { rate: data.rate, cachedAt: data.timestamp };
+  } catch {
+    return null;
+  }
+}
+function writeDiskCache(rate) {
+  try {
+    ensureConfigSubdir(dirname(CACHE_FILE));
+    writeFileSync(CACHE_FILE, JSON.stringify({ rate, timestamp: Date.now() }));
+  } catch {
+  }
+}
+var MAX_PLAUSIBLE_BTC_USD = 1e7;
+function isPlausibleBtcUsdRate(rate) {
+  return typeof rate === "number" && Number.isFinite(rate) && rate > 0 && rate < MAX_PLAUSIBLE_BTC_USD;
+}
+async function fetchFromApi() {
+  const spot = await fetchCoinGeckoBtcUsd();
+  const rate = spot.btc_usd;
+  if (!isPlausibleBtcUsdRate(rate)) {
+    throw new Error(`implausible BTC/USD rate from upstream: ${String(rate)}`);
   }
-  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
-  if (LOOPBACK_HOSTS.has(host)) return true;
-  if (host.endsWith(".localhost")) return true;
-  return TEST_MINT_HOSTS.has(host);
+  return rate;
 }
-var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1"]);
-var TEST_MINT_HOSTS = /* @__PURE__ */ new Set(["testnut.cashu.space", "dvmkit-testmint.fly.dev"]);
 
 // src/lib/secret-backup.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 function backupSecretFile(file, nextContent) {
-  const content = existsSync(file) ? readFileSync(file) : null;
+  const content = existsSync2(file) ? readFileSync2(file) : null;
   if (content === null) return null;
   if (content.toString("utf-8").trim() === nextContent?.trim()) return null;
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   for (let n = 0; n < 100; n++) {
     const backup = n === 0 ? `${file}.${stamp}.bak` : `${file}.${stamp}-${String(n)}.bak`;
     try {
-      writeFileSync(backup, content, { mode: 384, flag: "wx" });
+      writeFileSync2(backup, content, { mode: 384, flag: "wx" });
       return backup;
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
@@ -89,20 +282,20 @@ function backupSecretFile(file, nextContent) {
 
 // src/lib/wallet-agent/agent-mnemonic-file.ts
 import {
-  chmodSync,
-  existsSync as existsSync2,
-  readFileSync as readFileSync2,
+  chmodSync as chmodSync2,
+  existsSync as existsSync3,
+  readFileSync as readFileSync3,
   renameSync,
   unlinkSync,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "fs";
 function readAgentMnemonic() {
-  if (!existsSync2(AGENT_MNEMONIC_FILE)) return null;
-  const raw = readFileSync2(AGENT_MNEMONIC_FILE, "utf-8");
+  if (!existsSync3(AGENT_MNEMONIC_FILE)) return null;
+  const raw = readFileSync3(AGENT_MNEMONIC_FILE, "utf-8");
   return raw.trim().toLowerCase().split(/\s+/).join(" ");
 }
 function assertAgentMnemonicReplaceable(opts = {}) {
-  if (existsSync2(AGENT_MNEMONIC_FILE) && !opts.force) {
+  if (existsSync3(AGENT_MNEMONIC_FILE) && !opts.force) {
     throw new DvmError(
       "agent_mnemonic_exists",
       `An agent wallet recovery mnemonic already exists at ${AGENT_MNEMONIC_FILE}.`,
@@ -116,7 +309,7 @@ function writeAgentMnemonic(mnemonic, opts = {}) {
   ensureConfigDir();
   const backupFile = backupSecretFile(AGENT_MNEMONIC_FILE, normalised);
   const tmp = `${AGENT_MNEMONIC_FILE}.tmp`;
-  writeFileSync2(tmp, normalised + "\n", { mode: 384 });
+  writeFileSync3(tmp, normalised + "\n", { mode: 384 });
   try {
     renameSync(tmp, AGENT_MNEMONIC_FILE);
   } catch (err) {
@@ -127,13 +320,13 @@ function writeAgentMnemonic(mnemonic, opts = {}) {
     throw err;
   }
   try {
-    chmodSync(AGENT_MNEMONIC_FILE, 384);
+    chmodSync2(AGENT_MNEMONIC_FILE, 384);
   } catch {
   }
   return { backupFile };
 }
 function deleteAgentMnemonic() {
-  if (!existsSync2(AGENT_MNEMONIC_FILE)) return { backupFile: null };
+  if (!existsSync3(AGENT_MNEMONIC_FILE)) return { backupFile: null };
   const backupFile = backupSecretFile(AGENT_MNEMONIC_FILE);
   unlinkSync(AGENT_MNEMONIC_FILE);
   return { backupFile };
@@ -195,7 +388,7 @@ function mnemonicFingerprint(mnemonic) {
 }
 
 // src/lib/wallet-agent/store.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
 import lockfile from "proper-lockfile";
 var LOCK_FILE = `${WALLET_FILE}.lock`;
 var DEFAULT_LOCK_STALE_MS = 3e4;
@@ -204,9 +397,22 @@ var DEFAULT_LOCK_RETRY_INTERVAL_MS = 1e3;
 var WALLET_VERSION = 9;
 var RECENT_SPENDS_CAP = 10;
 var DEFAULT_AGENT_MINT_URL = "https://mint.coinos.io";
+var MAX_STORABLE_JOB_ID_LENGTH = 512;
+function isStorableJobId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_STORABLE_JOB_ID_LENGTH && // eslint-disable-next-line no-control-regex -- control characters are what this rejects
+  !/[\u0000-\u001f\u007f-\u009f]/u.test(value);
+}
+function loadWalletConfiguredMints() {
+  return loadAgentWallet()?.mints ?? [];
+}
 function loadAgentWallet() {
-  if (!existsSync3(WALLET_FILE)) return null;
-  const raw = readFileSync3(WALLET_FILE, "utf-8");
+  const wallet = parseAgentWallet();
+  if (wallet) normalizeAcceptedUnresolved(wallet);
+  return wallet;
+}
+function parseAgentWallet() {
+  if (!existsSync4(WALLET_FILE)) return null;
+  const raw = readFileSync4(WALLET_FILE, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -285,10 +491,11 @@ function loadAgentWallet() {
   return parsed;
 }
 function saveAgentWallet(wallet) {
+  assertAcceptedUnresolvedStorable(wallet);
   ensureConfigDir();
   const tmp = `${WALLET_FILE}.tmp`;
   const data = JSON.stringify(wallet, null, 2) + "\n";
-  writeFileSync3(tmp, data, { mode: 384 });
+  writeFileSync4(tmp, data, { mode: 384 });
   try {
     renameSync2(tmp, WALLET_FILE);
   } catch (err) {
@@ -300,7 +507,7 @@ function saveAgentWallet(wallet) {
   }
 }
 function walletExists() {
-  return existsSync3(WALLET_FILE);
+  return existsSync4(WALLET_FILE);
 }
 async function withWalletLock(fn, opts = {}) {
   ensureConfigDir();
@@ -453,6 +660,62 @@ function migrateV8ToV9(parsed) {
     created_at: typeof parsed.created_at === "string" ? parsed.created_at : (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+var ACCEPTED_UNRESOLVED_KINDS = /* @__PURE__ */ new Set([
+  "identity_mismatch",
+  "body_unreadable",
+  "router_identity_conflict"
+]);
+var OBSERVED_JOB_ID_FIELDS = ["header_job_id", "body_job_id", "accepted_job_id"];
+var PLACEHOLDER_KIND = "body_unreadable";
+var PLACEHOLDER_OBSERVED_AT = (/* @__PURE__ */ new Date(0)).toISOString();
+function assertAcceptedUnresolvedStorable(wallet) {
+  const entries = wallet.pending_submissions;
+  if (!Array.isArray(entries)) return;
+  for (const entry of entries) {
+    const record = entry?.accepted_unresolved;
+    if (record === void 0 || isStorableAcceptedUnresolved(record)) continue;
+    throw new DvmError(
+      "accepted_unresolved_invalid",
+      `Refusing to save pending submission ${String(entry?.request_id)}: its accepted_unresolved record is outside the stored contract.`,
+      "Use one of the three kinds, an ISO-8601 observed_at, and job IDs and ambiguity_id that pass isStorableJobId; omit an observed ID that does not. The wallet file was not changed."
+    );
+  }
+}
+function isStorableAcceptedUnresolved(value) {
+  if (!isPlainRecord(value)) return false;
+  return ACCEPTED_UNRESOLVED_KINDS.has(value.kind) && isIsoTimestamp(value.observed_at) && isStorableJobId(value.ambiguity_id) && OBSERVED_JOB_ID_FIELDS.every((field) => value[field] === void 0 || isStorableJobId(value[field]));
+}
+function normalizeAcceptedUnresolved(wallet) {
+  const entries = wallet.pending_submissions;
+  if (!Array.isArray(entries)) return;
+  for (const entry of entries) {
+    if (!entry || entry.accepted_unresolved === void 0) continue;
+    const stored = entry.accepted_unresolved;
+    if (isStorableAcceptedUnresolved(stored)) continue;
+    const record = isPlainRecord(stored) ? { ...stored } : {};
+    if (!ACCEPTED_UNRESOLVED_KINDS.has(record.kind)) record.kind = PLACEHOLDER_KIND;
+    if (!isIsoTimestamp(record.observed_at)) record.observed_at = PLACEHOLDER_OBSERVED_AT;
+    if (!isStorableJobId(record.ambiguity_id)) {
+      record.ambiguity_id = isStorableJobId(entry.request_id) ? entry.request_id : "missing-ambiguity";
+    }
+    for (const field of OBSERVED_JOB_ID_FIELDS) {
+      if (record[field] !== void 0 && !isStorableJobId(record[field])) delete record[field];
+    }
+    entry.accepted_unresolved = record;
+  }
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var ISO_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d{1,9})?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+function isIsoTimestamp(value) {
+  if (typeof value !== "string") return false;
+  const match = ISO_TIMESTAMP.exec(value);
+  if (!match) return false;
+  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
 function isCounterMap(value) {
   if (typeof value !== "object" || value === null) return false;
   for (const inner of Object.values(value)) {
@@ -1059,36 +1322,47 @@ function buildAdminAuthHeader(args) {
   };
 }
 
+// src/lib/job-identity-header.ts
+var JOB_IDENTITY_HEADER = "dvm-job-identity-v1";
+var JOB_IDENTITY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+function isJobIdentityValue(value) {
+  return typeof value === "string" && JOB_IDENTITY_PATTERN.test(value);
+}
+function parseJobIdentityHeader(value) {
+  if (value === null) return { kind: "absent" };
+  return isJobIdentityValue(value) ? { kind: "valid", jobId: value } : { kind: "invalid" };
+}
+
 // src/lib/builder-identity.ts
 import {
-  chmodSync as chmodSync3,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync5,
+  chmodSync as chmodSync4,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync6,
   renameSync as renameSync4,
-  statSync,
+  statSync as statSync2,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
 import { schnorr as schnorr3 } from "@noble/curves/secp256k1.js";
 import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 
 // src/lib/builder-store.ts
 import {
-  chmodSync as chmodSync2,
-  existsSync as existsSync4,
-  mkdirSync,
-  readFileSync as readFileSync4,
+  chmodSync as chmodSync3,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync5,
   renameSync as renameSync3,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 var CURRENT_VERSION = 2;
 function loadBuilderStore() {
-  if (!existsSync4(BUILDER_FILE)) {
+  if (!existsSync5(BUILDER_FILE)) {
     return { version: CURRENT_VERSION, dvms: {} };
   }
-  const raw = readFileSync4(BUILDER_FILE, "utf-8");
+  const raw = readFileSync5(BUILDER_FILE, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -1124,7 +1398,7 @@ function loadIdentityPubkey() {
   return loadBuilderStore().identity_pubkey ?? null;
 }
 function setIdentityPubkey(pubkey) {
-  mkdirSync(BUILDER_CONFIG_DIR, { recursive: true, mode: 448 });
+  mkdirSync2(BUILDER_CONFIG_DIR, { recursive: true, mode: 448 });
   const store = loadBuilderStore();
   store.identity_pubkey = pubkey;
   writeBuilderStore(store);
@@ -1134,7 +1408,7 @@ function writeBuilderStore(store) {
   backupSecretFile(BUILDER_FILE, content);
   const tmp = `${BUILDER_FILE}.tmp`;
   try {
-    writeFileSync4(tmp, content, { mode: 384 });
+    writeFileSync5(tmp, content, { mode: 384 });
     renameSync3(tmp, BUILDER_FILE);
   } catch (err) {
     try {
@@ -1144,7 +1418,7 @@ function writeBuilderStore(store) {
     throw err;
   }
   try {
-    chmodSync2(BUILDER_FILE, 384);
+    chmodSync3(BUILDER_FILE, 384);
   } catch {
   }
 }
@@ -1180,9 +1454,9 @@ function generateIdentity() {
   return { pubkey: bytesToHex4(publicKey), secret: bytesToHex4(secretKey) };
 }
 function loadIdentitySecret() {
-  if (!existsSync5(BUILDER_KEY_FILE)) return null;
+  if (!existsSync6(BUILDER_KEY_FILE)) return null;
   warnAndTightenLooseKeyMode();
-  const raw = readFileSync5(BUILDER_KEY_FILE, "utf-8").trim();
+  const raw = readFileSync6(BUILDER_KEY_FILE, "utf-8").trim();
   if (!/^[0-9a-f]{64}$/.test(raw)) {
     throw new DvmError(
       "identity_secret_malformed",
@@ -1201,9 +1475,9 @@ function writeIdentity(keypair, opts = {}) {
       "Pass --force to overwrite. Any DVMs deployed under the old key will need to be re-deployed to refresh their /v1/info attestation."
     );
   }
-  mkdirSync2(BUILDER_CONFIG_DIR, { recursive: true, mode: 448 });
+  mkdirSync3(BUILDER_CONFIG_DIR, { recursive: true, mode: 448 });
   const tmp = `${BUILDER_KEY_FILE}.tmp`;
-  writeFileSync5(tmp, keypair.secret + "\n", { mode: 384 });
+  writeFileSync6(tmp, keypair.secret + "\n", { mode: 384 });
   try {
     renameSync4(tmp, BUILDER_KEY_FILE);
   } catch (err) {
@@ -1214,7 +1488,7 @@ function writeIdentity(keypair, opts = {}) {
     throw err;
   }
   try {
-    chmodSync3(BUILDER_KEY_FILE, 384);
+    chmodSync4(BUILDER_KEY_FILE, 384);
   } catch {
   }
   setIdentityPubkey(keypair.pubkey);
@@ -1248,7 +1522,7 @@ function verifyAttestation(payload, signatureHex, pubkeyHex) {
 function warnAndTightenLooseKeyMode() {
   if (process.platform === "win32") return;
   try {
-    const mode = statSync(BUILDER_KEY_FILE).mode & 511;
+    const mode = statSync2(BUILDER_KEY_FILE).mode & 511;
     if ((mode & 63) === 0) return;
     diagnosticConsole.warn(
       {
@@ -1259,7 +1533,7 @@ function warnAndTightenLooseKeyMode() {
         mode: mode.toString(8).padStart(3, "0")
       }
     );
-    chmodSync3(BUILDER_KEY_FILE, 384);
+    chmodSync4(BUILDER_KEY_FILE, 384);
   } catch {
   }
 }
@@ -1279,6 +1553,82 @@ function hexToBytes4(hex) {
   return out;
 }
 
+// src/lib/receipt.ts
+import { schnorr as schnorr4 } from "@noble/curves/secp256k1.js";
+import { sha256 as sha2564 } from "@noble/hashes/sha2.js";
+import { bytesToHex as bytesToHex5, hexToBytes as hexToBytes5 } from "@noble/hashes/utils.js";
+function computeResultHash(summary, artifactContents) {
+  const artifactHashes = artifactContents.map(
+    (content) => bytesToHex5(sha2564(canonicaliseForSigning(content)))
+  );
+  return bytesToHex5(
+    sha2564(
+      canonicaliseForSigning({
+        summary: summary ?? null,
+        artifact_hashes: artifactHashes
+      })
+    )
+  );
+}
+function signReceipt(unsigned, secretHex) {
+  const bytes = canonicaliseForSigning(unsigned);
+  const signature = bytesToHex5(schnorr4.sign(bytes, hexToBytes5(secretHex)));
+  return { ...unsigned, signature };
+}
+function verifyReceipt(receipt) {
+  try {
+    const { signature, ...unsigned } = receipt;
+    const bytes = canonicaliseForSigning(unsigned);
+    return schnorr4.verify(hexToBytes5(signature), bytes, hexToBytes5(receipt.receipt_pubkey));
+  } catch {
+    return false;
+  }
+}
+function isSignedJobReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const r = value;
+  const paid = r.paid;
+  return r.v === 1 && typeof r.job_id === "string" && typeof r.dvm_id === "string" && typeof r.dvm === "string" && typeof r.capability === "string" && (r.outcome === "completed" || r.outcome === "failed" || r.outcome === "cancelled") && typeof r.seq === "number" && typeof r.issued_at === "number" && typeof r.receipt_pubkey === "string" && typeof r.signature === "string" && !!paid && typeof paid === "object" && !Array.isArray(paid) && typeof paid.msats === "number";
+}
+function signDrainReceipt(unsigned, secretHex) {
+  const bytes = canonicaliseForSigning(unsigned);
+  const signature = bytesToHex5(schnorr4.sign(bytes, hexToBytes5(secretHex)));
+  return { ...unsigned, signature };
+}
+function signFundingReceipt(unsigned, secretHex) {
+  const bytes = canonicaliseForSigning(unsigned);
+  const signature = bytesToHex5(schnorr4.sign(bytes, hexToBytes5(secretHex)));
+  return { ...unsigned, signature };
+}
+function isFundingReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const r = value;
+  return r.v === 1 && r.kind === "credit_funding" && typeof r.credit_id === "string" && typeof r.fund_id === "string" && typeof r.funded_micro === "number" && typeof r.balance_after_micro === "number" && typeof r.ledger_seq === "number" && typeof r.issued_at === "number" && typeof r.caller_pubkey === "string" && typeof r.dvm_id === "string" && typeof r.dvm === "string" && typeof r.receipt_pubkey === "string" && typeof r.signature === "string";
+}
+function verifyFundingReceipt(receipt) {
+  try {
+    const { signature, ...unsigned } = receipt;
+    const bytes = canonicaliseForSigning(unsigned);
+    return schnorr4.verify(hexToBytes5(signature), bytes, hexToBytes5(receipt.receipt_pubkey));
+  } catch {
+    return false;
+  }
+}
+function isDrainReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const r = value;
+  return r.v === 1 && r.kind === "credit_drain" && typeof r.credit_id === "string" && typeof r.drain_id === "string" && (r.event === "requested" || r.event === "parked" || r.event === "picked_up" || r.event === "sent" || r.event === "released") && typeof r.method === "string" && typeof r.amount_micro === "number" && typeof r.issued_at === "number" && typeof r.caller_pubkey === "string" && typeof r.dvm_id === "string" && typeof r.dvm === "string" && typeof r.receipt_pubkey === "string" && typeof r.signature === "string";
+}
+function verifyDrainReceipt(receipt) {
+  try {
+    const { signature, ...unsigned } = receipt;
+    const bytes = canonicaliseForSigning(unsigned);
+    return schnorr4.verify(hexToBytes5(signature), bytes, hexToBytes5(receipt.receipt_pubkey));
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/receipt-verify.ts
 function attestedDvmIdentity(builder) {
   const builderPubkey = authenticatedBuilderPubkey(builder);
@@ -1424,90 +1774,6 @@ function weakestReceiptVerdict(statuses) {
   if (statuses.includes("verified_unattested")) return "verified_unattested";
   return "verified";
 }
-function drainReceiptsDisplay(status, sound, total) {
-  const tally = `${String(sound)} of ${String(total)}`;
-  switch (status) {
-    case "verified":
-      return `Verified reclaim receipts (${tally}): signed by the key this DVM's builder identity attests.`;
-    case "verified_unattested":
-      return `Reclaim receipts, signed but unattested (${tally}): the signature holds, but this DVM publishes no builder identity to vouch for the signing key.`;
-    case "invalid":
-      return `UNVERIFIED reclaim receipts: only ${tally} hold up \u2014 the refund is still owed, but this evidence is not sound.`;
-    case "absent":
-      return "No reclaim receipts: this DVM returned no signed evidence of the drain.";
-  }
-}
-function drainReceiptsHint(status) {
-  switch (status) {
-    case "verified":
-      return "The refund evidence chains to this DVM's published builder identity, and is stored locally with that identity pinned beside it \u2014 so an unhonoured refund stays provable against the builder, not against an anonymous key.";
-    case "verified_unattested":
-      return "The receipts are signed, but nothing vouches for the signing key \u2014 expected for a locally-run or development DVM, not for a deployed one. Stored either way; the refund is owed regardless.";
-    case "invalid":
-      return "The refund is unaffected \u2014 this is a problem with the proof, not the money. Keep this output, and treat the reclaim as unattested when deciding how much to leave on deposit at this DVM.";
-    case "absent":
-      return "This DVM countersigned nothing, so the only artifact behind this reclaim is the drain request the caller signed. Weaker evidence than a countersigned drain, and worth weighing before funding here again.";
-  }
-}
-function receiptDisplay(receipt, status, rate = 0) {
-  const what = `${receipt.dvm}/${receipt.capability} (DVM ID ${receipt.dvm_id})`;
-  const when = receiptIssuedAtIso(receipt)?.slice(0, 10);
-  return `${VERDICT_PREFIX[status]}: paid ${formatPaid(receipt.paid.msats, rate)} for ${what}, ${receipt.outcome}${when ? ` ${when}` : ""}.`;
-}
-function receiptIssuedAtIso(receipt) {
-  const seconds = receipt.issued_at;
-  return typeof seconds === "number" ? epochMsToIso(seconds * 1e3) : null;
-}
-function epochMsToIso(ms) {
-  if (typeof ms !== "number" || !Number.isFinite(ms) || Math.abs(ms) > MAX_TIMESTAMP_MS) {
-    return null;
-  }
-  return new Date(ms).toISOString();
-}
-function receiptHint(status, jobId) {
-  const verifyCmd = jobId ? `'dvm receipts verify ${jobId}'` : "'dvm receipts verify <job-id>'";
-  switch (status) {
-    case "verified":
-      return `Proof of purchase is stored locally. Re-check it any time with ${verifyCmd}, or hand over the raw bundle with 'dvm receipts export'.`;
-    case "verified_unattested":
-      return `The receipt's signature is valid, but this DVM publishes no builder identity to vouch for the signing key \u2014 expected for a locally-run or development DVM, not for a deployed one. Stored either way; inspect it with ${verifyCmd}.`;
-    case "invalid":
-      return `The job itself is unaffected \u2014 this is a problem with the proof, not the result. Run ${verifyCmd} to see which check failed before relying on this receipt as evidence.`;
-    case "absent":
-      return "This DVM does not issue signed receipts, so there is no proof of purchase to store. Nothing went wrong.";
-  }
-}
-function receiptFailureDetail(reason) {
-  switch (reason) {
-    case "job_id_mismatch":
-      return "The receipt names a different job than the one it was collected for \u2014 it is not proof of this job, whoever signed it.";
-    case "drain_id_mismatch":
-      return "The receipt names a different reclaim than the one it is filed under \u2014 it is not evidence of this drain, whoever signed it.";
-    case "credit_id_mismatch":
-      return "The receipt names a different credit than the one this reclaim was against \u2014 it is not evidence of this refund, whoever signed it.";
-    case "fund_id_mismatch":
-      return "The receipt names a different funding operation than the caller submitted.";
-    case "funding_amount_mismatch":
-      return "The signed funded amount differs from the provider's funding response.";
-    case "funding_balance_mismatch":
-      return "The signed post-funding balance differs from the provider's fresh balance response.";
-    case "funding_ledger_seq_mismatch":
-      return "The signed funding sequence differs from the provider's fresh balance response.";
-    case "caller_pubkey_mismatch":
-      return "The funding receipt names a different caller than the key that submitted the funding.";
-    case "signature_invalid":
-      return "The receipt's signature does not verify under the key it names \u2014 the bytes were altered, or it was never signed by that key.";
-    case "attestation_invalid":
-      return "The DVM's published builder attestation does not verify under its own builder pubkey.";
-    case "dvm_identity_mismatch":
-      return "The receipt names a different immutable DVM ID than the builder attestation, so it is not evidence for this provider.";
-    case "receipt_key_mismatch":
-      return "The receipt was signed by a different key than the one the DVM's builder attested.";
-    case "result_hash_mismatch":
-      return "The receipt attests a different result than the one delivered.";
-  }
-}
-var MAX_TIMESTAMP_MS = 864e13;
 function checkJobId(receipt, expectedJobId) {
   if (expectedJobId === void 0) return "unchecked";
   return receipt.job_id === expectedJobId ? "ok" : "mismatch";
@@ -1516,12 +1782,6 @@ function checkDrainField(actual, expected) {
   if (expected === void 0 || actual === void 0) return "unchecked";
   return actual === expected ? "ok" : "mismatch";
 }
-var VERDICT_PREFIX = {
-  verified: "Verified receipt",
-  verified_unattested: "Receipt (signed, unattested)",
-  invalid: "UNVERIFIED receipt",
-  absent: "No receipt"
-};
 function checkResultHash(receipt, delivered) {
   if (!delivered) return "unchecked";
   if (receipt.result_hash === null) return "unchecked";
@@ -1539,14 +1799,6 @@ function isTrustAnchor(value) {
   const anchor = value;
   return typeof anchor.pubkey === "string" && typeof anchor.signature === "string" && !!anchor.attestation && typeof anchor.attestation === "object" && !Array.isArray(anchor.attestation);
 }
-function formatPaid(msats, rate) {
-  if (msats === 0) return "nothing (free job)";
-  const sats = msats % 1e3 === 0 ? msats / 1e3 : Math.round(msats / 1e3 * 100) / 100;
-  const satsLabel = `${sats.toLocaleString("en-US")} sats`;
-  if (rate <= 0) return satsLabel;
-  const usd = msatsToUsd(msats, rate);
-  return `~$${formatUsd(usd)} (${satsLabel}, ${costAnchor(usd)})`;
-}
 
 // src/lib/request-id.ts
 var MAX_REQUEST_ID_LENGTH = 128;
@@ -1583,54 +1835,44 @@ function createMonotonicClock() {
   };
 }
 
-// src/lib/cashu/verify.ts
-import { getTokenMetadata } from "@cashu/cashu-ts";
-function verifyCashuToken(token, acceptedMints) {
-  let mint, unit, totalMsats;
-  try {
-    const meta = getTokenMetadata(token);
-    mint = meta.mint;
-    unit = meta.unit;
-    totalMsats = meta.amount.toNumber() * 1e3;
-  } catch {
-    throw new DvmError(
-      "cashu_invalid_token",
-      "The Cashu token could not be decoded.",
-      "Ensure the token is a valid cashuA... or cashuB... string."
-    );
-  }
-  const normalised = acceptedMints.map(normaliseMintUrl);
-  if (!normalised.includes(normaliseMintUrl(mint))) {
-    throw new DvmError(
-      "cashu_mint_not_accepted",
-      `Mint ${mint} is not accepted by this provider.`,
-      `Accepted mints: ${acceptedMints.join(", ")}`
-    );
-  }
-  return { mint, totalMsats, unit };
-}
-function normaliseMintUrl(url) {
-  try {
-    const u = new URL(url);
-    u.hostname = u.hostname.toLowerCase();
-    u.pathname = u.pathname.replace(/\/+/g, "/").replace(/\/+$/, "") || "/";
-    return u.toString().replace(/\/$/, "");
-  } catch {
-    return url.toLowerCase().replace(/\/+$/, "");
-  }
-}
-
-// src/lib/payment-rails/tempo-wire.ts
-var TEMPO_SESSION_UPDATED_REASON = "Tempo session updated; attach the next voucher to fund this credit.";
-
 export {
   toLockPubkey,
   isX402SettlementReconciliationReason,
-  verifyCashuToken,
-  normaliseMintUrl,
+  IMPLICIT_CREDIT_TTL_MS,
   TEMPO_SESSION_UPDATED_REASON,
-  RECOMMENDED_MINTS,
-  isTestMintUrl,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  CONFIG_BACKUP_FILE,
+  CONFIG_AUDIT_FILE,
+  CONFIG_PINNED_FILE,
+  JOBS_FILE,
+  REQUEST_INTENTS_DIR,
+  FAVORITES_FILE,
+  MESSAGES_DIR,
+  RECEIPTS_FILE,
+  CREDITS_FILE,
+  X402_CHANNELS_FILE,
+  TEMPO_CHANNELS_FILE,
+  FEEDBACK_NUDGES_FILE,
+  RECOVERY_MNEMONIC_FILE,
+  WALLET_FILE,
+  AGENT_MNEMONIC_FILE,
+  IDENTITIES_FILE,
+  PAIRINGS_DIR,
+  BUDGET_FILE,
+  BTC_RATE_FILE,
+  ensureConfigDir,
+  ensureConfigSubdir,
+  repairConfigDirMode,
+  COINGECKO_SIMPLE_PRICE_URL,
+  fetchCoinGeckoSpot,
+  fetchCoinGeckoBtcUsd,
+  costAnchor,
+  formatUsd,
+  formatUsdcMicrounits,
+  fetchBtcUsdRate,
+  getLastKnownBtcRate,
+  formatStaleness,
   backupSecretFile,
   readAgentMnemonic,
   assertAgentMnemonicReplaceable,
@@ -1644,6 +1886,8 @@ export {
   WALLET_VERSION,
   RECENT_SPENDS_CAP,
   DEFAULT_AGENT_MINT_URL,
+  isStorableJobId,
+  loadWalletConfiguredMints,
   loadAgentWallet,
   saveAgentWallet,
   walletExists,
@@ -1670,6 +1914,9 @@ export {
   ADMIN_STATE_UNAVAILABLE,
   buildAdminChallenge,
   buildAdminAuthHeader,
+  JOB_IDENTITY_HEADER,
+  isJobIdentityValue,
+  parseJobIdentityHeader,
   generateIdentity,
   loadIdentitySecret,
   writeIdentity,
@@ -1677,6 +1924,16 @@ export {
   buildAttestation,
   signAttestation,
   verifyAttestation,
+  computeResultHash,
+  signReceipt,
+  verifyReceipt,
+  isSignedJobReceipt,
+  signDrainReceipt,
+  signFundingReceipt,
+  isFundingReceipt,
+  verifyFundingReceipt,
+  isDrainReceipt,
+  verifyDrainReceipt,
   attestedDvmIdentity,
   authenticatedBuilderPubkey,
   verifyJobReceipt,
@@ -1684,13 +1941,6 @@ export {
   verifyDrainReceiptChain,
   verifyFundingReceiptChain,
   weakestReceiptVerdict,
-  drainReceiptsDisplay,
-  drainReceiptsHint,
-  receiptDisplay,
-  receiptIssuedAtIso,
-  epochMsToIso,
-  receiptHint,
-  receiptFailureDetail,
   isPublicRequestId,
   parseTraceparent,
   createMonotonicClock