@cloak.ag/sdk 1.0.1 → 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((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 {
   /**
@@ -1510,7 +1262,7 @@ var RelayService = class {
    * Sleep utility
    */
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
 
@@ -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
   );
@@ -1879,16 +1631,66 @@ function getShieldPoolPDAs(programId, mint) {
 
 // src/utils/proof-generation.ts
 import * as snarkjs from "snarkjs";
-import * as path from "path";
-import * as fs from "fs";
-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
@@ -1927,13 +1729,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);
@@ -1974,21 +1786,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;
     }
   }
@@ -1996,7 +1822,7 @@ 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 {
   /**
@@ -2004,21 +1830,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 = 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 = 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) {
@@ -2044,6 +1884,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
    *
@@ -2084,7 +1942,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(
@@ -2095,7 +1954,7 @@ 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,
@@ -2103,26 +1962,58 @@ var CloakSDK = class {
       });
       const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
       const transaction = new Transaction({
-        feePayer: this.keypair.publicKey,
-        blockhash,
-        lastValidBlockHeight
+        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,
@@ -2184,13 +2075,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;
             }
           }
@@ -2198,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) {
@@ -2223,7 +2114,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;
@@ -2349,8 +2240,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) {
@@ -2413,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(
       {
@@ -2610,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(
@@ -2631,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,
@@ -2647,8 +2505,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) {
@@ -2692,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(
         {
@@ -3499,7 +3321,6 @@ function keypairToAdapter(keypair) {
 // src/index.ts
 var VERSION = "1.0.0";
 export {
-  ArtifactProverService,
   CLOAK_PROGRAM_ID,
   CloakError,
   CloakSDK,
@@ -3552,6 +3373,8 @@ export {
   generateMasterSeed,
   generateNote,
   generateNoteFromWallet,
+  generateWithdrawRegularProof,
+  generateWithdrawSwapProof,
   getAddressExplorerUrl,
   getDistributableAmount2 as getDistributableAmount,
   getExplorerUrl,