@cloak.ag/sdk 1.0.7 → 1.0.9

package/dist/index.js

@@ -1,33 +1,9 @@
-import {
-  __require,
-  bigintToBytes32,
-  buildPublicInputsBytes,
-  bytesToHex,
-  computeCommitment,
-  computeMerkleRoot,
-  computeNullifier,
-  computeNullifierAsync,
-  computeNullifierSync,
-  computeOutputsHash,
-  computeOutputsHashAsync,
-  computeOutputsHashSync,
-  computeProofForLatestDeposit,
-  computeProofFromChain,
-  computeSwapOutputsHash,
-  computeSwapOutputsHashAsync,
-  computeSwapOutputsHashSync,
-  generateCommitment,
-  generateCommitmentAsync,
-  hexToBigint,
-  hexToBytes,
-  isValidHex,
-  poseidonHash,
-  proofToBytes,
-  pubkeyToLimbs,
-  randomBytes,
-  readMerkleTreeState,
-  splitTo2Limbs
-} from "./chunk-QDMAIFO4.js";
+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');
+});
 
 // src/core/CloakSDK.ts
 import {
@@ -52,6 +28,273 @@ var CloakError = class extends Error {
 // src/core/keys.ts
 import { blake3 } from "@noble/hashes/blake3";
 import nacl from "tweetnacl";
+
+// src/utils/crypto.ts
+import { buildPoseidon } from "circomlibjs";
+var poseidon = null;
+async function getPoseidon() {
+  if (!poseidon) {
+    poseidon = await buildPoseidon();
+  }
+  return poseidon;
+}
+async function poseidonHash(inputs) {
+  const p = await getPoseidon();
+  const hash = p(inputs.map((x) => p.F.e(x)));
+  return p.F.toObject(hash);
+}
+function splitTo2Limbs(value) {
+  const mask = (1n << 128n) - 1n;
+  const lo = value & mask;
+  const hi = value >> 128n;
+  return [lo, hi];
+}
+function pubkeyToLimbs(pubkey) {
+  const bytes = typeof pubkey.toBytes === "function" ? pubkey.toBytes() : pubkey;
+  const value = BigInt("0x" + Buffer.from(bytes).toString("hex"));
+  return splitTo2Limbs(value);
+}
+async function computeMerkleRoot(leaf, pathElements, pathIndices) {
+  let current = leaf;
+  for (let i = 0; i < pathElements.length; i++) {
+    if (pathIndices[i] === 0) {
+      current = await poseidonHash([current, pathElements[i]]);
+    } else {
+      current = await poseidonHash([pathElements[i], current]);
+    }
+  }
+  return current;
+}
+function hexToBigint(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return BigInt("0x" + cleanHex);
+}
+async function computeCommitment(amount, r, sk_spend) {
+  const [sk0, sk1] = splitTo2Limbs(sk_spend);
+  const [r0, r1] = splitTo2Limbs(r);
+  const pk_spend = await poseidonHash([sk0, sk1]);
+  return await poseidonHash([amount, r0, r1, pk_spend]);
+}
+async function generateCommitmentAsync(amountLamports, r, skSpend) {
+  const amount = BigInt(amountLamports);
+  const rValue = hexToBigint(bytesToHex(r));
+  const skValue = hexToBigint(bytesToHex(skSpend));
+  return await computeCommitment(amount, rValue, skValue);
+}
+function generateCommitment(_amountLamports, _r, _skSpend) {
+  throw new Error("generateCommitment is deprecated. Use generateCommitmentAsync instead.");
+}
+async function computeNullifier(sk_spend, leafIndex) {
+  const [sk0, sk1] = splitTo2Limbs(sk_spend);
+  return await poseidonHash([sk0, sk1, leafIndex]);
+}
+async function computeNullifierAsync(skSpend, leafIndex) {
+  const skValue = typeof skSpend === "string" ? hexToBigint(skSpend) : hexToBigint(bytesToHex(skSpend));
+  return await computeNullifier(skValue, BigInt(leafIndex));
+}
+function computeNullifierSync(_skSpend, _leafIndex) {
+  throw new Error("computeNullifierSync is deprecated. Use computeNullifierAsync instead.");
+}
+async function computeOutputsHashAsync(outputs) {
+  let hash = 0n;
+  for (const output of outputs) {
+    const [lo, hi] = pubkeyToLimbs(output.recipient);
+    hash = await poseidonHash([hash, lo, hi, BigInt(output.amount)]);
+  }
+  return hash;
+}
+async function computeOutputsHash(outAddr, outAmount, outFlags) {
+  let hash = 0n;
+  for (let i = 0; i < 5; i++) {
+    if (outFlags[i] === 1) {
+      hash = await poseidonHash([hash, outAddr[i][0], outAddr[i][1], outAmount[i]]);
+    }
+  }
+  return hash;
+}
+function computeOutputsHashSync(_outputs) {
+  throw new Error("computeOutputsHashSync is deprecated. Use computeOutputsHashAsync instead.");
+}
+async function computeSwapOutputsHash(inputMintLimbs, outputMintLimbs, recipientAtaLimbs, minOutputAmount, publicAmount) {
+  return await poseidonHash([
+    inputMintLimbs[0],
+    inputMintLimbs[1],
+    outputMintLimbs[0],
+    outputMintLimbs[1],
+    recipientAtaLimbs[0],
+    recipientAtaLimbs[1],
+    minOutputAmount,
+    publicAmount
+  ]);
+}
+async function computeSwapOutputsHashAsync(inputMint, outputMint, recipientAta, minOutputAmount, amount) {
+  const inputMintLimbs = pubkeyToLimbs(inputMint);
+  const outputMintLimbs = pubkeyToLimbs(outputMint);
+  const recipientAtaLimbs = pubkeyToLimbs(recipientAta);
+  return await computeSwapOutputsHash(
+    inputMintLimbs,
+    outputMintLimbs,
+    recipientAtaLimbs,
+    BigInt(minOutputAmount),
+    BigInt(amount)
+  );
+}
+function computeSwapOutputsHashSync(_outputMint, _recipientAta, _minOutputAmount, _amount) {
+  throw new Error("computeSwapOutputsHashSync is deprecated. Use computeSwapOutputsHashAsync instead.");
+}
+function bigintToBytes32(n) {
+  const hex = n.toString(16).padStart(64, "0");
+  const bytes = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = parseInt(cleanHex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes, prefix = false) {
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return prefix ? `0x${hex}` : hex;
+}
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  const g = globalThis;
+  try {
+    const cryptoObj = g?.crypto || g?.window?.crypto || g?.self?.crypto;
+    if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+      cryptoObj.getRandomValues(bytes);
+      return bytes;
+    }
+  } catch {
+  }
+  try {
+    const nodeCrypto = __require("crypto");
+    if (nodeCrypto?.randomBytes) {
+      const buffer = nodeCrypto.randomBytes(length);
+      bytes.set(buffer);
+      return bytes;
+    }
+    if (nodeCrypto?.webcrypto?.getRandomValues) {
+      nodeCrypto.webcrypto.getRandomValues(bytes);
+      return bytes;
+    }
+  } catch {
+  }
+  for (let i = 0; i < length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  return bytes;
+}
+function isValidHex(hex, expectedLength) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (!/^[0-9a-f]*$/i.test(cleanHex)) {
+    return false;
+  }
+  if (cleanHex.length % 2 !== 0) {
+    return false;
+  }
+  if (expectedLength !== void 0) {
+    return cleanHex.length === expectedLength * 2;
+  }
+  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]);
+  const pi_a_y_neg = (BN254_MODULUS - pi_a_y) % BN254_MODULUS;
+  const pi_a_x_le = bigintToBytes32LE(pi_a_x);
+  const pi_a_y_neg_le = bigintToBytes32LE(pi_a_y_neg);
+  const pi_a_le = new Uint8Array(64);
+  pi_a_le.set(pi_a_x_le, 0);
+  pi_a_le.set(pi_a_y_neg_le, 32);
+  const pi_a_be = convertEndianness32(pi_a_le);
+  const pi_b_x1 = BigInt(proof.pi_b[0][0]);
+  const pi_b_x2 = BigInt(proof.pi_b[0][1]);
+  const pi_b_y1 = BigInt(proof.pi_b[1][0]);
+  const pi_b_y2 = BigInt(proof.pi_b[1][1]);
+  const pi_b_x1_le = bigintToBytes32LE(pi_b_x1);
+  const pi_b_x2_le = bigintToBytes32LE(pi_b_x2);
+  const pi_b_y1_le = bigintToBytes32LE(pi_b_y1);
+  const pi_b_y2_le = bigintToBytes32LE(pi_b_y2);
+  const pi_b_le = new Uint8Array(128);
+  pi_b_le.set(pi_b_x1_le, 0);
+  pi_b_le.set(pi_b_x2_le, 32);
+  pi_b_le.set(pi_b_y1_le, 64);
+  pi_b_le.set(pi_b_y2_le, 96);
+  const pi_b_be = convertEndianness64(pi_b_le);
+  const pi_c_x = BigInt(proof.pi_c[0]);
+  const pi_c_y = BigInt(proof.pi_c[1]);
+  const pi_c_x_le = bigintToBytes32LE(pi_c_x);
+  const pi_c_y_le = bigintToBytes32LE(pi_c_y);
+  const pi_c_le = new Uint8Array(64);
+  pi_c_le.set(pi_c_x_le, 0);
+  pi_c_le.set(pi_c_y_le, 32);
+  const pi_c_be = convertEndianness32(pi_c_le);
+  const result = new Uint8Array(256);
+  result.set(pi_a_be, 0);
+  result.set(pi_b_be, 64);
+  result.set(pi_c_be, 192);
+  return result;
+}
+function bigintToBytes32LE(n) {
+  const bytes = new Uint8Array(32);
+  let value = n % BN254_MODULUS;
+  if (value < 0) {
+    value = (value + BN254_MODULUS) % BN254_MODULUS;
+  }
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = Number(value & BigInt(255));
+    value = value >> BigInt(8);
+  }
+  return bytes;
+}
+function convertEndianness32(bytes) {
+  if (bytes.length !== 64) {
+    throw new Error("convertEndianness32 expects 64 bytes");
+  }
+  const result = new Uint8Array(64);
+  for (let i = 0; i < 32; i++) {
+    result[i] = bytes[31 - i];
+  }
+  for (let i = 0; i < 32; i++) {
+    result[32 + i] = bytes[63 - i];
+  }
+  return result;
+}
+function convertEndianness64(bytes) {
+  if (bytes.length !== 128) {
+    throw new Error("convertEndianness64 expects 128 bytes");
+  }
+  const result = new Uint8Array(128);
+  for (let i = 0; i < 64; i++) {
+    result[i] = bytes[63 - i];
+  }
+  for (let i = 0; i < 64; i++) {
+    result[64 + i] = bytes[127 - i];
+  }
+  return result;
+}
+function buildPublicInputsBytes(root, nullifier, outputsHash, publicAmount) {
+  const result = new Uint8Array(104);
+  result.set(bigintToBytes32(root), 0);
+  result.set(bigintToBytes32(nullifier), 32);
+  result.set(bigintToBytes32(outputsHash), 64);
+  const amountBytes = new Uint8Array(8);
+  let amt = publicAmount;
+  for (let i = 7; i >= 0; i--) {
+    amountBytes[i] = Number(amt & 0xffn);
+    amt = amt >> 8n;
+  }
+  result.set(amountBytes, 96);
+  return result;
+}
+
+// src/core/keys.ts
 function generateMasterSeed() {
   const seed = new Uint8Array(32);
   const g = globalThis;
@@ -1633,29 +1876,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 PublicKey3.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 PublicKey3.findProgramAddressSync(
+    [Buffer.from("swap_state"), Buffer.from(nullifier)],
+    pid
+  );
+}
 
 // src/utils/proof-generation.ts
 import * as snarkjs from "snarkjs";
 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() {
@@ -1676,29 +1974,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
@@ -1722,7 +2032,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,
@@ -1733,22 +2043,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);
@@ -1777,8 +2099,8 @@ async function generateWithdrawSwapProof(inputs, circuitsPath) {
   };
   const { proof, publicSignals } = await snarkjs.groth16.fullProve(
     circuitInputs,
-    wasmPath,
-    zkeyPath
+    wasmInput,
+    zkeyInput
   );
   const proofBytes = proofToBytes(proof);
   return {
@@ -1790,8 +2112,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");
@@ -1800,22 +2128,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")
   ];
