@cloak.ag/sdk 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -30,7 +30,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ArtifactProverService: () => ArtifactProverService,
   CLOAK_PROGRAM_ID: () => CLOAK_PROGRAM_ID,
   CloakError: () => CloakError,
   CloakSDK: () => CloakSDK,
@@ -40,7 +39,6 @@ __export(index_exports, {
   LAMPORTS_PER_SOL: () => LAMPORTS_PER_SOL,
   LocalStorageAdapter: () => LocalStorageAdapter,
   MemoryStorageAdapter: () => MemoryStorageAdapter,
-  ProverService: () => ProverService,
   RelayService: () => RelayService,
   VARIABLE_FEE_RATE: () => VARIABLE_FEE_RATE,
   VERSION: () => VERSION,
@@ -129,7 +127,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/core/CloakSDK.ts
-var import_web36 = require("@solana/web3.js");
+var import_web35 = require("@solana/web3.js");
 
 // src/core/types.ts
 var CloakError = class extends Error {
@@ -147,7 +145,6 @@ var import_blake3 = require("@noble/hashes/blake3.js");
 var import_tweetnacl = __toESM(require("tweetnacl"), 1);
 
 // src/utils/crypto.ts
-var import_web3 = require("@solana/web3.js");
 var import_circomlibjs = require("circomlibjs");
 var poseidon = null;
 async function getPoseidon() {
@@ -168,7 +165,7 @@ function splitTo2Limbs(value) {
   return [lo, hi];
 }
 function pubkeyToLimbs(pubkey) {
-  const bytes = pubkey instanceof import_web3.PublicKey ? pubkey.toBytes() : pubkey;
+  const bytes = typeof pubkey.toBytes === "function" ? pubkey.toBytes() : pubkey;
   const value = BigInt("0x" + Buffer.from(bytes).toString("hex"));
   return splitTo2Limbs(value);
 }
@@ -796,10 +793,10 @@ var LocalStorageAdapter = class {
 };
 
 // src/utils/validation.ts
-var import_web32 = require("@solana/web3.js");
+var import_web3 = require("@solana/web3.js");
 function isValidSolanaAddress(address) {
   try {
-    new import_web32.PublicKey(address);
+    new import_web3.PublicKey(address);
     return true;
   } catch {
     return false;
@@ -898,8 +895,9 @@ function validateTransfers(recipients, totalAmount) {
   }
   for (let i = 0; i < recipients.length; i++) {
     const transfer = recipients[i];
-    if (!transfer.recipient || !(transfer.recipient instanceof import_web32.PublicKey)) {
-      throw new Error(`Recipient ${i} must be a PublicKey`);
+    const isPublicKeyLike = transfer.recipient && typeof transfer.recipient.toBase58 === "function" && typeof transfer.recipient.toBuffer === "function";
+    if (!isPublicKeyLike) {
+      throw new Error(`Recipient ${i} must be a PublicKey (got ${typeof transfer.recipient})`);
     }
     if (typeof transfer.amount !== "number" || transfer.amount <= 0) {
       throw new Error(`Recipient ${i} amount must be a positive number`);
@@ -1144,254 +1142,6 @@ var IndexerService = class {
   }
 };
 
-// src/services/ArtifactProverService.ts
-var ArtifactProverService = class {
-  /**
-   * Create a new Artifact Prover Service client
-   *
-   * @param indexerUrl - Indexer service base URL
-   * @param timeout - Proof generation timeout in ms (default: 5 minutes)
-   * @param pollInterval - Polling interval for status checks (default: 2 seconds)
-   */
-  constructor(indexerUrl, timeout = 5 * 60 * 1e3, pollInterval = 2e3) {
-    this.indexerUrl = indexerUrl.replace(/\/$/, "");
-    this.timeout = timeout;
-    this.pollInterval = pollInterval;
-  }
-  /**
-   * Generate a zero-knowledge proof using artifact-based flow
-   *
-   * This process typically takes 30-180 seconds depending on the TEE.
-   * Private inputs are uploaded directly to TEE, never passing through backend.
-   *
-   * @param inputs - Circuit inputs (private + public + outputs)
-   * @param options - Optional progress tracking and callbacks
-   * @returns Proof result with hex-encoded proof and public inputs
-   *
-   * @example
-   * ```typescript
-   * const result = await prover.generateProof(inputs);
-   * if (result.success) {
-   *   console.log(`Proof: ${result.proof}`);
-   * }
-   * ```
-   */
-  async generateProof(inputs, options) {
-    const startTime = Date.now();
-    const actualTimeout = options?.timeout || this.timeout;
-    const pollInterval = options?.pollInterval || this.pollInterval;
-    options?.onStart?.();
-    options?.onProgress?.(5);
-    try {
-      options?.onProgress?.(10);
-      const artifactResponse = await fetch(`${this.indexerUrl}/api/v1/tee/artifact`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          program_id: null
-          // Optional, can be null
-        })
-      });
-      if (!artifactResponse.ok) {
-        const errorText = await artifactResponse.text();
-        const errorMessage2 = `Failed to create artifact: ${errorText}`;
-        options?.onError?.(errorMessage2);
-        return {
-          success: false,
-          generationTimeMs: Date.now() - startTime,
-          error: errorMessage2
-        };
-      }
-      const artifactData = await artifactResponse.json();
-      const { artifact_id, upload_url } = artifactData;
-      if (!artifact_id || !upload_url) {
-        const errorMessage2 = "Invalid artifact response: missing artifact_id or upload_url";
-        options?.onError?.(errorMessage2);
-        return {
-          success: false,
-          generationTimeMs: Date.now() - startTime,
-          error: errorMessage2
-        };
-      }
-      const fullUploadUrl = upload_url.startsWith("http") ? upload_url : `${this.indexerUrl}${upload_url}`;
-      options?.onProgress?.(20);
-      const stdinPayload = JSON.stringify({
-        private: inputs.privateInputs,
-        public: inputs.publicInputs,
-        outputs: inputs.outputs,
-        // Include swap_params if present (for swap transactions)
-        ...inputs.swapParams && { swap_params: inputs.swapParams }
-      });
-      const uploadResponse = await fetch(fullUploadUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: stdinPayload
-      });
-      if (!uploadResponse.ok) {
-        const errorText = await uploadResponse.text();
-        const errorMessage2 = `Failed to upload stdin to TEE: ${errorText}`;
-        options?.onError?.(errorMessage2);
-        return {
-          success: false,
-          generationTimeMs: Date.now() - startTime,
-          error: errorMessage2
-        };
-      }
-      options?.onProgress?.(30);
-      const requestProofBody = {
-        artifact_id,
-        program_id: null,
-        public_inputs: JSON.stringify(inputs.publicInputs)
-      };
-      const requestProofResponse = await fetch(
-        `${this.indexerUrl}/api/v1/tee/request-proof`,
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(requestProofBody)
-        }
-      );
-      if (!requestProofResponse.ok) {
-        const errorText = await requestProofResponse.text();
-        const errorMessage2 = `Failed to request proof: ${errorText}`;
-        options?.onError?.(errorMessage2);
-        return {
-          success: false,
-          generationTimeMs: Date.now() - startTime,
-          error: errorMessage2
-        };
-      }
-      const requestProofData = await requestProofResponse.json();
-      const { request_id } = requestProofData;
-      if (!request_id) {
-        const errorMessage2 = "Invalid proof request response: missing request_id";
-        options?.onError?.(errorMessage2);
-        return {
-          success: false,
-          generationTimeMs: Date.now() - startTime,
-          error: errorMessage2
-        };
-      }
-      options?.onProgress?.(40);
-      const pollStartTime = Date.now();
-      let lastProgress = 40;
-      while (Date.now() - pollStartTime < actualTimeout) {
-        const statusResponse = await fetch(
-          `${this.indexerUrl}/api/v1/tee/proof-status?request_id=${request_id}`,
-          {
-            method: "GET"
-          }
-        );
-        if (!statusResponse.ok) {
-          const errorText = await statusResponse.text();
-          const errorMessage2 = `Failed to check proof status: ${errorText}`;
-          options?.onError?.(errorMessage2);
-          return {
-            success: false,
-            generationTimeMs: Date.now() - startTime,
-            error: errorMessage2
-          };
-        }
-        const statusData = await statusResponse.json();
-        const { status, proof, public_inputs, generation_time_ms, error } = statusData;
-        if (status === "ready") {
-          options?.onProgress?.(100);
-          if (!proof || !public_inputs) {
-            const errorMessage2 = "Proof status is 'ready' but proof or public_inputs is missing";
-            options?.onError?.(errorMessage2);
-            return {
-              success: false,
-              generationTimeMs: Date.now() - startTime,
-              error: errorMessage2
-            };
-          }
-          const result = {
-            success: true,
-            proof,
-            publicInputs: public_inputs,
-            generationTimeMs: generation_time_ms || Date.now() - startTime
-          };
-          options?.onSuccess?.(result);
-          return result;
-        }
-        if (status === "failed") {
-          const errorMessage2 = error || "Proof generation failed";
-          options?.onError?.(errorMessage2);
-          return {
-            success: false,
-            generationTimeMs: Date.now() - startTime,
-            error: errorMessage2
-          };
-        }
-        const elapsed = Date.now() - pollStartTime;
-        const progress = Math.min(90, 40 + Math.floor(elapsed / actualTimeout * 50));
-        if (progress > lastProgress) {
-          lastProgress = progress;
-          options?.onProgress?.(progress);
-        }
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
-      }
-      const errorMessage = `Proof generation timed out after ${actualTimeout}ms`;
-      options?.onError?.(errorMessage);
-      return {
-        success: false,
-        generationTimeMs: Date.now() - startTime,
-        error: errorMessage
-      };
-    } catch (error) {
-      const totalTime = Date.now() - startTime;
-      let errorMessage;
-      if (error instanceof Error && error.name === "AbortError") {
-        errorMessage = `Proof generation timed out after ${actualTimeout}ms`;
-      } else {
-        errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-      }
-      options?.onError?.(errorMessage);
-      return {
-        success: false,
-        generationTimeMs: totalTime,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Check if the artifact prover service is available
-   *
-   * @returns True if service is healthy
-   */
-  async healthCheck() {
-    try {
-      const response = await fetch(`${this.indexerUrl}/health`, {
-        method: "GET"
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get the configured timeout
-   */
-  getTimeout() {
-    return this.timeout;
-  }
-  /**
-   * Set a new timeout
-   */
-  setTimeout(timeout) {
-    if (timeout <= 0) {
-      throw new Error("Timeout must be positive");
-    }
-    this.timeout = timeout;
-  }
-};
-
 // src/services/RelayService.ts
 var RelayService = class {
   /**
@@ -1634,7 +1384,7 @@ var RelayService = class {
 };
 
 // src/services/DepositRecoveryService.ts
-var import_web33 = require("@solana/web3.js");
+var import_web32 = require("@solana/web3.js");
 
 // src/helpers/encrypted-output.ts
 function prepareEncryptedOutput(note, cloakKeys) {
@@ -1725,7 +1475,7 @@ var DepositRecoveryService = class {
       } catch (e) {
       }
       onProgress?.("Fetching transaction details...");
-      const connection = new import_web33.Connection(
+      const connection = new import_web32.Connection(
         process.env.NEXT_PUBLIC_SOLANA_RPC_URL || "https://api.devnet.solana.com"
       );
       const txDetails = await connection.getTransaction(signature, {
@@ -1887,7 +1637,7 @@ var DepositRecoveryService = class {
 };
 
 // src/solana/instructions.ts
-var import_web34 = require("@solana/web3.js");
+var import_web33 = require("@solana/web3.js");
 function createDepositInstruction(params) {
   if (params.commitment.length !== 32) {
     throw new Error(
@@ -1909,7 +1659,7 @@ function createDepositInstruction(params) {
   data.set(discriminant, 0);
   data.set(amountBytes, 1);
   data.set(params.commitment, 9);
-  return new import_web34.TransactionInstruction({
+  return new import_web33.TransactionInstruction({
     programId: params.programId,
     keys: [
       // Account 0: Payer (signer, writable) - pays for transaction
@@ -1917,7 +1667,7 @@ function createDepositInstruction(params) {
       // Account 1: Pool (writable) - receives SOL
       { pubkey: params.pool, isSigner: false, isWritable: true },
       // Account 2: System Program (readonly) - for transfers
-      { pubkey: import_web34.SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: import_web33.SystemProgram.programId, isSigner: false, isWritable: false },
       // Account 3: Merkle Tree (writable) - stores on-chain Merkle tree
       { pubkey: params.merkleTree, isSigner: false, isWritable: true }
     ],
@@ -1925,16 +1675,16 @@ function createDepositInstruction(params) {
   });
 }
 function validateDepositParams(params) {
-  if (!(params.programId instanceof import_web34.PublicKey)) {
+  if (!(params.programId instanceof import_web33.PublicKey)) {
     throw new Error("programId must be a PublicKey");
   }
-  if (!(params.payer instanceof import_web34.PublicKey)) {
+  if (!(params.payer instanceof import_web33.PublicKey)) {
     throw new Error("payer must be a PublicKey");
   }
-  if (!(params.pool instanceof import_web34.PublicKey)) {
+  if (!(params.pool instanceof import_web33.PublicKey)) {
     throw new Error("pool must be a PublicKey");
   }
-  if (!(params.merkleTree instanceof import_web34.PublicKey)) {
+  if (!(params.merkleTree instanceof import_web33.PublicKey)) {
     throw new Error("merkleTree must be a PublicKey");
   }
   if (typeof params.amount !== "number" || params.amount <= 0) {
@@ -1951,34 +1701,34 @@ function validateDepositParams(params) {
 }
 
 // src/utils/pda.ts
-var import_web35 = require("@solana/web3.js");
+var import_web34 = require("@solana/web3.js");
 function getShieldPoolPDAs(programId, mint) {
   const pid = programId || CLOAK_PROGRAM_ID;
-  const mintKey = mint ?? new import_web35.PublicKey(
+  const mintKey = mint ?? new import_web34.PublicKey(
     // 32 zero bytes, matching Rust `Pubkey::default()`
     new Uint8Array(32)
   );
-  const [pool] = import_web35.PublicKey.findProgramAddressSync(
+  const [pool] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("pool"), mintKey.toBytes()],
     pid
   );
-  const [merkleTree] = import_web35.PublicKey.findProgramAddressSync(
+  const [merkleTree] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("merkle_tree"), mintKey.toBytes()],
     pid
   );
-  const [commitments] = import_web35.PublicKey.findProgramAddressSync(
+  const [commitments] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("commitments"), mintKey.toBytes()],
     pid
   );
-  const [rootsRing] = import_web35.PublicKey.findProgramAddressSync(
+  const [rootsRing] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("roots_ring"), mintKey.toBytes()],
     pid
   );
-  const [nullifierShard] = import_web35.PublicKey.findProgramAddressSync(
+  const [nullifierShard] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("nullifier_shard"), mintKey.toBytes()],
     pid
   );
-  const [treasury] = import_web35.PublicKey.findProgramAddressSync(
+  const [treasury] = import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("treasury"), mintKey.toBytes()],
     pid
   );
@@ -2025,6 +1775,15 @@ async function fileExists(filePath) {
       return false;
     }
   }
+  const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+  if (isBrowser) {
+    try {
+      const response = await fetch(filePath, { method: "HEAD" });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
   return false;
 }
 async function generateWithdrawRegularProof(inputs, circuitsPath) {
@@ -2068,11 +1827,7 @@ async function generateWithdrawRegularProof(inputs, circuitsPath) {
     var_fee: inputs.var_fee.toString(),
     rem: inputs.rem.toString()
   };
-  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
-    circuitInputs,
-    wasmPath,
-    zkeyPath
-  );
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(circuitInputs, wasmPath, zkeyPath);
   const proofBytes = proofToBytes(proof);
   return {
     proof,
@@ -2141,6 +1896,10 @@ async function generateWithdrawSwapProof(inputs, circuitsPath) {
   };
 }
 async function areCircuitsAvailable(circuitsPath) {
+  const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+  if (isBrowser) {
+    return Boolean(circuitsPath && circuitsPath !== "");
+  }
   const wasmPath = joinPath(circuitsPath, "build", "withdraw_regular_js", "withdraw_regular.wasm");
   const zkeyPath = joinPath(circuitsPath, "build", "withdraw_regular_final.zkey");
   const wasmExists = await fileExists(wasmPath);
@@ -2172,11 +1931,11 @@ async function getDefaultCircuitsPath() {
 }
 
 // src/core/CloakSDK.ts
-var CLOAK_PROGRAM_ID = new import_web36.PublicKey("c1oak6tetxYnNfvXKFkpn1d98FxtK7B68vBQLYQpWKp");
+var CLOAK_PROGRAM_ID = new import_web35.PublicKey("c1oak6tetxYnNfvXKFkpn1d98FxtK7B68vBQLYQpWKp");
 var CLOAK_API_URL = "https://api.cloak.ag";
 var CloakSDK = class {
   /**
-   * Create a new Cloak SDK client
+  * Create a new Cloak SDK client
    *
    * @param config - Client configuration
    * 
@@ -2201,7 +1960,7 @@ var CloakSDK = class {
       throw new Error("Must provide either keypairBytes (Node.js) or wallet (Browser)");
     }
     if (config.keypairBytes) {
-      this.keypair = import_web36.Keypair.fromSecretKey(config.keypairBytes);
+      this.keypair = import_web35.Keypair.fromSecretKey(config.keypairBytes);
     }
     this.wallet = config.wallet;
     this.cloakKeys = config.cloakKeys;
@@ -2209,7 +1968,6 @@ var CloakSDK = class {
     const indexerUrl = config.indexerUrl || typeof process !== "undefined" && process.env?.CLOAK_INDEXER_URL || CLOAK_API_URL;
     const relayUrl = config.relayUrl || typeof process !== "undefined" && process.env?.CLOAK_RELAY_URL || CLOAK_API_URL;
     this.indexer = new IndexerService(indexerUrl);
-    this.artifactProver = new ArtifactProverService(indexerUrl, 5 * 60 * 1e3, 2e3);
     this.relay = new RelayService(relayUrl);
     this.depositRecovery = new DepositRecoveryService(this.indexer, indexerUrl);
     if (!this.cloakKeys) {
@@ -2312,29 +2070,50 @@ var CloakSDK = class {
         commitment: commitmentBytes
       });
       const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
-      const transaction = new import_web36.Transaction({
+      const transaction = new import_web35.Transaction({
         feePayer: payerPubkey,
-        blockhash,
-        lastValidBlockHeight
+        recentBlockhash: blockhash
       }).add(depositIx);
-      if (!options?.skipPreflight) {
-        const simulation = await connection.simulateTransaction(transaction);
-        if (simulation.value.err) {
-          const logs = simulation.value.logs?.join("\n") || "No logs";
-          throw new Error(
-            `Transaction simulation failed: ${JSON.stringify(simulation.value.err)}
-Logs:
-${logs}`
-          );
-        }
+      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?.sendTransaction) {
-        signature = await this.wallet.sendTransaction(transaction, connection, {
-          skipPreflight: options?.skipPreflight || false,
-          preflightCommitment: "confirmed",
-          maxRetries: 3
-        });
+      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,
@@ -2419,7 +2198,7 @@ ${logs}`
       }
       if (leafIndex === null) {
         const programId2 = this.config.programId || CLOAK_PROGRAM_ID;
-        const mintForSOL = new import_web36.PublicKey(new Uint8Array(32));
+        const mintForSOL = new import_web35.PublicKey(new Uint8Array(32));
         const { merkleTree } = getShieldPoolPDAs(programId2, mintForSOL);
         const merkleTreeAccount = await connection.getAccountInfo(merkleTree);
         if (!merkleTreeAccount) {
@@ -2524,17 +2303,10 @@ ${logs}`
     const feeBps = Math.ceil(protocolFee * 1e4 / note.amount);
     const distributableAmount = getDistributableAmount2(note.amount);
     validateTransfers(recipients, distributableAmount);
-    let merkleProof;
-    let merkleRoot;
-    if (note.merkleProof && note.root) {
-      merkleProof = {
-        pathElements: note.merkleProof.pathElements,
-        pathIndices: note.merkleProof.pathIndices
-      };
-      merkleRoot = note.root;
-    } else {
-      merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
-      merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+    const merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
+    const merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+    if (!merkleRoot) {
+      throw new Error("Failed to get Merkle root from indexer");
     }
     const nullifier = await computeNullifierAsync(note.sk_spend, note.leafIndex);
     const nullifierHex = nullifier.toString(16).padStart(64, "0");
@@ -2570,7 +2342,8 @@ ${logs}`
         throw new Error(`Merkle proof path element at position ${i} must be 64 hex characters (32 bytes)`);
       }
     }
-    const circuitsPath = typeof process !== "undefined" && process.env?.CIRCUITS_PATH || await getDefaultCircuitsPath();
+    const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+    const circuitsPath = isBrowser ? "/circuits" : typeof process !== "undefined" && process.env?.CIRCUITS_PATH || await getDefaultCircuitsPath();
     const useDirectProof = await areCircuitsAvailable(circuitsPath);
     let proofHex;
     let finalPublicInputs;
@@ -2607,6 +2380,13 @@ ${logs}`
       }
       const sk = splitTo2Limbs(sk_spend_bigint);
       const r = splitTo2Limbs(r_bigint);
+      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,
@@ -2625,7 +2405,9 @@ ${logs}`
         var_fee: varFee,
         rem
       };
+      options?.onProgress?.("proof_generating");
       const proofResult = await generateWithdrawRegularProof(proofInputs, circuitsPath);
+      options?.onProgress?.("proof_complete");
       proofHex = Buffer.from(proofResult.proofBytes).toString("hex");
       finalPublicInputs = {
         root: merkleRoot,
@@ -2634,43 +2416,9 @@ ${logs}`
         amount: note.amount
       };
     } else {
-      const proofInputs = {
-        privateInputs: {
-          amount: note.amount,
-          r: note.r,
-          sk_spend: note.sk_spend,
-          leaf_index: note.leafIndex,
-          merkle_path: {
-            path_elements: merkleProof.pathElements,
-            path_indices: merkleProof.pathIndices
-          }
-        },
-        publicInputs: {
-          root: merkleRoot,
-          nf: nullifierHex,
-          outputs_hash: outputsHashHex,
-          amount: note.amount
-        },
-        outputs: recipients.map((r) => ({
-          address: r.recipient.toBase58(),
-          amount: r.amount
-        }))
-      };
-      const proofResult = await this.artifactProver.generateProof(proofInputs, {
-        onProgress: options?.onProofProgress,
-        onError: options?.onProgress ? (error) => options.onProgress?.(`Proof generation error: ${error}`) : void 0
-      });
-      if (!proofResult.success || !proofResult.proof) {
-        let errorMessage = proofResult.error || "Proof generation failed";
-        if (errorMessage.startsWith("Proof generation failed: ")) {
-          errorMessage = errorMessage.substring("Proof generation failed: ".length);
-        }
-        errorMessage += `
-Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., nullifier=${nullifierHex.slice(0, 16)}...`;
-        throw new Error(errorMessage);
-      }
-      proofHex = proofResult.proof;
-      finalPublicInputs = proofInputs.publicInputs;
+      throw new Error(
+        `Circuits not available at ${circuitsPath}. Make sure circuits are built and accessible. In browser, circuits should be served from /circuits. In Node.js, set CIRCUITS_PATH environment variable or ensure circuits are in the expected location.`
+      );
     }
     const signature = await this.relay.submitWithdraw(
       {
@@ -2825,35 +2573,32 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
         );
       }
       let recipientAta;
-      try {
-        const splTokenModule = await import("@solana/spl-token");
-        const getAssociatedTokenAddress = splTokenModule.getAssociatedTokenAddress;
-        if (!getAssociatedTokenAddress) {
-          throw new Error("getAssociatedTokenAddress not found");
+      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.`
+          );
         }
-        const outputMint2 = new import_web36.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.`
-        );
       }
-      let merkleProof;
-      let merkleRoot;
-      if (note.merkleProof && note.root) {
-        merkleProof = {
-          pathElements: note.merkleProof.pathElements,
-          pathIndices: note.merkleProof.pathIndices
-        };
-        merkleRoot = note.root;
-      } else {
-        merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
-        merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+      const merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
+      const merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+      if (!merkleRoot) {
+        throw new Error("Failed to get Merkle root from indexer");
       }
       const nullifier = await computeNullifierAsync(note.sk_spend, note.leafIndex);
       const nullifierHex = nullifier.toString(16).padStart(64, "0");
-      const inputMint = new import_web36.PublicKey("11111111111111111111111111111111");
-      const outputMint = new import_web36.PublicKey(options.outputMint);
+      const inputMint = new import_web35.PublicKey("11111111111111111111111111111111");
+      const outputMint = new import_web35.PublicKey(options.outputMint);
       const outputsHash = await computeSwapOutputsHashAsync(
         inputMint,
         outputMint,
@@ -2868,7 +2613,8 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
       if (!merkleProof.pathElements || merkleProof.pathElements.length === 0) {
         throw new Error("Merkle proof is invalid: missing path elements");
       }
-      const circuitsPath = typeof process !== "undefined" && process.env?.CIRCUITS_PATH || await getDefaultCircuitsPath();
+      const envCircuitsPath = typeof window !== "undefined" ? typeof process !== "undefined" && process.env?.NEXT_PUBLIC_CIRCUITS_PATH || void 0 : typeof process !== "undefined" && process.env?.CIRCUITS_PATH || void 0;
+      const circuitsPath = envCircuitsPath || await getDefaultCircuitsPath();
       const useDirectProof = await areCircuitsAvailable(circuitsPath);
       let proofHex;
       let finalPublicInputs;
@@ -2883,6 +2629,13 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
         const inputMintLimbs = pubkeyToLimbs(inputMint.toBytes());
         const outputMintLimbs = pubkeyToLimbs(outputMint.toBytes());
         const recipientAtaLimbs = pubkeyToLimbs(recipientAta.toBytes());
+        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 * 5n;
         const varFee = t / 1000n;
         const rem = t % 1000n;
@@ -2904,7 +2657,9 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
           var_fee: varFee,
           rem
         };
+        options?.onProgress?.("proof_generating");
         const proofResult = await generateWithdrawSwapProof(proofInputs, circuitsPath);
+        options?.onProgress?.("proof_complete");
         proofHex = Buffer.from(proofResult.proofBytes).toString("hex");
         finalPublicInputs = {
           root: merkleRoot,
@@ -2913,46 +2668,9 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
           amount: note.amount
         };
       } else {
-        const proofInputs = {
-          privateInputs: {
-            amount: note.amount,
-            r: note.r,
-            sk_spend: note.sk_spend,
-            leaf_index: note.leafIndex,
-            merkle_path: {
-              path_elements: merkleProof.pathElements,
-              path_indices: merkleProof.pathIndices
-            }
-          },
-          publicInputs: {
-            root: merkleRoot,
-            nf: nullifierHex,
-            outputs_hash: outputsHashHex,
-            amount: note.amount
-          },
-          outputs: [],
-          // Empty for swaps
-          swapParams: {
-            output_mint: options.outputMint,
-            recipient_ata: recipientAta.toBase58(),
-            min_output_amount: minOutputAmount
-          }
-        };
-        const proofResult = await this.artifactProver.generateProof(proofInputs, {
-          onProgress: options.onProofProgress,
-          onError: options.onProgress ? (error) => options.onProgress?.(`Proof generation error: ${error}`) : void 0
-        });
-        if (!proofResult.success || !proofResult.proof) {
-          let errorMessage = proofResult.error || "Proof generation failed";
-          if (errorMessage.startsWith("Proof generation failed: ")) {
-            errorMessage = errorMessage.substring("Proof generation failed: ".length);
-          }
-          errorMessage += `
-Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., nullifier=${nullifierHex.slice(0, 16)}...`;
-          throw new Error(errorMessage);
-        }
-        proofHex = proofResult.proof;
-        finalPublicInputs = proofInputs.publicInputs;
+        throw new Error(
+          `Circuits not available at ${circuitsPath}. Make sure circuits are built and accessible. In browser, circuits should be served from /circuits. In Node.js, set CIRCUITS_PATH environment variable or ensure circuits are in the expected location.`
+        );
       }
       const signature = await this.relay.submitSwap(
         {
@@ -3461,192 +3179,10 @@ function formatErrorForLogging(error) {
   return String(error);
 }
 
-// src/services/ProverService.ts
-var ProverService = class {
-  /**
-   * Create a new Prover Service client
-   *
-   * @param indexerUrl - Indexer/Prover service base URL
-   * @param timeout - Proof generation timeout in ms (default: 5 minutes)
-   */
-  constructor(indexerUrl, timeout = 5 * 60 * 1e3) {
-    this.indexerUrl = indexerUrl.replace(/\/$/, "");
-    this.timeout = timeout;
-  }
-  /**
-   * Generate a zero-knowledge proof for withdrawal
-   *
-   * This process typically takes 30-180 seconds depending on the backend.
-   *
-   * @param inputs - Circuit inputs (private + public + outputs)
-   * @param options - Optional progress tracking and callbacks
-   * @returns Proof result with hex-encoded proof and public inputs
-   *
-   * @example
-   * ```typescript
-   * const result = await prover.generateProof(inputs);
-   * if (result.success) {
-   *   console.log(`Proof: ${result.proof}`);
-   * }
-   * ```
-   * 
-   * @example
-   * ```typescript
-   * // With progress tracking
-   * const result = await prover.generateProof(inputs, {
-   *   onProgress: (progress) => console.log(`Progress: ${progress}%`),
-   *   onStart: () => console.log("Starting proof generation..."),
-   *   onSuccess: (result) => console.log("Proof generated!"),
-   *   onError: (error) => console.error("Failed:", error)
-   * });
-   * ```
-   */
-  async generateProof(inputs, options) {
-    const startTime = Date.now();
-    const actualTimeout = options?.timeout || this.timeout;
-    options?.onStart?.();
-    let progressInterval;
-    try {
-      const requestBody = {
-        private_inputs: JSON.stringify(inputs.privateInputs),
-        public_inputs: JSON.stringify(inputs.publicInputs),
-        outputs: JSON.stringify(inputs.outputs)
-      };
-      if (inputs.swapParams) {
-        requestBody.swap_params = inputs.swapParams;
-      }
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), actualTimeout);
-      if (options?.onProgress) {
-        let progress = 0;
-        progressInterval = setInterval(() => {
-          progress = Math.min(90, progress + Math.random() * 10);
-          options.onProgress(Math.floor(progress));
-        }, 2e3);
-      }
-      const response = await fetch(`${this.indexerUrl}/api/v1/prove`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody),
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (progressInterval) clearInterval(progressInterval);
-      if (!response.ok) {
-        let errorMessage = `${response.status} ${response.statusText}`;
-        try {
-          const errorText = await response.text();
-          try {
-            const errorJson = JSON.parse(errorText);
-            errorMessage = errorJson.error || errorJson.message || errorText;
-          } catch {
-            errorMessage = errorText || errorMessage;
-          }
-        } catch {
-        }
-        options?.onError?.(errorMessage);
-        return {
-          success: false,
-          generationTimeMs: Date.now() - startTime,
-          error: errorMessage
-        };
-      }
-      options?.onProgress?.(100);
-      const rawData = await response.json();
-      const result = {
-        success: rawData.success,
-        proof: rawData.proof,
-        publicInputs: rawData.public_inputs,
-        // Map snake_case
-        generationTimeMs: rawData.generation_time_ms || Date.now() - startTime,
-        error: rawData.error
-      };
-      if (!result.success && rawData.execution_report) {
-      }
-      if (!result.success && result.error) {
-        try {
-          const errorObj = typeof result.error === "string" ? JSON.parse(result.error) : result.error;
-          if (errorObj?.error && typeof errorObj.error === "string") {
-            result.error = errorObj.error;
-          } else if (typeof errorObj === "string") {
-            result.error = errorObj;
-          }
-          if (errorObj?.execution_report && typeof errorObj.execution_report === "string") {
-            result.error += `
-Execution report: ${errorObj.execution_report}`;
-          }
-          if (errorObj?.total_cycles !== void 0) {
-            result.error += `
-Total cycles: ${errorObj.total_cycles}`;
-          }
-          if (errorObj?.total_syscalls !== void 0) {
-            result.error += `
-Total syscalls: ${errorObj.total_syscalls}`;
-          }
-        } catch {
-        }
-      }
-      if (result.success) {
-        options?.onSuccess?.(result);
-      } else if (result.error) {
-        options?.onError?.(result.error);
-      }
-      return result;
-    } catch (error) {
-      const totalTime = Date.now() - startTime;
-      if (progressInterval) clearInterval(progressInterval);
-      let errorMessage;
-      if (error instanceof Error && error.name === "AbortError") {
-        errorMessage = `Proof generation timed out after ${actualTimeout}ms`;
-      } else {
-        errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-      }
-      options?.onError?.(errorMessage);
-      return {
-        success: false,
-        generationTimeMs: totalTime,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Check if the prover service is available
-   *
-   * @returns True if service is healthy
-   */
-  async healthCheck() {
-    try {
-      const response = await fetch(`${this.indexerUrl}/health`, {
-        method: "GET"
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get the configured timeout
-   */
-  getTimeout() {
-    return this.timeout;
-  }
-  /**
-   * Set a new timeout
-   */
-  setTimeout(timeout) {
-    if (timeout <= 0) {
-      throw new Error("Timeout must be positive");
-    }
-    this.timeout = timeout;
-  }
-};
-
 // src/helpers/wallet-integration.ts
-var import_web37 = require("@solana/web3.js");
+var import_web36 = require("@solana/web3.js");
 function validateWalletConnected(wallet) {
-  if (wallet instanceof import_web37.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     return;
   }
   if (!wallet.publicKey) {
@@ -3658,7 +3194,7 @@ function validateWalletConnected(wallet) {
   }
 }
 function getPublicKey(wallet) {
-  if (wallet instanceof import_web37.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     return wallet.publicKey;
   }
   if (!wallet.publicKey) {
@@ -3671,7 +3207,7 @@ function getPublicKey(wallet) {
   return wallet.publicKey;
 }
 async function sendTransaction(transaction, wallet, connection, options) {
-  if (wallet instanceof import_web37.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     return await connection.sendTransaction(transaction, [wallet], options);
   }
   if (wallet.sendTransaction) {
@@ -3688,7 +3224,7 @@ async function sendTransaction(transaction, wallet, connection, options) {
   }
 }
 async function signTransaction(transaction, wallet) {
-  if (wallet instanceof import_web37.Keypair) {
+  if (wallet instanceof import_web36.Keypair) {
     transaction.sign(wallet);
     return transaction;
   }
@@ -3719,7 +3255,6 @@ function keypairToAdapter(keypair) {
 var VERSION = "1.0.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ArtifactProverService,
   CLOAK_PROGRAM_ID,
   CloakError,
   CloakSDK,
@@ -3729,7 +3264,6 @@ var VERSION = "1.0.0";
   LAMPORTS_PER_SOL,
   LocalStorageAdapter,
   MemoryStorageAdapter,
-  ProverService,
   RelayService,
   VARIABLE_FEE_RATE,
   VERSION,