@dvmkit/sdk 0.1.0-rc.5 → 0.1.0-rc.6

package/dist/{chunk-ATQIII6K.js → chunk-CMDI3ENK.js}

@@ -17,24 +17,26 @@ import {
   verifyWithFacilitator,
   x402NetworkByCaip2,
   x402NetworkToCaip2
-} from "./chunk-AAJNGQMC.js";
+} from "./chunk-JGGI65I3.js";
 import {
-  AGENT_MNEMONIC_FILE,
-  BUILDER_CONFIG_DIR,
-  BUILDER_FILE,
-  BUILDER_KEY_FILE,
-  DvmError,
   IMPLICIT_CREDIT_TTL_MS,
-  WALLET_FILE,
   costAnchor,
-  ensureConfigDir,
   formatStaleness,
   formatUsd,
   msatsToUsd,
   msatsToUsdc,
-  resolveRpcOverride,
   usdcToMsats
-} from "./chunk-F2L6KIMD.js";
+} from "./chunk-5URG56JJ.js";
+import {
+  AGENT_MNEMONIC_FILE,
+  BUILDER_CONFIG_DIR,
+  BUILDER_FILE,
+  BUILDER_KEY_FILE,
+  DvmError,
+  WALLET_FILE,
+  ensureConfigDir,
+  resolveRpcOverride
+} from "./chunk-MKI6OVW4.js";
 import {
   MemoryCreditLedger
 } from "./chunk-EXHBXA4U.js";