@@ -1824,7 +2155,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
@@ -1998,6 +2329,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 PublicKey4("ComputeBudget111111111111111111111111111111");
 function createSetLoadedAccountsDataSizeLimitInstruction(bytes) {
@@ -2326,11 +2744,10 @@ var CloakSDK = class {
       }
       let merkleProof;
       try {
-        const { computeProofFromChain: computeProofFromChain2 } = await import("./onchain-proof-CY7AWF43.js");
         const programId2 = this.config.programId || CLOAK_PROGRAM_ID;
         const mintForSOL = new PublicKey4(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
@@ -2450,11 +2867,10 @@ var CloakSDK = class {
           merkleProof = note.merkleProof;
           merkleRoot = note.root;
         } else {
-          const { computeProofFromChain: computeProofFromChain2 } = await import("./onchain-proof-CY7AWF43.js");
           const programId = this.config.programId || CLOAK_PROGRAM_ID;
           const mintForSOL = new PublicKey4(new Uint8Array(32));
           const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
-          const chainProof = await computeProofFromChain2(
+          const chainProof = await computeProofFromChain(
             connection,
             merkleTreePDA,
             note.leafIndex
@@ -2776,11 +3192,10 @@ var CloakSDK = class {
             options?.onProgress?.(`proof_refresh_${attempt + 1}`);
             await new Promise((resolve) => setTimeout(resolve, 1e3));
           }
-          const { computeProofFromChain: computeProofFromChain2 } = await import("./onchain-proof-CY7AWF43.js");
           const programId = this.config.programId || CLOAK_PROGRAM_ID;
           const mintForSOL = new PublicKey4(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
@@ -2950,11 +3365,10 @@ var CloakSDK = class {
    * @returns Merkle proof computed from on-chain data
    */
   async getMerkleProof(connection, leafIndex) {
-    const { computeProofFromChain: computeProofFromChain2 } = await import("./onchain-proof-CY7AWF43.js");
     const programId = this.config.programId || CLOAK_PROGRAM_ID;
     const mintForSOL = new PublicKey4(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,
@@ -2968,11 +3382,10 @@ var CloakSDK = class {
    * @returns Current root hash from on-chain tree
    */
   async getCurrentRoot(connection) {
-    const { readMerkleTreeState: readMerkleTreeState2 } = await import("./onchain-proof-CY7AWF43.js");
     const programId = this.config.programId || CLOAK_PROGRAM_ID;
     const mintForSOL = new PublicKey4(new Uint8Array(32));
     const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
-    const state = await readMerkleTreeState2(connection, merkleTreePDA);
+    const state = await readMerkleTreeState(connection, merkleTreePDA);
     return state.root;
   }
   /**
@@ -3442,6 +3855,7 @@ export {
   CLOAK_PROGRAM_ID,
   CloakError,
   CloakSDK,
+  DEFAULT_CIRCUITS_URL,
   EXPECTED_CIRCUIT_HASHES,
   FIXED_FEE_LAMPORTS,
   LAMPORTS_PER_SOL,
@@ -3452,6 +3866,7 @@ export {
   ShieldPoolErrors,
   VARIABLE_FEE_RATE,
   VERSION,
+  areCircuitsAvailable,
   bigintToBytes32,
   buildPublicInputsBytes,
   bytesToHex,
@@ -3501,14 +3916,17 @@ export {
   generateWithdrawRegularProof,
   generateWithdrawSwapProof,
   getAddressExplorerUrl,
+  getDefaultCircuitsPath,
   getDistributableAmount2 as getDistributableAmount,
   getExplorerUrl,
+  getNullifierPDA,
   getPendingOperationsSummary,
   getPublicKey,
   getPublicViewKey,
   getRecipientAmount,
   getRpcUrlForNetwork,
   getShieldPoolPDAs,
+  getSwapStatePDA,
   getViewKey,
   hasPendingOperations,
   hexToBigint,