@veil-cash/sdk 0.6.3 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veil-cash/sdk",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "SDK and CLI for interacting with Veil Cash privacy pools - keypair generation, deposits, and status checking",
   "type": "module",
   "main": "./dist/index.js",
@@ -48,6 +48,7 @@
     "url": "https://github.com/veildotcash/veildotcash-sdk"
   },
   "dependencies": {
+    "buffer": "^6.0.3",
     "circomlib": "github:tornadocash/circomlib#d20d53411d1bef61f38c99a8b36d5d0cc4836aa1",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",

package/src/ffjavascript.d.ts

@@ -0,0 +1,28 @@
+declare module 'ffjavascript' {
+  export const utils: {
+    stringifyBigInts: (obj: unknown) => unknown;
+    unstringifyBigInts: (obj: unknown) => unknown;
+  };
+}
+
+declare module 'circomlib' {
+  const circomlib: {
+    poseidon: (items: Array<bigint | string | number>) => { toString: () => string };
+  };
+  export default circomlib;
+}
+
+declare module 'eth-sig-util' {
+  import type { EncryptedMessage } from './types.js';
+
+  const ethSigUtil: {
+    getEncryptionPublicKey: (privateKey: string) => string;
+    encrypt: (
+      receiverPublicKey: string,
+      msgParams: { data: string },
+      version: 'x25519-xsalsa20-poly1305'
+    ) => EncryptedMessage;
+    decrypt: (encryptedData: EncryptedMessage, receiverPrivateKey: string) => string;
+  };
+  export default ethSigUtil;
+}

package/src/index.ts

@@ -96,7 +96,7 @@ export {
   selectCircuit,
   CIRCUIT_CONFIG,
 } from './prover.js';
-export type { ProofInput } from './prover.js';
+export type { ProofInput, ProveOptions, ProvingKeyPath } from './prover.js';
 
 // Addresses and config
 export { 

package/src/keypair.ts

@@ -4,7 +4,9 @@
  */
 
 import { ethers } from 'ethers';
+import { Buffer } from 'buffer';
 import { privateKeyToAccount } from 'viem/accounts';
+import ethSigUtil from 'eth-sig-util';
 import { poseidonHash, toFixedHex } from './utils.js';
 import type { EncryptedMessage } from './types.js';
 
@@ -20,10 +22,6 @@ export const VEIL_SIGNED_MESSAGE = "Sign this message to create your Veil Wallet
  */
 export type MessageSigner = (message: string) => Promise<string>;
 
-// eth-sig-util for x25519 encryption
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const ethSigUtil = require('eth-sig-util');
-
 /**
  * Pack encrypted message into hex string
  */

package/src/prover.ts

@@ -4,10 +4,8 @@
  */
 
 import { groth16 } from 'snarkjs';
+import { utils } from 'ffjavascript';
 import { toFixedHex } from './utils.js';
-import * as path from 'path';
-import * as fs from 'fs';
-import { fileURLToPath } from 'url';
 
 // Type definition for ffjavascript utils
 interface FFJavascriptUtils {
@@ -15,15 +13,7 @@ interface FFJavascriptUtils {
   unstringifyBigInts: (obj: unknown) => unknown;
 }
 
-// Dynamic import for ffjavascript
-let utils: FFJavascriptUtils | null = null;
-try {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const ffjavascript = require('ffjavascript');
-  utils = ffjavascript.utils;
-} catch {
-  console.warn('ffjavascript not found. Proof generation may not work.');
-}
+const ffUtils = utils as FFJavascriptUtils;
 
 /**
  * Input data for ZK proof generation
@@ -62,19 +52,70 @@ interface ProveResult {
   publicSignals: string[];
 }
 
+/**
+ * Directory/base URL where proving keys are hosted, or a resolver that returns
+ * the circuit base path without the `.wasm` / `.zkey` extension.
+ */
+export type ProvingKeyPath = string | ((circuitName: string) => string);
+
+export interface ProveOptions {
+  /**
+   * Proving key location.
+   *
+   * In Node this defaults to the package/source `keys` directory. In browsers
+   * this defaults to `/keys`, so apps can serve `/keys/transaction2.wasm` and
+   * `/keys/transaction2.zkey` from their own origin.
+   */
+  provingKeyPath?: ProvingKeyPath;
+  /** Force snarkjs single-threaded proving. Defaults to true. */
+  singleThread?: boolean;
+}
+
+function isBrowserRuntime(): boolean {
+  return !(typeof process !== 'undefined' && !!process.versions?.node);
+}
+
+function stripTrailingSlash(value: string): string {
+  return value.endsWith('/') ? value.slice(0, -1) : value;
+}
+
+function normalizeCircuitBasePath(provingKeyPath: ProvingKeyPath, circuitName: string): string {
+  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<T>(specifier: string): Promise<T> {
+  const dynamicImport = new Function('specifier', 'return import(specifier)') as (
+    specifier: string
+  ) => Promise<T>;
+  return dynamicImport(specifier);
+}
+
 /**
  * Find the keys directory containing circuit files
  * Works in both development and installed package scenarios
  */
-function findKeysDirectory(): string {
+async function findNodeKeysDirectory(): Promise<string> {
+  const [{ existsSync }, pathModule, { fileURLToPath }] = await Promise.all([
+    importNodeModule<typeof import('node:fs')>('node:fs'),
+    importNodeModule<typeof import('node:path')>('node:path'),
+    importNodeModule<typeof import('node:url')>('node:url'),
+  ]);
+  const path = pathModule;
+
   // Try multiple possible locations
   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 to get module directory for ESM
@@ -83,11 +124,11 @@ function findKeysDirectory(): string {
     const currentDir = path.dirname(currentFilePath);
     possiblePaths.unshift(path.resolve(currentDir, '..', 'keys'));
   } catch {
-    // Not ESM environment, use __dirname
+    // Ignore non-file module URLs.
   }
 
   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;
     }
   }
@@ -97,6 +138,46 @@ function findKeysDirectory(): string {
   );
 }
 
+async function resolveProvingKeyPaths(
+  circuitName: string,
+  provingKeyPath?: ProvingKeyPath,
+): Promise<{ wasmPath: string; zkeyPath: string }> {
+  if (provingKeyPath) {
+    const circuitBasePath = normalizeCircuitBasePath(provingKeyPath, circuitName);
+    return {
+      wasmPath: `${circuitBasePath}.wasm`,
+      zkeyPath: `${circuitBasePath}.zkey`,
+    };
+  }
+
+  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: string, zkeyPath: string): Promise<void> {
+  if (isBrowserRuntime() || wasmPath.startsWith('http://') || wasmPath.startsWith('https://')) {
+    return;
+  }
+
+  const { existsSync } = await importNodeModule<typeof import('node:fs')>('node:fs');
+  if (!existsSync(wasmPath)) {
+    throw new Error(`Circuit WASM file not found: ${wasmPath}`);
+  }
+  if (!existsSync(zkeyPath)) {
+    throw new Error(`Circuit zkey file not found: ${zkeyPath}`);
+  }
+}
+
 /**
  * Generate a ZK proof for a transaction
  * 
@@ -110,32 +191,23 @@ function findKeysDirectory(): string {
  * // Returns: 0x1234...abcd (256 bytes hex)
  * ```
  */
-export async function prove(input: ProofInput, circuitName: string): Promise<string> {
-  if (!utils) {
-    throw new Error('ffjavascript is required for proof generation. Please install it: npm install ffjavascript');
-  }
-
-  const keysDir = findKeysDirectory();
-  const wasmPath = path.join(keysDir, `${circuitName}.wasm`);
-  const zkeyPath = path.join(keysDir, `${circuitName}.zkey`);
-
-  // Verify files exist
-  if (!fs.existsSync(wasmPath)) {
-    throw new Error(`Circuit WASM file not found: ${wasmPath}`);
-  }
-  if (!fs.existsSync(zkeyPath)) {
-    throw new Error(`Circuit zkey file not found: ${zkeyPath}`);
-  }
+export async function prove(
+  input: ProofInput,
+  circuitName: string,
+  options: ProveOptions = {},
+): Promise<string> {
+  const { wasmPath, zkeyPath } = await resolveProvingKeyPaths(circuitName, options.provingKeyPath);
+  await assertNodeKeyFilesExist(wasmPath, zkeyPath);
 
   // Generate proof using snarkjs
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const result = await groth16.fullProve(
-    utils.stringifyBigInts(input) as any,
+    ffUtils.stringifyBigInts(input) as any,
     wasmPath,
     zkeyPath,
     undefined,
     undefined,
-    { singleThread: true },
+    { singleThread: options.singleThread ?? true },
   );
   const proof = result.proof as unknown as SnarkProof;
 

package/src/subaccount.ts

@@ -563,6 +563,7 @@ export async function mergeSubaccount(
     pool = 'eth',
     rpcUrl,
     relayUrl,
+    provingKeyPath,
     onProgress,
   } = options;
 
@@ -684,6 +685,7 @@ export async function mergeSubaccount(
     recipient: '0x0000000000000000000000000000000000000000',
     relayer: '0x0000000000000000000000000000000000000000',
     onProgress,
+    provingKeyPath,
   });
 
   // Submit to relay

package/src/transaction.ts

@@ -4,7 +4,7 @@
  */
 
 import { buildMerkleTree, MERKLE_TREE_HEIGHT } from './merkle.js';
-import { prove, selectCircuit, type ProofInput } from './prover.js';
+import { prove, selectCircuit, type ProofInput, type ProvingKeyPath } from './prover.js';
 import { toFixedHex, getExtDataHash, shuffle, FIELD_SIZE } from './utils.js';
 import { Utxo } from './utxo.js';
 
@@ -58,6 +58,8 @@ export interface PrepareTransactionParams {
   relayer?: string | bigint | number;
   /** Optional progress callback */
   onProgress?: (stage: string, detail?: string) => void;
+  /** Optional proving key directory/base URL or circuit path resolver */
+  provingKeyPath?: ProvingKeyPath;
 }
 
 /**
@@ -72,6 +74,7 @@ interface GetProofParams {
   recipient: string | bigint;
   relayer: string | bigint;
   onProgress?: (stage: string, detail?: string) => void;
+  provingKeyPath?: ProvingKeyPath;
 }
 
 async function getProof({
@@ -83,6 +86,7 @@ async function getProof({
   recipient,
   relayer,
   onProgress,
+  provingKeyPath,
 }: GetProofParams): Promise<TransactionResult> {
   // Shuffle inputs and outputs for privacy
   inputs = shuffle([...inputs]);
@@ -160,7 +164,7 @@ async function getProof({
 
   // Select circuit based on input count and generate proof
   const circuitName = selectCircuit(inputs.length);
-  const proof = await prove(proofInput, circuitName);
+  const proof = await prove(proofInput, circuitName, { provingKeyPath });
 
   // Build proof arguments for on-chain verification
   const args: ProofArgs = {
@@ -218,6 +222,7 @@ export async function prepareTransaction({
   recipient = 0,
   relayer = 0,
   onProgress,
+  provingKeyPath,
 }: PrepareTransactionParams): Promise<TransactionResult> {
   // Validate input/output counts
   if (inputs.length > 16 || outputs.length > 2) {
@@ -254,6 +259,7 @@ export async function prepareTransaction({
     recipient: String(recipient),
     relayer: String(relayer),
     onProgress,
+    provingKeyPath,
   });
 
   return result;

package/src/transfer.ts

@@ -140,6 +140,7 @@ export async function buildTransferProof(
     senderKeypair,
     pool = 'eth',
     rpcUrl,
+    provingKeyPath,
     onProgress,
   } = options;
 
@@ -246,6 +247,7 @@ export async function buildTransferProof(
     recipient: '0x0000000000000000000000000000000000000000',
     relayer: '0x0000000000000000000000000000000000000000',
     onProgress,
+    provingKeyPath,
   });
 
   return {
@@ -338,9 +340,10 @@ export async function mergeUtxos(options: {
   keypair: Keypair;
   pool?: RelayPool;
   rpcUrl?: string;
+  provingKeyPath?: import('./prover.js').ProvingKeyPath;
   onProgress?: (stage: string, detail?: string) => void;
 }): Promise<TransferResult> {
-  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);
@@ -432,6 +435,7 @@ export async function mergeUtxos(options: {
     recipient: '0x0000000000000000000000000000000000000000',
     relayer: '0x0000000000000000000000000000000000000000',
     onProgress,
+    provingKeyPath,
   });
 
   // 6. Submit to relay

package/src/types.ts

@@ -228,6 +228,13 @@ export interface BuildWithdrawProofOptions {
   pool?: RelayPool;
   /** Optional RPC URL */
   rpcUrl?: string;
+  /**
+   * Optional proving key directory/base URL or resolver.
+   *
+   * Browsers default to `/keys`, expecting files like
+   * `/keys/transaction2.wasm` and `/keys/transaction2.zkey`.
+   */
+  provingKeyPath?: import('./prover.js').ProvingKeyPath;
   /** Progress callback */
   onProgress?: (stage: string, detail?: string) => void;
 }
@@ -246,6 +253,13 @@ export interface BuildTransferProofOptions {
   pool?: RelayPool;
   /** Optional RPC URL */
   rpcUrl?: string;
+  /**
+   * Optional proving key directory/base URL or resolver.
+   *
+   * Browsers default to `/keys`, expecting files like
+   * `/keys/transaction2.wasm` and `/keys/transaction2.zkey`.
+   */
+  provingKeyPath?: import('./prover.js').ProvingKeyPath;
   /** Progress callback */
   onProgress?: (stage: string, detail?: string) => void;
 }
@@ -461,6 +475,13 @@ export interface SubaccountMergeOptions {
   rpcUrl?: string;
   /** Optional relay URL */
   relayUrl?: string;
+  /**
+   * Optional proving key directory/base URL or resolver.
+   *
+   * Browsers default to `/keys`, expecting files like
+   * `/keys/transaction2.wasm` and `/keys/transaction2.zkey`.
+   */
+  provingKeyPath?: import('./prover.js').ProvingKeyPath;
   /** Progress callback */
   onProgress?: (stage: string, detail?: string) => void;
 }

package/src/utils.ts

@@ -3,10 +3,10 @@
  * Poseidon hash, hex conversion, and random number generation
  */
 
-import * as crypto from 'crypto';
+import { ethers } from 'ethers';
+import { Buffer } from 'buffer';
+import circomlib from 'circomlib';
 
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const circomlib = require('circomlib');
 const poseidon = circomlib.poseidon;
 
 /**
@@ -39,7 +39,15 @@ export const poseidonHash2 = (a: bigint | string | number, b: bigint | string |
  * @returns Random bigint
  */
 export const randomBN = (nbytes: number = 31): bigint => {
-  const bytes = crypto.randomBytes(nbytes);
+  const cryptoApi = (globalThis as unknown as {
+    crypto?: { getRandomValues?: <T extends Uint8Array>(array: T) => T };
+  }).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');
@@ -106,7 +114,6 @@ export interface ExtDataInput {
  */
 export function getExtDataHash(extData: ExtDataInput): bigint {
   // Use ethers ABI encoder for Solidity-compatible encoding
-  const { ethers } = require('ethers');
   const abi = ethers.AbiCoder.defaultAbiCoder();
 
   // Encode the struct exactly as Solidity would

package/src/utxo.ts

@@ -3,6 +3,7 @@
  * Represents a private balance entry that can be spent
  */
 
+import { Buffer } from 'buffer';
 import { Keypair } from './keypair.js';
 import { poseidonHash, toBuffer, randomBN } from './utils.js';
 

package/src/withdraw.ts

@@ -145,6 +145,7 @@ export async function buildWithdrawProof(
     keypair,
     pool = 'eth',
     rpcUrl,
+    provingKeyPath,
     onProgress,
   } = options;
 
@@ -231,6 +232,7 @@ export async function buildWithdrawProof(
     recipient,
     relayer: '0x0000000000000000000000000000000000000000',
     onProgress,
+    provingKeyPath,
   });
 
   return {