@veil-cash/sdk 0.6.3 → 0.6.5

package/dist/index.cjs

@@ -1,15 +1,15 @@
 'use strict';
 
 var ethers = require('ethers');
+var buffer = require('buffer');
 var accounts = require('viem/accounts');
-var crypto = require('crypto');
+var _ethSigUtil = require('eth-sig-util');
+var _circomlib = require('circomlib');
 var viem = require('viem');
 var chains = require('viem/chains');
 var MerkleTree = require('fixed-merkle-tree-legacy');
 var snarkjs = require('snarkjs');
-var path = require('path');
-var fs = require('fs');
-var url = require('url');
+var ffjavascript = require('ffjavascript');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -32,18 +32,20 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+var _ethSigUtil__namespace = /*#__PURE__*/_interopNamespace(_ethSigUtil);
+var _circomlib__namespace = /*#__PURE__*/_interopNamespace(_circomlib);
 var MerkleTree__default = /*#__PURE__*/_interopDefault(MerkleTree);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var circomlib = __require("circomlib");
+// src/keypair.ts
+function resolveInterop(mod) {
+  if (mod && typeof mod === "object" && "default" in mod) {
+    const defaultVal = mod.default;
+    if (defaultVal != null) return defaultVal;
+  }
+  return mod;
+}
+var ethSigUtil = resolveInterop(_ethSigUtil__namespace);
+var circomlib = resolveInterop(_circomlib__namespace);
 var poseidon = circomlib.poseidon;
 var FIELD_SIZE = BigInt(
   "21888242871839275222246405745257275088548364400416034343698204186575808495617"
@@ -51,7 +53,11 @@ var FIELD_SIZE = BigInt(
 var poseidonHash = (items) => BigInt(poseidon(items).toString());
 var poseidonHash2 = (a, b) => poseidonHash([a, b]);
 var randomBN = (nbytes = 31) => {
-  const bytes = crypto__namespace.randomBytes(nbytes);
+  const cryptoApi = globalThis.crypto;
+  if (!cryptoApi?.getRandomValues) {
+    throw new Error("Secure random number generation is unavailable in this runtime");
+  }
+  const bytes = cryptoApi.getRandomValues(new Uint8Array(nbytes));
   let hex = "0x";
   for (let i = 0; i < bytes.length; i++) {
     hex += bytes[i].toString(16).padStart(2, "0");
@@ -60,7 +66,7 @@ var randomBN = (nbytes = 31) => {
 };
 function toFixedHex(number, length = 32) {
   let hexValue;
-  if (number instanceof Buffer) {
+  if (number instanceof buffer.Buffer) {
     hexValue = number.toString("hex");
   } else {
     let bigIntValue = BigInt(number);
@@ -75,11 +81,10 @@ function toFixedHex(number, length = 32) {
 var toBuffer = (value, length) => {
   const bigIntValue = BigInt(value);
   const hex = bigIntValue.toString(16).padStart(length * 2, "0");
-  return Buffer.from(hex, "hex");
+  return buffer.Buffer.from(hex, "hex");
 };
 function getExtDataHash(extData) {
-  const { ethers: ethers2 } = __require("ethers");
-  const abi = ethers2.AbiCoder.defaultAbiCoder();
+  const abi = ethers.ethers.AbiCoder.defaultAbiCoder();
   const encodedData = abi.encode(
     ["tuple(address,int256,address,uint256,bytes,bytes)"],
     [[
@@ -91,7 +96,7 @@ function getExtDataHash(extData) {
       extData.encryptedOutput2
     ]]
   );
-  const hash = ethers2.keccak256(encodedData);
+  const hash = ethers.ethers.keccak256(encodedData);
   return BigInt(hash) % FIELD_SIZE;
 }
 function shuffle(array) {
@@ -107,15 +112,14 @@ function shuffle(array) {
 
 // src/keypair.ts
 var VEIL_SIGNED_MESSAGE = "Sign this message to create your Veil Wallet private key. This will be used to decrypt your balances. Ensure you are signing this message on the Veil Cash website.";
-var ethSigUtil = __require("eth-sig-util");
 function packEncryptedMessage(encryptedMessage) {
-  const nonceBuf = Buffer.from(encryptedMessage.nonce, "base64");
-  const ephemPublicKeyBuf = Buffer.from(encryptedMessage.ephemPublicKey, "base64");
-  const ciphertextBuf = Buffer.from(encryptedMessage.ciphertext, "base64");
-  const messageBuff = Buffer.concat([
-    Buffer.alloc(24 - nonceBuf.length),
+  const nonceBuf = buffer.Buffer.from(encryptedMessage.nonce, "base64");
+  const ephemPublicKeyBuf = buffer.Buffer.from(encryptedMessage.ephemPublicKey, "base64");
+  const ciphertextBuf = buffer.Buffer.from(encryptedMessage.ciphertext, "base64");
+  const messageBuff = buffer.Buffer.concat([
+    buffer.Buffer.alloc(24 - nonceBuf.length),
     nonceBuf,
-    Buffer.alloc(32 - ephemPublicKeyBuf.length),
+    buffer.Buffer.alloc(32 - ephemPublicKeyBuf.length),
     ephemPublicKeyBuf,
     ciphertextBuf
   ]);
@@ -125,7 +129,7 @@ function unpackEncryptedMessage(encryptedMessage) {
   if (encryptedMessage.slice(0, 2) === "0x") {
     encryptedMessage = encryptedMessage.slice(2);
   }
-  const messageBuff = Buffer.from(encryptedMessage, "hex");
+  const messageBuff = buffer.Buffer.from(encryptedMessage, "hex");
   const nonceBuf = messageBuff.slice(0, 24);
   const ephemPublicKeyBuf = messageBuff.slice(24, 56);
   const ciphertextBuf = messageBuff.slice(56);
@@ -158,7 +162,7 @@ var Keypair = class _Keypair {
    * @returns Deposit key as hex string (130 chars with 0x prefix)
    */
   toString() {
-    return toFixedHex(this.pubkey) + Buffer.from(this.encryptionKey, "base64").toString("hex");
+    return toFixedHex(this.pubkey) + buffer.Buffer.from(this.encryptionKey, "base64").toString("hex");
   }
   /**
    * Alias for toString() - returns the deposit key
@@ -183,7 +187,7 @@ var Keypair = class _Keypair {
     return Object.assign(new _Keypair(), {
       privkey: null,
       pubkey: BigInt("0x" + str.slice(0, 64)),
-      encryptionKey: Buffer.from(str.slice(64, 128), "hex").toString("base64")
+      encryptionKey: buffer.Buffer.from(str.slice(64, 128), "hex").toString("base64")
     });
   }
   /**
@@ -284,14 +288,12 @@ var Keypair = class _Keypair {
     if (!this.privkey) {
       throw new Error("Cannot decrypt without private key");
     }
-    return Buffer.from(
+    return buffer.Buffer.from(
       ethSigUtil.decrypt(unpackEncryptedMessage(data), this.privkey.slice(2)),
       "base64"
     );
   }
 };
-
-// src/utxo.ts
 var Utxo = class _Utxo {
   amount;
   blinding;
@@ -342,7 +344,7 @@ var Utxo = class _Utxo {
    * @returns Encrypted data as 0x-prefixed hex string
    */
   encrypt() {
-    const bytes = Buffer.concat([
+    const bytes = buffer.Buffer.concat([
       toBuffer(this.amount, 31),
       toBuffer(this.blinding, 31)
     ]);
@@ -1484,30 +1486,46 @@ function getMerklePath(tree, commitment) {
     pathIndices: index
   };
 }
-var utils = null;
-try {
-  const ffjavascript = __require("ffjavascript");
-  utils = ffjavascript.utils;
-} catch {
-  console.warn("ffjavascript not found. Proof generation may not work.");
+var ffUtils = ffjavascript.utils;
+function isBrowserRuntime() {
+  return !(typeof process !== "undefined" && !!process.versions?.node);
+}
+function stripTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
 }
-function findKeysDirectory() {
+function normalizeCircuitBasePath(provingKeyPath, circuitName) {
+  const resolvedPath = typeof provingKeyPath === "function" ? provingKeyPath(circuitName) : provingKeyPath;
+  const withoutExtension = resolvedPath.replace(/\.(wasm|zkey)$/i, "");
+  if (withoutExtension.endsWith(`/${circuitName}`) || withoutExtension.endsWith(`\\${circuitName}`)) {
+    return withoutExtension;
+  }
+  return `${stripTrailingSlash(withoutExtension)}/${circuitName}`;
+}
+function importNodeModule(specifier) {
+  const dynamicImport = new Function("specifier", "return import(specifier)");
+  return dynamicImport(specifier);
+}
+async function findNodeKeysDirectory() {
+  const [{ existsSync }, pathModule, { fileURLToPath }] = await Promise.all([
+    importNodeModule("node:fs"),
+    importNodeModule("node:path"),
+    importNodeModule("node:url")
+  ]);
+  const path = pathModule;
   const possiblePaths = [
     // When running from package (installed via npm)
-    path__namespace.resolve(__dirname, "..", "keys"),
-    path__namespace.resolve(__dirname, "..", "..", "keys"),
+    path.resolve(process.cwd(), "node_modules", "@veil-cash", "sdk", "keys"),
     // When running from source
-    path__namespace.resolve(process.cwd(), "keys")
-    // ESM module path
+    path.resolve(process.cwd(), "keys")
   ];
   try {
-    const currentFilePath = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-    const currentDir = path__namespace.dirname(currentFilePath);
-    possiblePaths.unshift(path__namespace.resolve(currentDir, "..", "keys"));
+    const currentFilePath = fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    const currentDir = path.dirname(currentFilePath);
+    possiblePaths.unshift(path.resolve(currentDir, "..", "keys"));
   } catch {
   }
   for (const p of possiblePaths) {
-    if (fs__namespace.existsSync(p) && fs__namespace.existsSync(path__namespace.join(p, "transaction2.wasm"))) {
+    if (existsSync(p) && existsSync(path.join(p, "transaction2.wasm"))) {
       return p;
     }
   }
@@ -1515,26 +1533,48 @@ function findKeysDirectory() {
     "Circuit keys not found. Expected to find keys/ directory with transaction2.wasm and transaction2.zkey files."
   );
 }
-async function prove(input, circuitName) {
-  if (!utils) {
-    throw new Error("ffjavascript is required for proof generation. Please install it: npm install ffjavascript");
+async function resolveProvingKeyPaths(circuitName, provingKeyPath) {
+  if (provingKeyPath) {
+    const circuitBasePath = normalizeCircuitBasePath(provingKeyPath, circuitName);
+    return {
+      wasmPath: `${circuitBasePath}.wasm`,
+      zkeyPath: `${circuitBasePath}.zkey`
+    };
   }
-  const keysDir = findKeysDirectory();
-  const wasmPath = path__namespace.join(keysDir, `${circuitName}.wasm`);
-  const zkeyPath = path__namespace.join(keysDir, `${circuitName}.zkey`);
-  if (!fs__namespace.existsSync(wasmPath)) {
+  if (isBrowserRuntime()) {
+    return {
+      wasmPath: `/keys/${circuitName}.wasm`,
+      zkeyPath: `/keys/${circuitName}.zkey`
+    };
+  }
+  const keysDir = await findNodeKeysDirectory();
+  return {
+    wasmPath: `${keysDir}/${circuitName}.wasm`,
+    zkeyPath: `${keysDir}/${circuitName}.zkey`
+  };
+}
+async function assertNodeKeyFilesExist(wasmPath, zkeyPath) {
+  if (isBrowserRuntime() || wasmPath.startsWith("http://") || wasmPath.startsWith("https://")) {
+    return;
+  }
+  const { existsSync } = await importNodeModule("node:fs");
+  if (!existsSync(wasmPath)) {
     throw new Error(`Circuit WASM file not found: ${wasmPath}`);
   }
-  if (!fs__namespace.existsSync(zkeyPath)) {
+  if (!existsSync(zkeyPath)) {
     throw new Error(`Circuit zkey file not found: ${zkeyPath}`);
   }
+}
+async function prove(input, circuitName, options = {}) {
+  const { wasmPath, zkeyPath } = await resolveProvingKeyPaths(circuitName, options.provingKeyPath);
+  await assertNodeKeyFilesExist(wasmPath, zkeyPath);
   const result = await snarkjs.groth16.fullProve(
-    utils.stringifyBigInts(input),
+    ffUtils.stringifyBigInts(input),
     wasmPath,
     zkeyPath,
     void 0,
     void 0,
-    { singleThread: true }
+    { singleThread: options.singleThread ?? true }
   );
   const proof = result.proof;
   return "0x" + toFixedHex(proof.pi_a[0]).slice(2) + toFixedHex(proof.pi_a[1]).slice(2) + toFixedHex(proof.pi_b[0][1]).slice(2) + toFixedHex(proof.pi_b[0][0]).slice(2) + toFixedHex(proof.pi_b[1][1]).slice(2) + toFixedHex(proof.pi_b[1][0]).slice(2) + toFixedHex(proof.pi_c[0]).slice(2) + toFixedHex(proof.pi_c[1]).slice(2);
@@ -1562,7 +1602,8 @@ async function getProof({
   fee,
   recipient,
   relayer,
-  onProgress
+  onProgress,
+  provingKeyPath
 }) {
   inputs = shuffle([...inputs]);
   outputs = shuffle([...outputs]);
@@ -1622,7 +1663,7 @@ async function getProof({
   };
   onProgress?.("Generating ZK proof...", `${inputs.length} inputs`);
   const circuitName = selectCircuit(inputs.length);
-  const proof = await prove(proofInput, circuitName);
+  const proof = await prove(proofInput, circuitName, { provingKeyPath });
   const args = {
     proof,
     root: toFixedHex(proofInput.root),
@@ -1644,7 +1685,8 @@ async function prepareTransaction({
   fee = 0,
   recipient = 0,
   relayer = 0,
-  onProgress
+  onProgress,
+  provingKeyPath
 }) {
   if (inputs.length > 16 || outputs.length > 2) {
     throw new Error("Incorrect inputs/outputs count. Maximum: 16 inputs, 2 outputs.");
@@ -1666,7 +1708,8 @@ async function prepareTransaction({
     fee: BigInt(fee),
     recipient: String(recipient),
     relayer: String(relayer),
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   return result;
 }
@@ -1824,6 +1867,7 @@ async function buildWithdrawProof(options) {
     keypair,
     pool = "eth",
     rpcUrl,
+    provingKeyPath,
     onProgress
   } = options;
   const poolConfig = POOL_CONFIG[pool];
@@ -1887,7 +1931,8 @@ async function buildWithdrawProof(options) {
     fee: 0,
     recipient,
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   return {
     proofArgs: {
@@ -1984,6 +2029,7 @@ async function buildTransferProof(options) {
     senderKeypair,
     pool = "eth",
     rpcUrl,
+    provingKeyPath,
     onProgress
   } = options;
   const poolConfig = POOL_CONFIG[pool];
@@ -2062,7 +2108,8 @@ async function buildTransferProof(options) {
     fee: 0,
     recipient: "0x0000000000000000000000000000000000000000",
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   return {
     proofArgs: {
@@ -2104,7 +2151,7 @@ async function transfer(options) {
   };
 }
 async function mergeUtxos(options) {
-  const { amount, keypair, pool = "eth", rpcUrl, onProgress } = options;
+  const { amount, keypair, pool = "eth", rpcUrl, provingKeyPath, onProgress } = options;
   const poolConfig = POOL_CONFIG[pool];
   const poolAddress = getPoolAddress(pool);
   onProgress?.("Fetching your UTXOs...");
@@ -2172,7 +2219,8 @@ async function mergeUtxos(options) {
     fee: 0,
     recipient: "0x0000000000000000000000000000000000000000",
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({
@@ -2584,6 +2632,7 @@ async function mergeSubaccount(options) {
     pool = "eth",
     rpcUrl,
     relayUrl,
+    provingKeyPath,
     onProgress
   } = options;
   const normalizedSlot = normalizeSlot(slot);
@@ -2676,7 +2725,8 @@ async function mergeSubaccount(options) {
     fee: 0,
     recipient: "0x0000000000000000000000000000000000000000",
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({