@@ -50,7 +52,7 @@ import {
   isZodSchema,
   signedRequestInput,
   zodIssuesOf
-} from "./chunk-AZBXSXQT.js";
+} from "./chunk-P4RUVDU7.js";
 import {
   JobCancelledError,
   MemoryJobStore,
@@ -1246,8 +1248,115 @@ function backupSecretFile(file, nextContent) {
   throw new Error(`Could not create a backup of ${file}: 100 candidate paths already exist.`);
 }
 
+// src/lib/wallet-agent/agent-mnemonic-file.ts
+import {
+  chmodSync,
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+function readAgentMnemonic() {
+  if (!existsSync2(AGENT_MNEMONIC_FILE)) return null;
+  const raw = readFileSync2(AGENT_MNEMONIC_FILE, "utf-8");
+  return raw.trim().toLowerCase().split(/\s+/).join(" ");
+}
+function assertAgentMnemonicReplaceable(opts = {}) {
+  if (existsSync2(AGENT_MNEMONIC_FILE) && !opts.force) {
+    throw new DvmError(
+      "agent_mnemonic_exists",
+      `An agent wallet recovery mnemonic already exists at ${AGENT_MNEMONIC_FILE}.`,
+      "Re-run with --force to replace it. WARNING: funds locked to keys derived from the current words become unrecoverable without a backup. The replaced mnemonic is copied to a timestamped .bak sibling."
+    );
+  }
+}
+function writeAgentMnemonic(mnemonic, opts = {}) {
+  const normalised = mnemonic.trim().toLowerCase().split(/\s+/).join(" ");
+  assertAgentMnemonicReplaceable(opts);
+  ensureConfigDir();
+  const backupFile = backupSecretFile(AGENT_MNEMONIC_FILE, normalised);
+  const tmp = `${AGENT_MNEMONIC_FILE}.tmp`;
+  writeFileSync2(tmp, normalised + "\n", { mode: 384 });
+  try {
+    renameSync(tmp, AGENT_MNEMONIC_FILE);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  try {
+    chmodSync(AGENT_MNEMONIC_FILE, 384);
+  } catch {
+  }
+  return { backupFile };
+}
+function deleteAgentMnemonic() {
+  if (!existsSync2(AGENT_MNEMONIC_FILE)) return { backupFile: null };
+  const backupFile = backupSecretFile(AGENT_MNEMONIC_FILE);
+  unlinkSync(AGENT_MNEMONIC_FILE);
+  return { backupFile };
+}
+
+// src/lib/wallet-agent/mnemonic.ts
+import { createHash as createHash3 } from "crypto";
+import { HDKey } from "@scure/bip32";
+import {
+  generateMnemonic,
+  mnemonicToEntropy,
+  mnemonicToSeedSync,
+  validateMnemonic
+} from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+var MNEMONIC_PURPOSE_INDEX = 1789;
+var AGENT_MASTER_ROLE_INDEX = 1;
+var MNEMONIC_STRENGTH_BITS = 128;
+function agentMasterKeypairPath() {
+  return `m/${MNEMONIC_PURPOSE_INDEX}'/${AGENT_MASTER_ROLE_INDEX}'`;
+}
+function generateAgentMnemonic() {
+  return generateMnemonic(wordlist, MNEMONIC_STRENGTH_BITS);
+}
+function deriveAgentMasterKeypair(mnemonic) {
+  const seed = mnemonicToSeedSync(mnemonic);
+  const hd = HDKey.fromMasterSeed(seed);
+  const child = hd.derive(agentMasterKeypairPath());
+  if (!child.privateKey || !child.publicKey) {
+    throw new Error("Failed to derive agent master keypair from mnemonic");
+  }
+  return {
+    privkey: Buffer.from(child.privateKey).toString("hex"),
+    pubkey: Buffer.from(child.publicKey).toString("hex")
+  };
+}
+function validateAgentMnemonic(mnemonic) {
+  const words = mnemonic.trim().toLowerCase().split(/\s+/);
+  if (words.length !== 12) {
+    return { ok: false, reason: "wrong_length", wordCount: words.length };
+  }
+  for (let i = 0; i < words.length; i++) {
+    if (!wordlist.includes(words[i])) {
+      return { ok: false, reason: "unknown_word", badWordIndex: i + 1, badWord: words[i] };
+    }
+  }
+  if (!validateMnemonic(words.join(" "), wordlist)) {
+    return { ok: false, reason: "checksum" };
+  }
+  return { ok: true };
+}
+function looksLikeMnemonic(input) {
+  return /\s/.test(input.trim());
+}
+function mnemonicFingerprint(mnemonic) {
+  const normalised = mnemonic.trim().toLowerCase().split(/\s+/).join(" ");
+  const entropy = mnemonicToEntropy(normalised, wordlist);
+  return createHash3("sha256").update(entropy).digest("hex");
+}
+
 // src/lib/wallet-agent/store.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import lockfile from "proper-lockfile";
 var LOCK_FILE = `${WALLET_FILE}.lock`;
 var DEFAULT_LOCK_STALE_MS = 3e4;
@@ -1255,9 +1364,10 @@ var DEFAULT_LOCK_RETRIES = 30;
 var DEFAULT_LOCK_RETRY_INTERVAL_MS = 1e3;
 var WALLET_VERSION = 8;
 var RECENT_SPENDS_CAP = 10;
+var DEFAULT_AGENT_MINT_URL = "https://mint.coinos.io";
 function loadAgentWallet() {
-  if (!existsSync2(WALLET_FILE)) return null;
-  const raw = readFileSync2(WALLET_FILE, "utf-8");
+  if (!existsSync3(WALLET_FILE)) return null;
+  const raw = readFileSync3(WALLET_FILE, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -1322,17 +1432,20 @@ function saveAgentWallet(wallet) {
   ensureConfigDir();
   const tmp = `${WALLET_FILE}.tmp`;
   const data = JSON.stringify(wallet, null, 2) + "\n";
-  writeFileSync2(tmp, data, { mode: 384 });
+  writeFileSync3(tmp, data, { mode: 384 });
   try {
-    renameSync(tmp, WALLET_FILE);
+    renameSync2(tmp, WALLET_FILE);
   } catch (err) {
     try {
-      unlinkSync(tmp);
+      unlinkSync2(tmp);
     } catch {
     }
     throw err;
   }
 }
+function walletExists() {
+  return existsSync3(WALLET_FILE);
+}
 async function withWalletLock(fn, opts = {}) {
   ensureConfigDir();
   const stale = opts.stale ?? DEFAULT_LOCK_STALE_MS;
@@ -1363,6 +1476,12 @@ async function withWalletLock(fn, opts = {}) {
     }
   }
 }
+function effectiveMints(wallet) {
+  return wallet.mints.length > 0 ? wallet.mints : [DEFAULT_AGENT_MINT_URL];
+}
+function effectiveFundingMint(mints) {
+  return mints.length > 0 ? { url: mints[0], source: "configured" } : { url: DEFAULT_AGENT_MINT_URL, source: "fallback" };
+}
 function migrateV1ToV4(parsed) {
   const proofs = Array.isArray(parsed.proofs) ? parsed.proofs : [];
   const pending = Array.isArray(parsed.pending_mints) ? parsed.pending_mints : [];
@@ -1473,6 +1592,98 @@ function isCounterMap(value) {
   return true;
 }
 
+// src/lib/wallet-agent/nut13-counters.ts
+var PersistentCounterSource = class {
+  constructor(mintUrl) {
+    this.mintUrl = mintUrl;
+  }
+  mintUrl;
+  /**
+   * Reserve `n` counters for `keysetId`. Returns `{ start, count: n }`
+   * and bumps the persisted `next` to `start + n` under the wallet lock.
+   *
+   * Per cashu-ts contract, `n === 0` MUST NOT mutate state and is a
+   * pure peek — we honour that by returning `{ start, count: 0 }`
+   * without acquiring the lock.
+   */
+  async reserve(keysetId, n) {
+    if (n === 0) {
+      const wallet = loadAgentWallet();
+      const current = wallet?.nut13_counters[this.mintUrl]?.[keysetId] ?? 0;
+      return { start: current, count: 0 };
+    }
+    return withWalletLock(() => {
+      const wallet = this.loadOrThrow();
+      const current = wallet.nut13_counters[this.mintUrl]?.[keysetId] ?? 0;
+      saveAgentWallet(this.withCounter(wallet, keysetId, current + n));
+      return { start: current, count: n };
+    });
+  }
+  /**
+   * Monotonic bump: ensure the persisted `next` for `keysetId` is at
+   * least `minNext`. No-op if the wallet is already ahead. Used by
+   * cashu-ts when the mint reports `outputs_already_signed` — the
+   * losing wallet rolls forward past the colliding counter.
+   */
+  async advanceToAtLeast(keysetId, minNext) {
+    await withWalletLock(() => {
+      const wallet = this.loadOrThrow();
+      const current = wallet.nut13_counters[this.mintUrl]?.[keysetId] ?? 0;
+      if (current >= minNext) return;
+      saveAgentWallet(this.withCounter(wallet, keysetId, minNext));
+    });
+  }
+  /**
+   * Snapshot the per-keyset `next` map for this mint. Useful for
+   * `dvm wallet show` and test assertions; cashu-ts itself does not
+   * depend on `snapshot` being implemented.
+   */
+  snapshot() {
+    const wallet = loadAgentWallet();
+    const counters = wallet?.nut13_counters[this.mintUrl] ?? {};
+    const out = {};
+    for (const [keyset, next] of Object.entries(counters)) {
+      if (typeof next === "number") out[keyset] = next;
+    }
+    return Promise.resolve(out);
+  }
+  /**
+   * Hard-set the persisted `next` for `keysetId`. Used by
+   * `dvm wallet restore` to re-anchor counters after walking
+   * `batchRestore` per keyset. cashu-ts also exposes this on
+   * `wallet.counters.setNext`.
+   */
+  async setNext(keysetId, next) {
+    await withWalletLock(() => {
+      const wallet = this.loadOrThrow();
+      saveAgentWallet(this.withCounter(wallet, keysetId, next));
+    });
+  }
+  loadOrThrow() {
+    const wallet = loadAgentWallet();
+    if (!wallet) {
+      throw new DvmError(
+        "wallet_missing",
+        "NUT-13 counter persistence requires an agent wallet at ~/.dvm/wallet.json.",
+        "Run `dvm wallet init` or `dvm wallet recover --file <path>` (or pipe the mnemonic via stdin) first."
+      );
+    }
+    return wallet;
+  }
+  withCounter(wallet, keysetId, next) {
+    return {
+      ...wallet,
+      nut13_counters: {
+        ...wallet.nut13_counters,
+        [this.mintUrl]: {
+          ...wallet.nut13_counters[this.mintUrl] ?? {},
+          [keysetId]: next
+        }
+      }
+    };
+  }
+};
+
 // src/lib/cashu/health.ts
 var DEFAULT_REQUIRED_NUTS = [4, 5, 7, 9, 10, 11, 20];
 async function checkMintHealth(mintUrl, opts) {
@@ -1592,6 +1803,12 @@ function mintAmountBounds(nuts) {
 function meltAmountBounds(nuts) {
   return boundsOf(nuts["5"]);
 }
+function amountBoundsVerdict(sats, bounds) {
+  if (!bounds) return "ok";
+  if (bounds.minSats !== null && sats < bounds.minSats) return "below_min";
+  if (bounds.maxSats !== null && sats > bounds.maxSats) return "above_max";
+  return "ok";
+}
 function boundsOf(node) {
   const method = findBolt11Sat(node);
   return {
@@ -1680,131 +1897,6 @@ function sleep(ms) {
 // src/lib/cashu/wallet.ts
 import { Wallet } from "@cashu/cashu-ts";
 import { mnemonicToSeedSync as mnemonicToSeedSync2 } from "@scure/bip39";
-
-// src/lib/wallet-agent/agent-mnemonic-file.ts
-import {
-  chmodSync,
-  existsSync as existsSync3,
-  readFileSync as readFileSync3,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
-} from "fs";
-function readAgentMnemonic() {
-  if (!existsSync3(AGENT_MNEMONIC_FILE)) return null;
-  const raw = readFileSync3(AGENT_MNEMONIC_FILE, "utf-8");
-  return raw.trim().toLowerCase().split(/\s+/).join(" ");
-}
-
-// src/lib/wallet-agent/mnemonic.ts
-import { createHash as createHash3 } from "crypto";
-import { HDKey } from "@scure/bip32";
-import {
-  generateMnemonic,
-  mnemonicToEntropy,
-  mnemonicToSeedSync,
-  validateMnemonic
-} from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-function mnemonicFingerprint(mnemonic) {
-  const normalised = mnemonic.trim().toLowerCase().split(/\s+/).join(" ");
-  const entropy = mnemonicToEntropy(normalised, wordlist);
-  return createHash3("sha256").update(entropy).digest("hex");
-}
-
-// src/lib/wallet-agent/nut13-counters.ts
-var PersistentCounterSource = class {
-  constructor(mintUrl) {
-    this.mintUrl = mintUrl;
-  }
-  mintUrl;
-  /**
-   * Reserve `n` counters for `keysetId`. Returns `{ start, count: n }`
-   * and bumps the persisted `next` to `start + n` under the wallet lock.
-   *
-   * Per cashu-ts contract, `n === 0` MUST NOT mutate state and is a
-   * pure peek — we honour that by returning `{ start, count: 0 }`
-   * without acquiring the lock.
-   */
-  async reserve(keysetId, n) {
-    if (n === 0) {
-      const wallet = loadAgentWallet();
-      const current = wallet?.nut13_counters[this.mintUrl]?.[keysetId] ?? 0;
-      return { start: current, count: 0 };
-    }
-    return withWalletLock(() => {
-      const wallet = this.loadOrThrow();
-      const current = wallet.nut13_counters[this.mintUrl]?.[keysetId] ?? 0;
-      saveAgentWallet(this.withCounter(wallet, keysetId, current + n));
-      return { start: current, count: n };
-    });
-  }
-  /**
-   * Monotonic bump: ensure the persisted `next` for `keysetId` is at
-   * least `minNext`. No-op if the wallet is already ahead. Used by
-   * cashu-ts when the mint reports `outputs_already_signed` — the
-   * losing wallet rolls forward past the colliding counter.
-   */
-  async advanceToAtLeast(keysetId, minNext) {
-    await withWalletLock(() => {
-      const wallet = this.loadOrThrow();
-      const current = wallet.nut13_counters[this.mintUrl]?.[keysetId] ?? 0;
-      if (current >= minNext) return;
-      saveAgentWallet(this.withCounter(wallet, keysetId, minNext));
-    });
-  }
-  /**
-   * Snapshot the per-keyset `next` map for this mint. Useful for
-   * `dvm wallet show` and test assertions; cashu-ts itself does not
-   * depend on `snapshot` being implemented.
-   */
-  snapshot() {
-    const wallet = loadAgentWallet();
-    const counters = wallet?.nut13_counters[this.mintUrl] ?? {};
-    const out = {};
-    for (const [keyset, next] of Object.entries(counters)) {
-      if (typeof next === "number") out[keyset] = next;
-    }
-    return Promise.resolve(out);
-  }
-  /**
-   * Hard-set the persisted `next` for `keysetId`. Used by
-   * `dvm wallet restore` to re-anchor counters after walking
-   * `batchRestore` per keyset. cashu-ts also exposes this on
-   * `wallet.counters.setNext`.
-   */
-  async setNext(keysetId, next) {
-    await withWalletLock(() => {
-      const wallet = this.loadOrThrow();
-      saveAgentWallet(this.withCounter(wallet, keysetId, next));
-    });
-  }
-  loadOrThrow() {
-    const wallet = loadAgentWallet();
-    if (!wallet) {
-      throw new DvmError(
-        "wallet_missing",
-        "NUT-13 counter persistence requires an agent wallet at ~/.dvm/wallet.json.",
-        "Run `dvm wallet init` or `dvm wallet recover --file <path>` (or pipe the mnemonic via stdin) first."
-      );
-    }
-    return wallet;
-  }
-  withCounter(wallet, keysetId, next) {
-    return {
-      ...wallet,
-      nut13_counters: {
-        ...wallet.nut13_counters,
-        [this.mintUrl]: {
-          ...wallet.nut13_counters[this.mintUrl] ?? {},
-          [keysetId]: next
-        }
-      }
-    };
-  }
-};
-
-// src/lib/cashu/wallet.ts
 var walletCache = /* @__PURE__ */ new Map();
 var keysetResidueRegistry = /* @__PURE__ */ new Map();
 var NUT13_MODULUS = BigInt(2 ** 31 - 1);
@@ -4365,7 +4457,7 @@ async function verifyUpfrontPayment(opts) {
           x402Requirements
         });
       }
-      const { verifyX402Payment } = await import("./x402-3VQ64MCS.js");
+      const { verifyX402Payment } = await import("./x402-FTG2GRAQ.js");
       const receipt = await verifyX402Payment(
         x402Payment,
         x402Config,
@@ -5285,7 +5377,7 @@ async function verifyIncomingPayment(body, opts, snapshot) {
           snapshot
         });
       }
-      const { verifyX402Payment } = await import("./x402-3VQ64MCS.js");
+      const { verifyX402Payment } = await import("./x402-FTG2GRAQ.js");
       const receipt = await verifyX402Payment(
         body.content.x402_payment,
         opts.x402Config,
@@ -5695,7 +5787,7 @@ async function processIncomingPayment(job, body, opts) {
     try {
       const requiredMsats = job.pendingPaymentMsats ?? 0;
       const requiredUsdcMicro = job.pendingX402AmountUsdcMicro !== void 0 ? BigInt(job.pendingX402AmountUsdcMicro) : BigInt(msatsToUsdc(requiredMsats, rate));
-      const { verifyX402Payment } = await import("./x402-3VQ64MCS.js");
+      const { verifyX402Payment } = await import("./x402-FTG2GRAQ.js");
       const receipt = await verifyX402Payment(
         body.content.x402_payment,
         opts.x402Config,
@@ -9098,6 +9190,34 @@ function pickPrimary(credits, currency) {
   return best;
 }
 
+// src/lib/mints.ts
+var RECOMMENDED_MINTS = [
+  {
+    name: "Testnut",
+    description: "Cashu test mint \u2014 use for testing only, not real funds",
+    url: "https://testnut.cashu.space"
+  },
+  {
+    name: "Voltz Mint",
+    description: "Production Cashu mint by the Voltz Wallet team",
+    url: "https://mint.lnvoltz.com"
+  }
+];
+function isTestMintUrl(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  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);
+}
+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"]);
+
 // src/lib/receipt-key.ts
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
 import { hkdf } from "@noble/hashes/hkdf.js";
@@ -10076,14 +10196,57 @@ function formatPaid(msats, rate) {
   return `~$${formatUsd(usd)} (${satsLabel}, ${costAnchor(usd)})`;
 }
 
-// src/lib/wallet-agent/sign.ts
-import { schnorr as schnorr4 } from "@noble/curves/secp256k1.js";
+// src/lib/request-id.ts
+var MAX_REQUEST_ID_LENGTH = 128;
+var REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+function isPublicRequestId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_REQUEST_ID_LENGTH && REQUEST_ID_PATTERN.test(value);
+}
+
+// src/lib/traceparent.ts
+var TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+var ALL_ZERO_TRACE = "00000000000000000000000000000000";
+var ALL_ZERO_SPAN = "0000000000000000";
+function parseTraceparent(header) {
+  if (!header) return null;
+  const match = TRACEPARENT_RE.exec(header.trim());
+  if (!match) return null;
+  const [, traceId, parentSpanId, flagsHex] = match;
+  if (traceId === ALL_ZERO_TRACE || parentSpanId === ALL_ZERO_SPAN) return null;
+  return { traceId, parentSpanId, flags: parseInt(flagsHex, 16) };
+}
 
 // src/lib/wallet-agent/keypair.ts
 import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1.js";
 var PRIVKEY_HEX_RE = /^[0-9a-f]{64}$/i;
+function derivePubkeyFromPrivkey(privkey) {
+  if (!PRIVKEY_HEX_RE.test(privkey)) {
+    throw new DvmError(
+      "invalid_privkey",
+      "Privkey must be 64 hex characters (32 bytes).",
+      "Provide a valid secp256k1 private key as a 64-char hex string."
+    );
+  }
+  const bytes = hexToBytes4(privkey);
+  if (!secp256k12.utils.isValidSecretKey(bytes)) {
+    throw new DvmError(
+      "invalid_privkey",
+      "Privkey is not a valid secp256k1 scalar (zero or out of curve order).",
+      "Generate a fresh key with: dvm wallet init"
+    );
+  }
+  const pub = secp256k12.getPublicKey(bytes);
+  return bytesToHex4(pub);
+}
+function bytesToHex4(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function hexToBytes4(hex) {
+  return Uint8Array.from(Buffer.from(hex, "hex"));
+}
 
 // src/lib/wallet-agent/sign.ts
+import { schnorr as schnorr4 } from "@noble/curves/secp256k1.js";
 var PUBKEY_COMPRESSED_HEX_RE = /^0[23][0-9a-f]{64}$/i;
 var PUBKEY_XONLY_HEX_RE = /^[0-9a-f]{64}$/i;
 var SIG_HEX_RE = /^[0-9a-f]{128}$/i;
@@ -10102,30 +10265,30 @@ function signChallenge(privkeyHex, challenge) {
       "Pass the SHA-256 digest output (32 bytes)."
     );
   }
-  const sig = schnorr4.sign(challenge, hexToBytes4(privkeyHex));
-  return bytesToHex4(sig);
+  const sig = schnorr4.sign(challenge, hexToBytes5(privkeyHex));
+  return bytesToHex5(sig);
 }
 function verifyChallenge(pubkeyHex, challenge, sigHex) {
   if (!SIG_HEX_RE.test(sigHex)) return false;
   if (challenge.length !== 32) return false;
   let xonly;
   if (PUBKEY_COMPRESSED_HEX_RE.test(pubkeyHex)) {
-    xonly = hexToBytes4(pubkeyHex.slice(2));
+    xonly = hexToBytes5(pubkeyHex.slice(2));
   } else if (PUBKEY_XONLY_HEX_RE.test(pubkeyHex)) {
-    xonly = hexToBytes4(pubkeyHex);
+    xonly = hexToBytes5(pubkeyHex);
   } else {
     return false;
   }
   try {
-    return schnorr4.verify(hexToBytes4(sigHex), challenge, xonly);
+    return schnorr4.verify(hexToBytes5(sigHex), challenge, xonly);
   } catch {
     return false;
   }
 }
-function hexToBytes4(hex) {
+function hexToBytes5(hex) {
   return Uint8Array.from(Buffer.from(hex, "hex"));
 }
-function bytesToHex4(bytes) {
+function bytesToHex5(bytes) {
   return Buffer.from(bytes).toString("hex");
 }
 
@@ -10867,13 +11030,6 @@ function createMonotonicClock() {
   };
 }
 
-// src/lib/request-id.ts
-var MAX_REQUEST_ID_LENGTH = 128;
-var REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
-function isPublicRequestId(value) {
-  return typeof value === "string" && value.length > 0 && value.length <= MAX_REQUEST_ID_LENGTH && REQUEST_ID_PATTERN.test(value);
-}
-
 // src/sdk/server/request-envelope.ts
 var REQUEST_ID_FIELD = "request_id";
 var AUTH_STATEMENT_FIELD = "auth_statement";
@@ -15068,19 +15224,6 @@ function shortSha(sha) {
   return base2.slice(0, 7) + (dirty ? DIRTY_SUFFIX : "");
 }
 
-// src/lib/traceparent.ts
-var TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
-var ALL_ZERO_TRACE = "00000000000000000000000000000000";
-var ALL_ZERO_SPAN = "0000000000000000";
-function parseTraceparent(header) {
-  if (!header) return null;
-  const match = TRACEPARENT_RE.exec(header.trim());
-  if (!match) return null;
-  const [, traceId, parentSpanId, flagsHex] = match;
-  if (traceId === ALL_ZERO_TRACE || parentSpanId === ALL_ZERO_SPAN) return null;
-  return { traceId, parentSpanId, flags: parseInt(flagsHex, 16) };
-}
-
 // src/sdk/server/admin-credit.ts
 import {
   Amount as Amount3,
@@ -20978,7 +21121,7 @@ function parseNwcUri(uri) {
   if (!/^[0-9a-fA-F]{64}$/.test(secretHex)) {
     throw new NwcError("invalid_uri", "NWC URI secret must be 64 hex characters");
   }
-  const secret = hexToBytes5(secretHex);
+  const secret = hexToBytes6(secretHex);
   const clientPubkey = getPublicKey(secret);
   return { walletPubkey, relays, secret, clientPubkey };
 }
@@ -21358,7 +21501,7 @@ function positiveSecondsEnv(name, fallbackSec) {
   if (!Number.isFinite(n) || n <= 0) return fallbackSec * 1e3;
   return Math.floor(n) * 1e3;
 }
-function hexToBytes5(hex) {
+function hexToBytes6(hex) {
   const bytes = new Uint8Array(hex.length / 2);
   for (let i = 0; i < bytes.length; i++) {
     bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
@@ -21626,12 +21769,29 @@ export {
   rateUnavailablePaymentError,
   backupSecretFile,
   readAgentMnemonic,
+  assertAgentMnemonicReplaceable,
+  writeAgentMnemonic,
+  deleteAgentMnemonic,
+  generateAgentMnemonic,
+  deriveAgentMasterKeypair,
+  validateAgentMnemonic,
+  looksLikeMnemonic,
+  mnemonicFingerprint,
+  WALLET_VERSION,
   RECENT_SPENDS_CAP,
+  DEFAULT_AGENT_MINT_URL,
   loadAgentWallet,
   saveAgentWallet,
+  walletExists,
   withWalletLock,
+  effectiveMints,
+  effectiveFundingMint,
+  PersistentCounterSource,
   checkMintHealth,
   canSwap,
+  meltAmountBounds,
+  amountBoundsVerdict,
+  assertNutSupport,
   getWallet,
   X402_BATCH_CHANNEL_ABI,
   X402_BATCH_SETTLEMENT_NETWORK,
@@ -21656,6 +21816,8 @@ export {
   repairX402ExactSettlementEffect,
   CREDIT_REQUEST_SCHEMA,
   handleCreditRequest,
+  RECOMMENDED_MINTS,
+  isTestMintUrl,
   deriveReceiptSecret,
   receiptPubkeyFromSecret,
   deriveReceiptKeypair,
@@ -21702,6 +21864,10 @@ export {
   epochMsToIso,
   receiptHint,
   receiptFailureDetail,
+  isPublicRequestId,
+  parseTraceparent,
+  PRIVKEY_HEX_RE,
+  derivePubkeyFromPrivkey,
   verifyChallenge,
   ADMIN_STATE_UNAVAILABLE,
   buildAdminChallenge,