@cloak.ag/sdk 1.0.2 → 1.0.3

package/dist/index.js

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/core/CloakSDK.ts
 import {
   Keypair,
-  PublicKey as PublicKey5,
+  PublicKey as PublicKey4,
   Transaction
 } from "@solana/web3.js";
 
@@ -28,7 +28,6 @@ import { blake3 } from "@noble/hashes/blake3.js";
 import nacl from "tweetnacl";
 
 // src/utils/crypto.ts
-import { PublicKey } from "@solana/web3.js";
 import { buildPoseidon } from "circomlibjs";
 var poseidon = null;
 async function getPoseidon() {
@@ -49,7 +48,7 @@ function splitTo2Limbs(value) {
   return [lo, hi];
 }
 function pubkeyToLimbs(pubkey) {
-  const bytes = pubkey instanceof 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);
 }
@@ -677,10 +676,10 @@ var LocalStorageAdapter = class {
 };
 
 // src/utils/validation.ts
-import { PublicKey as PublicKey2 } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
 function isValidSolanaAddress(address) {
   try {
-    new PublicKey2(address);
+    new PublicKey(address);
     return true;
   } catch {
     return false;
@@ -779,8 +778,9 @@ function validateTransfers(recipients, totalAmount) {
   }
   for (let i = 0; i < recipients.length; i++) {
     const transfer = recipients[i];
-    if (!transfer.recipient || !(transfer.recipient instanceof PublicKey2)) {
-      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`);
@@ -1025,254 +1025,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 {
   /**
@@ -1769,7 +1521,7 @@ var DepositRecoveryService = class {
 
 // src/solana/instructions.ts
 import {
-  PublicKey as PublicKey3,
+  PublicKey as PublicKey2,
   SystemProgram,
   TransactionInstruction
 } from "@solana/web3.js";
@@ -1810,16 +1562,16 @@ function createDepositInstruction(params) {
   });
 }
 function validateDepositParams(params) {
-  if (!(params.programId instanceof PublicKey3)) {
+  if (!(params.programId instanceof PublicKey2)) {
     throw new Error("programId must be a PublicKey");
   }
-  if (!(params.payer instanceof PublicKey3)) {
+  if (!(params.payer instanceof PublicKey2)) {
     throw new Error("payer must be a PublicKey");
   }
-  if (!(params.pool instanceof PublicKey3)) {
+  if (!(params.pool instanceof PublicKey2)) {
     throw new Error("pool must be a PublicKey");
   }
-  if (!(params.merkleTree instanceof PublicKey3)) {
+  if (!(params.merkleTree instanceof PublicKey2)) {
     throw new Error("merkleTree must be a PublicKey");
   }
   if (typeof params.amount !== "number" || params.amount <= 0) {
@@ -1836,34 +1588,34 @@ function validateDepositParams(params) {
 }
 
 // src/utils/pda.ts
-import { PublicKey as PublicKey4 } from "@solana/web3.js";
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
 function getShieldPoolPDAs(programId, mint) {
   const pid = programId || CLOAK_PROGRAM_ID;
-  const mintKey = mint ?? new PublicKey4(
+  const mintKey = mint ?? new PublicKey3(
     // 32 zero bytes, matching Rust `Pubkey::default()`
     new Uint8Array(32)
   );
-  const [pool] = PublicKey4.findProgramAddressSync(
+  const [pool] = PublicKey3.findProgramAddressSync(
     [Buffer.from("pool"), mintKey.toBytes()],
     pid
   );
-  const [merkleTree] = PublicKey4.findProgramAddressSync(
+  const [merkleTree] = PublicKey3.findProgramAddressSync(
     [Buffer.from("merkle_tree"), mintKey.toBytes()],
     pid
   );
-  const [commitments] = PublicKey4.findProgramAddressSync(
+  const [commitments] = PublicKey3.findProgramAddressSync(
     [Buffer.from("commitments"), mintKey.toBytes()],
     pid
   );
-  const [rootsRing] = PublicKey4.findProgramAddressSync(
+  const [rootsRing] = PublicKey3.findProgramAddressSync(
     [Buffer.from("roots_ring"), mintKey.toBytes()],
     pid
   );
-  const [nullifierShard] = PublicKey4.findProgramAddressSync(
+  const [nullifierShard] = PublicKey3.findProgramAddressSync(
     [Buffer.from("nullifier_shard"), mintKey.toBytes()],
     pid
   );
-  const [treasury] = PublicKey4.findProgramAddressSync(
+  const [treasury] = PublicKey3.findProgramAddressSync(
     [Buffer.from("treasury"), mintKey.toBytes()],
     pid
   );
@@ -1910,6 +1662,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) {
@@ -2026,6 +1787,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);
@@ -2057,11 +1822,11 @@ async function getDefaultCircuitsPath() {
 }
 
 // src/core/CloakSDK.ts
-var CLOAK_PROGRAM_ID = new PublicKey5("c1oak6tetxYnNfvXKFkpn1d98FxtK7B68vBQLYQpWKp");
+var CLOAK_PROGRAM_ID = new PublicKey4("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
    * 
@@ -2094,7 +1859,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) {
@@ -2199,27 +1963,48 @@ var CloakSDK = class {
       const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
       const transaction = new 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,
@@ -2304,7 +2089,7 @@ ${logs}`
       }
       if (leafIndex === null) {
         const programId2 = this.config.programId || CLOAK_PROGRAM_ID;
-        const mintForSOL = new PublicKey5(new Uint8Array(32));
+        const mintForSOL = new PublicKey4(new Uint8Array(32));
         const { merkleTree } = getShieldPoolPDAs(programId2, mintForSOL);
         const merkleTreeAccount = await connection.getAccountInfo(merkleTree);
         if (!merkleTreeAccount) {
@@ -2455,7 +2240,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;
@@ -2519,43 +2305,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(
       {
@@ -2716,7 +2468,7 @@ Note details: leafIndex=${note.leafIndex}, root=${merkleRoot.slice(0, 16)}..., n
         if (!getAssociatedTokenAddress) {
           throw new Error("getAssociatedTokenAddress not found");
         }
-        const outputMint2 = new PublicKey5(options.outputMint);
+        const outputMint2 = new PublicKey4(options.outputMint);
         recipientAta = await getAssociatedTokenAddress(outputMint2, recipient);
       } catch (error) {
         throw new Error(
@@ -2737,8 +2489,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 PublicKey5("11111111111111111111111111111111");
-      const outputMint = new PublicKey5(options.outputMint);
+      const inputMint = new PublicKey4("11111111111111111111111111111111");
+      const outputMint = new PublicKey4(options.outputMint);
       const outputsHash = await computeSwapOutputsHashAsync(
         inputMint,
         outputMint,
@@ -2753,7 +2505,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;
@@ -2798,46 +2551,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(
         {
@@ -3605,7 +3321,6 @@ function keypairToAdapter(keypair) {
 // src/index.ts
 var VERSION = "1.0.0";
 export {
-  ArtifactProverService,
   CLOAK_PROGRAM_ID,
   CloakError,
   CloakSDK,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloak.ag/sdk",
   "description": "TypeScript SDK for Cloak",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",