@cloak.dev/sdk 0.1.6 → 0.1.8

package/dist/index.cjs

@@ -36,8 +36,8 @@ __export(utxo_exports, {
   NATIVE_SOL_MINT: () => NATIVE_SOL_MINT,
   bigintToBytes32: () => bigintToBytes322,
   bigintToHex: () => bigintToHex,
-  computeCommitment: () => computeCommitment,
-  computeNullifier: () => computeNullifier,
+  computeCommitment: () => computeCommitment2,
+  computeNullifier: () => computeNullifier2,
   computeSignature: () => computeSignature,
   createUtxo: () => createUtxo,
   createZeroUtxo: () => createZeroUtxo,
@@ -112,7 +112,7 @@ async function createUtxo(amount, keypair, mintAddress = NATIVE_SOL_MINT) {
     blinding,
     mintAddress
   };
-  utxo.commitment = await computeCommitment(utxo);
+  utxo.commitment = await computeCommitment2(utxo);
   return utxo;
 }
 async function createZeroUtxo(mintAddress = NATIVE_SOL_MINT, salt) {
@@ -127,7 +127,7 @@ async function createZeroUtxo(mintAddress = NATIVE_SOL_MINT, salt) {
     blinding: BigInt(0),
     mintAddress
   };
-  utxo.commitment = await computeCommitment(utxo);
+  utxo.commitment = await computeCommitment2(utxo);
   utxo.index = 0;
   return utxo;
 }
@@ -139,7 +139,7 @@ function pubkeyToFieldElement(pubkey) {
   }
   return value % FIELD_MODULUS;
 }
