@cloak.ag/sdk 1.0.7 → 1.0.9

package/dist/index.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,7 +27,159 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CLOAK_PROGRAM_ID: () => CLOAK_PROGRAM_ID,
+  CloakError: () => CloakError,
+  CloakSDK: () => CloakSDK,
+  DEFAULT_CIRCUITS_URL: () => DEFAULT_CIRCUITS_URL,
+  EXPECTED_CIRCUIT_HASHES: () => EXPECTED_CIRCUIT_HASHES,
+  FIXED_FEE_LAMPORTS: () => FIXED_FEE_LAMPORTS,
+  LAMPORTS_PER_SOL: () => LAMPORTS_PER_SOL,
+  LocalStorageAdapter: () => LocalStorageAdapter,
+  MemoryStorageAdapter: () => MemoryStorageAdapter,
+  RelayService: () => RelayService,
+  RootNotFoundError: () => RootNotFoundError,
+  ShieldPoolErrors: () => ShieldPoolErrors,
+  VARIABLE_FEE_RATE: () => VARIABLE_FEE_RATE,
+  VERSION: () => VERSION,
+  areCircuitsAvailable: () => areCircuitsAvailable,
+  bigintToBytes32: () => bigintToBytes32,
+  buildPublicInputsBytes: () => buildPublicInputsBytes,
+  bytesToHex: () => bytesToHex,
+  calculateFee: () => calculateFee2,
+  calculateRelayFee: () => calculateRelayFee,
+  cleanupStalePendingOperations: () => cleanupStalePendingOperations,
+  clearPendingDeposits: () => clearPendingDeposits,
+  clearPendingWithdrawals: () => clearPendingWithdrawals,
+  computeCommitment: () => computeCommitment,
+  computeMerkleRoot: () => computeMerkleRoot,
+  computeNullifier: () => computeNullifier,
+  computeNullifierAsync: () => computeNullifierAsync,
+  computeNullifierSync: () => computeNullifierSync,
+  computeOutputsHash: () => computeOutputsHash,
+  computeOutputsHashAsync: () => computeOutputsHashAsync,
+  computeOutputsHashSync: () => computeOutputsHashSync,
+  computeProofForLatestDeposit: () => computeProofForLatestDeposit,
+  computeProofFromChain: () => computeProofFromChain,
+  computeSwapOutputsHash: () => computeSwapOutputsHash,
+  computeSwapOutputsHashAsync: () => computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync: () => computeSwapOutputsHashSync,
+  copyNoteToClipboard: () => copyNoteToClipboard,
+  createCloakError: () => createCloakError,
+  createDepositInstruction: () => createDepositInstruction,
+  createLogger: () => createLogger,
+  deriveSpendKey: () => deriveSpendKey,
+  deriveViewKey: () => deriveViewKey,
+  detectNetworkFromRpcUrl: () => detectNetworkFromRpcUrl,
+  downloadNote: () => downloadNote,
+  encodeNoteSimple: () => encodeNoteSimple,
+  encryptNoteForRecipient: () => encryptNoteForRecipient,
+  exportKeys: () => exportKeys,
+  exportNote: () => exportNote,
+  exportWalletKeys: () => exportWalletKeys,
+  filterNotesByNetwork: () => filterNotesByNetwork,
+  filterWithdrawableNotes: () => filterWithdrawableNotes,
+  findNoteByCommitment: () => findNoteByCommitment,
+  formatAmount: () => formatAmount,
+  formatErrorForLogging: () => formatErrorForLogging,
+  formatSol: () => formatSol,
+  generateCloakKeys: () => generateCloakKeys,
+  generateCommitment: () => generateCommitment,
+  generateCommitmentAsync: () => generateCommitmentAsync,
+  generateMasterSeed: () => generateMasterSeed,
+  generateNote: () => generateNote,
+  generateNoteFromWallet: () => generateNoteFromWallet,
+  generateWithdrawRegularProof: () => generateWithdrawRegularProof,
+  generateWithdrawSwapProof: () => generateWithdrawSwapProof,
+  getAddressExplorerUrl: () => getAddressExplorerUrl,
+  getDefaultCircuitsPath: () => getDefaultCircuitsPath,
+  getDistributableAmount: () => getDistributableAmount2,
+  getExplorerUrl: () => getExplorerUrl,
+  getNullifierPDA: () => getNullifierPDA,
+  getPendingOperationsSummary: () => getPendingOperationsSummary,
+  getPublicKey: () => getPublicKey,
+  getPublicViewKey: () => getPublicViewKey,
+  getRecipientAmount: () => getRecipientAmount,
+  getRpcUrlForNetwork: () => getRpcUrlForNetwork,
+  getShieldPoolPDAs: () => getShieldPoolPDAs,
+  getSwapStatePDA: () => getSwapStatePDA,
+  getViewKey: () => getViewKey,
+  hasPendingOperations: () => hasPendingOperations,
+  hexToBigint: () => hexToBigint,
+  hexToBytes: () => hexToBytes,
+  importKeys: () => importKeys,
+  importWalletKeys: () => importWalletKeys,
+  isDebugEnabled: () => isDebugEnabled,
+  isRootNotFoundError: () => isRootNotFoundError,
+  isValidHex: () => isValidHex,
+  isValidRpcUrl: () => isValidRpcUrl,
+  isValidSolanaAddress: () => isValidSolanaAddress,
+  isWithdrawable: () => isWithdrawable,
+  keypairToAdapter: () => keypairToAdapter,
+  loadPendingDeposits: () => loadPendingDeposits,
+  loadPendingWithdrawals: () => loadPendingWithdrawals,
+  parseAmount: () => parseAmount,
+  parseError: () => parseError,
+  parseNote: () => parseNote,
+  parseTransactionError: () => parseTransactionError,
+  poseidonHash: () => poseidonHash,
+  prepareEncryptedOutput: () => prepareEncryptedOutput,
+  prepareEncryptedOutputForRecipient: () => prepareEncryptedOutputForRecipient,
+  proofToBytes: () => proofToBytes,
+  pubkeyToLimbs: () => pubkeyToLimbs,
+  randomBytes: () => randomBytes,
+  readMerkleTreeState: () => readMerkleTreeState,
+  removePendingDeposit: () => removePendingDeposit,
+  removePendingWithdrawal: () => removePendingWithdrawal,
+  savePendingDeposit: () => savePendingDeposit,
+  savePendingWithdrawal: () => savePendingWithdrawal,
+  scanNotesForWallet: () => scanNotesForWallet,
+  sdkLogger: () => sdkLogger,
+  sendTransaction: () => sendTransaction,
+  serializeNote: () => serializeNote,
+  setDebugMode: () => setDebugMode,
+  signTransaction: () => signTransaction,
+  splitTo2Limbs: () => splitTo2Limbs,
+  truncate: () => truncate,
+  tryDecryptNote: () => tryDecryptNote,
+  updateNoteWithDeposit: () => updateNoteWithDeposit,
+  updatePendingDeposit: () => updatePendingDeposit,
+  updatePendingWithdrawal: () => updatePendingWithdrawal,
+  validateDepositParams: () => validateDepositParams,
+  validateNote: () => validateNote,
+  validateOutputsSum: () => validateOutputsSum,
+  validateTransfers: () => validateTransfers,
+  validateWalletConnected: () => validateWalletConnected,
+  validateWithdrawableNote: () => validateWithdrawableNote,
+  verifyAllCircuits: () => verifyAllCircuits,
+  verifyCircuitIntegrity: () => verifyCircuitIntegrity,
+  withTiming: () => withTiming
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/CloakSDK.ts
+var import_web34 = require("@solana/web3.js");
+
+// src/core/types.ts
+var CloakError = class extends Error {
+  constructor(message, category, retryable = false, originalError) {
+    super(message);
+    this.category = category;
+    this.retryable = retryable;
+    this.originalError = originalError;
+    this.name = "CloakError";
+  }
+};
+
+// src/core/keys.ts
+var import_blake3 = require("@noble/hashes/blake3");
+var import_tweetnacl = __toESM(require("tweetnacl"), 1);
+
 // src/utils/crypto.ts
