@veil-cash/sdk 0.6.3 → 0.6.5

package/dist/index.js

@@ -1,21 +1,24 @@
 import { ethers } from 'ethers';
+import { Buffer } from 'buffer';
 import { privateKeyToAccount, privateKeyToAddress } from 'viem/accounts';
-import * as crypto from 'crypto';
+import * as _ethSigUtil from 'eth-sig-util';
+import * as _circomlib from 'circomlib';
 import { encodeFunctionData, parseEther, parseUnits, createPublicClient, http, formatUnits, keccak256, encodePacked, isAddress, formatEther } from 'viem';
 import { base } from 'viem/chains';
 import MerkleTree from 'fixed-merkle-tree-legacy';
 import { groth16 } from 'snarkjs';
-import * as path from 'path';
-import * as fs from 'fs';
-import { fileURLToPath } from 'url';
+import { utils } from 'ffjavascript';
 
-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);
+var circomlib = resolveInterop(_circomlib);
 var poseidon = circomlib.poseidon;
 var FIELD_SIZE = BigInt(
   "21888242871839275222246405745257275088548364400416034343698204186575808495617"
@@ -23,7 +26,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.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");
@@ -50,8 +57,7 @@ var toBuffer = (value, length) => {
   return Buffer.from(hex, "hex");
 };
 function getExtDataHash(extData) {
-  const { ethers: ethers2 } = __require("ethers");
-  const abi = ethers2.AbiCoder.defaultAbiCoder();
+  const abi = ethers.AbiCoder.defaultAbiCoder();
   const encodedData = abi.encode(
     ["tuple(address,int256,address,uint256,bytes,bytes)"],
     [[
@@ -63,7 +69,7 @@ function getExtDataHash(extData) {
       extData.encryptedOutput2
     ]]
   );
-  const hash = ethers2.keccak256(encodedData);
+  const hash = ethers.keccak256(encodedData);
   return BigInt(hash) % FIELD_SIZE;
 }
 function shuffle(array) {
@@ -79,7 +85,6 @@ 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");
@@ -262,8 +267,6 @@ var Keypair = class _Keypair {
     );
   }
 };
-
-// src/utxo.ts
 var Utxo = class _Utxo {
   amount;
   blinding;
@@ -1456,21 +1459,37 @@ 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 = 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.resolve(__dirname, "..", "keys"),
-    path.resolve(__dirname, "..", "..", "keys"),
+    path.resolve(process.cwd(), "node_modules", "@veil-cash", "sdk", "keys"),
     // When running from source
     path.resolve(process.cwd(), "keys")
-    // ESM module path
   ];
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
@@ -1479,7 +1498,7 @@ function findKeysDirectory() {
   } catch {
   }
   for (const p of possiblePaths) {
-    if (fs.existsSync(p) && fs.existsSync(path.join(p, "transaction2.wasm"))) {
+    if (existsSync(p) && existsSync(path.join(p, "transaction2.wasm"))) {
       return p;
     }
   }
@@ -1487,26 +1506,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.join(keysDir, `${circuitName}.wasm`);
-  const zkeyPath = path.join(keysDir, `${circuitName}.zkey`);
-  if (!fs.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.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 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);
@@ -1534,7 +1575,8 @@ async function getProof({
   fee,
   recipient,
   relayer,
-  onProgress
+  onProgress,
+  provingKeyPath
 }) {
   inputs = shuffle([...inputs]);
   outputs = shuffle([...outputs]);
@@ -1594,7 +1636,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),
@@ -1616,7 +1658,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.");
@@ -1638,7 +1681,8 @@ async function prepareTransaction({
     fee: BigInt(fee),
     recipient: String(recipient),
     relayer: String(relayer),
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   return result;
 }
@@ -1796,6 +1840,7 @@ async function buildWithdrawProof(options) {
     keypair,
     pool = "eth",
     rpcUrl,
+    provingKeyPath,
     onProgress
   } = options;
   const poolConfig = POOL_CONFIG[pool];
@@ -1859,7 +1904,8 @@ async function buildWithdrawProof(options) {
     fee: 0,
     recipient,
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   return {
     proofArgs: {
@@ -1956,6 +2002,7 @@ async function buildTransferProof(options) {
     senderKeypair,
     pool = "eth",
     rpcUrl,
+    provingKeyPath,
     onProgress
   } = options;
   const poolConfig = POOL_CONFIG[pool];
@@ -2034,7 +2081,8 @@ async function buildTransferProof(options) {
     fee: 0,
     recipient: "0x0000000000000000000000000000000000000000",
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   return {
     proofArgs: {
@@ -2076,7 +2124,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...");
@@ -2144,7 +2192,8 @@ async function mergeUtxos(options) {
     fee: 0,
     recipient: "0x0000000000000000000000000000000000000000",
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({
@@ -2556,6 +2605,7 @@ async function mergeSubaccount(options) {
     pool = "eth",
     rpcUrl,
     relayUrl,
+    provingKeyPath,
     onProgress
   } = options;
   const normalizedSlot = normalizeSlot(slot);
@@ -2648,7 +2698,8 @@ async function mergeSubaccount(options) {
     fee: 0,
     recipient: "0x0000000000000000000000000000000000000000",
     relayer: "0x0000000000000000000000000000000000000000",
-    onProgress
+    onProgress,
+    provingKeyPath
   });
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({