@cloak.ag/sdk 1.0.2 → 1.0.3

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,
@@ -129,7 +128,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 +146,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 +166,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 +794,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 +896,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 +1143,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 +1385,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 +1476,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 +1638,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 +1660,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 +1668,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 +1676,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 +1702,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 +1776,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) {
@@ -2141,6 +1901,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 +1936,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 +1965,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 +1973,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 +2075,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 +2203,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) {
@@ -2570,7 +2354,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;
@@ -2634,43 +2419,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(
       {
@@ -2831,7 +2582,7 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
         if (!getAssociatedTokenAddress) {
           throw new Error("getAssociatedTokenAddress not found");
         }
-        const outputMint2 = new import_web36.PublicKey(options.outputMint);
+        const outputMint2 = new import_web35.PublicKey(options.outputMint);
         recipientAta = await getAssociatedTokenAddress(outputMint2, recipient);
       } catch (error) {
         throw new Error(
@@ -2852,8 +2603,8 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
       }
       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 +2619,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;
@@ -2913,46 +2665,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(
         {
@@ -3644,9 +3359,9 @@ Total syscalls: ${errorObj.total_syscalls}`;
 };
 
 // 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 +3373,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 +3386,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 +3403,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 +3434,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,