@cloak.ag/sdk 1.0.1 → 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,
@@ -83,6 +82,8 @@ __export(index_exports, {
   generateMasterSeed: () => generateMasterSeed,
   generateNote: () => generateNote,
   generateNoteFromWallet: () => generateNoteFromWallet,
+  generateWithdrawRegularProof: () => generateWithdrawRegularProof,
+  generateWithdrawSwapProof: () => generateWithdrawSwapProof,
   getAddressExplorerUrl: () => getAddressExplorerUrl,
   getDistributableAmount: () => getDistributableAmount2,
   getExplorerUrl: () => getExplorerUrl,
@@ -127,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 {
@@ -145,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() {
@@ -166,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);
 }
@@ -794,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;
@@ -896,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`);
@@ -1142,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((resolve2) => setTimeout(resolve2, 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 {
   /**
@@ -1627,12 +1380,12 @@ var RelayService = class {
    * Sleep utility
    */
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
 
 // 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) {
@@ -1723,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, {
@@ -1885,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(
@@ -1907,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
@@ -1915,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 }
     ],
@@ -1923,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) {
@@ -1949,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
   );
@@ -1992,16 +1745,66 @@ function getShieldPoolPDAs(programId, mint) {
 
 // src/utils/proof-generation.ts
 var snarkjs = __toESM(require("snarkjs"), 1);
-var path = __toESM(require("path"), 1);
-var fs = __toESM(require("fs"), 1);
-async function generateWithdrawRegularProof(inputs, circuitsPath) {
-  const wasmPath = path.join(circuitsPath, "build", "withdraw_regular_js", "withdraw_regular.wasm");
-  const zkeyPath = path.join(circuitsPath, "build", "withdraw_regular_final.zkey");
-  if (!fs.existsSync(wasmPath)) {
-    throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages-new/circuits first.`);
+var path = null;
+var fs = null;
+async function loadNodeModules() {
+  const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+  if (!isBrowser && typeof process !== "undefined" && process.versions?.node) {
+    if (!path) {
+      path = await import("path");
+    }
+    if (!fs) {
+      fs = await import("fs");
+    }
+    return { path, fs };
+  }
+  return { path: null, fs: null };
+}
+function joinPath(...parts) {
+  const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+  if (!isBrowser && path) {
+    return path.join(...parts);
+  }
+  return parts.join("/").replace(/\/+/g, "/");
+}
+async function fileExists(filePath) {
+  const { fs: fs2 } = await loadNodeModules();
+  if (fs2) {
+    try {
+      return fs2.existsSync(filePath);
+    } catch {
+      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;
+    }
   }
-  if (!fs.existsSync(zkeyPath)) {
-    throw new Error(`Circuit zkey not found at ${zkeyPath}. Run circuit setup first.`);
+  return false;
+}
+async function generateWithdrawRegularProof(inputs, circuitsPath) {
+  const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+  let wasmPath;
+  let zkeyPath;
+  if (isBrowser) {
+    wasmPath = `${circuitsPath}/withdraw_regular_js/withdraw_regular.wasm`;
+    zkeyPath = `${circuitsPath}/withdraw_regular_final.zkey`;
+  } else {
+    wasmPath = joinPath(circuitsPath, "build", "withdraw_regular_js", "withdraw_regular.wasm");
+    zkeyPath = joinPath(circuitsPath, "build", "withdraw_regular_final.zkey");
+    const wasmExists = await fileExists(wasmPath);
+    const zkeyExists = await fileExists(zkeyPath);
+    if (!wasmExists) {
+      throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages-new/circuits first.`);
+    }
+    if (!zkeyExists) {
+      throw new Error(`Circuit zkey not found at ${zkeyPath}. Run circuit setup first.`);
+    }
   }
   const circuitInputs = {
     // Public signals
@@ -2040,13 +1843,23 @@ async function generateWithdrawRegularProof(inputs, circuitsPath) {
   };
 }
 async function generateWithdrawSwapProof(inputs, circuitsPath) {
-  const wasmPath = path.join(circuitsPath, "build", "withdraw_swap_js", "withdraw_swap.wasm");
-  const zkeyPath = path.join(circuitsPath, "build", "withdraw_swap_final.zkey");
-  if (!fs.existsSync(wasmPath)) {
-    throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages-new/circuits first.`);
-  }
-  if (!fs.existsSync(zkeyPath)) {
-    throw new Error(`Circuit zkey not found at ${zkeyPath}. Run circuit setup first.`);
+  const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+  let wasmPath;
+  let zkeyPath;
+  if (isBrowser) {
+    wasmPath = `${circuitsPath}/withdraw_swap_js/withdraw_swap.wasm`;
+    zkeyPath = `${circuitsPath}/withdraw_swap_final.zkey`;
+  } else {
+    wasmPath = joinPath(circuitsPath, "build", "withdraw_swap_js", "withdraw_swap.wasm");
+    zkeyPath = joinPath(circuitsPath, "build", "withdraw_swap_final.zkey");
+    const wasmExists = await fileExists(wasmPath);
+    const zkeyExists = await fileExists(zkeyPath);
+    if (!wasmExists) {
+      throw new Error(`Circuit WASM not found at ${wasmPath}. Run 'just circuits-compile' in packages-new/circuits first.`);
+    }
+    if (!zkeyExists) {
+      throw new Error(`Circuit zkey not found at ${zkeyPath}. Run circuit setup first.`);
+    }
   }
   const sk = splitTo2Limbs(inputs.sk_spend);
   const r = splitTo2Limbs(inputs.r);
@@ -2087,21 +1900,35 @@ async function generateWithdrawSwapProof(inputs, circuitsPath) {
     // Not used, kept for compatibility
   };
 }
-function areCircuitsAvailable(circuitsPath) {
-  const wasmPath = path.join(circuitsPath, "build", "withdraw_regular_js", "withdraw_regular.wasm");
-  const zkeyPath = path.join(circuitsPath, "build", "withdraw_regular_final.zkey");
-  return fs.existsSync(wasmPath) && fs.existsSync(zkeyPath);
+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);
+  const zkeyExists = await fileExists(zkeyPath);
+  return wasmExists && zkeyExists;
 }
-function getDefaultCircuitsPath() {
+async function getDefaultCircuitsPath() {
+  const isBrowser = typeof window !== "undefined" || typeof globalThis !== "undefined" && globalThis.window;
+  if (isBrowser) {
+    return "/circuits";
+  }
+  const { path: path2 } = await loadNodeModules();
+  if (!path2 || typeof process === "undefined" || !process.cwd) {
+    return "/circuits";
+  }
   const possiblePaths = [
-    path.resolve(process.cwd(), "../../packages-new/circuits"),
-    path.resolve(process.cwd(), "../packages-new/circuits"),
-    path.resolve(process.cwd(), "packages-new/circuits"),
-    path.resolve(process.cwd(), "../../circuits"),
-    path.resolve(process.cwd(), "../circuits")
+    path2.resolve(process.cwd(), "../../packages-new/circuits"),
+    path2.resolve(process.cwd(), "../packages-new/circuits"),
+    path2.resolve(process.cwd(), "packages-new/circuits"),
+    path2.resolve(process.cwd(), "../../circuits"),
+    path2.resolve(process.cwd(), "../circuits")
   ];
   for (const p of possiblePaths) {
-    if (areCircuitsAvailable(p)) {
+    if (await areCircuitsAvailable(p)) {
       return p;
     }
   }
@@ -2109,7 +1936,7 @@ 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 {
   /**
@@ -2117,21 +1944,35 @@ var CloakSDK = class {
    *
    * @param config - Client configuration
    * 
-   * @example
+   * @example Node.js mode (with keypair)
    * ```typescript
    * const sdk = new CloakSDK({
    *   keypairBytes: keypair.secretKey,
    *   network: "devnet"
-   * });  
+   * });
+   * ```
+   * 
+   * @example Browser mode (with wallet adapter)
+   * ```typescript
+   * const sdk = new CloakSDK({
+   *   wallet: walletAdapter,
+   *   network: "devnet"
+   * });
+   * ```
    */
   constructor(config) {
-    this.keypair = import_web36.Keypair.fromSecretKey(config.keypairBytes);
+    if (!config.keypairBytes && !config.wallet) {
+      throw new Error("Must provide either keypairBytes (Node.js) or wallet (Browser)");
+    }
+    if (config.keypairBytes) {
+      this.keypair = import_web35.Keypair.fromSecretKey(config.keypairBytes);
+    }
+    this.wallet = config.wallet;
     this.cloakKeys = config.cloakKeys;
     this.storage = config.storage || new MemoryStorageAdapter();
-    const indexerUrl = config.indexerUrl || process.env.CLOAK_INDEXER_URL || CLOAK_API_URL;
-    const relayUrl = config.relayUrl || process.env.CLOAK_RELAY_URL || CLOAK_API_URL;
+    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) {
@@ -2157,6 +1998,24 @@ var CloakSDK = class {
       treasuryAddress: treasury
     };
   }
+  /**
+   * Get the public key for deposits (from keypair or wallet)
+   */
+  getPublicKey() {
+    if (this.keypair) {
+      return this.keypair.publicKey;
+    }
+    if (this.wallet?.publicKey) {
+      return this.wallet.publicKey;
+    }
+    throw new Error("No public key available - wallet not connected or keypair not provided");
+  }
+  /**
+   * Check if the SDK is using a wallet adapter
+   */
+  isWalletMode() {
+    return !!this.wallet && !this.keypair;
+  }
   /**
    * Deposit SOL into the Cloak protocol
    *
@@ -2197,7 +2056,8 @@ var CloakSDK = class {
           throw new Error("Note has already been deposited");
         }
       }
-      const balance = await connection.getBalance(this.keypair.publicKey);
+      const payerPubkey = this.getPublicKey();
+      const balance = await connection.getBalance(payerPubkey);
       const requiredAmount = note.amount + 5e3;
       if (balance < requiredAmount) {
         throw new Error(
@@ -2208,34 +2068,66 @@ var CloakSDK = class {
       const programId = this.config.programId || CLOAK_PROGRAM_ID;
       const depositIx = createDepositInstruction({
         programId,
-        payer: this.keypair.publicKey,
+        payer: payerPubkey,
         pool: this.config.poolAddress,
         merkleTree: this.config.merkleTreeAddress,
         amount: note.amount,
         commitment: commitmentBytes
       });
       const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
-      const transaction = new import_web36.Transaction({
-        feePayer: this.keypair.publicKey,
-        blockhash,
-        lastValidBlockHeight
+      const transaction = new import_web35.Transaction({
+        feePayer: payerPubkey,
+        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) {
+        if (!this.wallet.publicKey) {
+          throw new Error("Wallet not connected - publicKey is null");
         }
+        if (this.wallet.signTransaction) {
+          try {
+            const signedTransaction = await this.wallet.signTransaction(transaction);
+            const rawTransaction = signedTransaction.serialize();
+            signature = await connection.sendRawTransaction(rawTransaction, {
+              skipPreflight: options?.skipPreflight || false,
+              preflightCommitment: "confirmed",
+              maxRetries: 3
+            });
+          } catch (signError) {
+            if (this.wallet.sendTransaction) {
+              signature = await this.wallet.sendTransaction(transaction, connection, {
+                skipPreflight: options?.skipPreflight || false,
+                preflightCommitment: "confirmed",
+                maxRetries: 3
+              });
+            } else {
+              throw signError;
+            }
+          }
+        } else if (this.wallet.sendTransaction) {
+          signature = await this.wallet.sendTransaction(transaction, connection, {
+            skipPreflight: options?.skipPreflight || false,
+            preflightCommitment: "confirmed",
+            maxRetries: 3
+          });
+        } else {
+          throw new Error("Wallet adapter must provide either sendTransaction or signTransaction");
+        }
+      } else if (this.keypair) {
+        signature = await connection.sendTransaction(transaction, [this.keypair], {
+          skipPreflight: options?.skipPreflight || false,
+          preflightCommitment: "confirmed",
+          maxRetries: 3
+        });
+      } else {
+        throw new Error("No signing method available - provide keypair or wallet");
       }
-      const signature = await connection.sendTransaction(transaction, [this.keypair], {
-        skipPreflight: options?.skipPreflight || false,
-        preflightCommitment: "confirmed",
-        maxRetries: 3
-      });
       const confirmation = await connection.confirmTransaction({
         signature,
         blockhash,
@@ -2297,13 +2189,13 @@ ${logs}`
               break;
             } else if (response.status === 404 && attempt < maxRetries2 - 1) {
               const delay = Math.min(initialRetryDelay2 * (attempt + 1), 2e3);
-              await new Promise((resolve2) => setTimeout(resolve2, delay));
+              await new Promise((resolve) => setTimeout(resolve, delay));
               continue;
             }
           } catch (e) {
             if (attempt < maxRetries2 - 1) {
               const delay = Math.min(initialRetryDelay2 * (attempt + 1), 2e3);
-              await new Promise((resolve2) => setTimeout(resolve2, delay));
+              await new Promise((resolve) => setTimeout(resolve, delay));
               continue;
             }
           }
@@ -2311,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) {
@@ -2336,7 +2228,7 @@ ${logs}`
           const errorMessage = error instanceof Error ? error.message : String(error);
           if (errorMessage.includes("404") && attempt < maxRetries - 1) {
             const delay = Math.min(initialRetryDelay * (attempt + 1), 2e3);
-            await new Promise((resolve2) => setTimeout(resolve2, delay));
+            await new Promise((resolve) => setTimeout(resolve, delay));
             continue;
           }
           throw error;
@@ -2462,8 +2354,9 @@ ${logs}`
         throw new Error(`Merkle proof path element at position ${i} must be 64 hex characters (32 bytes)`);
       }
     }
-    const circuitsPath = process.env.CIRCUITS_PATH || getDefaultCircuitsPath();
-    const useDirectProof = areCircuitsAvailable(circuitsPath);
+    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;
     if (useDirectProof) {
@@ -2526,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(
       {
@@ -2723,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(
@@ -2744,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,
@@ -2760,8 +2619,9 @@ 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 = process.env.CIRCUITS_PATH || getDefaultCircuitsPath();
-      const useDirectProof = areCircuitsAvailable(circuitsPath);
+      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;
       if (useDirectProof) {
@@ -2805,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(
         {
@@ -3536,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) {
@@ -3550,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) {
@@ -3563,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) {
@@ -3580,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;
   }
@@ -3611,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,
@@ -3664,6 +3486,8 @@ var VERSION = "1.0.0";
   generateMasterSeed,
   generateNote,
   generateNoteFromWallet,
+  generateWithdrawRegularProof,
+  generateWithdrawSwapProof,
   getAddressExplorerUrl,
   getDistributableAmount,
   getExplorerUrl,