@cloak.ag/sdk 1.0.8 → 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,266 +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,
-  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);
-init_crypto();
 function generateMasterSeed() {
   const seed = new Uint8Array(32);
   const g = globalThis;
@@ -720,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);
@@ -939,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);
@@ -1057,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") {
@@ -1729,7 +1616,6 @@ function calculateRelayFee(amountLamports, feeBps) {
 }
 
 // src/services/RelayService.ts
-init_crypto();
 var RelayService = class {
   /**
    * Create a new Relay Service client
@@ -2157,7 +2043,6 @@ function getSwapStatePDA(nullifier, programId) {
 
 // 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";
@@ -2501,9 +2386,6 @@ async function verifyAllCircuits(circuitsPath) {
   return results;
 }
 
-// src/core/CloakSDK.ts
-init_crypto();
-
 // src/utils/logger.ts
 var globalDebugEnabled = false;
 function checkEnvDebug() {
@@ -2591,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) {
@@ -2919,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
@@ -3043,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
@@ -3369,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
@@ -3543,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,
@@ -3561,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;
   }
   /**
@@ -3717,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);
@@ -3750,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,
@@ -3865,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";

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;
@@ -2086,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) {
@@ -2414,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
@@ -2538,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
@@ -2864,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
@@ -3038,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,
@@ -3056,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;
   }
   /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloak.ag/sdk",
   "description": "TypeScript SDK for Cloak",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -25,8 +25,7 @@
     "example:multiple": "tsx examples/multiple-withdraw.ts",
     "example:swap": "tsx examples/swap.ts",
     "example:usdc-send": "tsx examples/usdc-send.ts",
-    "example:usdc-receive": "tsx examples/usdc-receive.ts",
-    "example:stress": "tsx examples/concurrent-stress.ts"
+    "example:usdc-receive": "tsx examples/usdc-receive.ts"
   },
   "keywords": [
     "solana",
@@ -101,4 +100,4 @@
     "bigint-buffer": "npm:bigint-buffer-fixed@^1.1.6",
     "tar": "^7.5.4"
   }
-}
+}