@rozoai/checkout 0.1.7 → 0.1.11

package/scripts/dist/create-order.js

@@ -153,6 +153,9 @@ function maskMemo(memo) {
   return `${s.slice(0, 4)}...${s.slice(-3)}`;
 }
 
+// scripts/src/lib/api.mjs
+import { createRequire } from "node:module";
+
 // scripts/src/lib/http.mjs
 var DEFAULT_TIMEOUT_MS = 2e4;
 var USER_AGENT = "rozo-checkout-skill/1.0";
@@ -222,7 +225,20 @@ function postJson(url, body, opts) {
 }
 
 // scripts/src/lib/api.mjs
+var PKG_VERSION = (() => {
+  const requireFrom = createRequire(import.meta.url);
+  for (const candidate of ["../../package.json", "../../../package.json"]) {
+    try {
+      const pkg = requireFrom(candidate);
+      if (pkg?.name === "@rozoai/checkout" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+})();
 var MPP_BASE = process.env.ROZO_CHECKOUT_MPP_BASE || "https://apiserver.mpprouter.dev/v1/services/rozo-agent-api";
+var CLIENT_LABEL = `rozo-checkout-cli/${PKG_VERSION}`;
+var ATTRIBUTION_CLIENT = `rozo-checkout-skill/${PKG_VERSION}`;
 var INTENTS_BASE = process.env.ROZO_CHECKOUT_INTENTS_BASE || "https://intentapiv4.rozo.ai/functions/v1/payment-api";
 async function quoteInvoice({ url, linkId }) {
   const body = url ? { url } : { payment_id: linkId };
@@ -232,7 +248,9 @@ async function createInvoice({ url, linkId, source, quoteReceipt }) {
   const body = {
     ...url ? { url } : { payment_id: linkId },
     source: { chainId: String(source.chainId), tokenSymbol: source.tokenSymbol },
-    ...quoteReceipt ? { quoteReceipt } : {}
+    ...quoteReceipt ? { quoteReceipt } : {},
+    client: CLIENT_LABEL,
+    attribution: { client: ATTRIBUTION_CLIENT }
   };
   return postJson(`${MPP_BASE}/create-invoice`, body);
 }

package/scripts/dist/quote.js

@@ -133,6 +133,9 @@ function extractLinkId(urlOrId) {
   );
 }
 
+// scripts/src/lib/api.mjs
+import { createRequire } from "node:module";
+
 // scripts/src/lib/http.mjs
 var DEFAULT_TIMEOUT_MS = 2e4;
 var USER_AGENT = "rozo-checkout-skill/1.0";
@@ -199,7 +202,20 @@ function postJson(url, body, opts) {
 }
 
 // scripts/src/lib/api.mjs
+var PKG_VERSION = (() => {
+  const requireFrom = createRequire(import.meta.url);
+  for (const candidate of ["../../package.json", "../../../package.json"]) {
+    try {
+      const pkg = requireFrom(candidate);
+      if (pkg?.name === "@rozoai/checkout" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+})();
 var MPP_BASE = process.env.ROZO_CHECKOUT_MPP_BASE || "https://apiserver.mpprouter.dev/v1/services/rozo-agent-api";
+var CLIENT_LABEL = `rozo-checkout-cli/${PKG_VERSION}`;
+var ATTRIBUTION_CLIENT = `rozo-checkout-skill/${PKG_VERSION}`;
 var INTENTS_BASE = process.env.ROZO_CHECKOUT_INTENTS_BASE || "https://intentapiv4.rozo.ai/functions/v1/payment-api";
 async function quoteInvoice({ url, linkId }) {
   const body = url ? { url } : { payment_id: linkId };

package/scripts/dist/send-evm.js

@@ -999,7 +999,7 @@ var init_size = __esm({
 var version2;
 var init_version2 = __esm({
   "node_modules/viem/_esm/errors/version.js"() {
-    version2 = "2.55.11";
+    version2 = "2.55.13";
   }
 });
 
@@ -1759,10 +1759,10 @@ var init_u64 = __esm({
 
 // node_modules/@noble/hashes/esm/cryptoNode.js
 import * as nc from "node:crypto";
-var crypto2;
+var crypto3;
 var init_cryptoNode = __esm({
   "node_modules/@noble/hashes/esm/cryptoNode.js"() {
-    crypto2 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+    crypto3 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
   }
 });
 
@@ -1857,11 +1857,11 @@ function createHasher(hashCons) {
   return hashC;
 }
 function randomBytes(bytesLength = 32) {
-  if (crypto2 && typeof crypto2.getRandomValues === "function") {
-    return crypto2.getRandomValues(new Uint8Array(bytesLength));
+  if (crypto3 && typeof crypto3.getRandomValues === "function") {
+    return crypto3.getRandomValues(new Uint8Array(bytesLength));
   }
-  if (crypto2 && typeof crypto2.randomBytes === "function") {
-    return Uint8Array.from(crypto2.randomBytes(bytesLength));
+  if (crypto3 && typeof crypto3.randomBytes === "function") {
+    return Uint8Array.from(crypto3.randomBytes(bytesLength));
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
@@ -10214,43 +10214,148 @@ function chainFamily(chainId) {
 // scripts/src/lib/keys.mjs
 import fs from "node:fs";
 import path from "node:path";
-import { execFileSync } from "node:child_process";
-var ENV_FILE_RE = /^\.env(\..+)?$/;
-var PUBLIC_ENV_RE = /^\.env\.(example|sample|template)$/;
-function insideGitWorkTree(dir, whatFor) {
+import crypto2 from "node:crypto";
+function findGitRepo(dir) {
+  for (const v of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE"]) {
+    if (process.env[v]) {
+      throw new SkillError(
+        "TRACKED_DOTENV_UNVERIFIABLE",
+        `${v} is set, so the repository layout cannot be resolved by reading the filesystem alone. Unset it (or run from a plain checkout) before using hot-wallet keys.`
+      );
+    }
+  }
+  let cur = path.resolve(dir);
+  for (; ; ) {
+    const dotGit = path.join(cur, ".git");
+    let st = null;
+    try {
+      st = fs.statSync(dotGit);
+    } catch (err) {
+      if (err?.code !== "ENOENT" && err?.code !== "ENOTDIR") {
+        throw new SkillError(
+          "TRACKED_DOTENV_UNVERIFIABLE",
+          `A .git entry here could not be inspected (${err?.code || "error"}), so tracked status cannot be proved. Refusing.`
+        );
+      }
+      st = null;
+    }
+    if (st) {
+      if (st.isDirectory()) return { root: cur, gitDir: dotGit };
+      let text;
+      try {
+        text = fs.readFileSync(dotGit, "utf8");
+      } catch {
+        throw new SkillError(
+          "TRACKED_DOTENV_UNVERIFIABLE",
+          "A .git entry exists here but could not be read, so tracked status cannot be proved. Refusing."
+        );
+      }
+      const m = /^gitdir:\s*(.+)\s*$/m.exec(text);
+      if (!m) {
+        throw new SkillError(
+          "TRACKED_DOTENV_UNVERIFIABLE",
+          "A .git file exists here but is not a recognised gitdir pointer. Refusing."
+        );
+      }
+      return { root: cur, gitDir: path.resolve(cur, m[1]) };
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+function trackedPathsFromIndex(buf, { hashLen = 20 } = {}) {
+  const fail2 = (why) => new SkillError(
+    "TRACKED_DOTENV_UNVERIFIABLE",
+    `The git index could not be interpreted (${why}), so tracked status cannot be proved. Refusing.`
+  );
+  if (buf.length < 12 + hashLen || buf.toString("latin1", 0, 4) !== "DIRC") throw fail2("bad header");
+  const algo = hashLen === 32 ? "sha256" : "sha1";
+  const expected = buf.subarray(buf.length - hashLen);
+  const actual = crypto2.createHash(algo).update(buf.subarray(0, buf.length - hashLen)).digest();
+  if (!actual.equals(expected)) throw fail2(`${algo} checksum mismatch`);
+  const version4 = buf.readUInt32BE(4);
+  if (version4 !== 2 && version4 !== 3) throw fail2(`unsupported index version ${version4}`);
+  const count = buf.readUInt32BE(8);
+  const paths = /* @__PURE__ */ new Set();
+  const fixed = 40 + hashLen + 2;
+  let off = 12;
+  for (let i = 0; i < count; i++) {
+    const entryStart = off;
+    if (off + fixed > buf.length - hashLen) throw fail2("truncated entry");
+    const flags = buf.readUInt16BE(off + fixed - 2);
+    let nameOff = off + fixed;
+    if (flags & 16384) {
+      if (version4 < 3) throw fail2("extended flags in v2 index");
+      nameOff += 2;
+    }
+    const nameLen = flags & 4095;
+    let end;
+    if (nameLen < 4095) {
+      end = nameOff + nameLen;
+      if (end > buf.length - hashLen) throw fail2("truncated path");
+    } else {
+      end = buf.indexOf(0, nameOff);
+      if (end === -1 || end > buf.length - hashLen) throw fail2("unterminated path");
+    }
+    paths.add(buf.toString("utf8", nameOff, end));
+    const entryLen = end - entryStart;
+    off = entryStart + (Math.floor(entryLen / 8) + 1) * 8;
+  }
+  while (off < buf.length - hashLen) {
+    if (off + 8 > buf.length - hashLen) throw fail2("truncated extension header");
+    const extName = buf.toString("latin1", off, off + 4);
+    const extSize = buf.readUInt32BE(off + 4);
+    const first = extName.charCodeAt(0);
+    if (first >= 97 && first <= 122) {
+      throw fail2(`mandatory index extension "${extName}" (e.g. core.splitIndex) is not supported`);
+    }
+    off += 8 + extSize;
+    if (off > buf.length - hashLen) throw fail2("truncated extension");
+  }
+  return paths;
+}
+function repoHashLen(gitDir) {
+  let configDir = gitDir;
   try {
-    return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
-      cwd: dir,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8"
-    }).trim() === "true";
+    const common = fs.readFileSync(path.join(gitDir, "commondir"), "utf8").trim();
+    if (common) configDir = path.resolve(gitDir, common);
+  } catch {
+  }
+  try {
+    const cfg = fs.readFileSync(path.join(configDir, "config"), "utf8");
+    if (/^\s*objectformat\s*=\s*sha256\s*$/im.test(cfg)) return 32;
+  } catch {
+  }
+  return 20;
+}
+function trackedAmong(repo, files) {
+  const indexPath = path.join(repo.gitDir, "index");
+  let buf;
+  try {
+    buf = fs.readFileSync(indexPath);
   } catch (err) {
-    const stderr = String(err?.stderr || "");
-    if (/not a git repository|does not appear to be a git repository/i.test(stderr)) return false;
+    if (err?.code === "ENOENT") return [];
     throw new SkillError(
       "TRACKED_DOTENV_UNVERIFIABLE",
-      `git could not be consulted (${err?.code || "unknown error"}), so it cannot be proved that ${whatFor} is untracked. Refusing rather than assuming it is safe.`
+      "The git index exists but could not be read, so tracked status cannot be proved. Refusing."
     );
   }
+  const tracked = trackedPathsFromIndex(buf, { hashLen: repoHashLen(repo.gitDir) });
+  return files.filter((f) => {
+    const rel = path.relative(repo.root, path.resolve(f)).split(path.sep).join("/");
+    return tracked.has(rel);
+  });
 }
+var ENV_FILE_RE = /^\.env(\..+)?$/;
+var PUBLIC_ENV_RE = /^\.env\.(example|sample|template)$/;
 function assertNotTrackedByGit(file) {
   const dir = path.dirname(path.resolve(file));
-  const base = path.basename(file);
-  if (!insideGitWorkTree(dir, "this key file")) return { checked: true, tracked: false };
-  let out;
-  try {
-    out = execFileSync("git", ["ls-files", "-z", "--", base], {
-      cwd: dir,
-      stdio: ["ignore", "pipe", "ignore"],
-      encoding: "utf8"
-    });
-  } catch {
-    throw new SkillError(
-      "TRACKED_DOTENV_UNVERIFIABLE",
-      "git could not report whether this key file is tracked. Refusing to use it."
-    );
-  }
-  if (out.split("\0").filter(Boolean).length) {
+  const repo = findGitRepo(dir);
+  if (!repo) return { checked: true, tracked: false };
+  const hits = trackedAmong(repo, [file]);
+  if (hits.length) {
+    const base = path.basename(file);
     throw new SkillError(
       "TRACKED_KEYFILE",
       `${base} is tracked by git. A committed key is one push from being public \u2014 untrack it (git rm --cached ${base}) and gitignore it before using it to sign.`
@@ -10269,37 +10374,11 @@ function assertNoTrackedDotEnv(cwd = process.cwd()) {
     );
   }
   if (candidates.length === 0) return { checked: true, tracked: false, candidates: [] };
-  let insideRepo;
-  try {
-    insideRepo = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8"
-    }).trim() === "true";
-  } catch (err) {
-    const stderr = String(err?.stderr || "");
-    const notARepo = /not a git repository|does not appear to be a git repository/i.test(stderr);
-    if (notARepo) return { checked: true, tracked: false, candidates };
-    throw new SkillError(
-      "TRACKED_DOTENV_UNVERIFIABLE",
-      `Found ${candidates.length} .env file(s) here, but git could not be consulted (${err?.code || "unknown error"}), so it cannot be proved they are untracked. Refusing to use hot-wallet keys in this directory.`
-    );
-  }
-  if (!insideRepo) return { checked: true, tracked: false, candidates };
-  let out;
-  try {
-    out = execFileSync("git", ["ls-files", "-z", "--", ...candidates], {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"],
-      encoding: "utf8"
-    });
-  } catch {
-    throw new SkillError(
-      "TRACKED_DOTENV_UNVERIFIABLE",
-      "git could not report whether the .env file(s) in this directory are tracked. Refusing to use hot-wallet keys rather than assuming they are safe."
-    );
-  }
-  const tracked = out.split("\0").filter(Boolean);
+  const repo = findGitRepo(cwd);
+  if (!repo) return { checked: true, tracked: false, candidates };
+  const tracked = trackedAmong(repo, candidates.map((f) => path.join(cwd, f))).map(
+    (f) => path.basename(f)
+  );
   if (tracked.length) {
     throw new SkillError(
       "TRACKED_DOTENV",
@@ -10313,7 +10392,7 @@ function assertNoTrackedDotEnv(cwd = process.cwd()) {
 import fs3 from "node:fs";
 import path3 from "node:path";
 import os2 from "node:os";
-import crypto3 from "node:crypto";
+import crypto4 from "node:crypto";
 
 // node_modules/viem/_esm/utils/getAction.js
 function getAction(client, actionFn, name) {
@@ -11375,14 +11454,6 @@ async function prepareTransactionRequest(client, args) {
   }
   let account = account_ ? parseAccount(account_) : account_;
   let nonce = request2.nonce;
-  if (parameters.includes("nonce") && typeof nonce === "undefined" && account && nonceManager) {
-    const chainId2 = await getChainId2();
-    nonce = await nonceManager.consume({
-      address: account.address,
-      chainId: chainId2,
-      client
-    });
-  }
   if (prepareTransactionRequest2?.fn && prepareTransactionRequest2.runAt?.includes("beforeFillTransaction")) {
     request2 = await prepareTransactionRequest2.fn({ ...request2, chain }, {
       client,
@@ -11392,13 +11463,21 @@ async function prepareTransactionRequest(client, args) {
     const sender = request2.account ?? request2.from;
     account = sender ? parseAccount(sender) : void 0;
   }
+  if (parameters.includes("nonce") && typeof nonce === "undefined" && account && nonceManager) {
+    const chainId2 = await getChainId2();
+    nonce = await nonceManager.consume({
+      address: account.address,
+      chainId: chainId2,
+      client
+    });
+  }
   const attemptFill = (() => {
     if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && request2.kzg && request2.blobs)
       return false;
-    if (supportsFillTransaction.get(client.uid) === false)
-      return false;
     if (parameters.length > 0 && "feePayer" in request2 && request2.feePayer && !("feePayerSignature" in request2 && request2.feePayerSignature))
       return true;
+    if (supportsFillTransaction.get(client.uid) === false)
+      return false;
     const shouldAttempt = ["fees", "gas"].some((parameter) => parameters.includes(parameter));
     if (!shouldAttempt)
       return false;
@@ -12530,17 +12609,29 @@ async function sendTransaction(client, parameters) {
       }
     }
     if (account?.type === "local") {
-      if (account.nonceManager && typeof nonce === "undefined") {
-        const requestChainId = rest.chainId;
-        const chainId = await (async () => {
-          if (typeof requestChainId === "number")
-            return requestChainId;
-          if (chain)
-            return chain.id;
-          return getAction(client, getChainId, "getChainId")({});
-        })();
-        nonceManagerParameters = { address: account.address, chainId };
-      }
+      const nonceManager = (() => {
+        if (!account.nonceManager || typeof nonce !== "undefined")
+          return account.nonceManager;
+        const nonceManager2 = account.nonceManager;
+        return {
+          consume(parameters2) {
+            nonceManagerParameters = {
+              address: parameters2.address,
+              chainId: parameters2.chainId
+            };
+            return nonceManager2.consume(parameters2);
+          },
+          get(parameters2) {
+            return nonceManager2.get(parameters2);
+          },
+          increment(parameters2) {
+            return nonceManager2.increment(parameters2);
+          },
+          reset(parameters2) {
+            return nonceManager2.reset(parameters2);
+          }
+        };
+      })();
       const request2 = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
         account,
         accessList,
@@ -12554,7 +12645,7 @@ async function sendTransaction(client, parameters) {
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
-        nonceManager: account.nonceManager,
+        nonceManager,
         parameters: [...defaultParameters, "sidecars"],
         type,
         value,
@@ -13059,6 +13150,7 @@ function bindActionDecorators(client, action) {
     "estimateGas",
     "prepare",
     "prepareRecipient",
+    "predict",
     "simulate"
   ])
     if (Object.hasOwn(action, key)) {
@@ -20454,17 +20546,29 @@ async function sendTransactionSync(client, parameters) {
       return receipt;
     }
     if (account?.type === "local") {
-      if (account.nonceManager && typeof nonce === "undefined") {
-        const requestChainId = rest.chainId;
-        const chainId = await (async () => {
-          if (typeof requestChainId === "number")
-            return requestChainId;
-          if (chain)
-            return chain.id;
-          return getAction(client, getChainId, "getChainId")({});
-        })();
-        nonceManagerParameters = { address: account.address, chainId };
-      }
+      const nonceManager = (() => {
+        if (!account.nonceManager || typeof nonce !== "undefined")
+          return account.nonceManager;
+        const nonceManager2 = account.nonceManager;
+        return {
+          consume(parameters2) {
+            nonceManagerParameters = {
+              address: parameters2.address,
+              chainId: parameters2.chainId
+            };
+            return nonceManager2.consume(parameters2);
+          },
+          get(parameters2) {
+            return nonceManager2.get(parameters2);
+          },
+          increment(parameters2) {
+            return nonceManager2.increment(parameters2);
+          },
+          reset(parameters2) {
+            return nonceManager2.reset(parameters2);
+          }
+        };
+      })();
       const request2 = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
         account,
         accessList,
@@ -20478,7 +20582,7 @@ async function sendTransactionSync(client, parameters) {
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
-        nonceManager: account.nonceManager,
+        nonceManager,
         parameters: [...defaultParameters, "sidecars"],
         type,
         value,
@@ -21504,7 +21608,7 @@ function decryptKeystoreV3(keystore, passphrase) {
     if (!n || !r || !p || !dklen || !salt) {
       throw new SkillError("BAD_KEYSTORE", "The keystore scrypt parameters are incomplete.");
     }
-    derived = crypto3.scryptSync(pass, Buffer.from(salt, "hex"), dklen, {
+    derived = crypto4.scryptSync(pass, Buffer.from(salt, "hex"), dklen, {
       N: n,
       r,
       p,
@@ -21520,7 +21624,7 @@ function decryptKeystoreV3(keystore, passphrase) {
     if (!iterations || !dklen || !salt) {
       throw new SkillError("BAD_KEYSTORE", "The keystore pbkdf2 parameters are incomplete.");
     }
-    derived = crypto3.pbkdf2Sync(pass, Buffer.from(salt, "hex"), iterations, dklen, "sha256");
+    derived = crypto4.pbkdf2Sync(pass, Buffer.from(salt, "hex"), iterations, dklen, "sha256");
   } else {
     throw new SkillError("BAD_KEYSTORE", `Unsupported keystore KDF "${c.kdf}".`);
   }
@@ -21535,7 +21639,7 @@ function decryptKeystoreV3(keystore, passphrase) {
   if (c.cipher !== "aes-128-ctr") {
     throw new SkillError("BAD_KEYSTORE", `Unsupported keystore cipher "${c.cipher}".`);
   }
-  const decipher = crypto3.createDecipheriv(
+  const decipher = crypto4.createDecipheriv(
     "aes-128-ctr",
     derived.subarray(0, 16),
     Buffer.from(c.cipherparams.iv, "hex")
@@ -21557,7 +21661,7 @@ function timingSafeEqualHex(a, b) {
   const ab = Buffer.from(String(a).toLowerCase(), "hex");
   const bb = Buffer.from(String(b).toLowerCase(), "hex");
   if (ab.length === 0 || ab.length !== bb.length) return false;
-  return crypto3.timingSafeEqual(ab, bb);
+  return crypto4.timingSafeEqual(ab, bb);
 }
 function looksLikeKeystore(text) {
   const t = String(text).trimStart();
@@ -21713,6 +21817,9 @@ function promptPassphrase(prompt = "  Keystore passphrase: ") {
   });
 }
 
+// scripts/src/lib/api.mjs
+import { createRequire } from "node:module";
+
 // scripts/src/lib/http.mjs
 var DEFAULT_TIMEOUT_MS = 2e4;
 var USER_AGENT = "rozo-checkout-skill/1.0";
@@ -21779,7 +21886,20 @@ function getJson(url, opts) {
 }
 
 // scripts/src/lib/api.mjs
+var PKG_VERSION = (() => {
+  const requireFrom = createRequire(import.meta.url);
+  for (const candidate of ["../../package.json", "../../../package.json"]) {
+    try {
+      const pkg = requireFrom(candidate);
+      if (pkg?.name === "@rozoai/checkout" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+})();
 var MPP_BASE = process.env.ROZO_CHECKOUT_MPP_BASE || "https://apiserver.mpprouter.dev/v1/services/rozo-agent-api";
+var CLIENT_LABEL = `rozo-checkout-cli/${PKG_VERSION}`;
+var ATTRIBUTION_CLIENT = `rozo-checkout-skill/${PKG_VERSION}`;
 var INTENTS_BASE = process.env.ROZO_CHECKOUT_INTENTS_BASE || "https://intentapiv4.rozo.ai/functions/v1/payment-api";
 async function invoiceStatus({ linkId, rozoPaymentId }) {
   const qs = new URLSearchParams();
@@ -22107,7 +22227,7 @@ function checkExpiry({
 // scripts/src/lib/blacklist.mjs
 import fs4 from "node:fs";
 import path4 from "node:path";
-import crypto4 from "node:crypto";
+import crypto5 from "node:crypto";
 import { fileURLToPath } from "node:url";
 var BlacklistError = class extends Error {
   constructor(code, message) {
@@ -22142,7 +22262,7 @@ function parseBlacklist(doc) {
     }
     addresses.push(e.address);
   }
-  const digest = crypto4.createHash("sha256").update(JSON.stringify(addresses), "utf8").digest("hex");
+  const digest = crypto5.createHash("sha256").update(JSON.stringify(addresses), "utf8").digest("hex");
   if (typeof provenance.addressesSha256 !== "string" || !provenance.addressesSha256) {
     throw new BlacklistError("BLACKLIST_UNAVAILABLE", "Blacklist provenance digest is missing.");
   }
@@ -22231,7 +22351,7 @@ function assertNotBlacklisted(targets, blacklist) {
 import fs5 from "node:fs";
 import path5 from "node:path";
 import os3 from "node:os";
-import crypto5 from "node:crypto";
+import crypto6 from "node:crypto";
 var LOCK_STALE_MS = 6e4;
 var LOCK_WAIT_MS = 1e4;
 var LOCK_POLL_MS = 25;
@@ -22261,7 +22381,7 @@ function withLock(fn) {
     try {
       const age = Date.now() - fs5.statSync(file).mtimeMs;
       if (age > LOCK_STALE_MS) {
-        const stolen = `${file}.stale.${crypto5.randomBytes(4).toString("hex")}`;
+        const stolen = `${file}.stale.${crypto6.randomBytes(4).toString("hex")}`;
         try {
           fs5.renameSync(file, stolen);
           fs5.unlinkSync(stolen);
@@ -22302,7 +22422,7 @@ function statePath(rozoPaymentId) {
 function writeAtomic(file, data) {
   const dir = path5.dirname(file);
   fs5.mkdirSync(dir, { recursive: true, mode: 448 });
-  const tmp = path5.join(dir, `.${path5.basename(file)}.${crypto5.randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path5.join(dir, `.${path5.basename(file)}.${crypto6.randomBytes(6).toString("hex")}.tmp`);
   const fd = fs5.openSync(tmp, "wx", 384);
   try {
     fs5.writeFileSync(fd, JSON.stringify(data, null, 2) + "\n", "utf8");
@@ -22341,7 +22461,7 @@ function depositDigest(source) {
     amountUnit: source?.amountUnit ?? null,
     lnInvoice: source?.lnInvoice ?? null
   });
-  return crypto5.createHash("sha256").update(canonical, "utf8").digest("hex");
+  return crypto6.createHash("sha256").update(canonical, "utf8").digest("hex");
 }
 function claimSend(rozoPaymentId, intent, { skipCaps = false } = {}) {
   return withLock(() => {