+var import_circomlibjs = require("circomlibjs");
+var poseidon = null;
 async function getPoseidon() {
   if (!poseidon) {
     poseidon = await (0, import_circomlibjs.buildPoseidon)();
@@ -201,6 +350,7 @@ function isValidHex(hex, expectedLength) {
   }
   return true;
 }
+var BN254_MODULUS = BigInt("0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47");
 function proofToBytes(proof) {
   const pi_a_x = BigInt(proof.pi_a[0]);
   const pi_a_y = BigInt(proof.pi_a[1]);
@@ -291,261 +441,8 @@ function buildPublicInputsBytes(root, nullifier, outputsHash, publicAmount) {
   result.set(amountBytes, 96);
   return result;
 }
-var import_circomlibjs, poseidon, BN254_MODULUS;
-var init_crypto = __esm({
-  "src/utils/crypto.ts"() {
-    "use strict";
-    import_circomlibjs = require("circomlibjs");
-    poseidon = null;
-    BN254_MODULUS = BigInt("0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47");
-  }
-});
-
-// src/utils/onchain-proof.ts
-var onchain_proof_exports = {};
-__export(onchain_proof_exports, {
-  computeProofForLatestDeposit: () => computeProofForLatestDeposit,
-  computeProofFromChain: () => computeProofFromChain,
-  readMerkleTreeState: () => readMerkleTreeState
-});
-async function ensureZeroValues() {
-  if (zeroValuesComputed) return;
-  for (let i = 1; i <= MERKLE_TREE_HEIGHT; i++) {
-    const prevZeroHex = POSEIDON_ZERO_VALUES[i - 1];
-    const prevZeroBigInt = BigInt("0x" + prevZeroHex);
-    const hash = await poseidonHash([prevZeroBigInt, prevZeroBigInt]);
-    POSEIDON_ZERO_VALUES[i] = hash.toString(16).padStart(64, "0");
-  }
-  zeroValuesComputed = true;
-}
-async function readMerkleTreeState(connection, merkleTreePDA) {
-  const accountInfo = await connection.getAccountInfo(merkleTreePDA);
-  if (!accountInfo) {
-    throw new Error("Merkle tree account not found");
-  }
-  const data = accountInfo.data;
-  const nextIndex = Number(data.readBigUInt64LE(32));
-  const subtrees = [];
-  for (let i = 0; i < MERKLE_TREE_HEIGHT; i++) {
-    const offset = SUBTREES_OFFSET + i * 32;
-    const subtree = data.slice(offset, offset + 32);
-    subtrees.push(Buffer.from(subtree).toString("hex"));
-  }
-  const root = Buffer.from(data.slice(ROOT_OFFSET, ROOT_OFFSET + 32)).toString("hex");
-  return { nextIndex, root, subtrees };
-}
-async function computeProofFromChain(connection, merkleTreePDA, leafIndex) {
-  await ensureZeroValues();
-  const { nextIndex, root, subtrees } = await readMerkleTreeState(connection, merkleTreePDA);
-  if (leafIndex >= nextIndex) {
-    throw new Error(`Leaf index ${leafIndex} is beyond next_index ${nextIndex}`);
-  }
-  const pathElements = [];
-  const pathIndices = [];
-  let index = leafIndex;
-  for (let level = 0; level < MERKLE_TREE_HEIGHT; level++) {
-    pathIndices.push(index % 2);
-    if (index % 2 === 0) {
-      const siblingIndex = index + 1;
-      const levelNextIndex = Math.ceil(nextIndex / (1 << level));
-      if (siblingIndex >= levelNextIndex) {
-        pathElements.push(POSEIDON_ZERO_VALUES[level]);
-      } else {
-        pathElements.push(POSEIDON_ZERO_VALUES[level]);
-      }
-    } else {
-      pathElements.push(subtrees[level]);
-    }
-    index = Math.floor(index / 2);
-  }
-  return { pathElements, pathIndices, root };
-}
-async function computeProofForLatestDeposit(connection, merkleTreePDA) {
-  await ensureZeroValues();
-  const { nextIndex, root, subtrees } = await readMerkleTreeState(connection, merkleTreePDA);
-  if (nextIndex === 0) {
-    throw new Error("No leaves in tree");
-  }
-  const leafIndex = nextIndex - 1;
-  const proof = await computeProofInternal(leafIndex, nextIndex, subtrees);
-  return { ...proof, root, leafIndex };
-}
-async function computeProofInternal(leafIndex, _nextIndex, subtrees) {
-  const pathElements = [];
-  const pathIndices = [];
-  let index = leafIndex;
-  for (let level = 0; level < MERKLE_TREE_HEIGHT; level++) {
-    pathIndices.push(index % 2);
-    if (index % 2 === 0) {
-      pathElements.push(POSEIDON_ZERO_VALUES[level]);
-    } else {
-      pathElements.push(subtrees[level]);
-    }
-    index = Math.floor(index / 2);
-  }
-  return { pathElements, pathIndices };
-}
-var MERKLE_TREE_HEIGHT, SUBTREES_OFFSET, ROOT_OFFSET, POSEIDON_ZERO_VALUES, zeroValuesComputed;
-var init_onchain_proof = __esm({
-  "src/utils/onchain-proof.ts"() {
-    "use strict";
-    init_crypto();
-    MERKLE_TREE_HEIGHT = 32;
-    SUBTREES_OFFSET = 40;
-    ROOT_OFFSET = 40 + MERKLE_TREE_HEIGHT * 32;
-    POSEIDON_ZERO_VALUES = [
-      "0000000000000000000000000000000000000000000000000000000000000000"
-      // level 0
-    ];
-    zeroValuesComputed = false;
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  CLOAK_PROGRAM_ID: () => CLOAK_PROGRAM_ID,
-  CloakError: () => CloakError,
-  CloakSDK: () => CloakSDK,
-  EXPECTED_CIRCUIT_HASHES: () => EXPECTED_CIRCUIT_HASHES,
-  FIXED_FEE_LAMPORTS: () => FIXED_FEE_LAMPORTS,
-  LAMPORTS_PER_SOL: () => LAMPORTS_PER_SOL,
-  LocalStorageAdapter: () => LocalStorageAdapter,
-  MemoryStorageAdapter: () => MemoryStorageAdapter,
-  RelayService: () => RelayService,
-  RootNotFoundError: () => RootNotFoundError,
-  ShieldPoolErrors: () => ShieldPoolErrors,
-  VARIABLE_FEE_RATE: () => VARIABLE_FEE_RATE,
-  VERSION: () => VERSION,
-  bigintToBytes32: () => bigintToBytes32,
-  buildPublicInputsBytes: () => buildPublicInputsBytes,
-  bytesToHex: () => bytesToHex,
-  calculateFee: () => calculateFee2,
-  calculateRelayFee: () => calculateRelayFee,
-  cleanupStalePendingOperations: () => cleanupStalePendingOperations,
-  clearPendingDeposits: () => clearPendingDeposits,
-  clearPendingWithdrawals: () => clearPendingWithdrawals,
-  computeCommitment: () => computeCommitment,
-  computeMerkleRoot: () => computeMerkleRoot,
-  computeNullifier: () => computeNullifier,
-  computeNullifierAsync: () => computeNullifierAsync,
-  computeNullifierSync: () => computeNullifierSync,
-  computeOutputsHash: () => computeOutputsHash,
-  computeOutputsHashAsync: () => computeOutputsHashAsync,
-  computeOutputsHashSync: () => computeOutputsHashSync,
-  computeProofForLatestDeposit: () => computeProofForLatestDeposit,
-  computeProofFromChain: () => computeProofFromChain,
-  computeSwapOutputsHash: () => computeSwapOutputsHash,
-  computeSwapOutputsHashAsync: () => computeSwapOutputsHashAsync,
-  computeSwapOutputsHashSync: () => computeSwapOutputsHashSync,
-  copyNoteToClipboard: () => copyNoteToClipboard,
-  createCloakError: () => createCloakError,
-  createDepositInstruction: () => createDepositInstruction,
-  createLogger: () => createLogger,
-  deriveSpendKey: () => deriveSpendKey,
-  deriveViewKey: () => deriveViewKey,
-  detectNetworkFromRpcUrl: () => detectNetworkFromRpcUrl,
-  downloadNote: () => downloadNote,
-  encodeNoteSimple: () => encodeNoteSimple,
-  encryptNoteForRecipient: () => encryptNoteForRecipient,
-  exportKeys: () => exportKeys,
-  exportNote: () => exportNote,
-  exportWalletKeys: () => exportWalletKeys,
-  filterNotesByNetwork: () => filterNotesByNetwork,
-  filterWithdrawableNotes: () => filterWithdrawableNotes,
-  findNoteByCommitment: () => findNoteByCommitment,
-  formatAmount: () => formatAmount,
-  formatErrorForLogging: () => formatErrorForLogging,
-  formatSol: () => formatSol,
-  generateCloakKeys: () => generateCloakKeys,
-  generateCommitment: () => generateCommitment,
-  generateCommitmentAsync: () => generateCommitmentAsync,
-  generateMasterSeed: () => generateMasterSeed,
-  generateNote: () => generateNote,
-  generateNoteFromWallet: () => generateNoteFromWallet,
-  generateWithdrawRegularProof: () => generateWithdrawRegularProof,
-  generateWithdrawSwapProof: () => generateWithdrawSwapProof,
-  getAddressExplorerUrl: () => getAddressExplorerUrl,
-  getDistributableAmount: () => getDistributableAmount2,
-  getExplorerUrl: () => getExplorerUrl,
-  getPendingOperationsSummary: () => getPendingOperationsSummary,
-  getPublicKey: () => getPublicKey,
-  getPublicViewKey: () => getPublicViewKey,
-  getRecipientAmount: () => getRecipientAmount,
-  getRpcUrlForNetwork: () => getRpcUrlForNetwork,
-  getShieldPoolPDAs: () => getShieldPoolPDAs,
-  getViewKey: () => getViewKey,
-  hasPendingOperations: () => hasPendingOperations,
-  hexToBigint: () => hexToBigint,
-  hexToBytes: () => hexToBytes,
-  importKeys: () => importKeys,
-  importWalletKeys: () => importWalletKeys,
-  isDebugEnabled: () => isDebugEnabled,
-  isRootNotFoundError: () => isRootNotFoundError,
-  isValidHex: () => isValidHex,
-  isValidRpcUrl: () => isValidRpcUrl,
-  isValidSolanaAddress: () => isValidSolanaAddress,
-  isWithdrawable: () => isWithdrawable,
-  keypairToAdapter: () => keypairToAdapter,
-  loadPendingDeposits: () => loadPendingDeposits,
-  loadPendingWithdrawals: () => loadPendingWithdrawals,
-  parseAmount: () => parseAmount,
-  parseError: () => parseError,
-  parseNote: () => parseNote,
-  parseTransactionError: () => parseTransactionError,
-  poseidonHash: () => poseidonHash,
-  prepareEncryptedOutput: () => prepareEncryptedOutput,
-  prepareEncryptedOutputForRecipient: () => prepareEncryptedOutputForRecipient,
-  proofToBytes: () => proofToBytes,
-  pubkeyToLimbs: () => pubkeyToLimbs,
-  randomBytes: () => randomBytes,
-  readMerkleTreeState: () => readMerkleTreeState,
-  removePendingDeposit: () => removePendingDeposit,
-  removePendingWithdrawal: () => removePendingWithdrawal,
-  savePendingDeposit: () => savePendingDeposit,
-  savePendingWithdrawal: () => savePendingWithdrawal,
-  scanNotesForWallet: () => scanNotesForWallet,
-  sdkLogger: () => sdkLogger,
-  sendTransaction: () => sendTransaction,
-  serializeNote: () => serializeNote,
-  setDebugMode: () => setDebugMode,
-  signTransaction: () => signTransaction,
-  splitTo2Limbs: () => splitTo2Limbs,
-  truncate: () => truncate,
-  tryDecryptNote: () => tryDecryptNote,
-  updateNoteWithDeposit: () => updateNoteWithDeposit,
-  updatePendingDeposit: () => updatePendingDeposit,
-  updatePendingWithdrawal: () => updatePendingWithdrawal,
-  validateDepositParams: () => validateDepositParams,
-  validateNote: () => validateNote,
-  validateOutputsSum: () => validateOutputsSum,
-  validateTransfers: () => validateTransfers,
-  validateWalletConnected: () => validateWalletConnected,
-  validateWithdrawableNote: () => validateWithdrawableNote,
-  verifyAllCircuits: () => verifyAllCircuits,
-  verifyCircuitIntegrity: () => verifyCircuitIntegrity,
-  withTiming: () => withTiming
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/core/CloakSDK.ts
-var import_web34 = require("@solana/web3.js");
-
-// src/core/types.ts
-var CloakError = class extends Error {
-  constructor(message, category, retryable = false, originalError) {
-    super(message);
-    this.category = category;
-    this.retryable = retryable;
-    this.originalError = originalError;
-    this.name = "CloakError";
-  }
-};
 
 // src/core/keys.ts
-var import_blake3 = require("@noble/hashes/blake3");
-var import_tweetnacl = __toESM(require("tweetnacl"), 1);
-init_crypto();
 function generateMasterSeed() {
   const seed = new Uint8Array(32);
   const g = globalThis;
@@ -715,7 +612,6 @@ function getAddressExplorerUrl(address, network = "devnet") {
 }
 
 // src/core/note-manager.ts
-init_crypto();
 async function generateNote(amountLamports, network) {
   const actualNetwork = network || detectNetworkFromRpcUrl();
   const skSpend = randomBytes(32);
@@ -934,7 +830,6 @@ var LocalStorageAdapter = class {
 
 // src/utils/validation.ts
 var import_web3 = require("@solana/web3.js");
-init_crypto();
 function isValidSolanaAddress(address) {
   try {
     new import_web3.PublicKey(address);
@@ -1052,9 +947,6 @@ function validateTransfers(recipients, totalAmount) {
   }
 }
 
-// src/core/CloakSDK.ts
-init_crypto();
-
 // src/utils/errors.ts
 var RootNotFoundError = class extends Error {
   constructor(message = "Merkle root not found in history") {
@@ -1724,7 +1616,6 @@ function calculateRelayFee(amountLamports, feeBps) {
 }
 
 // src/services/RelayService.ts
-init_crypto();
 var RelayService = class {
   /**
    * Create a new Relay Service client
@@ -2129,30 +2020,84 @@ function getShieldPoolPDAs(programId, mint) {
     treasury
   };
 }
+function getNullifierPDA(nullifier, programId) {
+  const pid = programId || CLOAK_PROGRAM_ID;
+  if (nullifier.length !== 32) {
+    throw new Error(`Nullifier must be 32 bytes, got ${nullifier.length}`);
+  }
+  return import_web33.PublicKey.findProgramAddressSync(
+    [Buffer.from("nullifier"), Buffer.from(nullifier)],
+    pid
+  );
+}
+function getSwapStatePDA(nullifier, programId) {
+  const pid = programId || CLOAK_PROGRAM_ID;
+  if (nullifier.length !== 32) {
+    throw new Error(`Nullifier must be 32 bytes, got ${nullifier.length}`);
+  }
+  return import_web33.PublicKey.findProgramAddressSync(
+    [Buffer.from("swap_state"), Buffer.from(nullifier)],
+    pid
+  );
+}
 
 // src/utils/proof-generation.ts
 var snarkjs = __toESM(require("snarkjs"), 1);
-init_crypto();
 var IS_REACT_NATIVE = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var IS_BROWSER = IS_REACT_NATIVE || typeof window !== "undefined" || typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+var DEFAULT_CIRCUITS_URL = "https://www.cloak.ag/circuits";
+function isUrl(path) {
+  return path.startsWith("http://") || path.startsWith("https://");
+}
+async function fetchFileAsBuffer(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return new Uint8Array(arrayBuffer);
+}
 var _nodePath = null;
 var _nodeFs = null;
 var _nodeCrypto = null;
+var _fs = null;
+var _path = null;
+async function loadNodeModules() {
+  if (_fs && _path) {
+    return { fs: _fs, path: _path };
+  }
+  if (IS_BROWSER) {
+    throw new Error("Node.js modules not available in browser/React Native");
+  }
+  const [fsModule, pathModule] = await Promise.all([
+    import("fs"),
+    import("path")
+  ]);
+  _fs = fsModule;
+  _path = pathModule;
+  return { fs: _fs, path: _path };
+}
 function nodeRequire(moduleName) {
   if (IS_BROWSER) {
     throw new Error(`Node.js ${moduleName} module not available in browser/React Native`);
   }
-  const requireFunc = new Function("moduleName", "return require(moduleName)");
-  return requireFunc(moduleName);
+  try {
+    const requireFunc = new Function("moduleName", "return require(moduleName)");
+    return requireFunc(moduleName);
+  } catch {
+    throw new Error(`Cannot load Node.js module ${moduleName} synchronously in ESM. Use async loadNodeModules() instead.`);
+  }
 }
 async function getNodePath() {
   if (_nodePath) return _nodePath;
-  _nodePath = nodeRequire("path");
+  const { path } = await loadNodeModules();
+  _nodePath = path;
   return _nodePath;
 }
 async function getNodeFs() {
   if (_nodeFs) return _nodeFs;
-  _nodeFs = nodeRequire("fs");
+  const { fs } = await loadNodeModules();
+  _nodeFs = fs;
   return _nodeFs;
 }
 async function getNodeCrypto() {
@@ -2173,29 +2118,41 @@ async function fileExists(filePath) {
     }
   }
   try {
-    const nodeFs = nodeRequire("fs");
-    return nodeFs.existsSync(filePath);
+    const { fs } = await loadNodeModules();
+    return fs.existsSync(filePath);
   } catch {
     return false;
   }
 }
 async function generateWithdrawRegularProof(inputs, circuitsPath) {
-  let wasmPath;
-  let zkeyPath;
+  let wasmInput;
+  let zkeyInput;
+  const useUrl = isUrl(circuitsPath);
   if (IS_BROWSER) {
-    wasmPath = `${circuitsPath}/withdraw_regular_js/withdraw_regular.wasm`;
-    zkeyPath = `${circuitsPath}/withdraw_regular_final.zkey`;
+    wasmInput = `${circuitsPath}/withdraw_regular_js/withdraw_regular.wasm`;
+    zkeyInput = `${circuitsPath}/withdraw_regular_final.zkey`;
+  } else if (useUrl) {
+    const wasmUrl = `${circuitsPath}/withdraw_regular_js/withdraw_regular.wasm`;
+    const zkeyUrl = `${circuitsPath}/withdraw_regular_final.zkey`;
+    const [wasmData, zkeyData] = await Promise.all([
+      fetchFileAsBuffer(wasmUrl),
+      fetchFileAsBuffer(zkeyUrl)
+    ]);
+    wasmInput = wasmData;
+    zkeyInput = zkeyData;
   } else {
-    wasmPath = joinPath(circuitsPath, "build", "withdraw_regular_js", "withdraw_regular.wasm");
-    zkeyPath = joinPath(circuitsPath, "build", "withdraw_regular_final.zkey");
+    const wasmPath = joinPath(circuitsPath, "build", "withdraw_regular_js", "withdraw_regular.wasm");
+    const zkeyPath = joinPath(circuitsPath, "build", "withdraw_regular_final.zkey");
     const wasmExists = await fileExists(wasmPath);
     const zkeyExists = await fileExists(zkeyPath);
     if (!wasmExists) {
-      throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages-new/circuits first.`);
+      throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages/ first.`);
     }
     if (!zkeyExists) {
       throw new Error(`Circuit zkey not found at ${zkeyPath}. Run circuit setup first.`);
     }
+    wasmInput = wasmPath;
+    zkeyInput = zkeyPath;
   }
   const circuitInputs = {
     // Public signals
@@ -2219,7 +2176,7 @@ async function generateWithdrawRegularProof(inputs, circuitsPath) {
     var_fee: inputs.var_fee.toString(),
     rem: inputs.rem.toString()
   };
-  const { proof, publicSignals } = await snarkjs.groth16.fullProve(circuitInputs, wasmPath, zkeyPath);
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(circuitInputs, wasmInput, zkeyInput);
   const proofBytes = proofToBytes(proof);
   return {
     proof,
@@ -2230,22 +2187,34 @@ async function generateWithdrawRegularProof(inputs, circuitsPath) {
   };
 }
 async function generateWithdrawSwapProof(inputs, circuitsPath) {
-  let wasmPath;
-  let zkeyPath;
+  let wasmInput;
+  let zkeyInput;
+  const useUrl = isUrl(circuitsPath);
   if (IS_BROWSER) {
-    wasmPath = `${circuitsPath}/withdraw_swap_js/withdraw_swap.wasm`;
-    zkeyPath = `${circuitsPath}/withdraw_swap_final.zkey`;
+    wasmInput = `${circuitsPath}/withdraw_swap_js/withdraw_swap.wasm`;
+    zkeyInput = `${circuitsPath}/withdraw_swap_final.zkey`;
+  } else if (useUrl) {
+    const wasmUrl = `${circuitsPath}/withdraw_swap_js/withdraw_swap.wasm`;
+    const zkeyUrl = `${circuitsPath}/withdraw_swap_final.zkey`;
+    const [wasmData, zkeyData] = await Promise.all([
+      fetchFileAsBuffer(wasmUrl),
+      fetchFileAsBuffer(zkeyUrl)
+    ]);
+    wasmInput = wasmData;
+    zkeyInput = zkeyData;
   } else {
-    wasmPath = joinPath(circuitsPath, "build", "withdraw_swap_js", "withdraw_swap.wasm");
-    zkeyPath = joinPath(circuitsPath, "build", "withdraw_swap_final.zkey");
+    const wasmPath = joinPath(circuitsPath, "build", "withdraw_swap_js", "withdraw_swap.wasm");
+    const zkeyPath = joinPath(circuitsPath, "build", "withdraw_swap_final.zkey");
     const wasmExists = await fileExists(wasmPath);
     const zkeyExists = await fileExists(zkeyPath);
     if (!wasmExists) {
-      throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages-new/circuits first.`);
+      throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages/ first.`);
     }
     if (!zkeyExists) {
       throw new Error(`Circuit zkey not found at ${zkeyPath}. Run circuit setup first.`);
     }
+    wasmInput = wasmPath;
+    zkeyInput = zkeyPath;
   }
   const sk = splitTo2Limbs(inputs.sk_spend);
   const r = splitTo2Limbs(inputs.r);
@@ -2274,8 +2243,8 @@ async function generateWithdrawSwapProof(inputs, circuitsPath) {
   };
   const { proof, publicSignals } = await snarkjs.groth16.fullProve(
     circuitInputs,
-    wasmPath,
-    zkeyPath
+    wasmInput,
+    zkeyInput
   );
   const proofBytes = proofToBytes(proof);
   return {
@@ -2287,8 +2256,14 @@ async function generateWithdrawSwapProof(inputs, circuitsPath) {
   };
 }
 async function areCircuitsAvailable(circuitsPath) {
+  if (!circuitsPath || circuitsPath === "") {
+    return false;
+  }
+  if (isUrl(circuitsPath)) {
+    return true;
+  }
   if (IS_BROWSER) {
-    return Boolean(circuitsPath && circuitsPath !== "");
+    return true;
   }
   const wasmPath = joinPath(circuitsPath, "build", "withdraw_regular_js", "withdraw_regular.wasm");
   const zkeyPath = joinPath(circuitsPath, "build", "withdraw_regular_final.zkey");
@@ -2297,22 +2272,25 @@ async function areCircuitsAvailable(circuitsPath) {
   return wasmExists && zkeyExists;
 }
 async function getDefaultCircuitsPath() {
+  if (typeof process !== "undefined" && process.env?.CIRCUITS_PATH) {
+    return process.env.CIRCUITS_PATH;
+  }
   if (IS_BROWSER) {
     return "/circuits";
   }
   if (typeof process === "undefined" || !process.cwd) {
-    return "/circuits";
+    return DEFAULT_CIRCUITS_URL;
   }
   let nodePath;
   try {
     nodePath = await getNodePath();
-  } catch {
-    return "/circuits";
+  } catch (e) {
+    return DEFAULT_CIRCUITS_URL;
   }
   const possiblePaths = [
-    nodePath.resolve(process.cwd(), "../../packages-new/circuits"),
-    nodePath.resolve(process.cwd(), "../packages-new/circuits"),
-    nodePath.resolve(process.cwd(), "packages-new/circuits"),
+    nodePath.resolve(process.cwd(), "../../packages/circuits"),
+    nodePath.resolve(process.cwd(), "../packages/circuits"),
+    nodePath.resolve(process.cwd(), "packages/circuits"),
     nodePath.resolve(process.cwd(), "../../circuits"),
     nodePath.resolve(process.cwd(), "../circuits")
   ];
@@ -2321,7 +2299,7 @@ async function getDefaultCircuitsPath() {
       return p;
     }
   }
-  return possiblePaths[0];
+  return DEFAULT_CIRCUITS_URL;
 }
 var EXPECTED_CIRCUIT_HASHES = {
   // SHA-256 of the verification key JSON from withdraw_regular circuit
@@ -2408,9 +2386,6 @@ async function verifyAllCircuits(circuitsPath) {
   return results;
 }
 
-// src/core/CloakSDK.ts
-init_crypto();
-
 // src/utils/logger.ts
 var globalDebugEnabled = false;
 function checkEnvDebug() {
@@ -2498,6 +2473,93 @@ function truncate(str, len = 20) {
 }
 var sdkLogger = createLogger("cloak::sdk");
 
+// src/utils/onchain-proof.ts
+var MERKLE_TREE_HEIGHT = 32;
+var SUBTREES_OFFSET = 40;
+var ROOT_OFFSET = 40 + MERKLE_TREE_HEIGHT * 32;
+var POSEIDON_ZERO_VALUES = [
+  "0000000000000000000000000000000000000000000000000000000000000000"
+  // level 0
+];
+var zeroValuesComputed = false;
+async function ensureZeroValues() {
+  if (zeroValuesComputed) return;
+  for (let i = 1; i <= MERKLE_TREE_HEIGHT; i++) {
+    const prevZeroHex = POSEIDON_ZERO_VALUES[i - 1];
+    const prevZeroBigInt = BigInt("0x" + prevZeroHex);
+    const hash = await poseidonHash([prevZeroBigInt, prevZeroBigInt]);
+    POSEIDON_ZERO_VALUES[i] = hash.toString(16).padStart(64, "0");
+  }
+  zeroValuesComputed = true;
+}
+async function readMerkleTreeState(connection, merkleTreePDA) {
+  const accountInfo = await connection.getAccountInfo(merkleTreePDA);
+  if (!accountInfo) {
+    throw new Error("Merkle tree account not found");
+  }
+  const data = accountInfo.data;
+  const nextIndex = Number(data.readBigUInt64LE(32));
+  const subtrees = [];
+  for (let i = 0; i < MERKLE_TREE_HEIGHT; i++) {
+    const offset = SUBTREES_OFFSET + i * 32;
+    const subtree = data.slice(offset, offset + 32);
+    subtrees.push(Buffer.from(subtree).toString("hex"));
+  }
+  const root = Buffer.from(data.slice(ROOT_OFFSET, ROOT_OFFSET + 32)).toString("hex");
+  return { nextIndex, root, subtrees };
+}
+async function computeProofFromChain(connection, merkleTreePDA, leafIndex) {
+  await ensureZeroValues();
+  const { nextIndex, root, subtrees } = await readMerkleTreeState(connection, merkleTreePDA);
+  if (leafIndex >= nextIndex) {
+    throw new Error(`Leaf index ${leafIndex} is beyond next_index ${nextIndex}`);
+  }
+  const pathElements = [];
+  const pathIndices = [];
+  let index = leafIndex;
+  for (let level = 0; level < MERKLE_TREE_HEIGHT; level++) {
+    pathIndices.push(index % 2);
+    if (index % 2 === 0) {
+      const siblingIndex = index + 1;
+      const levelNextIndex = Math.ceil(nextIndex / (1 << level));
+      if (siblingIndex >= levelNextIndex) {
+        pathElements.push(POSEIDON_ZERO_VALUES[level]);
+      } else {
+        pathElements.push(POSEIDON_ZERO_VALUES[level]);
+      }
+    } else {
+      pathElements.push(subtrees[level]);
+    }
+    index = Math.floor(index / 2);
+  }
+  return { pathElements, pathIndices, root };
+}
+async function computeProofForLatestDeposit(connection, merkleTreePDA) {
+  await ensureZeroValues();
+  const { nextIndex, root, subtrees } = await readMerkleTreeState(connection, merkleTreePDA);
+  if (nextIndex === 0) {
+    throw new Error("No leaves in tree");
+  }
+  const leafIndex = nextIndex - 1;
+  const proof = await computeProofInternal(leafIndex, nextIndex, subtrees);
+  return { ...proof, root, leafIndex };
+}
+async function computeProofInternal(leafIndex, _nextIndex, subtrees) {
+  const pathElements = [];
+  const pathIndices = [];
+  let index = leafIndex;
+  for (let level = 0; level < MERKLE_TREE_HEIGHT; level++) {
+    pathIndices.push(index % 2);
+    if (index % 2 === 0) {
+      pathElements.push(POSEIDON_ZERO_VALUES[level]);
+    } else {
+      pathElements.push(subtrees[level]);
+    }
+    index = Math.floor(index / 2);
+  }
+  return { pathElements, pathIndices };
+}
+
 // src/core/CloakSDK.ts
 var COMPUTE_BUDGET_PROGRAM_ID = new import_web34.PublicKey("ComputeBudget111111111111111111111111111111");
 function createSetLoadedAccountsDataSizeLimitInstruction(bytes) {
@@ -2826,11 +2888,10 @@ var CloakSDK = class {
       }
       let merkleProof;
       try {
-        const { computeProofFromChain: computeProofFromChain2 } = await Promise.resolve().then(() => (init_onchain_proof(), onchain_proof_exports));
         const programId2 = this.config.programId || CLOAK_PROGRAM_ID;
         const mintForSOL = new import_web34.PublicKey(new Uint8Array(32));
         const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId2, mintForSOL);
-        const chainProof = await computeProofFromChain2(connection, merkleTreePDA, leafIndex);
+        const chainProof = await computeProofFromChain(connection, merkleTreePDA, leafIndex);
         merkleProof = {
           pathElements: chainProof.pathElements,
           pathIndices: chainProof.pathIndices
@@ -2950,11 +3011,10 @@ var CloakSDK = class {
           merkleProof = note.merkleProof;
           merkleRoot = note.root;
         } else {
-          const { computeProofFromChain: computeProofFromChain2 } = await Promise.resolve().then(() => (init_onchain_proof(), onchain_proof_exports));
           const programId = this.config.programId || CLOAK_PROGRAM_ID;
           const mintForSOL = new import_web34.PublicKey(new Uint8Array(32));
           const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
-          const chainProof = await computeProofFromChain2(
+          const chainProof = await computeProofFromChain(
             connection,
             merkleTreePDA,
             note.leafIndex
@@ -3276,11 +3336,10 @@ var CloakSDK = class {
             options?.onProgress?.(`proof_refresh_${attempt + 1}`);
             await new Promise((resolve) => setTimeout(resolve, 1e3));
           }
-          const { computeProofFromChain: computeProofFromChain2 } = await Promise.resolve().then(() => (init_onchain_proof(), onchain_proof_exports));
           const programId = this.config.programId || CLOAK_PROGRAM_ID;
           const mintForSOL = new import_web34.PublicKey(new Uint8Array(32));
           const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
-          const chainProof = await computeProofFromChain2(connection, merkleTreePDA, note.leafIndex);
+          const chainProof = await computeProofFromChain(connection, merkleTreePDA, note.leafIndex);
           const merkleProof = {
             pathElements: chainProof.pathElements,
             pathIndices: chainProof.pathIndices
@@ -3450,11 +3509,10 @@ var CloakSDK = class {
    * @returns Merkle proof computed from on-chain data
    */
   async getMerkleProof(connection, leafIndex) {
-    const { computeProofFromChain: computeProofFromChain2 } = await Promise.resolve().then(() => (init_onchain_proof(), onchain_proof_exports));
     const programId = this.config.programId || CLOAK_PROGRAM_ID;
     const mintForSOL = new import_web34.PublicKey(new Uint8Array(32));
     const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
-    const chainProof = await computeProofFromChain2(connection, merkleTreePDA, leafIndex);
+    const chainProof = await computeProofFromChain(connection, merkleTreePDA, leafIndex);
     return {
       pathElements: chainProof.pathElements,
       pathIndices: chainProof.pathIndices,
@@ -3468,11 +3526,10 @@ var CloakSDK = class {
    * @returns Current root hash from on-chain tree
    */
   async getCurrentRoot(connection) {
-    const { readMerkleTreeState: readMerkleTreeState2 } = await Promise.resolve().then(() => (init_onchain_proof(), onchain_proof_exports));
     const programId = this.config.programId || CLOAK_PROGRAM_ID;
     const mintForSOL = new import_web34.PublicKey(new Uint8Array(32));
     const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
-    const state = await readMerkleTreeState2(connection, merkleTreePDA);
+    const state = await readMerkleTreeState(connection, merkleTreePDA);
     return state.root;
   }
   /**
@@ -3624,7 +3681,6 @@ var CloakSDK = class {
 };
 
 // src/core/note.ts
-init_crypto();
 function serializeNote(note, pretty = false) {
   validateNote(note);
   return pretty ? JSON.stringify(note, null, 2) : JSON.stringify(note);
@@ -3657,11 +3713,7 @@ async function copyNoteToClipboard(note) {
   await nav.clipboard.writeText(json);
 }
 
-// src/index.ts
-init_crypto();
-
 // src/helpers/encrypted-output.ts
-init_crypto();
 function prepareEncryptedOutput(note, cloakKeys) {
   const noteData = {
     amount: note.amount,
@@ -3772,9 +3824,6 @@ function keypairToAdapter(keypair) {
   };
 }
 
-// src/index.ts
-init_onchain_proof();
-
 // src/utils/pending-operations.ts
 var PENDING_DEPOSITS_KEY = "cloak_pending_deposits";
 var PENDING_WITHDRAWALS_KEY = "cloak_pending_withdrawals";
@@ -3949,6 +3998,7 @@ var VERSION = "1.0.0";
   CLOAK_PROGRAM_ID,
   CloakError,
   CloakSDK,
+  DEFAULT_CIRCUITS_URL,
   EXPECTED_CIRCUIT_HASHES,
   FIXED_FEE_LAMPORTS,
   LAMPORTS_PER_SOL,
@@ -3959,6 +4009,7 @@ var VERSION = "1.0.0";
   ShieldPoolErrors,
   VARIABLE_FEE_RATE,
   VERSION,
+  areCircuitsAvailable,
   bigintToBytes32,
   buildPublicInputsBytes,
   bytesToHex,
@@ -4008,14 +4059,17 @@ var VERSION = "1.0.0";
   generateWithdrawRegularProof,
   generateWithdrawSwapProof,
   getAddressExplorerUrl,
+  getDefaultCircuitsPath,
   getDistributableAmount,
   getExplorerUrl,
+  getNullifierPDA,
   getPendingOperationsSummary,
   getPublicKey,
   getPublicViewKey,
   getRecipientAmount,
   getRpcUrlForNetwork,
   getShieldPoolPDAs,
+  getSwapStatePDA,
   getViewKey,
   hasPendingOperations,
   hexToBigint,