-async function computeCommitment(utxo) {
+async function computeCommitment2(utxo) {
   const poseidon3 = await getPoseidon2();
   const mintField = pubkeyToFieldElement(utxo.mintAddress);
   const hash = poseidon3([
@@ -155,12 +155,12 @@ async function computeSignature(privateKey, commitment, pathIndex) {
   const hash = poseidon3([privateKey, commitment, pathIndex]);
   return poseidon3.F.toObject(hash);
 }
-async function computeNullifier(utxo) {
+async function computeNullifier2(utxo) {
   if (utxo.index === void 0) {
     throw new Error("UTXO must have an index to compute nullifier");
   }
   const poseidon3 = await getPoseidon2();
-  const commitment = utxo.commitment ?? await computeCommitment(utxo);
+  const commitment = utxo.commitment ?? await computeCommitment2(utxo);
   const pathIndex = BigInt(utxo.index);
   const signature = await computeSignature(
     utxo.keypair.privateKey,
@@ -202,7 +202,7 @@ async function deserializeUtxo(bytes) {
   const blindingBytes = bytes.slice(40, 72);
   const blinding = bytesToBigint(blindingBytes);
   const mintBytes = bytes.slice(72, 104);
-  const mintAddress = new import_web3.PublicKey(mintBytes);
+  const mintAddress = new import_web33.PublicKey(mintBytes);
   const index = view.getUint32(104, true);
   const utxo = {
     amount,
@@ -211,7 +211,7 @@ async function deserializeUtxo(bytes) {
     mintAddress,
     index: index > 0 ? index : void 0
   };
-  utxo.commitment = await computeCommitment(utxo);
+  utxo.commitment = await computeCommitment2(utxo);
   return utxo;
 }
 function bigintToBytes(value, length) {
@@ -247,8 +247,8 @@ function bigintToBytes322(value) {
   return result;
 }
 async function utxoEquals(a, b) {
-  const commitmentA = a.commitment ?? await computeCommitment(a);
-  const commitmentB = b.commitment ?? await computeCommitment(b);
+  const commitmentA = a.commitment ?? await computeCommitment2(a);
+  const commitmentB = b.commitment ?? await computeCommitment2(b);
   return commitmentA === commitmentB;
 }
 function sumUtxoAmounts(utxos) {
@@ -270,16 +270,16 @@ function selectUtxos(available, targetAmount) {
   }
   return selected;
 }
-var import_web3, import_circomlibjs2, import_blake32, FIELD_MODULUS, UTXO_KEY_DOMAIN, NATIVE_SOL_MINT, poseidonInstance;
+var import_web33, import_circomlibjs2, import_blake32, FIELD_MODULUS, UTXO_KEY_DOMAIN, NATIVE_SOL_MINT, poseidonInstance;
 var init_utxo = __esm({
   "src/core/utxo.ts"() {
     "use strict";
-    import_web3 = require("@solana/web3.js");
+    import_web33 = require("@solana/web3.js");
     import_circomlibjs2 = require("circomlibjs");
     import_blake32 = require("@noble/hashes/blake3");
     FIELD_MODULUS = BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");
     UTXO_KEY_DOMAIN = new TextEncoder().encode("cloak_utxo_priv_v1");
-    NATIVE_SOL_MINT = new import_web3.PublicKey("So11111111111111111111111111111111111111112");
+    NATIVE_SOL_MINT = new import_web33.PublicKey("So11111111111111111111111111111111111111112");
     poseidonInstance = null;
   }
 });
@@ -290,7 +290,9 @@ __export(index_exports, {
   CLOAK_PROGRAM_ID: () => CLOAK_PROGRAM_ID,
   CloakError: () => CloakError,
   CloakSDK: () => CloakSDK,
+  DEFAULT_CIRCUITS_URL: () => DEFAULT_CIRCUITS_URL,
   DEFAULT_TRANSACTION_CIRCUITS_URL: () => DEFAULT_TRANSACTION_CIRCUITS_URL,
+  EXPECTED_CIRCUIT_HASHES: () => EXPECTED_CIRCUIT_HASHES,
   FIXED_FEE_LAMPORTS: () => FIXED_FEE_LAMPORTS,
   LAMPORTS_PER_SOL: () => LAMPORTS_PER_SOL,
   LocalStorageAdapter: () => LocalStorageAdapter,
@@ -313,6 +315,7 @@ __export(index_exports, {
   VARIABLE_FEE_NUMERATOR: () => VARIABLE_FEE_NUMERATOR,
   VARIABLE_FEE_RATE: () => VARIABLE_FEE_RATE,
   VERSION: () => VERSION,
+  areCircuitsAvailable: () => areCircuitsAvailable,
   bigintToBytes32: () => bigintToBytes32,
   bigintToHex: () => bigintToHex,
   buildMerkleTree: () => buildMerkleTree,
@@ -326,15 +329,30 @@ __export(index_exports, {
   chainNoteFromBase64: () => chainNoteFromBase64,
   chainNoteToBase64: () => chainNoteToBase64,
   classifyRelayError: () => classifyRelayError,
+  cleanupStalePendingOperations: () => cleanupStalePendingOperations,
+  clearPendingDeposits: () => clearPendingDeposits,
+  clearPendingWithdrawals: () => clearPendingWithdrawals,
   computeChainNoteHash: () => computeChainNoteHash,
+  computeCommitment: () => computeCommitment,
   computeExtDataHash: () => computeExtDataHash,
   computeMerkleRoot: () => computeMerkleRoot,
+  computeNullifier: () => computeNullifier,
+  computeNullifierAsync: () => computeNullifierAsync,
+  computeNullifierSync: () => computeNullifierSync,
+  computeOutputsHash: () => computeOutputsHash,
+  computeOutputsHashAsync: () => computeOutputsHashAsync,
+  computeOutputsHashSync: () => computeOutputsHashSync,
   computeProofForLatestDeposit: () => computeProofForLatestDeposit,
   computeProofFromChain: () => computeProofFromChain,
   computeSignature: () => computeSignature,
-  computeUtxoCommitment: () => computeCommitment,
-  computeUtxoNullifier: () => computeNullifier,
+  computeSwapOutputsHash: () => computeSwapOutputsHash,
+  computeSwapOutputsHashAsync: () => computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync: () => computeSwapOutputsHashSync,
+  computeUtxoCommitment: () => computeCommitment2,
+  computeUtxoNullifier: () => computeNullifier2,
+  copyNoteToClipboard: () => copyNoteToClipboard,
   createCloakError: () => createCloakError,
+  createDepositInstruction: () => createDepositInstruction,
   createLogger: () => createLogger,
   createUtxo: () => createUtxo,
   createZeroUtxo: () => createZeroUtxo,
@@ -354,52 +372,78 @@ __export(index_exports, {
   deriveViewingKeyFromUtxoPrivateKey: () => deriveViewingKeyFromUtxoPrivateKey,
   deserializeUtxo: () => deserializeUtxo,
   detectNetworkFromRpcUrl: () => detectNetworkFromRpcUrl,
+  downloadNote: () => downloadNote,
+  encodeNoteSimple: () => encodeNoteSimple,
   encryptCompactChainNote: () => encryptCompactChainNote,
   encryptNoteForRecipient: () => encryptNoteForRecipient,
   encryptTransactionMetadata: () => encryptTransactionMetadata,
   encryptTransactionMetadataBundle: () => encryptTransactionMetadataBundle,
   expandSpendKey: () => expandSpendKey,
   exportKeys: () => exportKeys,
+  exportNote: () => exportNote,
+  exportWalletKeys: () => exportWalletKeys,
   fetchCommitments: () => fetchCommitments,
   fetchRiskQuoteInstruction: () => fetchRiskQuoteInstruction,
   fetchRiskQuoteIx: () => fetchRiskQuoteIx,
+  filterNotesByNetwork: () => filterNotesByNetwork,
+  filterWithdrawableNotes: () => filterWithdrawableNotes,
+  findNoteByCommitment: () => findNoteByCommitment,
   formatAmount: () => formatAmount,
   formatComplianceCsv: () => formatComplianceCsv,
   formatErrorForLogging: () => formatErrorForLogging,
   formatSol: () => formatSol,
   fullWithdraw: () => fullWithdraw,
   generateCloakKeys: () => generateCloakKeys,
+  generateCommitment: () => generateCommitment,
+  generateCommitmentAsync: () => generateCommitmentAsync,
   generateMasterSeed: () => generateMasterSeed,
+  generateNote: () => generateNote,
+  generateNoteFromWallet: () => generateNoteFromWallet,
   generateUtxoKeypair: () => generateUtxoKeypair,
   generateViewingKeyPair: () => generateViewingKeyPair,
+  generateWithdrawRegularProof: () => generateWithdrawRegularProof,
+  generateWithdrawSwapProof: () => generateWithdrawSwapProof,
   getAddressExplorerUrl: () => getAddressExplorerUrl,
   getCircuitsPath: () => getCircuitsPath,
+  getDefaultCircuitsPath: () => getDefaultCircuitsPath,
   getDistributableAmount: () => getDistributableAmount,
   getExplorerUrl: () => getExplorerUrl,
   getNkFromUtxoPrivateKey: () => getNkFromUtxoPrivateKey,
   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,
   isWithdrawAmountSufficient: () => isWithdrawAmountSufficient,
+  isWithdrawable: () => isWithdrawable,
   keypairToAdapter: () => keypairToAdapter,
+  loadPendingDeposits: () => loadPendingDeposits,
+  loadPendingWithdrawals: () => loadPendingWithdrawals,
   parseAmount: () => parseAmount,
   parseError: () => parseError,
+  parseNote: () => parseNote,
   parseRelayErrorResponse: () => parseRelayErrorResponse,
   parseTransactionError: () => parseTransactionError,
   partialWithdraw: () => partialWithdraw,
   poseidonHash: () => poseidonHash,
   preflightCheck: () => preflightCheck,
   preflightNullifiers: () => preflightNullifiers,
+  prepareEncryptedOutput: () => prepareEncryptedOutput,
+  prepareEncryptedOutputForRecipient: () => prepareEncryptedOutputForRecipient,
   proofToBytes: () => proofToBytes,
   pubkeyToFieldElement: () => pubkeyToFieldElement,
   pubkeyToLimbs: () => pubkeyToLimbs,
@@ -407,11 +451,16 @@ __export(index_exports, {
   randomFieldElement: () => randomFieldElement,
   readMerkleTreeState: () => readMerkleTreeState,
   registerViewingKey: () => registerViewingKey,
+  removePendingDeposit: () => removePendingDeposit,
+  removePendingWithdrawal: () => removePendingWithdrawal,
+  savePendingDeposit: () => savePendingDeposit,
+  savePendingWithdrawal: () => savePendingWithdrawal,
   scanNotesForWallet: () => scanNotesForWallet,
   scanTransactions: () => scanTransactions,
   sdkLogger: () => sdkLogger,
   selectUtxos: () => selectUtxos,
   sendTransaction: () => sendTransaction,
+  serializeNote: () => serializeNote,
   serializeUtxo: () => serializeUtxo,
   setCircuitsPath: () => setCircuitsPath,
   setDebugMode: () => setDebugMode,
@@ -425,12 +474,21 @@ __export(index_exports, {
   transfer: () => transfer,
   truncate: () => truncate,
   tryDecryptNote: () => tryDecryptNote,
+  updateNoteWithDeposit: () => updateNoteWithDeposit,
+  updatePendingDeposit: () => updatePendingDeposit,
+  updatePendingWithdrawal: () => updatePendingWithdrawal,
   utxoBigintToBytes32: () => bigintToBytes322,
   utxoEquals: () => utxoEquals,
   utxoHexToBigint: () => hexToBigint2,
+  validateDepositParams: () => validateDepositParams,
+  validateNote: () => validateNote,
   validateOutputsSum: () => validateOutputsSum,
   validateRoot: () => validateRoot,
+  validateTransfers: () => validateTransfers,
   validateWalletConnected: () => validateWalletConnected,
+  validateWithdrawableNote: () => validateWithdrawableNote,
+  verifyAllCircuits: () => verifyAllCircuits,
+  verifyCircuitIntegrity: () => verifyCircuitIntegrity,
   verifyUtxos: () => verifyUtxos,
   waitForRoot: () => waitForRoot,
   withTiming: () => withTiming
@@ -438,7 +496,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/core/CloakSDK.ts
-var import_web33 = require("@solana/web3.js");
+var import_web35 = require("@solana/web3.js");
 
 // src/core/types.ts
 var CloakError = class extends Error {
@@ -495,6 +553,79 @@ 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);
@@ -767,11 +898,223 @@ function importKeys(exported) {
   return generateCloakKeys(masterSeed);
 }
 
+// src/utils/network.ts
+function detectNetworkFromRpcUrl(rpcUrl) {
+  const url = rpcUrl || process.env.NEXT_PUBLIC_SOLANA_RPC_URL || "";
+  const lowerUrl = url.toLowerCase();
+  if (lowerUrl.includes("mainnet") || lowerUrl.includes("api.mainnet-beta") || lowerUrl.includes("mainnet-beta")) {
+    return "mainnet";
+  }
+  if (lowerUrl.includes("testnet") || lowerUrl.includes("api.testnet")) {
+    return "testnet";
+  }
+  if (lowerUrl.includes("devnet") || lowerUrl.includes("api.devnet")) {
+    return "devnet";
+  }
+  if (lowerUrl.includes("localhost") || lowerUrl.includes("127.0.0.1") || lowerUrl.includes("local")) {
+    return "localnet";
+  }
+  return "mainnet";
+}
+function getRpcUrlForNetwork(network) {
+  switch (network) {
+    case "mainnet":
+      return "https://api.mainnet-beta.solana.com";
+    case "devnet":
+      return "https://api.devnet.solana.com";
+    case "localnet":
+      return "http://localhost:8899";
+    default:
+      return "https://api.mainnet-beta.solana.com";
+  }
+}
+function isValidRpcUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function getExplorerUrl(signature, network = "devnet") {
+  const cluster = network === "mainnet" ? "" : `?cluster=${network}`;
+  return `https://explorer.solana.com/tx/${signature}${cluster}`;
+}
+function getAddressExplorerUrl(address, network = "devnet") {
+  const cluster = network === "mainnet" ? "" : `?cluster=${network}`;
+  return `https://explorer.solana.com/address/${address}${cluster}`;
+}
+
+// src/utils/fees.ts
+var LAMPORTS_PER_SOL = 1e9;
+var FIXED_FEE_LAMPORTS = 5e6;
+var VARIABLE_FEE_NUMERATOR = 3;
+var VARIABLE_FEE_DENOMINATOR = 1e3;
+var VARIABLE_FEE_RATE = VARIABLE_FEE_NUMERATOR / VARIABLE_FEE_DENOMINATOR;
+var MIN_DEPOSIT_LAMPORTS = 1e7;
+function calculateFee(amountLamports) {
+  const variableFee = Math.floor(amountLamports * VARIABLE_FEE_NUMERATOR / VARIABLE_FEE_DENOMINATOR);
+  return FIXED_FEE_LAMPORTS + variableFee;
+}
+function calculateFeeBigint(amountLamports) {
+  const fixed = BigInt(FIXED_FEE_LAMPORTS);
+  const variable = amountLamports * BigInt(VARIABLE_FEE_NUMERATOR) / BigInt(VARIABLE_FEE_DENOMINATOR);
+  return fixed + variable;
+}
+function isWithdrawAmountSufficient(amountLamports) {
+  return amountLamports > calculateFeeBigint(amountLamports);
+}
+function getDistributableAmount(amountLamports) {
+  return amountLamports - calculateFee(amountLamports);
+}
+function formatAmount(lamports, decimals = 9) {
+  return (lamports / LAMPORTS_PER_SOL).toFixed(decimals);
+}
+function parseAmount(sol) {
+  const num = parseFloat(sol);
+  if (isNaN(num) || num < 0) {
+    throw new Error(`Invalid SOL amount: ${sol}`);
+  }
+  return Math.floor(num * LAMPORTS_PER_SOL);
+}
+function validateOutputsSum(outputs, expectedTotal) {
+  const sum = outputs.reduce((acc, out) => acc + out.amount, 0);
+  return sum === expectedTotal;
+}
+function calculateRelayFee(amountLamports, feeBps) {
+  if (feeBps < 0 || feeBps > 1e4) {
+    throw new Error("Fee basis points must be between 0 and 10000");
+  }
+  return Math.floor(amountLamports * feeBps / 1e4);
+}
+
+// src/core/note-manager.ts
+async function generateNote(amountLamports, network) {
+  const actualNetwork = network || detectNetworkFromRpcUrl();
+  const skSpend = randomBytes(32);
+  const rBytes = randomBytes(32);
+  const commitmentBigint = await generateCommitmentAsync(amountLamports, rBytes, skSpend);
+  const commitmentHex = commitmentBigint.toString(16).padStart(64, "0");
+  const skSpendHex = bytesToHex(skSpend);
+  const rHex = bytesToHex(rBytes);
+  return {
+    version: "1.0",
+    amount: amountLamports,
+    commitment: commitmentHex,
+    sk_spend: skSpendHex,
+    r: rHex,
+    timestamp: Date.now(),
+    network: actualNetwork
+  };
+}
+async function generateNoteFromWallet(amountLamports, keys, network) {
+  const actualNetwork = network || detectNetworkFromRpcUrl();
+  const rBytes = randomBytes(32);
+  const sk_spend = hexToBytes(keys.spend.sk_spend_hex);
+  const commitmentBigint = await generateCommitmentAsync(amountLamports, rBytes, sk_spend);
+  const commitmentHex = commitmentBigint.toString(16).padStart(64, "0");
+  return {
+    version: "2.0",
+    amount: amountLamports,
+    commitment: commitmentHex,
+    sk_spend: keys.spend.sk_spend_hex,
+    r: bytesToHex(rBytes),
+    timestamp: Date.now(),
+    network: actualNetwork
+  };
+}
+function parseNote(jsonString) {
+  const note = JSON.parse(jsonString);
+  if (!note.version || !note.amount || !note.commitment || !note.sk_spend || !note.r) {
+    throw new CloakError(
+      "Invalid note format: missing required fields",
+      "validation",
+      false
+    );
+  }
+  if (!/^[0-9a-f]{64}$/i.test(note.commitment)) {
+    throw new CloakError("Invalid commitment format", "validation", false);
+  }
+  if (!/^[0-9a-f]{64}$/i.test(note.sk_spend)) {
+    throw new CloakError("Invalid sk_spend format", "validation", false);
+  }
+  if (!/^[0-9a-f]{64}$/i.test(note.r)) {
+    throw new CloakError("Invalid r format", "validation", false);
+  }
+  return note;
+}
+function exportNote(note, pretty = false) {
+  return pretty ? JSON.stringify(note, null, 2) : JSON.stringify(note);
+}
+function isWithdrawable(note) {
+  return !!(note.depositSignature && note.leafIndex !== void 0 && note.root);
+}
+function updateNoteWithDeposit(note, depositInfo) {
+  const updated = {
+    ...note,
+    depositSignature: depositInfo.signature,
+    depositSlot: depositInfo.slot,
+    leafIndex: depositInfo.leafIndex,
+    root: depositInfo.root
+  };
+  if (depositInfo.merkleProof) {
+    updated.merkleProof = depositInfo.merkleProof;
+  }
+  return updated;
+}
+function findNoteByCommitment(notes, commitment) {
+  return notes.find((n) => n.commitment === commitment);
+}
+function filterNotesByNetwork(notes, network) {
+  return notes.filter((n) => n.network === network);
+}
+function filterWithdrawableNotes(notes) {
+  return notes.filter(isWithdrawable);
+}
+function exportWalletKeys(keys) {
+  return exportKeys(keys);
+}
+function importWalletKeys(keysJson) {
+  return importKeys(keysJson);
+}
+function getPublicViewKey(keys) {
+  return keys.view.pvk_hex;
+}
+function getViewKey(keys) {
+  return keys.view;
+}
+var calculateFee2 = calculateFee;
+function getDistributableAmount2(amountLamports) {
+  return amountLamports - calculateFee2(amountLamports);
+}
+function getRecipientAmount(amountLamports) {
+  return getDistributableAmount2(amountLamports);
+}
+
 // src/core/storage.ts
 var MemoryStorageAdapter = class {
   constructor() {
+    this.notes = /* @__PURE__ */ new Map();
     this.keys = null;
   }
+  saveNote(note) {
+    this.notes.set(note.commitment, note);
+  }
+  loadAllNotes() {
+    return Array.from(this.notes.values());
+  }
+  updateNote(commitment, updates) {
+    const existing = this.notes.get(commitment);
+    if (existing) {
+      this.notes.set(commitment, { ...existing, ...updates });
+    }
+  }
+  deleteNote(commitment) {
+    this.notes.delete(commitment);
+  }
+  clearAllNotes() {
+    this.notes.clear();
+  }
   saveKeys(keys) {
     this.keys = keys;
   }
@@ -782,10 +1125,10 @@ var MemoryStorageAdapter = class {
     this.keys = null;
   }
 };
-var _LocalStorageAdapter = class _LocalStorageAdapter {
-  constructor(keysKey = "cloak_wallet_keys") {
+var LocalStorageAdapter = class {
+  constructor(notesKey = "cloak_notes", keysKey = "cloak_wallet_keys") {
+    this.notesKey = notesKey;
     this.keysKey = keysKey;
-    _LocalStorageAdapter.runLegacyPurgeOnce();
   }
   getStorage() {
     if (typeof globalThis !== "undefined" && globalThis.localStorage) {
@@ -793,6 +1136,47 @@ var _LocalStorageAdapter = class _LocalStorageAdapter {
     }
     return null;
   }
+  saveNote(note) {
+    const storage = this.getStorage();
+    if (!storage) throw new Error("localStorage not available");
+    const notes = this.loadAllNotes();
+    notes.push(note);
+    storage.setItem(this.notesKey, JSON.stringify(notes));
+  }
+  loadAllNotes() {
+    const storage = this.getStorage();
+    if (!storage) return [];
+    const stored = storage.getItem(this.notesKey);
+    if (!stored) return [];
+    try {
+      return JSON.parse(stored);
+    } catch {
+      return [];
+    }
+  }
+  updateNote(commitment, updates) {
+    const storage = this.getStorage();
+    if (!storage) return;
+    const notes = this.loadAllNotes();
+    const index = notes.findIndex((n) => n.commitment === commitment);
+    if (index !== -1) {
+      notes[index] = { ...notes[index], ...updates };
+      storage.setItem(this.notesKey, JSON.stringify(notes));
+    }
+  }
+  deleteNote(commitment) {
+    const storage = this.getStorage();
+    if (!storage) return;
+    const notes = this.loadAllNotes();
+    const filtered = notes.filter((n) => n.commitment !== commitment);
+    storage.setItem(this.notesKey, JSON.stringify(filtered));
+  }
+  clearAllNotes() {
+    const storage = this.getStorage();
+    if (storage) {
+      storage.removeItem(this.notesKey);
+    }
+  }
   saveKeys(keys) {
     const storage = this.getStorage();
     if (!storage) throw new Error("localStorage not available");
@@ -815,64 +1199,126 @@ var _LocalStorageAdapter = class _LocalStorageAdapter {
       storage.removeItem(this.keysKey);
     }
   }
-  /**
-   * Runs the legacy-purge exactly once per browser origin. Invoked
-   * automatically by the constructor; exposed as a static for tests and
-   * for callers who want to force the check before the first adapter
-   * instantiation.
-   */
-  static runLegacyPurgeOnce() {
-    if (typeof globalThis === "undefined" || !globalThis.localStorage) {
-      return;
+};
+
+// src/utils/validation.ts
+var import_web3 = require("@solana/web3.js");
+function isValidSolanaAddress(address) {
+  try {
+    new import_web3.PublicKey(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateNote(note) {
+  if (!note || typeof note !== "object") {
+    throw new Error("Note must be an object");
+  }
+  const requiredFields = ["version", "amount", "commitment", "sk_spend", "r", "timestamp", "network"];
+  for (const field of requiredFields) {
+    if (!(field in note)) {
+      throw new Error(`Missing required field: ${field}`);
     }
-    const storage = globalThis.localStorage;
-    if (storage.getItem(_LocalStorageAdapter.LEGACY_PURGE_SENTINEL_KEY)) {
-      return;
+  }
+  if (typeof note.version !== "string") {
+    throw new Error("Version must be a string");
+  }
+  if (typeof note.amount !== "number" || note.amount <= 0) {
+    throw new Error("Amount must be a positive number");
+  }
+  if (!isValidHex(note.commitment, 32)) {
+    throw new Error("Invalid commitment format (expected 64 hex characters)");
+  }
+  if (!isValidHex(note.sk_spend, 32)) {
+    throw new Error("Invalid sk_spend format (expected 64 hex characters)");
+  }
+  if (!isValidHex(note.r, 32)) {
+    throw new Error("Invalid r format (expected 64 hex characters)");
+  }
+  if (typeof note.timestamp !== "number" || note.timestamp <= 0) {
+    throw new Error("Timestamp must be a positive number");
+  }
+  if (!["localnet", "devnet", "testnet", "mainnet"].includes(note.network)) {
+    throw new Error("Network must be localnet, devnet, testnet, or mainnet");
+  }
+  if (note.depositSignature !== void 0 && typeof note.depositSignature !== "string") {
+    throw new Error("Deposit signature must be a string");
+  }
+  if (note.depositSlot !== void 0 && typeof note.depositSlot !== "number") {
+    throw new Error("Deposit slot must be a number");
+  }
+  if (note.leafIndex !== void 0) {
+    if (typeof note.leafIndex !== "number" || note.leafIndex < 0) {
+      throw new Error("Leaf index must be a non-negative number");
     }
-    storage.removeItem(_LocalStorageAdapter.LEGACY_NOTES_KEY);
-    try {
-      storage.setItem(_LocalStorageAdapter.LEGACY_PURGE_SENTINEL_KEY, "1");
-    } catch {
+  }
+  if (note.root !== void 0 && !isValidHex(note.root, 32)) {
+    throw new Error("Invalid root format (expected 64 hex characters)");
+  }
+  if (note.merkleProof !== void 0) {
+    if (!Array.isArray(note.merkleProof.pathElements)) {
+      throw new Error("Merkle proof pathElements must be an array");
+    }
+    if (!Array.isArray(note.merkleProof.pathIndices)) {
+      throw new Error("Merkle proof pathIndices must be an array");
+    }
+    if (note.merkleProof.pathElements.length !== note.merkleProof.pathIndices.length) {
+      throw new Error("Merkle proof pathElements and pathIndices must have same length");
     }
   }
-  /**
-   * Manual cleanup helper for callers that stored notes under a non-default
-   * key. The auto-purge in the constructor only handles the canonical
-   * `cloak_notes` slot; pass the custom key here.
-   *
-   * Pre-0.1.6 versions stored the user's `CloakNote[]` (including
-   * `r` randomness and `sk_spend` secret-key hex) as JSON plaintext.
-   * Those notes are no longer usable (the OLD `withdraw_regular.circom`
-   * flow is incompatible with the deployed UTXO program) but the plaintext
-   * would otherwise linger indefinitely.
-   *
-   * Idempotent; safe to call when the key doesn't exist or when running
-   * outside a browser (no-op). Does NOT update the auto-purge sentinel.
-   *
-   * @param notesKey - localStorage key to remove (default `"cloak_notes"`,
-   *   matching the pre-0.1.6 default).
-   */
-  static purgeLegacyNoteStorage(notesKey = _LocalStorageAdapter.LEGACY_NOTES_KEY) {
-    if (typeof globalThis === "undefined" || !globalThis.localStorage) {
-      return;
+}
+function parseNote2(jsonString) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonString);
+  } catch (error) {
+    throw new Error("Invalid JSON format");
+  }
+  validateNote(parsed);
+  return parsed;
+}
+function validateWithdrawableNote(note) {
+  if (!note.depositSignature) {
+    throw new Error("Note must be deposited before withdrawal (missing depositSignature)");
+  }
+  if (note.leafIndex === void 0) {
+    throw new Error("Note must be deposited before withdrawal (missing leafIndex)");
+  }
+  if (!note.root) {
+    throw new Error("Note must have historical root for withdrawal");
+  }
+  if (!note.merkleProof) {
+    throw new Error("Note must have Merkle proof for withdrawal");
+  }
+  if (note.merkleProof.pathElements.length === 0) {
+    throw new Error("Merkle proof is empty");
+  }
+}
+function validateTransfers(recipients, totalAmount) {
+  if (recipients.length === 0) {
+    throw new Error("At least one recipient is required");
+  }
+  if (recipients.length > 5) {
+    throw new Error("Maximum 5 recipients allowed");
+  }
+  for (let i = 0; i < recipients.length; i++) {
+    const transfer2 = recipients[i];
+    const isPublicKeyLike = transfer2.recipient && typeof transfer2.recipient.toBase58 === "function" && typeof transfer2.recipient.toBuffer === "function";
+    if (!isPublicKeyLike) {
+      throw new Error(`Recipient ${i} must be a PublicKey (got ${typeof transfer2.recipient})`);
+    }
+    if (typeof transfer2.amount !== "number" || transfer2.amount <= 0) {
+      throw new Error(`Recipient ${i} amount must be a positive number`);
     }
-    globalThis.localStorage.removeItem(notesKey);
   }
-};
-/**
- * Sentinel key set after the auto-purge runs. Persists across browser
- * sessions so the purge never re-runs on the same origin.
- */
-_LocalStorageAdapter.LEGACY_PURGE_SENTINEL_KEY = "cloak_purged_v0_1_5";
-/**
- * Default localStorage key the legacy `<= 0.1.5` SDK used for the
- * plaintext `CloakNote[]` blob.
- */
-_LocalStorageAdapter.LEGACY_NOTES_KEY = "cloak_notes";
-var LocalStorageAdapter = _LocalStorageAdapter;
-
-// src/services/RelayService.ts
-var import_sha2 = require("@noble/hashes/sha2");
+  const sum = recipients.reduce((acc, t) => acc + t.amount, 0);
+  if (sum !== totalAmount) {
+    throw new Error(
+      `Recipients sum (${sum}) does not match expected total (${totalAmount})`
+    );
+  }
+}
 
 // src/utils/errors.ts
 var RootNotFoundError = class extends Error {
@@ -932,7 +1378,8 @@ function classifyRelayError(responseText, httpStatus) {
     inner = responseText;
   }
   const haystack = inner.toLowerCase();
-  if (haystack.includes("0x1020") || haystack.includes("doublespend")) {
+  if (haystack.includes("0x1020") || // 0x1020 as decimal in a JSON-stringified confirmTransaction err (`"Custom":4128`).
+  haystack.includes('"custom":4128') || haystack.includes("doublespend")) {
     return new UtxoAlreadySpentError(
       "This shielded balance was already spent. The UTXO's nullifier is registered on-chain \u2014 typically means you spent it via another session or device. Run verifyUtxos() to reconcile local state."
     );
@@ -1768,6 +2215,7 @@ function formatErrorForLogging(error) {
 }
 
 // src/services/RelayService.ts
+var import_sha2 = require("@noble/hashes/sha2");
 var RelayService = class {
   /**
    * Create a new Relay Service client
@@ -2136,24 +2584,88 @@ var RelayService = class {
   }
 };
 
-// src/utils/pda.ts
+// src/solana/instructions.ts
 var import_web32 = require("@solana/web3.js");
+function createDepositInstruction(params) {
+  if (params.commitment.length !== 32) {
+    throw new Error(
+      `Invalid commitment length: ${params.commitment.length} (expected 32 bytes)`
+    );
+  }
+  if (params.amount <= 0) {
+    throw new Error("Amount must be positive");
+  }
+  const discriminant = new Uint8Array([1]);
+  const amountBytes = new Uint8Array(8);
+  new DataView(amountBytes.buffer).setBigUint64(
+    0,
+    BigInt(params.amount),
+    true
+    // little-endian
+  );
+  const data = new Uint8Array(41);
+  data.set(discriminant, 0);
+  data.set(amountBytes, 1);
+  data.set(params.commitment, 9);
+  return new import_web32.TransactionInstruction({
+    programId: params.programId,
+    keys: [
+      // Account 0: Payer (signer, writable) - pays for transaction
+      { pubkey: params.payer, isSigner: true, isWritable: true },
+      // Account 1: Pool (writable) - receives SOL
+      { pubkey: params.pool, isSigner: false, isWritable: true },
+      // Account 2: System Program (readonly) - for transfers
+      { pubkey: import_web32.SystemProgram.programId, isSigner: false, isWritable: false },
+      // Account 3: Merkle Tree (writable) - stores on-chain Merkle tree
+      { pubkey: params.merkleTree, isSigner: false, isWritable: true }
+    ],
+    data: Buffer.from(data)
+  });
+}
+function validateDepositParams(params) {
+  if (!(params.programId instanceof import_web32.PublicKey)) {
+    throw new Error("programId must be a PublicKey");
+  }
+  if (!(params.payer instanceof import_web32.PublicKey)) {
+    throw new Error("payer must be a PublicKey");
+  }
+  if (!(params.pool instanceof import_web32.PublicKey)) {
+    throw new Error("pool must be a PublicKey");
+  }
+  if (!(params.merkleTree instanceof import_web32.PublicKey)) {
+    throw new Error("merkleTree must be a PublicKey");
+  }
+  if (typeof params.amount !== "number" || params.amount <= 0) {
+    throw new Error("amount must be a positive number");
+  }
+  if (!(params.commitment instanceof Uint8Array)) {
+    throw new Error("commitment must be a Uint8Array");
+  }
+  if (params.commitment.length !== 32) {
+    throw new Error(
+      `commitment must be 32 bytes (got ${params.commitment.length})`
+    );
+  }
+}
+
+// src/utils/pda.ts
+var import_web34 = require("@solana/web3.js");
 init_utxo();
 function getShieldPoolPDAs(programId, mint = NATIVE_SOL_MINT) {
   const pid = programId || CLOAK_PROGRAM_ID;
-  const [pool] = import_web32.PublicKey.findProgramAddressSync(
+  const [pool] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("pool"), mint.toBuffer()],
     pid
   );
-  const [merkleTree] = import_web32.PublicKey.findProgramAddressSync(
+  const [merkleTree] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("merkle_tree"), mint.toBuffer()],
     pid
   );
-  const [treasury] = import_web32.PublicKey.findProgramAddressSync(
+  const [treasury] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("treasury"), mint.toBuffer()],
     pid
   );
-  const [vaultAuthority] = import_web32.PublicKey.findProgramAddressSync(
+  const [vaultAuthority] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("vault_authority"), mint.toBuffer()],
     pid
   );
@@ -2169,7 +2681,7 @@ function getNullifierPDA(poolPubkey, nullifier, programId) {
   if (nullifier.length !== 32) {
     throw new Error(`Nullifier must be 32 bytes, got ${nullifier.length}`);
   }
-  return import_web32.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("nullifier"), poolPubkey.toBuffer(), Buffer.from(nullifier)],
     pid
   );
@@ -2179,29 +2691,273 @@ function getSwapStatePDA(poolPubkey, nullifier, programId) {
   if (nullifier.length !== 32) {
     throw new Error(`Nullifier must be 32 bytes, got ${nullifier.length}`);
   }
-  return import_web32.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("swap_state"), poolPubkey.toBuffer(), Buffer.from(nullifier)],
     pid
   );
 }
 
-// src/core/CloakSDK.ts
-init_utxo();
-
-// src/utils/logger.ts
-var globalDebugEnabled = false;
-function checkEnvDebug() {
-  if (typeof process !== "undefined" && process.env) {
-    return !!(process.env.CLOAK_DEBUG === "1" || process.env.CLOAK_DEBUG === "true" || process.env.DEBUG?.includes("cloak"));
-  }
-  return false;
+// src/utils/proof-generation.ts
+var snarkjs = __toESM(require("snarkjs"), 1);
+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://storage.googleapis.com/cloak-circuits/circuits/0.1.0";
+var SKIP_CIRCUIT_VERIFY_ENV = typeof process !== "undefined" && process.env && process.env.CLOAK_SKIP_CIRCUIT_INTEGRITY_CHECK === "1";
+function isUrl(path) {
+  return path.startsWith("http://") || path.startsWith("https://");
 }
-globalDebugEnabled = checkEnvDebug();
-function setDebugMode(enabled) {
-  globalDebugEnabled = enabled;
+function resolveCircuitsUrl(circuitsPath2) {
+  if (circuitsPath2.trim() !== "" && circuitsPath2.trim() !== DEFAULT_CIRCUITS_URL) {
+    return DEFAULT_CIRCUITS_URL;
+  }
+  return DEFAULT_CIRCUITS_URL;
 }
-function isDebugEnabled() {
-  return globalDebugEnabled;
+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);
+}
+async function sha256Hex(data) {
+  if (IS_BROWSER) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const buffer = bytes.buffer.slice(
+      bytes.byteOffset,
+      bytes.byteOffset + bytes.byteLength
+    );
+    const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const nodeCrypto = await getNodeCrypto();
+  return nodeCrypto.createHash("sha256").update(data).digest("hex");
+}
+var _nodeCrypto = null;
+function nodeRequire(moduleName) {
+  if (IS_BROWSER) {
+    throw new Error(`Node.js ${moduleName} module not available in browser/React Native`);
+  }
+  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.`);
+  }
+}
+async function getNodeCrypto() {
+  if (_nodeCrypto) return _nodeCrypto;
+  _nodeCrypto = nodeRequire("crypto");
+  return _nodeCrypto;
+}
+async function generateWithdrawRegularProof(inputs, circuitsPath2) {
+  const circuitsUrl = resolveCircuitsUrl(circuitsPath2);
+  let wasmInput;
+  let zkeyInput;
+  if (IS_BROWSER) {
+    wasmInput = `${circuitsUrl}/withdraw_regular_js/withdraw_regular.wasm`;
+    zkeyInput = `${circuitsUrl}/withdraw_regular_final.zkey`;
+  } else {
+    const wasmUrl = `${circuitsUrl}/withdraw_regular_js/withdraw_regular.wasm`;
+    const zkeyUrl = `${circuitsUrl}/withdraw_regular_final.zkey`;
+    const [wasmData, zkeyData] = await Promise.all([
+      fetchFileAsBuffer(wasmUrl),
+      fetchFileAsBuffer(zkeyUrl)
+    ]);
+    wasmInput = wasmData;
+    zkeyInput = zkeyData;
+  }
+  const verification = await verifyCircuitIntegrity(circuitsUrl, "withdraw_regular");
+  if (!verification.valid) {
+    throw new Error(
+      `withdraw_regular circuit integrity verification failed: ${verification.error ?? "hash mismatch"}`
+    );
+  }
+  const circuitInputs = {
+    // Public signals
+    root: inputs.root.toString(),
+    nullifier: inputs.nullifier.toString(),
+    outputs_hash: inputs.outputs_hash.toString(),
+    public_amount: inputs.public_amount.toString(),
+    // Private common inputs
+    amount: inputs.amount.toString(),
+    leaf_index: inputs.leaf_index.toString(),
+    sk: inputs.sk.map((x) => x.toString()),
+    r: inputs.r.map((x) => x.toString()),
+    pathElements: inputs.pathElements.map((x) => x.toString()),
+    pathIndices: inputs.pathIndices,
+    // Outputs
+    num_outputs: inputs.num_outputs,
+    out_addr: inputs.out_addr.map((addr) => addr.map((x) => x.toString())),
+    out_amount: inputs.out_amount.map((x) => x.toString()),
+    out_flags: inputs.out_flags,
+    // Fee calculation
+    var_fee: inputs.var_fee.toString(),
+    rem: inputs.rem.toString()
+  };
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(circuitInputs, wasmInput, zkeyInput);
+  const proofBytes = proofToBytes(proof);
+  return {
+    proof,
+    publicSignals,
+    proofBytes,
+    publicInputsBytes: new Uint8Array(0)
+    // Not used, kept for compatibility
+  };
+}
+async function generateWithdrawSwapProof(inputs, circuitsPath2) {
+  const circuitsUrl = resolveCircuitsUrl(circuitsPath2);
+  let wasmInput;
+  let zkeyInput;
+  if (IS_BROWSER) {
+    wasmInput = `${circuitsUrl}/withdraw_swap_js/withdraw_swap.wasm`;
+    zkeyInput = `${circuitsUrl}/withdraw_swap_final.zkey`;
+  } else {
+    const wasmUrl = `${circuitsUrl}/withdraw_swap_js/withdraw_swap.wasm`;
+    const zkeyUrl = `${circuitsUrl}/withdraw_swap_final.zkey`;
+    const [wasmData, zkeyData] = await Promise.all([
+      fetchFileAsBuffer(wasmUrl),
+      fetchFileAsBuffer(zkeyUrl)
+    ]);
+    wasmInput = wasmData;
+    zkeyInput = zkeyData;
+  }
+  const verification = await verifyCircuitIntegrity(circuitsUrl, "withdraw_swap");
+  if (!verification.valid) {
+    throw new Error(
+      `withdraw_swap circuit integrity verification failed: ${verification.error ?? "hash mismatch"}`
+    );
+  }
+  const sk = splitTo2Limbs(inputs.sk_spend);
+  const r = splitTo2Limbs(inputs.r);
+  const circuitInputs = {
+    // Public signals (must be provided for witness generation)
+    root: inputs.root.toString(),
+    nullifier: inputs.nullifier.toString(),
+    outputs_hash: inputs.outputs_hash.toString(),
+    public_amount: inputs.public_amount.toString(),
+    // Private inputs
+    sk: sk.map((x) => x.toString()),
+    r: r.map((x) => x.toString()),
+    amount: inputs.amount.toString(),
+    leaf_index: inputs.leaf_index.toString(),
+    pathElements: inputs.path_elements.map((x) => x.toString()),
+    pathIndices: inputs.path_indices,
+    input_mint: inputs.input_mint.map((x) => x.toString()),
+    output_mint: inputs.output_mint.map((x) => x.toString()),
+    recipient_ata: inputs.recipient_ata.map((x) => x.toString()),
+    min_output_amount: inputs.min_output_amount.toString(),
+    // Note: fee is computed off-chain and validated on-chain:
+    // - fixed_fee is 5000000 (0.005 SOL)
+    // - var_fee and rem are computed from amount * 3 / 1000 (0.3%)
+    var_fee: inputs.var_fee.toString(),
+    rem: inputs.rem.toString()
+  };
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+    circuitInputs,
+    wasmInput,
+    zkeyInput
+  );
+  const proofBytes = proofToBytes(proof);
+  return {
+    proof,
+    publicSignals,
+    proofBytes,
+    publicInputsBytes: new Uint8Array(0)
+    // Not used, kept for compatibility
+  };
+}
+async function areCircuitsAvailable(circuitsPath2) {
+  if (!circuitsPath2 || circuitsPath2 === "") {
+    return false;
+  }
+  return isUrl(resolveCircuitsUrl(circuitsPath2));
+}
+async function getDefaultCircuitsPath() {
+  return DEFAULT_CIRCUITS_URL;
+}
+var EXPECTED_CIRCUIT_HASHES = {
+  withdraw_regular_wasm: "b80c364c926332111945ef437b07a71720fae774e08206cb11b6171f2a2420a3",
+  withdraw_regular_zkey: "6dbca2612f7cc257b897d93384ae9dd09c1617fd1668f8287efb1b124488d144",
+  withdraw_swap_wasm: "a296badc0047c211a4724c96a4e64a77cd75fbde7cfa4cf23af3640a723e5686",
+  withdraw_swap_zkey: "95251954feaac80396651d12a0df3288630fa75db9410aebecb8aaee17a4f6ea"
+};
+async function verifyCircuitIntegrity(circuitsPath2, circuit) {
+  const circuitsUrl = resolveCircuitsUrl(circuitsPath2);
+  if (SKIP_CIRCUIT_VERIFY_ENV) {
+    return {
+      valid: true,
+      circuit,
+      error: "Verification skipped (CLOAK_SKIP_CIRCUIT_INTEGRITY_CHECK=1)"
+    };
+  }
+  const expected = circuit === "withdraw_regular" ? {
+    wasm: EXPECTED_CIRCUIT_HASHES.withdraw_regular_wasm,
+    zkey: EXPECTED_CIRCUIT_HASHES.withdraw_regular_zkey
+  } : {
+    wasm: EXPECTED_CIRCUIT_HASHES.withdraw_swap_wasm,
+    zkey: EXPECTED_CIRCUIT_HASHES.withdraw_swap_zkey
+  };
+  const wasmPath = `${circuitsUrl}/${circuit}_js/${circuit}.wasm`;
+  const zkeyPath = `${circuitsUrl}/${circuit}_final.zkey`;
+  try {
+    const [wasmBytes, zkeyBytes] = await Promise.all([
+      fetchFileAsBuffer(wasmPath),
+      fetchFileAsBuffer(zkeyPath)
+    ]);
+    const computed = {
+      wasm: await sha256Hex(wasmBytes),
+      zkey: await sha256Hex(zkeyBytes)
+    };
+    if (computed.wasm === expected.wasm && computed.zkey === expected.zkey) {
+      return {
+        valid: true,
+        circuit,
+        computed,
+        expected
+      };
+    }
+    return {
+      valid: false,
+      circuit,
+      error: `Circuit artifact hash mismatch for ${circuit}`,
+      computed,
+      expected
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      circuit,
+      error: `Circuit verification failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function verifyAllCircuits(circuitsPath2) {
+  const circuitsUrl = resolveCircuitsUrl(circuitsPath2);
+  const results = await Promise.all([
+    verifyCircuitIntegrity(circuitsUrl, "withdraw_regular"),
+    verifyCircuitIntegrity(circuitsUrl, "withdraw_swap")
+  ]);
+  return results;
+}
+
+// src/core/CloakSDK.ts
+init_utxo();
+
+// src/utils/logger.ts
+var globalDebugEnabled = false;
+function checkEnvDebug() {
+  if (typeof process !== "undefined" && process.env) {
+    return !!(process.env.CLOAK_DEBUG === "1" || process.env.CLOAK_DEBUG === "true" || process.env.DEBUG?.includes("cloak"));
+  }
+  return false;
+}
+globalDebugEnabled = checkEnvDebug();
+function setDebugMode(enabled) {
+  globalDebugEnabled = enabled;
+}
+function isDebugEnabled() {
+  return globalDebugEnabled;
 }
 var LOG_COLORS = {
   DEBUG: "\x1B[90m",
@@ -2404,22 +3160,50 @@ async function computeProofInternal(leafIndex, _nextIndex, subtrees) {
 }
 
 // src/core/CloakSDK.ts
-var CLOAK_PROGRAM_ID = new import_web33.PublicKey("zh1eLd6rSphLejbFfJEneUwzHRfMKxgzrgkfwA6qRkW");
+var COMPUTE_BUDGET_PROGRAM_ID = new import_web35.PublicKey("ComputeBudget111111111111111111111111111111");
+function createSetLoadedAccountsDataSizeLimitInstruction(bytes) {
+  const data = Buffer.alloc(5);
+  data.writeUInt8(4, 0);
+  data.writeUInt32LE(bytes, 1);
+  return new import_web35.TransactionInstruction({
+    keys: [],
+    programId: COMPUTE_BUDGET_PROGRAM_ID,
+    data
+  });
+}
+var CLOAK_PROGRAM_ID = new import_web35.PublicKey("zh1eLd6rSphLejbFfJEneUwzHRfMKxgzrgkfwA6qRkW");
 var CLOAK_API_URL = "https://api.cloak.ag";
 var CloakSDK = class {
+  /**
+  * Create a new Cloak SDK client
+   *
+   * @param config - Client configuration
+   * 
+   * @example Node.js mode (with keypair)
+   * ```typescript
+   * const sdk = new CloakSDK({
+   *   keypairBytes: keypair.secretKey,
+   *   network: "devnet"
+   * });
+   * ```
+   * 
+   * @example Browser mode (with wallet adapter)
+   * ```typescript
+   * const sdk = new CloakSDK({
+   *   wallet: walletAdapter,
+   *   network: "devnet"
+   * });
+   * ```
+   */
   constructor(config) {
     if (!config.keypairBytes && !config.wallet) {
-      throw new CloakError(
-        "Must provide either keypairBytes (Node.js) or wallet (Browser)",
-        "validation",
-        false
-      );
+      throw new Error("Must provide either keypairBytes (Node.js) or wallet (Browser)");
     }
     if (config.debug) {
       setDebugMode(true);
     }
     if (config.keypairBytes) {
-      this.keypair = import_web33.Keypair.fromSecretKey(config.keypairBytes);
+      this.keypair = import_web35.Keypair.fromSecretKey(config.keypairBytes);
     }
     this.wallet = config.wallet;
     this.cloakKeys = config.cloakKeys;
@@ -2433,9 +3217,13 @@ var CloakSDK = class {
       }
     }
     const programId = config.programId || CLOAK_PROGRAM_ID;
-    const { pool, merkleTree, treasury } = getShieldPoolPDAs(programId, NATIVE_SOL_MINT);
+    const { pool, merkleTree, treasury } = getShieldPoolPDAs(
+      programId,
+      NATIVE_SOL_MINT
+    );
     this.config = {
       network: config.network || "mainnet",
+      keypairBytes: config.keypairBytes,
       cloakKeys: config.cloakKeys,
       programId,
       poolAddress: pool,
@@ -2444,7 +3232,9 @@ var CloakSDK = class {
       debug: config.debug
     };
   }
-  /** Public key of the configured signer (keypair or wallet). */
+  /**
+   * Get the public key for deposits (from keypair or wallet)
+   */
   getPublicKey() {
     if (this.keypair) {
       return this.keypair.publicKey;
@@ -2452,23 +3242,877 @@ var CloakSDK = class {
     if (this.wallet?.publicKey) {
       return this.wallet.publicKey;
     }
-    throw new CloakError(
-      "No public key available - wallet not connected and no keypair provided",
-      "wallet",
-      false
+    throw new Error("No public key available - wallet not connected or keypair not provided");
+  }
+  /**
+   * Check if the SDK is using a wallet adapter
+   */
+  isWalletMode() {
+    return !!this.wallet && !this.keypair;
+  }
+  /**
+   * Deposit SOL into the Cloak protocol
+   *
+   * Creates a new note (or uses a provided one), submits a deposit transaction,
+   * and registers with the indexer.
+   *
+   * @param connection - Solana connection
+   * @param payer - Payer wallet with sendTransaction method
+   * @param amountOrNote - Amount in lamports OR an existing note to deposit
+   * @param options - Optional configuration
+   * @returns Deposit result with note and transaction info
+   *
+   * @example
+   * ```typescript
+   * // Generate and deposit in one step
+   * const result = await client.deposit(
+   *   connection,
+   *   wallet,
+   *   1_000_000_000,
+   *   {
+   *     onProgress: (status) => console.log(status)
+   *   }
+   * );
+   *
+   * // Or deposit a pre-generated note
+   * const note = client.generateNote(1_000_000_000);
+   * const result = await client.deposit(connection, wallet, note);
+   * ```
+   */
+  async deposit(connection, amountOrNote, options) {
+    try {
+      let note;
+      let isNewNote = false;
+      if (typeof amountOrNote === "number") {
+        options?.onProgress?.("generating_note", { message: "Generating note with secrets..." });
+        note = await generateNote(amountOrNote, this.config.network);
+        isNewNote = true;
+      } else {
+        note = amountOrNote;
+        if (note.depositSignature) {
+          throw new Error("Note has already been deposited");
+        }
+      }
+      if (isNewNote) {
+        await this.storage.saveNote(note);
+        if (options?.onNoteGenerated) {
+          options?.onProgress?.("awaiting_note_acknowledgment", {
+            message: "Waiting for note to be saved before proceeding with deposit..."
+          });
+          try {
+            await options.onNoteGenerated(note);
+          } catch (error) {
+            throw new Error(
+              `Failed to save note before deposit: ${error instanceof Error ? error.message : String(error)}. For your safety, the deposit has been aborted. Your funds are safe.`
+            );
+          }
+        }
+        options?.onProgress?.("note_saved", {
+          message: "Note saved. Proceeding with on-chain deposit..."
+        });
+      }
+      const payerPubkey = this.getPublicKey();
+      const balance = await connection.getBalance(payerPubkey);
+      const requiredAmount = note.amount + 5e3;
+      if (balance < requiredAmount) {
+        throw new Error(
+          `Insufficient balance. Required: ${requiredAmount} lamports (${note.amount} + fees), Available: ${balance} lamports`
+        );
+      }
+      const commitmentBytes = hexToBytes(note.commitment);
+      const programId = this.config.programId || CLOAK_PROGRAM_ID;
+      const depositIx = createDepositInstruction({
+        programId,
+        payer: payerPubkey,
+        pool: this.config.poolAddress,
+        merkleTree: this.config.merkleTreeAddress,
+        amount: note.amount,
+        commitment: commitmentBytes
+      });
+      const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+      const priorityFee = options?.priorityFee ?? 1e4;
+      const cuPriceIx = import_web35.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee });
+      const dataSizeLimit = options?.loadedAccountsDataSizeLimit ?? 256 * 1024;
+      const dataSizeLimitIx = dataSizeLimit > 0 ? createSetLoadedAccountsDataSizeLimitInstruction(dataSizeLimit) : null;
+      let computeUnits;
+      if (options?.optimizeCU && this.keypair) {
+        options?.onProgress?.("simulating", { message: "Simulating transaction for optimal CU..." });
+        const simCuLimitIx = import_web35.ComputeBudgetProgram.setComputeUnitLimit({ units: 2e5 });
+        const simTransaction = new import_web35.Transaction({
+          feePayer: payerPubkey,
+          recentBlockhash: blockhash
+        }).add(simCuLimitIx).add(cuPriceIx);
+        if (dataSizeLimitIx) {
+          simTransaction.add(dataSizeLimitIx);
+        }
+        simTransaction.add(depositIx);
+        try {
+          const simulation = await connection.simulateTransaction(simTransaction, [this.keypair]);
+          if (simulation.value.err) {
+            console.warn("Simulation failed, using default CU:", simulation.value.err);
+            computeUnits = 4e4;
+          } else {
+            const simulatedCU = simulation.value.unitsConsumed ?? 3e4;
+            computeUnits = Math.ceil(simulatedCU * 1.2);
+            console.log(`CU optimization: ${simulatedCU} simulated \u2192 ${computeUnits} limit`);
+          }
+        } catch (simError) {
+          console.warn("Simulation RPC error, using default CU:", simError);
+          computeUnits = 4e4;
+        }
+      } else if (options?.optimizeCU && this.wallet) {
+        console.warn("CU optimization via simulation not available in wallet mode (would require double signing). Using default.");
+        computeUnits = options?.computeUnits ?? 4e4;
+      } else {
+        computeUnits = options?.computeUnits ?? 4e4;
+      }
+      const cuLimitIx = import_web35.ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits });
+      const transaction = new import_web35.Transaction({
+        feePayer: payerPubkey,
+        recentBlockhash: blockhash
+      }).add(cuLimitIx).add(cuPriceIx);
+      if (dataSizeLimitIx) {
+        transaction.add(dataSizeLimitIx);
+      }
+      transaction.add(depositIx);
+      if (!transaction.feePayer) {
+        throw new Error("Transaction feePayer is not set");
+      }
+      if (!transaction.recentBlockhash) {
+        throw new Error("Transaction recentBlockhash is not set");
+      }
+      let signature;
+      if (this.wallet) {
+        if (!this.wallet.publicKey) {
+          throw new Error("Wallet not connected - publicKey is null");
+        }
+        if (this.wallet.signTransaction) {
+          try {
+            const signedTransaction = await this.wallet.signTransaction(transaction);
+            const rawTransaction = signedTransaction.serialize();
+            signature = await connection.sendRawTransaction(rawTransaction, {
+              skipPreflight: options?.skipPreflight || false,
+              preflightCommitment: "confirmed",
+              maxRetries: 3
+            });
+          } catch (signError) {
+            if (this.wallet.sendTransaction) {
+              signature = await this.wallet.sendTransaction(transaction, connection, {
+                skipPreflight: options?.skipPreflight || false,
+                preflightCommitment: "confirmed",
+                maxRetries: 3
+              });
+            } else {
+              throw signError;
+            }
+          }
+        } else if (this.wallet.sendTransaction) {
+          signature = await this.wallet.sendTransaction(transaction, connection, {
+            skipPreflight: options?.skipPreflight || false,
+            preflightCommitment: "confirmed",
+            maxRetries: 3
+          });
+        } else {
+          throw new Error("Wallet adapter must provide either sendTransaction or signTransaction");
+        }
+      } else if (this.keypair) {
+        signature = await connection.sendTransaction(transaction, [this.keypair], {
+          skipPreflight: options?.skipPreflight || false,
+          preflightCommitment: "confirmed",
+          maxRetries: 3
+        });
+      } else {
+        throw new Error("No signing method available - provide keypair or wallet");
+      }
+      const confirmation = await connection.confirmTransaction({
+        signature,
+        blockhash,
+        lastValidBlockHeight
+      });
+      if (confirmation.value.err) {
+        throw new Error(
+          `Transaction failed: ${JSON.stringify(confirmation.value.err)}`
+        );
+      }
+      const txDetails = await connection.getTransaction(signature, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      const depositSlot = txDetails?.slot ?? 0;
+      let leafIndex = null;
+      let root = null;
+      try {
+        if (txDetails?.meta?.logMessages) {
+          for (const log of txDetails.meta.logMessages) {
+            if (log.includes("Program data:")) {
+              try {
+                const parts = log.split("Program data:");
+                if (parts.length > 1) {
+                  const base64Data = parts[1].trim();
+                  const eventData = Buffer.from(base64Data, "base64");
+                  if (eventData.length >= 81 && eventData[0] === 1) {
+                    const parsedLeafIndex = Number(eventData.readBigUInt64LE(1));
+                    const loggedCommitment = eventData.slice(9, 41);
+                    if (Buffer.compare(loggedCommitment, Buffer.from(commitmentBytes)) === 0) {
+                      leafIndex = parsedLeafIndex;
+                      const loggedRoot = eventData.slice(49, 81);
+                      root = Buffer.from(loggedRoot).toString("hex");
+                      break;
+                    }
+                  }
+                }
+              } catch (e) {
+                continue;
+              }
+            }
+          }
+        }
+      } catch (e) {
+      }
+      if (leafIndex === null) {
+        const programId2 = this.config.programId || CLOAK_PROGRAM_ID;
+        const mintForSOL = NATIVE_SOL_MINT;
+        const { merkleTree } = getShieldPoolPDAs(programId2, mintForSOL);
+        const merkleTreeAccount = await connection.getAccountInfo(merkleTree);
+        if (!merkleTreeAccount) {
+          throw new Error("Failed to fetch merkle tree account");
+        }
+        const nextIndex = Number(merkleTreeAccount.data.readBigUInt64LE(32));
+        leafIndex = nextIndex - 1;
+        const rootBytes = merkleTreeAccount.data.slice(1064, 1096);
+        root = Buffer.from(rootBytes).toString("hex");
+      }
+      if (leafIndex === null || root === null) {
+        throw new Error("Failed to get leaf index and root from transaction logs or on-chain state");
+      }
+      let merkleProof;
+      try {
+        const programId2 = this.config.programId || CLOAK_PROGRAM_ID;
+        const mintForSOL = NATIVE_SOL_MINT;
+        const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId2, mintForSOL);
+        const chainProof = await computeProofFromChain(connection, merkleTreePDA, leafIndex);
+        merkleProof = {
+          pathElements: chainProof.pathElements,
+          pathIndices: chainProof.pathIndices
+        };
+        root = chainProof.root;
+      } catch (proofError) {
+        console.warn("[SDK] Could not compute proof from chain, will fetch at withdrawal:", proofError);
+      }
+      const updatedNote = updateNoteWithDeposit(note, {
+        signature,
+        slot: depositSlot,
+        leafIndex,
+        root,
+        merkleProof
+      });
+      await this.storage.updateNote(note.commitment, {
+        depositSignature: signature,
+        depositSlot,
+        leafIndex,
+        root,
+        merkleProof
+      });
+      return {
+        note: updatedNote,
+        signature,
+        leafIndex,
+        root
+      };
+    } catch (error) {
+      throw this.wrapError(error, "Deposit failed");
+    }
+  }
+  /**
+   * Private transfer with up to 5 recipients
+   *
+   * Handles the complete private transfer flow:
+   * 1. If note is not deposited, deposits it first and waits for confirmation
+   * 2. Generates a zero-knowledge proof
+   * 3. Submits the withdrawal via relay service to recipients
+   *
+   * This is the main method for performing private transfers - it handles everything!
+   *
+   * @param connection - Solana connection (required for deposit if not already deposited)
+   * @param payer - Payer wallet (required for deposit if not already deposited)
+   * @param note - Note to spend (can be deposited or not)
+   * @param recipients - Array of 1-5 recipients with amounts
+   * @param options - Optional configuration
+   * @returns Transfer result with signature and outputs
+   *
+   * @example
+   * ```typescript
+   * // Create a note (not deposited yet)
+   * const note = client.generateNote(1_000_000_000);
+   *
+   * // privateTransfer handles the full flow: deposit + withdraw
+   * const result = await client.privateTransfer(
+   *   connection,
+   *   wallet,
+   *   note,
+   *   [
+   *     { recipient: new PublicKey("..."), amount: 500_000_000 },
+   *     { recipient: new PublicKey("..."), amount: 492_500_000 }
+   *   ],
+   *   {
+   *     relayFeeBps: 50, // 0.5%
+   *     onProgress: (status) => console.log(status),
+   *     onProofProgress: (pct) => console.log(`Proof: ${pct}%`)
+   *   }
+   * );
+   * console.log(`Success! TX: ${result.signature}`);
+   * ```
+   */
+  async privateTransfer(connection, note, recipients, options) {
+    if (!isWithdrawable(note)) {
+      const depositResult = await this.deposit(connection, note, {
+        skipPreflight: false
+      });
+      note = depositResult.note;
+    }
+    const protocolFee = note.amount - getDistributableAmount(note.amount);
+    const feeBps = Math.ceil(protocolFee * 1e4 / note.amount);
+    const distributableAmount = getDistributableAmount(note.amount);
+    validateTransfers(recipients, distributableAmount);
+    if (!note.leafIndex && note.leafIndex !== 0) {
+      throw new Error("Note must have a leaf index (note must be deposited)");
+    }
+    if (!isValidHex(note.r, 32)) {
+      throw new Error("Note r must be 64 hex characters (32 bytes)");
+    }
+    if (!isValidHex(note.sk_spend, 32)) {
+      throw new Error("Note sk_spend must be 64 hex characters (32 bytes)");
+    }
+    const nullifier = await computeNullifierAsync(note.sk_spend, note.leafIndex);
+    const nullifierHex = nullifier.toString(16).padStart(64, "0");
+    const outputsHash = await computeOutputsHashAsync(recipients);
+    const outputsHashHex = outputsHash.toString(16).padStart(64, "0");
+    const circuitsPath2 = await getDefaultCircuitsPath();
+    const useDirectProof = await areCircuitsAvailable(circuitsPath2);
+    if (!useDirectProof) {
+      throw new Error(
+        `Circuits not available at ${circuitsPath2}. Make sure circuits are built and accessible. Circuit artifacts are pinned to S3 and must be reachable from this environment.`
+      );
+    }
+    const MAX_PROOF_RETRIES = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_PROOF_RETRIES; attempt++) {
+      try {
+        if (attempt > 0) {
+          options?.onProgress?.(`proof_refresh_${attempt + 1}`);
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+        let merkleProof;
+        let merkleRoot;
+        const hasStoredProof = note.merkleProof && note.root && note.merkleProof.pathElements && note.merkleProof.pathElements.length > 0;
+        if (attempt === 0 && hasStoredProof) {
+          merkleProof = note.merkleProof;
+          merkleRoot = note.root;
+        } else {
+          const programId = this.config.programId || CLOAK_PROGRAM_ID;
+          const mintForSOL = NATIVE_SOL_MINT;
+          const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
+          const chainProof = await computeProofFromChain(
+            connection,
+            merkleTreePDA,
+            note.leafIndex
+          );
+          merkleProof = {
+            pathElements: chainProof.pathElements,
+            pathIndices: chainProof.pathIndices,
+            root: chainProof.root
+          };
+          merkleRoot = chainProof.root;
+          note.merkleProof = merkleProof;
+          note.root = merkleRoot;
+        }
+        if (!merkleProof || !merkleRoot) {
+          throw new Error("Failed to get Merkle proof from chain");
+        }
+        if (!merkleProof.pathElements || merkleProof.pathElements.length === 0) {
+          throw new Error("Merkle proof is invalid: missing path elements");
+        }
+        if (merkleProof.pathElements.length !== merkleProof.pathIndices.length) {
+          throw new Error("Merkle proof is invalid: path elements and indices length mismatch");
+        }
+        for (let i = 0; i < merkleProof.pathIndices.length; i++) {
+          const idx = merkleProof.pathIndices[i];
+          if (idx !== 0 && idx !== 1) {
+            throw new Error(`Merkle proof path index at position ${i} must be 0 or 1, got ${idx}`);
+          }
+        }
+        if (!isValidHex(merkleRoot, 32)) {
+          throw new Error("Merkle root must be 64 hex characters (32 bytes)");
+        }
+        for (let i = 0; i < merkleProof.pathElements.length; i++) {
+          const element = merkleProof.pathElements[i];
+          if (typeof element !== "string" || !isValidHex(element, 32)) {
+            throw new Error(`Merkle proof path element at position ${i} must be 64 hex characters (32 bytes)`);
+          }
+        }
+        const sk_spend_bigint = BigInt("0x" + note.sk_spend);
+        const r_bigint = BigInt("0x" + note.r);
+        const root_bigint = BigInt("0x" + merkleRoot);
+        const nullifier_bigint = BigInt("0x" + nullifierHex);
+        const outputs_hash_bigint = BigInt("0x" + outputsHashHex);
+        const amount_bigint = BigInt(note.amount);
+        const pathElements = merkleProof.pathElements.map((p) => BigInt("0x" + p));
+        const outAddr = [];
+        for (let i = 0; i < 5; i++) {
+          if (i < recipients.length) {
+            const [lo, hi] = pubkeyToLimbs(recipients[i].recipient.toBytes());
+            outAddr.push([lo, hi]);
+          } else {
+            outAddr.push([0n, 0n]);
+          }
+        }
+        const t = amount_bigint * 3n;
+        const varFee = t / 1000n;
+        const rem = t % 1000n;
+        const outAmount = [];
+        const outFlags = [];
+        for (let i = 0; i < 5; i++) {
+          if (i < recipients.length) {
+            outAmount.push(BigInt(recipients[i].amount));
+            outFlags.push(1);
+          } else {
+            outAmount.push(0n);
+            outFlags.push(0);
+          }
+        }
+        const sk = splitTo2Limbs(sk_spend_bigint);
+        const r = splitTo2Limbs(r_bigint);
+        if (attempt === 0) {
+          const computedCommitment = await computeCommitment(amount_bigint, r_bigint, sk_spend_bigint);
+          const noteCommitment = BigInt("0x" + note.commitment);
+          if (computedCommitment !== noteCommitment) {
+            throw new Error(
+              `Commitment mismatch! Computed: ${computedCommitment.toString(16)}, Note: ${note.commitment}. This means the note's sk_spend, r, or amount doesn't match what was deposited.`
+            );
+          }
+        }
+        const proofInputs = {
+          root: root_bigint,
+          nullifier: nullifier_bigint,
+          outputs_hash: outputs_hash_bigint,
+          public_amount: amount_bigint,
+          amount: amount_bigint,
+          leaf_index: BigInt(note.leafIndex),
+          sk,
+          r,
+          pathElements,
+          pathIndices: merkleProof.pathIndices,
+          num_outputs: recipients.length,
+          out_addr: outAddr,
+          out_amount: outAmount,
+          out_flags: outFlags,
+          var_fee: varFee,
+          rem
+        };
+        options?.onProgress?.("proof_generating");
+        const proofResult = await generateWithdrawRegularProof(proofInputs, circuitsPath2);
+        options?.onProgress?.("proof_complete");
+        const proofHex = Buffer.from(proofResult.proofBytes).toString("hex");
+        const finalPublicInputs = {
+          root: merkleRoot,
+          nf: nullifierHex,
+          outputs_hash: outputsHashHex,
+          amount: note.amount
+        };
+        const metadataBundle = options?.metadataBundle;
+        const signature = await this.relay.submitWithdraw(
+          {
+            proof: proofHex,
+            publicInputs: finalPublicInputs,
+            outputs: recipients.map((r2) => ({
+              recipient: r2.recipient.toBase58(),
+              amount: r2.amount
+            })),
+            feeBps,
+            // Use calculated protocol fee BPS
+            metadataBundle
+          },
+          options?.onProgress
+        );
+        return {
+          signature,
+          outputs: recipients.map((r2) => ({
+            recipient: r2.recipient.toBase58(),
+            amount: r2.amount
+          })),
+          nullifier: nullifierHex,
+          root: merkleRoot
+        };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof RootNotFoundError) {
+          console.warn(
+            `[Cloak SDK] Merkle root expired (attempt ${attempt + 1}/${MAX_PROOF_RETRIES}). Regenerating proof with fresh root...`
+          );
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error(
+      `Withdrawal failed after ${MAX_PROOF_RETRIES} proof refresh attempts. The Merkle tree is updating too rapidly. Last error: ${lastError?.message}`
     );
   }
-  /** True when the SDK was constructed with a wallet adapter (browser). */
-  isWalletMode() {
-    return !!this.wallet && !this.keypair;
+  /**
+   * Withdraw to a single recipient
+   *
+   * Convenience method for withdrawing to one address.
+   * Handles the complete flow: deposits if needed, then withdraws.
+   *
+   * @param connection - Solana connection
+   * @param payer - Payer wallet
+   * @param note - Note to spend
+   * @param recipient - Recipient address
+   * @param options - Optional configuration
+   * @returns Transfer result
+   *
+   * @example
+   * ```typescript
+   * const note = client.generateNote(1_000_000_000);
+   * const result = await client.withdraw(
+   *   connection,
+   *   wallet,
+   *   note,
+   *   new PublicKey("..."),
+   *   { withdrawAll: true }
+   * );
+   * ```
+   */
+  async withdraw(connection, note, recipient, options) {
+    const withdrawAll = options?.withdrawAll ?? true;
+    const amount = withdrawAll ? getDistributableAmount(note.amount) : options?.amount || note.amount;
+    if (!withdrawAll && !options?.amount) {
+      throw new Error("Must specify amount or set withdrawAll: true");
+    }
+    return this.privateTransfer(
+      connection,
+      note,
+      [{ recipient, amount }],
+      options
+    );
+  }
+  /**
+   * Send SOL privately to multiple recipients
+   *
+   * Convenience method that wraps privateTransfer with a simpler API.
+   * Handles the complete flow: deposits if needed, then sends to recipients.
+   *
+   * @param connection - Solana connection
+   * @param note - Note to spend
+   * @param recipients - Array of 1-5 recipients with amounts
+   * @param options - Optional configuration
+   * @returns Transfer result
+   *
+   * @example
+   * ```typescript
+   * const note = client.generateNote(1_000_000_000);
+   * const result = await client.send(
+   *   connection,
+   *   note,
+   *   [
+   *     { recipient: new PublicKey("..."), amount: 500_000_000 },
+   *     { recipient: new PublicKey("..."), amount: 492_500_000 }
+   *   ]
+   * );
+   * ```
+   */
+  async send(connection, note, recipients, options) {
+    return this.privateTransfer(connection, note, recipients, options);
+  }
+  /**
+   * Swap SOL for tokens privately
+   *
+   * Withdraws SOL from a note and swaps it for tokens via the relay service.
+   * Handles the complete flow: deposits if needed, generates proof, and submits swap.
+   *
+   * @param connection - Solana connection
+   * @param note - Note to spend
+   * @param recipient - Recipient address (will receive tokens)
+   * @param options - Swap configuration
+   * @returns Swap result with transaction signature
+   *
+   * @example
+   * ```typescript
+   * const note = client.generateNote(1_000_000_000);
+   * const result = await client.swap(
+   *   connection,
+   *   note,
+   *   new PublicKey("..."), // recipient
+   *   {
+   *     outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
+   *     slippageBps: 100, // 1%
+   *     getQuote: async (amount, mint, slippage) => {
+   *       // Fetch quote from your swap API
+   *       const quote = await fetchSwapQuote(amount, mint, slippage);
+   *       return {
+   *         outAmount: quote.outAmount,
+   *         minOutputAmount: quote.minOutputAmount
+   *       };
+   *     }
+   *   }
+   * );
+   * ```
+   */
+  async swap(connection, note, recipient, options) {
+    try {
+      if (!isWithdrawable(note)) {
+        const depositResult = await this.deposit(connection, note, {
+          skipPreflight: false
+        });
+        note = depositResult.note;
+      }
+      const variableFee = Math.floor(note.amount * 3 / 1e3);
+      const feeBps = note.amount === 0 ? 0 : Math.min(Math.floor((variableFee * 1e4 + note.amount - 1) / note.amount), 65535);
+      const withdrawAmountLamports = getDistributableAmount(note.amount);
+      if (withdrawAmountLamports <= 0) {
+        throw new Error("Amount too small after fees");
+      }
+      let minOutputAmount;
+      if (options.minOutputAmount !== void 0) {
+        minOutputAmount = options.minOutputAmount;
+      } else if (options.getQuote) {
+        const quote = await options.getQuote(
+          withdrawAmountLamports,
+          options.outputMint,
+          options.slippageBps || 100
+        );
+        minOutputAmount = quote.minOutputAmount;
+      } else {
+        throw new Error(
+          "Must provide either minOutputAmount or getQuote function"
+        );
+      }
+      let recipientAta;
+      if (options.recipientAta) {
+        recipientAta = new import_web35.PublicKey(options.recipientAta);
+      } else {
+        try {
+          const splTokenModule = await import("@solana/spl-token");
+          const getAssociatedTokenAddress = splTokenModule.getAssociatedTokenAddress;
+          if (!getAssociatedTokenAddress) {
+            throw new Error("getAssociatedTokenAddress not found");
+          }
+          const outputMint2 = new import_web35.PublicKey(options.outputMint);
+          recipientAta = await getAssociatedTokenAddress(outputMint2, recipient);
+        } catch (error) {
+          throw new Error(
+            `Failed to get associated token account: ${error instanceof Error ? error.message : String(error)}. Please install @solana/spl-token or provide recipientAta in options.`
+          );
+        }
+      }
+      if (!note.leafIndex && note.leafIndex !== 0) {
+        throw new Error("Note must have a leaf index (note must be deposited)");
+      }
+      const nullifier = await computeNullifierAsync(note.sk_spend, note.leafIndex);
+      const nullifierHex = nullifier.toString(16).padStart(64, "0");
+      const inputMint = new import_web35.PublicKey("11111111111111111111111111111111");
+      const outputMint = new import_web35.PublicKey(options.outputMint);
+      const outputsHash = await computeSwapOutputsHashAsync(
+        inputMint,
+        outputMint,
+        recipientAta,
+        minOutputAmount,
+        note.amount
+      );
+      const outputsHashHex = outputsHash.toString(16).padStart(64, "0");
+      const circuitsPath2 = await getDefaultCircuitsPath();
+      const useDirectProof = await areCircuitsAvailable(circuitsPath2);
+      if (!useDirectProof) {
+        throw new Error(
+          `Circuits not available at ${circuitsPath2}. Make sure circuits are built and accessible. Circuit artifacts are pinned to S3 and must be reachable from this environment.`
+        );
+      }
+      const MAX_PROOF_RETRIES = 3;
+      let lastError = null;
+      for (let attempt = 0; attempt < MAX_PROOF_RETRIES; attempt++) {
+        try {
+          if (attempt > 0) {
+            options?.onProgress?.(`proof_refresh_${attempt + 1}`);
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+          }
+          const programId = this.config.programId || CLOAK_PROGRAM_ID;
+          const mintForSOL = NATIVE_SOL_MINT;
+          const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
+          const chainProof = await computeProofFromChain(connection, merkleTreePDA, note.leafIndex);
+          const merkleProof = {
+            pathElements: chainProof.pathElements,
+            pathIndices: chainProof.pathIndices
+          };
+          const merkleRoot = chainProof.root;
+          if (!merkleRoot) {
+            throw new Error("Failed to get Merkle root from chain");
+          }
+          if (!merkleProof.pathElements || merkleProof.pathElements.length === 0) {
+            throw new Error("Merkle proof is invalid: missing path elements");
+          }
+          const sk_spend_bigint = BigInt("0x" + note.sk_spend);
+          const r_bigint = BigInt("0x" + note.r);
+          const root_bigint = BigInt("0x" + merkleRoot);
+          const nullifier_bigint = BigInt("0x" + nullifierHex);
+          const outputs_hash_bigint = BigInt("0x" + outputsHashHex);
+          const amount_bigint = BigInt(note.amount);
+          const pathElements = merkleProof.pathElements.map((p) => BigInt("0x" + p));
+          const inputMintLimbs = pubkeyToLimbs(inputMint.toBytes());
+          const outputMintLimbs = pubkeyToLimbs(outputMint.toBytes());
+          const recipientAtaLimbs = pubkeyToLimbs(recipientAta.toBytes());
+          if (attempt === 0) {
+            const computedCommitment = await computeCommitment(amount_bigint, r_bigint, sk_spend_bigint);
+            const noteCommitment = BigInt("0x" + note.commitment);
+            if (computedCommitment !== noteCommitment) {
+              throw new Error(
+                `Commitment mismatch! Computed: ${computedCommitment.toString(16)}, Note: ${note.commitment}. This means the note's sk_spend, r, or amount doesn't match what was deposited.`
+              );
+            }
+          }
+          const t = amount_bigint * 3n;
+          const varFee = t / 1000n;
+          const rem = t % 1000n;
+          const proofInputs = {
+            sk_spend: sk_spend_bigint,
+            r: r_bigint,
+            amount: amount_bigint,
+            leaf_index: BigInt(note.leafIndex),
+            path_elements: pathElements,
+            path_indices: merkleProof.pathIndices,
+            root: root_bigint,
+            nullifier: nullifier_bigint,
+            outputs_hash: outputs_hash_bigint,
+            public_amount: amount_bigint,
+            input_mint: inputMintLimbs,
+            output_mint: outputMintLimbs,
+            recipient_ata: recipientAtaLimbs,
+            min_output_amount: BigInt(minOutputAmount),
+            var_fee: varFee,
+            rem
+          };
+          options?.onProgress?.("proof_generating");
+          const proofResult = await generateWithdrawSwapProof(proofInputs, circuitsPath2);
+          options?.onProgress?.("proof_complete");
+          const proofHex = Buffer.from(proofResult.proofBytes).toString("hex");
+          const finalPublicInputs = {
+            root: merkleRoot,
+            nf: nullifierHex,
+            outputs_hash: outputsHashHex,
+            amount: note.amount
+          };
+          const metadataBundle = options?.metadataBundle;
+          const signature = await this.relay.submitSwap(
+            {
+              proof: proofHex,
+              publicInputs: finalPublicInputs,
+              outputs: [
+                {
+                  recipient: recipient.toBase58(),
+                  amount: withdrawAmountLamports
+                }
+              ],
+              feeBps,
+              swap: {
+                output_mint: options.outputMint,
+                slippage_bps: options.slippageBps || 100,
+                min_output_amount: minOutputAmount
+              },
+              metadataBundle
+            },
+            options.onProgress
+          );
+          return {
+            signature,
+            outputs: [
+              {
+                recipient: recipient.toBase58(),
+                amount: withdrawAmountLamports
+              }
+            ],
+            nullifier: nullifierHex,
+            root: merkleRoot,
+            outputMint: options.outputMint,
+            minOutputAmount
+          };
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (error instanceof RootNotFoundError) {
+            console.warn(
+              `[Cloak SDK] Merkle root expired (attempt ${attempt + 1}/${MAX_PROOF_RETRIES}). Regenerating swap proof with fresh root...`
+            );
+            continue;
+          }
+          throw error;
+        }
+      }
+      throw new Error(
+        `Swap failed after ${MAX_PROOF_RETRIES} proof refresh attempts. The Merkle tree is updating too rapidly. Last error: ${lastError?.message}`
+      );
+    } catch (error) {
+      throw this.wrapError(error, "Swap failed");
+    }
+  }
+  /**
+   * Generate a new note without depositing
+   *
+   * @param amountLamports - Amount for the note
+   * @param useWalletKeys - Whether to use wallet keys (v2.0 recommended)
+   * @returns New note (not yet deposited)
+   */
+  async generateNote(amountLamports, useWalletKeys = false) {
+    if (useWalletKeys && this.cloakKeys) {
+      return await generateNoteFromWallet(amountLamports, this.cloakKeys, this.config.network);
+    } else if (useWalletKeys) {
+      const keys = generateCloakKeys();
+      this.cloakKeys = keys;
+      const result = this.storage.saveKeys(keys);
+      if (result instanceof Promise) {
+        result.catch(() => {
+        });
+      }
+      return await generateNoteFromWallet(amountLamports, keys, this.config.network);
+    }
+    return await generateNote(amountLamports, this.config.network);
+  }
+  /**
+   * Parse a note from JSON string
+   *
+   * @param jsonString - JSON representation
+   * @returns Parsed note
+   */
+  parseNote(jsonString) {
+    return parseNote2(jsonString);
+  }
+  /**
+   * Export a note to JSON string
+   *
+   * @param note - Note to export
+   * @param pretty - Format with indentation
+   * @returns JSON string
+   */
+  exportNote(note, pretty = false) {
+    return pretty ? JSON.stringify(note, null, 2) : JSON.stringify(note);
   }
   /**
-   * Compute a Merkle proof for `leafIndex` from on-chain state. No relay /
-   * indexer round-trip required.
+   * Check if a note is ready for withdrawal
+   *
+   * @param note - Note to check
+   * @returns True if withdrawable
+   */
+  isWithdrawable(note) {
+    return isWithdrawable(note);
+  }
+  /**
+   * Get Merkle proof for a leaf index directly from on-chain state
+   *
+   * @param connection - Solana connection
+   * @param leafIndex - Leaf index in tree
+   * @returns Merkle proof computed from on-chain data
    */
   async getMerkleProof(connection, leafIndex) {
     const programId = this.config.programId || CLOAK_PROGRAM_ID;
-    const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, NATIVE_SOL_MINT);
+    const mintForSOL = NATIVE_SOL_MINT;
+    const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
     const chainProof = await computeProofFromChain(connection, merkleTreePDA, leafIndex);
     return {
       pathElements: chainProof.pathElements,
@@ -2476,20 +4120,72 @@ var CloakSDK = class {
       root: chainProof.root
     };
   }
-  /** Read the current SOL-pool Merkle root from on-chain state. */
+  /**
+   * Get current Merkle root directly from on-chain state
+   *
+   * @param connection - Solana connection
+   * @returns Current root hash from on-chain tree
+   */
   async getCurrentRoot(connection) {
     const programId = this.config.programId || CLOAK_PROGRAM_ID;
-    const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, NATIVE_SOL_MINT);
+    const mintForSOL = NATIVE_SOL_MINT;
+    const { merkleTree: merkleTreePDA } = getShieldPoolPDAs(programId, mintForSOL);
     const state = await readMerkleTreeState(connection, merkleTreePDA);
     return state.root;
   }
-  /** Poll relay for the status of a previously-submitted request. */
+  /**
+   * Get transaction status from relay service
+   *
+   * @param requestId - Request ID from previous submission
+   * @returns Current status
+   */
   async getTransactionStatus(requestId) {
     return this.relay.getStatus(requestId);
   }
-  /** Import wallet keys from JSON; persists to the configured storage adapter. */
+  /**
+   * Fetch and decrypt this user's transaction metadata history.
+   * DEPRECATED: This functionality is no longer supported
+   */
+  async getTransactionMetadata(_options) {
+    throw new Error("getTransactionMetadata is deprecated - use compliance export API instead");
+  }
+  /**
+   * Load all notes from storage
+   * 
+   * @returns Array of saved notes
+   */
+  async loadNotes() {
+    const notes = this.storage.loadAllNotes();
+    return Array.isArray(notes) ? notes : await notes;
+  }
+  /**
+   * Save a note to storage
+   * 
+   * @param note - Note to save
+   */
+  async saveNote(note) {
+    const result = this.storage.saveNote(note);
+    if (result instanceof Promise) {
+      await result;
+    }
+  }
+  /**
+   * Find a note by its commitment
+   * 
+   * @param commitment - Commitment hash
+   * @returns Note if found
+   */
+  async findNote(commitment) {
+    const notes = await this.loadNotes();
+    return findNoteByCommitment(notes, commitment);
+  }
+  /**
+   * Import wallet keys from JSON
+   * 
+   * @param keysJson - JSON string containing keys
+   */
   async importWalletKeys(keysJson) {
-    const keys = importKeys(keysJson);
+    const keys = importWalletKeys(keysJson);
     this.cloakKeys = keys;
     const result = this.storage.saveKeys(keys);
     if (result instanceof Promise) {
@@ -2497,32 +4193,134 @@ var CloakSDK = class {
     }
   }
   /**
-   * Export wallet keys to JSON.
-   *
-   * WARNING: this exports secret keys. Store securely.
+   * Export wallet keys to JSON
+   * 
+   * WARNING: This exports secret keys! Store securely.
+   * 
+   * @returns JSON string with keys
    */
   exportWalletKeys() {
     if (!this.cloakKeys) {
       throw new CloakError("No wallet keys available", "wallet", false);
     }
-    return exportKeys(this.cloakKeys);
+    return exportWalletKeys(this.cloakKeys);
   }
   /**
-   * Snapshot of the active SDK configuration.
-   *
-   * The return type ({@link CloakConfig}) is structurally narrower than the
-   * constructor input ({@link CloakSDKOptions}): `keypairBytes`, `wallet`,
-   * and `storage` are intentionally absent from the snapshot. The secrets
-   * are consumed into private SDK state at construction time and are not
-   * re-exposable through this method — the type system enforces it. To
-   * sign, pass a `Keypair` / `WalletAdapter` directly to the standalone
-   * `transact` / `partialWithdraw` / `fullWithdraw` / `swapUtxo` helpers.
+   * Get the configuration
    */
   getConfig() {
     return { ...this.config };
   }
+  // Note: scanNotes was removed - it required the indexer to store encrypted outputs.
+  // Users should maintain their own note storage. This is more privacy-preserving.
+  /**
+   * Wrap errors with better categorization and user-friendly messages
+   * 
+   * @private
+   */
+  wrapError(error, context) {
+    if (error instanceof CloakError) {
+      return error;
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("duplicate key") || errorMessage.includes("already deposited")) {
+      return new CloakError(
+        "This note was already deposited. Generate a new note to continue.",
+        "validation",
+        false,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (errorMessage.includes("insufficient funds") || errorMessage.includes("insufficient lamports")) {
+      return new CloakError(
+        "Insufficient funds for this transaction. Please check your wallet balance.",
+        "wallet",
+        false,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (errorMessage.includes("Merkle tree") || errorMessage.includes("merkle")) {
+      return new CloakError(
+        "Failed to read on-chain Merkle tree state. Please try again.",
+        "network",
+        true,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (errorMessage.includes("timeout") || errorMessage.includes("timed out")) {
+      return new CloakError(
+        "Network timeout. Please check your connection and try again.",
+        "network",
+        true,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (errorMessage.includes("not connected") || errorMessage.includes("wallet")) {
+      return new CloakError(
+        "Wallet not connected. Please connect your wallet first.",
+        "wallet",
+        false,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (errorMessage.includes("proof") && (errorMessage.includes("failed") || errorMessage.includes("error"))) {
+      return new CloakError(
+        "Zero-knowledge proof generation failed. This is usually temporary - please try again.",
+        "prover",
+        true,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (errorMessage.includes("relay") || errorMessage.includes("withdraw")) {
+      return new CloakError(
+        "Relay service error. Please try again later.",
+        "relay",
+        true,
+        error instanceof Error ? error : void 0
+      );
+    }
+    return new CloakError(
+      `${context}: ${errorMessage}`,
+      "network",
+      false,
+      error instanceof Error ? error : void 0
+    );
+  }
 };
 
+// src/core/note.ts
+function serializeNote(note, pretty = false) {
+  validateNote(note);
+  return pretty ? JSON.stringify(note, null, 2) : JSON.stringify(note);
+}
+function downloadNote(note, filename) {
+  const g = globalThis;
+  const doc = g?.document;
+  const URL_ = g?.URL;
+  const Blob_ = g?.Blob;
+  if (!doc || !URL_ || !Blob_) {
+    throw new Error("downloadNote is only available in browser environments");
+  }
+  const json = serializeNote(note, true);
+  const blob = new Blob_([json], { type: "application/json" });
+  const url = URL_.createObjectURL(blob);
+  const defaultFilename = `cloak-note-${note.commitment.slice(0, 8)}.json`;
+  const link = doc.createElement("a");
+  link.href = url;
+  link.download = filename || defaultFilename;
+  link.click();
+  URL_.revokeObjectURL(url);
+}
+async function copyNoteToClipboard(note) {
+  const g = globalThis;
+  const nav = g?.navigator;
+  if (!nav || !nav.clipboard) {
+    throw new Error("Clipboard API not available");
+  }
+  const json = serializeNote(note, true);
+  await nav.clipboard.writeText(json);
+}
+
 // src/core/compliance-keys.ts
 var import_tweetnacl2 = __toESM(require("tweetnacl"), 1);
 var import_blake33 = require("@noble/hashes/blake3");
@@ -2909,107 +4707,6 @@ async function decryptComplianceMetadataWithMasterKey(encrypted, masterComplianc
   return decryptWithSharedSecret(payload, sharedSecret);
 }
 
-// src/utils/fees.ts
-var LAMPORTS_PER_SOL = 1e9;
-var FIXED_FEE_LAMPORTS = 5e6;
-var VARIABLE_FEE_NUMERATOR = 3;
-var VARIABLE_FEE_DENOMINATOR = 1e3;
-var VARIABLE_FEE_RATE = VARIABLE_FEE_NUMERATOR / VARIABLE_FEE_DENOMINATOR;
-var MIN_DEPOSIT_LAMPORTS = 1e7;
-function calculateFee(amountLamports) {
-  const variableFee = Math.floor(amountLamports * VARIABLE_FEE_NUMERATOR / VARIABLE_FEE_DENOMINATOR);
-  return FIXED_FEE_LAMPORTS + variableFee;
-}
-function calculateFeeBigint(amountLamports) {
-  const fixed = BigInt(FIXED_FEE_LAMPORTS);
-  const variable = amountLamports * BigInt(VARIABLE_FEE_NUMERATOR) / BigInt(VARIABLE_FEE_DENOMINATOR);
-  return fixed + variable;
-}
-function isWithdrawAmountSufficient(amountLamports) {
-  return amountLamports > calculateFeeBigint(amountLamports);
-}
-function getDistributableAmount(amountLamports) {
-  return amountLamports - calculateFee(amountLamports);
-}
-function formatAmount(lamports, decimals = 9) {
-  return (lamports / LAMPORTS_PER_SOL).toFixed(decimals);
-}
-function parseAmount(sol) {
-  const num = parseFloat(sol);
-  if (isNaN(num) || num < 0) {
-    throw new Error(`Invalid SOL amount: ${sol}`);
-  }
-  return Math.floor(num * LAMPORTS_PER_SOL);
-}
-function validateOutputsSum(outputs, expectedTotal) {
-  const sum = outputs.reduce((acc, out) => acc + out.amount, 0);
-  return sum === expectedTotal;
-}
-function calculateRelayFee(amountLamports, feeBps) {
-  if (feeBps < 0 || feeBps > 1e4) {
-    throw new Error("Fee basis points must be between 0 and 10000");
-  }
-  return Math.floor(amountLamports * feeBps / 1e4);
-}
-
-// src/utils/validation.ts
-var import_web34 = require("@solana/web3.js");
-function isValidSolanaAddress(address) {
-  try {
-    new import_web34.PublicKey(address);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/utils/network.ts
-function detectNetworkFromRpcUrl(rpcUrl) {
-  const url = rpcUrl || process.env.NEXT_PUBLIC_SOLANA_RPC_URL || "";
-  const lowerUrl = url.toLowerCase();
-  if (lowerUrl.includes("mainnet") || lowerUrl.includes("api.mainnet-beta") || lowerUrl.includes("mainnet-beta")) {
-    return "mainnet";
-  }
-  if (lowerUrl.includes("testnet") || lowerUrl.includes("api.testnet")) {
-    return "testnet";
-  }
-  if (lowerUrl.includes("devnet") || lowerUrl.includes("api.devnet")) {
-    return "devnet";
-  }
-  if (lowerUrl.includes("localhost") || lowerUrl.includes("127.0.0.1") || lowerUrl.includes("local")) {
-    return "localnet";
-  }
-  return "mainnet";
-}
-function getRpcUrlForNetwork(network) {
-  switch (network) {
-    case "mainnet":
-      return "https://api.mainnet-beta.solana.com";
-    case "devnet":
-      return "https://api.devnet.solana.com";
-    case "localnet":
-      return "http://localhost:8899";
-    default:
-      return "https://api.mainnet-beta.solana.com";
-  }
-}
-function isValidRpcUrl(url) {
-  try {
-    const parsed = new URL(url);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-function getExplorerUrl(signature, network = "devnet") {
-  const cluster = network === "mainnet" ? "" : `?cluster=${network}`;
-  return `https://explorer.solana.com/tx/${signature}${cluster}`;
-}
-function getAddressExplorerUrl(address, network = "devnet") {
-  const cluster = network === "mainnet" ? "" : `?cluster=${network}`;
-  return `https://explorer.solana.com/address/${address}${cluster}`;
-}
-
 // src/utils/verify-utxos.ts
 init_utxo();
 async function verifyUtxos(utxos, connection, programId, commitment = "confirmed") {
@@ -3021,7 +4718,7 @@ async function verifyUtxos(utxos, connection, programId, commitment = "confirmed
       continue;
     }
     try {
-      const nullifierBig = await computeNullifier(utxo);
+      const nullifierBig = await computeNullifier2(utxo);
       const nullifierHex = nullifierBig.toString(16).padStart(64, "0");
       const nullifierBytes = Buffer.from(nullifierHex, "hex");
       const { pool } = getShieldPoolPDAs(programId, utxo.mintAddress);
@@ -3139,10 +4836,49 @@ async function fetchRiskQuoteIx(connection, wallet, rangeApiKey) {
   };
 }
 
+// src/helpers/encrypted-output.ts
+function prepareEncryptedOutput(note, cloakKeys) {
+  const noteData = {
+    amount: note.amount,
+    r: note.r,
+    sk_spend: note.sk_spend,
+    commitment: note.commitment
+  };
+  const encrypted = encryptNoteForRecipient(noteData, cloakKeys.view.pvk);
+  return btoa(JSON.stringify(encrypted));
+}
+function prepareEncryptedOutputForRecipient(note, recipientPvkHex) {
+  const noteData = {
+    amount: note.amount,
+    r: note.r,
+    sk_spend: note.sk_spend,
+    commitment: note.commitment
+  };
+  const recipientPvk = hexToBytes(recipientPvkHex);
+  const encrypted = encryptNoteForRecipient(noteData, recipientPvk);
+  return btoa(JSON.stringify(encrypted));
+}
+function encodeNoteSimple(note) {
+  const data = {
+    amount: note.amount,
+    r: note.r,
+    sk_spend: note.sk_spend,
+    commitment: note.commitment
+  };
+  const json = JSON.stringify(data);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(json).toString("base64");
+  } else if (typeof btoa !== "undefined") {
+    return btoa(json);
+  } else {
+    throw new Error("No base64 encoding method available");
+  }
+}
+
 // src/helpers/wallet-integration.ts
-var import_web35 = require("@solana/web3.js");
+var import_web36 = require("@solana/web3.js");
 function validateWalletConnected(wallet) {
-  if (wallet instanceof import_web35.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     return;
   }
   if (!wallet.publicKey) {
@@ -3154,7 +4890,7 @@ function validateWalletConnected(wallet) {
   }
 }
 function getPublicKey(wallet) {
-  if (wallet instanceof import_web35.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     return wallet.publicKey;
   }
   if (!wallet.publicKey) {
@@ -3167,7 +4903,7 @@ function getPublicKey(wallet) {
   return wallet.publicKey;
 }
 async function sendTransaction(transaction, wallet, connection, options) {
-  if (wallet instanceof import_web35.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     return await connection.sendTransaction(transaction, [wallet], options);
   }
   if (wallet.sendTransaction) {
@@ -3184,7 +4920,7 @@ async function sendTransaction(transaction, wallet, connection, options) {
   }
 }
 async function signTransaction(transaction, wallet) {
-  if (wallet instanceof import_web35.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     transaction.sign(wallet);
     return transaction;
   }
@@ -3648,13 +5384,180 @@ async function preflightCheck(relayUrl, rootHex) {
   };
 }
 
+// src/utils/pending-operations.ts
+var PENDING_DEPOSITS_KEY = "cloak_pending_deposits";
+var PENDING_WITHDRAWALS_KEY = "cloak_pending_withdrawals";
+function getStorage() {
+  if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+    return globalThis.localStorage;
+  }
+  return null;
+}
+function savePendingDeposit(deposit) {
+  const storage = getStorage();
+  if (!storage) {
+    console.warn("localStorage not available - pending deposit not persisted");
+    return;
+  }
+  const deposits = loadPendingDeposits();
+  const index = deposits.findIndex((d) => d.note.commitment === deposit.note.commitment);
+  if (index >= 0) {
+    deposits[index] = deposit;
+  } else {
+    deposits.push(deposit);
+  }
+  storage.setItem(PENDING_DEPOSITS_KEY, JSON.stringify(deposits));
+}
+function loadPendingDeposits() {
+  const storage = getStorage();
+  if (!storage) return [];
+  const stored = storage.getItem(PENDING_DEPOSITS_KEY);
+  if (!stored) return [];
+  try {
+    return JSON.parse(stored);
+  } catch {
+    return [];
+  }
+}
+function updatePendingDeposit(commitment, updates) {
+  const storage = getStorage();
+  if (!storage) return;
+  const deposits = loadPendingDeposits();
+  const index = deposits.findIndex((d) => d.note.commitment === commitment);
+  if (index >= 0) {
+    deposits[index] = { ...deposits[index], ...updates };
+    storage.setItem(PENDING_DEPOSITS_KEY, JSON.stringify(deposits));
+  }
+}
+function removePendingDeposit(commitment) {
+  const storage = getStorage();
+  if (!storage) return;
+  const deposits = loadPendingDeposits();
+  const filtered = deposits.filter((d) => d.note.commitment !== commitment);
+  storage.setItem(PENDING_DEPOSITS_KEY, JSON.stringify(filtered));
+}
+function clearPendingDeposits() {
+  const storage = getStorage();
+  if (storage) {
+    storage.removeItem(PENDING_DEPOSITS_KEY);
+  }
+}
+function savePendingWithdrawal(withdrawal) {
+  const storage = getStorage();
+  if (!storage) {
+    console.warn("localStorage not available - pending withdrawal not persisted");
+    return;
+  }
+  const withdrawals = loadPendingWithdrawals();
+  const index = withdrawals.findIndex((w) => w.requestId === withdrawal.requestId);
+  if (index >= 0) {
+    withdrawals[index] = withdrawal;
+  } else {
+    withdrawals.push(withdrawal);
+  }
+  storage.setItem(PENDING_WITHDRAWALS_KEY, JSON.stringify(withdrawals));
+}
+function loadPendingWithdrawals() {
+  const storage = getStorage();
+  if (!storage) return [];
+  const stored = storage.getItem(PENDING_WITHDRAWALS_KEY);
+  if (!stored) return [];
+  try {
+    return JSON.parse(stored);
+  } catch {
+    return [];
+  }
+}
+function updatePendingWithdrawal(requestId, updates) {
+  const storage = getStorage();
+  if (!storage) return;
+  const withdrawals = loadPendingWithdrawals();
+  const index = withdrawals.findIndex((w) => w.requestId === requestId);
+  if (index >= 0) {
+    withdrawals[index] = { ...withdrawals[index], ...updates };
+    storage.setItem(PENDING_WITHDRAWALS_KEY, JSON.stringify(withdrawals));
+  }
+}
+function removePendingWithdrawal(requestId) {
+  const storage = getStorage();
+  if (!storage) return;
+  const withdrawals = loadPendingWithdrawals();
+  const filtered = withdrawals.filter((w) => w.requestId !== requestId);
+  storage.setItem(PENDING_WITHDRAWALS_KEY, JSON.stringify(filtered));
+}
+function clearPendingWithdrawals() {
+  const storage = getStorage();
+  if (storage) {
+    storage.removeItem(PENDING_WITHDRAWALS_KEY);
+  }
+}
+function hasPendingOperations() {
+  const deposits = loadPendingDeposits();
+  const withdrawals = loadPendingWithdrawals();
+  const pendingDeposits = deposits.filter(
+    (d) => d.status === "pending" || d.status === "tx_sent"
+  );
+  const pendingWithdrawals = withdrawals.filter(
+    (w) => w.status === "pending" || w.status === "processing"
+  );
+  return pendingDeposits.length > 0 || pendingWithdrawals.length > 0;
+}
+function getPendingOperationsSummary() {
+  const deposits = loadPendingDeposits().filter(
+    (d) => d.status === "pending" || d.status === "tx_sent"
+  );
+  const withdrawals = loadPendingWithdrawals().filter(
+    (w) => w.status === "pending" || w.status === "processing"
+  );
+  return {
+    deposits,
+    withdrawals,
+    totalPending: deposits.length + withdrawals.length
+  };
+}
+function cleanupStalePendingOperations(maxAgeMs = 24 * 60 * 60 * 1e3) {
+  const now = Date.now();
+  let removedDeposits = 0;
+  let removedWithdrawals = 0;
+  const deposits = loadPendingDeposits();
+  const activeDeposits = deposits.filter((d) => {
+    const age = now - d.startedAt;
+    const isStale = age > maxAgeMs;
+    const isTerminal = d.status === "confirmed" || d.status === "failed";
+    if (isStale || isTerminal) {
+      removedDeposits++;
+      return false;
+    }
+    return true;
+  });
+  const storage = getStorage();
+  if (storage) {
+    storage.setItem(PENDING_DEPOSITS_KEY, JSON.stringify(activeDeposits));
+  }
+  const withdrawals = loadPendingWithdrawals();
+  const activeWithdrawals = withdrawals.filter((w) => {
+    const age = now - w.startedAt;
+    const isStale = age > maxAgeMs;
+    const isTerminal = w.status === "completed" || w.status === "failed";
+    if (isStale || isTerminal) {
+      removedWithdrawals++;
+      return false;
+    }
+    return true;
+  });
+  if (storage) {
+    storage.setItem(PENDING_WITHDRAWALS_KEY, JSON.stringify(activeWithdrawals));
+  }
+  return { removedDeposits, removedWithdrawals };
+}
+
 // src/index.ts
 init_utxo();
 
 // src/core/transact.ts
-var import_web36 = require("@solana/web3.js");
+var import_web37 = require("@solana/web3.js");
 var import_spl_token = require("@solana/spl-token");
-var snarkjs = __toESM(require("snarkjs"), 1);
+var snarkjs2 = __toESM(require("snarkjs"), 1);
 init_utxo();
 
 // src/core/chain-note.ts
@@ -3805,8 +5708,8 @@ function chainNoteFromBase64(base64) {
 // src/core/transact.ts
 var import_circomlibjs4 = require("circomlibjs");
 var import_tweetnacl4 = __toESM(require("tweetnacl"), 1);
-var IS_BROWSER = typeof window !== "undefined" || typeof globalThis.document !== "undefined";
-var DEFAULT_TRANSACTION_CIRCUITS_URL = "https://cloak-circuits.s3.us-east-1.amazonaws.com/circuits/0.1.0";
+var IS_BROWSER2 = typeof window !== "undefined" || typeof globalThis.document !== "undefined";
+var DEFAULT_TRANSACTION_CIRCUITS_URL = "https://storage.googleapis.com/cloak-circuits/circuits/0.1.0";
 var DEFAULT_CLOAK_RELAY_URL = "https://api.cloak.ag";
 function resolveDefaultTransactionCircuitsPath() {
   return DEFAULT_TRANSACTION_CIRCUITS_URL;
@@ -3818,7 +5721,7 @@ async function resolveTransactionCircuitFiles() {
   const baseNorm = base.endsWith("/") ? base : `${base}/`;
   const wasmUrl = `${baseNorm}transaction_js/transaction.wasm`;
   const zkeyUrl = `${baseNorm}transaction_final.zkey`;
-  if (IS_BROWSER) {
+  if (IS_BROWSER2) {
     return { wasmPath: wasmUrl, zkeyPath: zkeyUrl };
   }
   if (_remoteTxCircuitsCache?.base === baseNorm) {
@@ -3955,7 +5858,7 @@ async function resolveAddressLookupTableAccounts(connection, relayUrl, altAddres
   const fetched = await Promise.all(
     altAddresses.map(async (addr) => {
       try {
-        const pubkey = new import_web36.PublicKey(addr);
+        const pubkey = new import_web37.PublicKey(addr);
         const result = await connection.getAddressLookupTable(pubkey);
         return result.value ?? null;
       } catch {
@@ -4117,7 +6020,7 @@ async function generateTransactionProof(inputs, onProgress) {
   onProgress?.(10);
   const { wasmPath: wasmInput, zkeyPath: zkeyInput } = await resolveTransactionCircuitFiles();
   onProgress?.(30);
-  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+  const { proof, publicSignals } = await snarkjs2.groth16.fullProve(
     inputs,
     wasmInput,
     zkeyInput
@@ -4197,7 +6100,7 @@ function buildPublicInputsBytesFromSignals(publicSignals) {
 }
 var TRANSACT_DISCRIMINATOR = 0;
 function deriveNullifierPDA(programId, poolPDA, nullifier) {
-  return import_web36.PublicKey.findProgramAddressSync(
+  return import_web37.PublicKey.findProgramAddressSync(
     [Buffer.from("nullifier"), poolPDA.toBuffer(), Buffer.from(nullifier)],
     programId
   );
@@ -4240,7 +6143,7 @@ function buildTransactInstruction(programId, payer, poolPDA, treasuryPDA, merkle
     // 4. nullifier PDA 0 (writable)
     { pubkey: nullifierPDA1, isSigner: false, isWritable: true },
     // 5. nullifier PDA 1 (writable)
-    { pubkey: import_web36.SystemProgram.programId, isSigner: false, isWritable: false }
+    { pubkey: import_web37.SystemProgram.programId, isSigner: false, isWritable: false }
     // 6. system_program
   ];
   if (splAccounts) {
@@ -4249,23 +6152,23 @@ function buildTransactInstruction(programId, payer, poolPDA, treasuryPDA, merkle
     accounts.push({ pubkey: splAccounts.tokenProgram, isSigner: false, isWritable: false });
     if (splAccounts.payerAta) {
       if (enableRiskCheck) {
-        accounts.push({ pubkey: import_web36.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
+        accounts.push({ pubkey: import_web37.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
       }
       accounts.push({ pubkey: splAccounts.payerAta, isSigner: false, isWritable: true });
     } else if (enableRiskCheck && !recipient) {
-      accounts.push({ pubkey: import_web36.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
+      accounts.push({ pubkey: import_web37.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
     }
   } else {
     if (recipient) {
       accounts.push({ pubkey: recipient, isSigner: false, isWritable: true });
       if (enableRiskCheck) {
-        accounts.push({ pubkey: import_web36.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
+        accounts.push({ pubkey: import_web37.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
       }
     } else if (enableRiskCheck) {
-      accounts.push({ pubkey: import_web36.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
+      accounts.push({ pubkey: import_web37.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false });
     }
   }
-  return new import_web36.TransactionInstruction({
+  return new import_web37.TransactionInstruction({
     programId,
     keys: accounts,
     data
@@ -4273,10 +6176,10 @@ function buildTransactInstruction(programId, payer, poolPDA, treasuryPDA, merkle
 }
 function getCommonALTAddresses() {
   return [
-    import_web36.SystemProgram.programId,
-    import_web36.SYSVAR_SLOT_HASHES_PUBKEY,
-    import_web36.SYSVAR_INSTRUCTIONS_PUBKEY,
-    import_web36.ComputeBudgetProgram.programId
+    import_web37.SystemProgram.programId,
+    import_web37.SYSVAR_SLOT_HASHES_PUBKEY,
+    import_web37.SYSVAR_INSTRUCTIONS_PUBKEY,
+    import_web37.ComputeBudgetProgram.programId
   ];
 }
 function dedupePubkeys(addresses) {
@@ -4326,23 +6229,23 @@ async function createEphemeralALT(connection, depositor, onProgress, additionalA
   for (let altAttempt = 0; altAttempt < MAX_ALT_CREATE_RETRIES; altAttempt++) {
     try {
       const slot = await connection.getSlot("finalized");
-      const [createIx, altAddress] = import_web36.AddressLookupTableProgram.createLookupTable({
+      const [createIx, altAddress] = import_web37.AddressLookupTableProgram.createLookupTable({
         authority: depositor.publicKey,
         payer: depositor.publicKey,
         recentSlot: slot
       });
-      const extendIx = import_web36.AddressLookupTableProgram.extendLookupTable({
+      const extendIx = import_web37.AddressLookupTableProgram.extendLookupTable({
         payer: depositor.publicKey,
         authority: depositor.publicKey,
         lookupTable: altAddress,
         addresses: addressesForCreate
       });
-      const tx = new import_web36.Transaction().add(createIx).add(extendIx);
+      const tx = new import_web37.Transaction().add(createIx).add(extendIx);
       const { blockhash } = await connection.getLatestBlockhash();
       tx.recentBlockhash = blockhash;
       tx.feePayer = depositor.publicKey;
       if (depositor.keypair) {
-        await (0, import_web36.sendAndConfirmTransaction)(connection, tx, [depositor.keypair], { commitment: "confirmed" });
+        await (0, import_web37.sendAndConfirmTransaction)(connection, tx, [depositor.keypair], { commitment: "confirmed" });
       } else if (depositor.signTransaction) {
         const signedTx = await depositor.signTransaction(tx);
         const sig = await connection.sendRawTransaction(signedTx.serialize());
@@ -4503,8 +6406,8 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
   if (riskQuoteIx) {
     baseInstructions.unshift(riskQuoteIx);
   }
-  const cuLimitIx = import_web36.ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
-  const cuPriceIx = import_web36.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1e5 });
+  const cuLimitIx = import_web37.ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
+  const cuPriceIx = import_web37.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1e5 });
   const fullInstructions = [...baseInstructions, cuLimitIx, cuPriceIx, transactIx];
   const compactInstructions = [...baseInstructions, cuLimitIx, transactIx];
   const minimalInstructions = [...baseInstructions, transactIx];
@@ -4515,7 +6418,7 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
   if (useV0) {
     const estimateV0Size = (ixs) => {
       try {
-        const messageV0 = new import_web36.TransactionMessage({
+        const messageV0 = new import_web37.TransactionMessage({
           payerKey: depositor.publicKey,
           recentBlockhash: blockhash,
           instructions: ixs
@@ -4566,6 +6469,38 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
     const sendV0 = async (ixs, options) => {
       const maxBlockhashRetries = 2;
       const maxTransportRetries = 3;
+      const alreadyLanded = async (sig) => {
+        if (!sig) return false;
+        for (let i = 0; i < 6; i++) {
+          try {
+            const { value } = await connection.getSignatureStatus(sig, {
+              searchTransactionHistory: true
+            });
+            if (value) {
+              if (value.err) return false;
+              if (value.confirmationStatus === "confirmed" || value.confirmationStatus === "finalized") {
+                return true;
+              }
+            }
+          } catch {
+          }
+          await new Promise((r) => setTimeout(r, 400));
+        }
+        return false;
+      };
+      const looksLikeDoubleSpend = (error) => {
+        const m = error instanceof Error ? error.message : String(error);
+        return m.includes("0x1020") || // confirmTransaction().value.err is JSON-stringified, so 0x1020 appears as
+        // its decimal form ("Custom":4128) rather than the hex "0x1020".
+        m.includes('"Custom":4128') || m.includes("already been processed") || m.toLowerCase().includes("doublespend");
+      };
+      const sentSigs = [];
+      const anyLanded = async () => {
+        for (const s of sentSigs) {
+          if (await alreadyLanded(s)) return s;
+        }
+        return void 0;
+      };
       for (let blockhashRetry = 0; blockhashRetry <= maxBlockhashRetries; blockhashRetry++) {
         if (blockhashRetry > 0) {
           ({ blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash());
@@ -4575,12 +6510,12 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
         }
         let transportAttempt = 0;
         while (true) {
-          const messageV0 = new import_web36.TransactionMessage({
+          const messageV0 = new import_web37.TransactionMessage({
             payerKey: depositor.publicKey,
             recentBlockhash: blockhash,
             instructions: ixs
           }).compileToV0Message(addressLookupTableAccounts);
-          const versionedTx = new import_web36.VersionedTransaction(messageV0);
+          const versionedTx = new import_web37.VersionedTransaction(messageV0);
           try {
             if (depositor.keypair) {
               onProgress?.("Signing and sending transaction...");
@@ -4588,6 +6523,7 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
               signature = await connection.sendRawTransaction(versionedTx.serialize(), {
                 skipPreflight: options?.skipPreflight ?? false
               });
+              sentSigs.push(signature);
               onProgress?.("Confirming transaction...");
               const confirmation = await connection.confirmTransaction({
                 signature,
@@ -4604,6 +6540,7 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
               signature = await connection.sendRawTransaction(signedTx.serialize(), {
                 skipPreflight: options?.skipPreflight ?? false
               });
+              sentSigs.push(signature);
               onProgress?.("Confirming transaction...");
               const confirmation = await connection.confirmTransaction({
                 signature,
@@ -4618,8 +6555,10 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
             }
             return signature;
           } catch (error) {
-            if (isBlockhashExpiryError(error) && blockhashRetry < maxBlockhashRetries) {
-              break;
+            if (isBlockhashExpiryError(error)) {
+              const landed = await anyLanded();
+              if (landed) return landed;
+              if (blockhashRetry < maxBlockhashRetries) break;
             }
             if (isTransientTransportError(error) && transportAttempt < maxTransportRetries) {
               transportAttempt++;
@@ -4631,6 +6570,10 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
               ({ blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash());
               continue;
             }
+            if (looksLikeDoubleSpend(error)) {
+              const landed = await anyLanded();
+              if (landed) return landed;
+            }
             throw error;
           }
         }
@@ -4713,7 +6656,7 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
     let legacyTransportAttempt = 0;
     while (true) {
       try {
-        const tx = new import_web36.Transaction();
+        const tx = new import_web37.Transaction();
         for (const ix of instructions) {
           tx.add(ix);
         }
@@ -4721,7 +6664,7 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
         tx.feePayer = depositor.publicKey;
         if (depositor.keypair) {
           onProgress?.("Signing and sending transaction...");
-          signature = await (0, import_web36.sendAndConfirmTransaction)(
+          signature = await (0, import_web37.sendAndConfirmTransaction)(
             connection,
             tx,
             [depositor.keypair],
@@ -4895,7 +6838,7 @@ async function fetchRiskQuoteInstruction(riskQuoteUrl, wallet, options) {
     const signerB58 = signerKey;
     const signatureBuf = Buffer.from(signatureB64, "base64");
     const messageArr = hexToBytes2(messageHex);
-    const publicKeyBytes = new import_web36.PublicKey(signerB58).toBytes();
+    const publicKeyBytes = new import_web37.PublicKey(signerB58).toBytes();
     if (signatureBuf.length !== 64 || messageArr.length !== 33 && messageArr.length !== 41 && messageArr.length !== 50 || publicKeyBytes.length !== 32) {
       throw new Error(
         `Invalid risk quote response: invalid lengths (sig=${signatureBuf.length}, msg=${messageArr.length}, pk=${publicKeyBytes.length})`
@@ -4904,7 +6847,7 @@ async function fetchRiskQuoteInstruction(riskQuoteUrl, wallet, options) {
     const signature = new Uint8Array(signatureBuf);
     const message = new Uint8Array(messageArr);
     const publicKey = new Uint8Array(publicKeyBytes);
-    return import_web36.Ed25519Program.createInstructionWithPublicKey({
+    return import_web37.Ed25519Program.createInstructionWithPublicKey({
       publicKey,
       message,
       signature
@@ -4917,10 +6860,10 @@ async function fetchRiskQuoteInstruction(riskQuoteUrl, wallet, options) {
       `Invalid risk quote response: expected relay format { signature, message, signer_pubkey } or { instruction }. Received keys: ${keys}`
     );
   }
-  return new import_web36.TransactionInstruction({
-    programId: new import_web36.PublicKey(raw.programId),
+  return new import_web37.TransactionInstruction({
+    programId: new import_web37.PublicKey(raw.programId),
     keys: raw.keys.map((k) => ({
-      pubkey: new import_web36.PublicKey(k.pubkey),
+      pubkey: new import_web37.PublicKey(k.pubkey),
       isSigner: k.isSigner,
       isWritable: k.isWritable
     })),
@@ -5290,7 +7233,7 @@ async function transact(params, options) {
   const outputCommitments = [];
   for (let i = 0; i < paddedOutputs.length; i++) {
     const utxo = paddedOutputs[i];
-    const commitment = await computeCommitment(utxo);
+    const commitment = await computeCommitment2(utxo);
     outputCommitments.push(commitment);
   }
   onProgress?.("Computing external data hash...");
@@ -5371,7 +7314,7 @@ async function transact(params, options) {
     }
     inputNullifiers = [];
     for (const utxo of paddedInputs) {
-      inputNullifiers.push(await computeNullifier(utxo));
+      inputNullifiers.push(await computeNullifier2(utxo));
     }
     if (nextIndex !== null) {
       onProgress?.(`[Submit ${submissionAttempts + 1}/${maxRootRetries + 1}] Root: ${rootHex.substring(0, 16)}..., nextIndex: ${nextIndex}`);
@@ -5804,12 +7747,12 @@ async function transact(params, options) {
   if (lastError) {
     const classified = classifyRelayError(lastError.message);
     const isMerkleClass = !(classified instanceof UtxoAlreadySpentError) && !(classified instanceof SanctionsQuoteError) && !isRootNotFoundError2(lastError);
-    if (!IS_BROWSER && isMerkleClass && relayUrl) {
+    if (!IS_BROWSER2 && isMerkleClass && relayUrl) {
       onProgress?.(
         "All relay-tree attempts failed. Rebuilding merkle tree from chain as last resort..."
       );
       try {
-        const [merkleTreePda] = import_web36.PublicKey.findProgramAddressSync(
+        const [merkleTreePda] = import_web37.PublicKey.findProgramAddressSync(
           [Buffer.from("merkle_tree"), mint.toBuffer()],
           programId
         );
@@ -6453,7 +8396,7 @@ async function swapUtxo(params, options) {
   let inputNullifiers = [];
   const outputCommitments = [];
   for (const utxo of paddedOutputs) {
-    outputCommitments.push(await computeCommitment(utxo));
+    outputCommitments.push(await computeCommitment2(utxo));
   }
   const chainNoteTimestamp = BigInt(Date.now());
   onProgress?.("Computing external data hash...");
@@ -6533,7 +8476,7 @@ async function swapUtxo(params, options) {
     }
     inputNullifiers = [];
     for (const utxo of paddedInputs) {
-      inputNullifiers.push(await computeNullifier(utxo));
+      inputNullifiers.push(await computeNullifier2(utxo));
     }
     if (merkleState) {
       onProgress?.(`[Attempt ${attempt + 1}/${maxRootRetries + 1}] Root: ${rootHex.substring(0, 16)}..., nextIndex: ${merkleState.nextIndex}`);
@@ -6877,7 +8820,7 @@ async function swapWithChange(inputUtxos, swapAmount, outputMint, recipientAta,
 
 // src/core/scanner.ts
 var import_bs582 = __toESM(require("bs58"), 1);
-var import_web37 = require("@solana/web3.js");
+var import_web38 = require("@solana/web3.js");
 var import_spl_token2 = require("@solana/spl-token");
 var bs582 = import_bs582.default.default || import_bs582.default;
 var TRANSACT_TAG2 = 0;
@@ -6964,7 +8907,7 @@ function parseSwapOutputMint(data) {
   const mintBytes = data.slice(SWAP_OUTPUT_MINT_OFFSET, end);
   if (mintBytes.every((byte) => byte === 0)) return void 0;
   try {
-    return new import_web37.PublicKey(mintBytes).toBase58();
+    return new import_web38.PublicKey(mintBytes).toBase58();
   } catch {
     return void 0;
   }
@@ -7054,7 +8997,7 @@ function parseSwapRecipientAta(data) {
   const recipientAtaBytes = data.slice(recipientAtaStart, recipientAtaEnd);
   if (recipientAtaBytes.every((byte) => byte === 0)) return void 0;
   try {
-    return new import_web37.PublicKey(recipientAtaBytes).toBase58();
+    return new import_web38.PublicKey(recipientAtaBytes).toBase58();
   } catch {
     return void 0;
   }
@@ -7369,8 +9312,8 @@ async function scanTransactions(opts) {
                   if (onChainAta) {
                     try {
                       const expectedAta = (0, import_spl_token2.getAssociatedTokenAddressSync)(
-                        new import_web37.PublicKey(asset.mint),
-                        new import_web37.PublicKey(walletPublicKey)
+                        new import_web38.PublicKey(asset.mint),
+                        new import_web38.PublicKey(walletPublicKey)
                       ).toBase58();
                       if (onChainAta === expectedAta) {
                         isOurs = true;
@@ -7673,7 +9616,7 @@ function formatComplianceCsv(report) {
 }
 
 // src/core/wallet.ts
-var import_web38 = require("@solana/web3.js");
+var import_web39 = require("@solana/web3.js");
 init_utxo();
 var UtxoWallet = class _UtxoWallet {
   constructor(viewingKey) {
@@ -7886,7 +9829,7 @@ var UtxoWallet = class _UtxoWallet {
       data.viewingKey ? new Uint8Array(data.viewingKey) : void 0
     );
     for (const w of data.wallets) {
-      const mint = new import_web38.PublicKey(w.mint);
+      const mint = new import_web39.PublicKey(w.mint);
       for (const u of w.utxos) {
         wallet.addUtxo({
           amount: BigInt(u.amount),
@@ -7969,14 +9912,16 @@ var SimpleWallet = class {
 };
 
 // src/index.ts
-var VERSION = "0.1.6";
+var VERSION = "0.1.5";
 var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CLOAK_PROGRAM_ID,
   CloakError,
   CloakSDK,
+  DEFAULT_CIRCUITS_URL,
   DEFAULT_TRANSACTION_CIRCUITS_URL,
+  EXPECTED_CIRCUIT_HASHES,
   FIXED_FEE_LAMPORTS,
   LAMPORTS_PER_SOL,
   LocalStorageAdapter,
@@ -7999,6 +9944,7 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   VARIABLE_FEE_NUMERATOR,
   VARIABLE_FEE_RATE,
   VERSION,
+  areCircuitsAvailable,
   bigintToBytes32,
   bigintToHex,
   buildMerkleTree,
@@ -8012,15 +9958,30 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   chainNoteFromBase64,
   chainNoteToBase64,
   classifyRelayError,
+  cleanupStalePendingOperations,
+  clearPendingDeposits,
+  clearPendingWithdrawals,
   computeChainNoteHash,
+  computeCommitment,
   computeExtDataHash,
   computeMerkleRoot,
+  computeNullifier,
+  computeNullifierAsync,
+  computeNullifierSync,
+  computeOutputsHash,
+  computeOutputsHashAsync,
+  computeOutputsHashSync,
   computeProofForLatestDeposit,
   computeProofFromChain,
   computeSignature,
+  computeSwapOutputsHash,
+  computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync,
   computeUtxoCommitment,
   computeUtxoNullifier,
+  copyNoteToClipboard,
   createCloakError,
+  createDepositInstruction,
   createLogger,
   createUtxo,
   createZeroUtxo,
@@ -8040,52 +10001,78 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   deriveViewingKeyFromUtxoPrivateKey,
   deserializeUtxo,
   detectNetworkFromRpcUrl,
+  downloadNote,
+  encodeNoteSimple,
   encryptCompactChainNote,
   encryptNoteForRecipient,
   encryptTransactionMetadata,
   encryptTransactionMetadataBundle,
   expandSpendKey,
   exportKeys,
+  exportNote,
+  exportWalletKeys,
   fetchCommitments,
   fetchRiskQuoteInstruction,
   fetchRiskQuoteIx,
+  filterNotesByNetwork,
+  filterWithdrawableNotes,
+  findNoteByCommitment,
   formatAmount,
   formatComplianceCsv,
   formatErrorForLogging,
   formatSol,
   fullWithdraw,
   generateCloakKeys,
+  generateCommitment,
+  generateCommitmentAsync,
   generateMasterSeed,
+  generateNote,
+  generateNoteFromWallet,
   generateUtxoKeypair,
   generateViewingKeyPair,
+  generateWithdrawRegularProof,
+  generateWithdrawSwapProof,
   getAddressExplorerUrl,
   getCircuitsPath,
+  getDefaultCircuitsPath,
   getDistributableAmount,
   getExplorerUrl,
   getNkFromUtxoPrivateKey,
   getNullifierPDA,
+  getPendingOperationsSummary,
   getPublicKey,
+  getPublicViewKey,
+  getRecipientAmount,
   getRpcUrlForNetwork,
   getShieldPoolPDAs,
   getSwapStatePDA,
+  getViewKey,
+  hasPendingOperations,
   hexToBigint,
   hexToBytes,
   importKeys,
+  importWalletKeys,
   isDebugEnabled,
   isRootNotFoundError,
   isValidHex,
   isValidRpcUrl,
   isValidSolanaAddress,
   isWithdrawAmountSufficient,
+  isWithdrawable,
   keypairToAdapter,
+  loadPendingDeposits,
+  loadPendingWithdrawals,
   parseAmount,
   parseError,
+  parseNote,
   parseRelayErrorResponse,
   parseTransactionError,
   partialWithdraw,
   poseidonHash,
   preflightCheck,
   preflightNullifiers,
+  prepareEncryptedOutput,
+  prepareEncryptedOutputForRecipient,
   proofToBytes,
   pubkeyToFieldElement,
   pubkeyToLimbs,
@@ -8093,11 +10080,16 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   randomFieldElement,
   readMerkleTreeState,
   registerViewingKey,
+  removePendingDeposit,
+  removePendingWithdrawal,
+  savePendingDeposit,
+  savePendingWithdrawal,
   scanNotesForWallet,
   scanTransactions,
   sdkLogger,
   selectUtxos,
   sendTransaction,
+  serializeNote,
   serializeUtxo,
   setCircuitsPath,
   setDebugMode,
@@ -8111,12 +10103,21 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   transfer,
   truncate,
   tryDecryptNote,
+  updateNoteWithDeposit,
+  updatePendingDeposit,
+  updatePendingWithdrawal,
   utxoBigintToBytes32,
   utxoEquals,
   utxoHexToBigint,
+  validateDepositParams,
+  validateNote,
   validateOutputsSum,
   validateRoot,
+  validateTransfers,
   validateWalletConnected,
+  validateWithdrawableNote,
+  verifyAllCircuits,
+  verifyCircuitIntegrity,
   verifyUtxos,
   waitForRoot,
   withTiming