@cloak.ag/sdk 1.0.3 → 1.0.4

package/dist/chunk-S76QK36U.js

@@ -0,0 +1,303 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/crypto.ts
+import { buildPoseidon } from "circomlibjs";
+var poseidon = null;
+async function getPoseidon() {
+  if (!poseidon) {
+    poseidon = await buildPoseidon();
+  }
+  return poseidon;
+}
+async function poseidonHash(inputs) {
+  const p = await getPoseidon();
+  const hash = p(inputs.map((x) => p.F.e(x)));
+  return p.F.toObject(hash);
+}
+function splitTo2Limbs(value) {
+  const mask = (1n << 128n) - 1n;
+  const lo = value & mask;
+  const hi = value >> 128n;
+  return [lo, hi];
+}
+function pubkeyToLimbs(pubkey) {
+  const bytes = typeof pubkey.toBytes === "function" ? pubkey.toBytes() : pubkey;
+  const value = BigInt("0x" + Buffer.from(bytes).toString("hex"));
+  return splitTo2Limbs(value);
+}
+async function computeMerkleRoot(leaf, pathElements, pathIndices) {
+  let current = leaf;
+  for (let i = 0; i < pathElements.length; i++) {
+    if (pathIndices[i] === 0) {
+      current = await poseidonHash([current, pathElements[i]]);
+    } else {
+      current = await poseidonHash([pathElements[i], current]);
+    }
+  }
+  return current;
+}
+function hexToBigint(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return BigInt("0x" + cleanHex);
+}
+async function computeCommitment(amount, r, sk_spend) {
+  const [sk0, sk1] = splitTo2Limbs(sk_spend);
+  const [r0, r1] = splitTo2Limbs(r);
+  const pk_spend = await poseidonHash([sk0, sk1]);
+  return await poseidonHash([amount, r0, r1, pk_spend]);
+}
+async function generateCommitmentAsync(amountLamports, r, skSpend) {
+  const amount = BigInt(amountLamports);
+  const rValue = hexToBigint(bytesToHex(r));
+  const skValue = hexToBigint(bytesToHex(skSpend));
+  return await computeCommitment(amount, rValue, skValue);
+}
+function generateCommitment(_amountLamports, _r, _skSpend) {
+  throw new Error("generateCommitment is deprecated. Use generateCommitmentAsync instead.");
+}
+async function computeNullifier(sk_spend, leafIndex) {
+  const [sk0, sk1] = splitTo2Limbs(sk_spend);
+  return await poseidonHash([sk0, sk1, leafIndex]);
+}
+async function computeNullifierAsync(skSpend, leafIndex) {
+  const skValue = typeof skSpend === "string" ? hexToBigint(skSpend) : hexToBigint(bytesToHex(skSpend));
+  return await computeNullifier(skValue, BigInt(leafIndex));
+}
+function computeNullifierSync(_skSpend, _leafIndex) {
+  throw new Error("computeNullifierSync is deprecated. Use computeNullifierAsync instead.");
+}
+async function computeOutputsHashAsync(outputs) {
+  let hash = 0n;
+  for (const output of outputs) {
+    const [lo, hi] = pubkeyToLimbs(output.recipient);
+    hash = await poseidonHash([hash, lo, hi, BigInt(output.amount)]);
+  }
+  return hash;
+}
+async function computeOutputsHash(outAddr, outAmount, outFlags) {
+  let hash = 0n;
+  for (let i = 0; i < 5; i++) {
+    if (outFlags[i] === 1) {
+      hash = await poseidonHash([hash, outAddr[i][0], outAddr[i][1], outAmount[i]]);
+    }
+  }
+  return hash;
+}
+async function computeOutputsHashFromLimbs(outAddr, outAmount, outFlags) {
+  return await computeOutputsHash(outAddr, outAmount, outFlags);
+}
+function computeOutputsHashSync(_outputs) {
+  throw new Error("computeOutputsHashSync is deprecated. Use computeOutputsHashAsync instead.");
+}
+async function computeSwapOutputsHash(inputMintLimbs, outputMintLimbs, recipientAtaLimbs, minOutputAmount, publicAmount) {
+  return await poseidonHash([
+    inputMintLimbs[0],
+    inputMintLimbs[1],
+    outputMintLimbs[0],
+    outputMintLimbs[1],
+    recipientAtaLimbs[0],
+    recipientAtaLimbs[1],
+    minOutputAmount,
+    publicAmount
+  ]);
+}
+async function computeSwapOutputsHashAsync(inputMint, outputMint, recipientAta, minOutputAmount, amount) {
+  const inputMintLimbs = pubkeyToLimbs(inputMint);
+  const outputMintLimbs = pubkeyToLimbs(outputMint);
+  const recipientAtaLimbs = pubkeyToLimbs(recipientAta);
+  return await computeSwapOutputsHash(
+    inputMintLimbs,
+    outputMintLimbs,
+    recipientAtaLimbs,
+    BigInt(minOutputAmount),
+    BigInt(amount)
+  );
+}
+function computeSwapOutputsHashSync(_outputMint, _recipientAta, _minOutputAmount, _amount) {
+  throw new Error("computeSwapOutputsHashSync is deprecated. Use computeSwapOutputsHashAsync instead.");
+}
+function bigintToBytes32(n) {
+  const hex = n.toString(16).padStart(64, "0");
+  const bytes = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = parseInt(cleanHex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes, prefix = false) {
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return prefix ? `0x${hex}` : hex;
+}
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  const g = globalThis;
+  try {
+    const cryptoObj = g?.crypto || g?.window?.crypto || g?.self?.crypto;
+    if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+      cryptoObj.getRandomValues(bytes);
+      return bytes;
+    }
+  } catch {
+  }
+  try {
+    const nodeCrypto = __require("crypto");
+    if (nodeCrypto?.randomBytes) {
+      const buffer = nodeCrypto.randomBytes(length);
+      bytes.set(buffer);
+      return bytes;
+    }
+    if (nodeCrypto?.webcrypto?.getRandomValues) {
+      nodeCrypto.webcrypto.getRandomValues(bytes);
+      return bytes;
+    }
+  } catch {
+  }
+  for (let i = 0; i < length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  return bytes;
+}
+function isValidHex(hex, expectedLength) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (!/^[0-9a-f]*$/i.test(cleanHex)) {
+    return false;
+  }
+  if (cleanHex.length % 2 !== 0) {
+    return false;
+  }
+  if (expectedLength !== void 0) {
+    return cleanHex.length === expectedLength * 2;
+  }
+  return true;
+}
+var BN254_MODULUS = BigInt("0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47");
+function proofToBytes(proof) {
+  const pi_a_x = BigInt(proof.pi_a[0]);
+  const pi_a_y = BigInt(proof.pi_a[1]);
+  const pi_a_y_neg = (BN254_MODULUS - pi_a_y) % BN254_MODULUS;
+  const pi_a_x_le = bigintToBytes32LE(pi_a_x);
+  const pi_a_y_neg_le = bigintToBytes32LE(pi_a_y_neg);
+  const pi_a_le = new Uint8Array(64);
+  pi_a_le.set(pi_a_x_le, 0);
+  pi_a_le.set(pi_a_y_neg_le, 32);
+  const pi_a_be = convertEndianness32(pi_a_le);
+  const pi_b_x1 = BigInt(proof.pi_b[0][0]);
+  const pi_b_x2 = BigInt(proof.pi_b[0][1]);
+  const pi_b_y1 = BigInt(proof.pi_b[1][0]);
+  const pi_b_y2 = BigInt(proof.pi_b[1][1]);
+  const pi_b_x1_le = bigintToBytes32LE(pi_b_x1);
+  const pi_b_x2_le = bigintToBytes32LE(pi_b_x2);
+  const pi_b_y1_le = bigintToBytes32LE(pi_b_y1);
+  const pi_b_y2_le = bigintToBytes32LE(pi_b_y2);
+  const pi_b_le = new Uint8Array(128);
+  pi_b_le.set(pi_b_x1_le, 0);
+  pi_b_le.set(pi_b_x2_le, 32);
+  pi_b_le.set(pi_b_y1_le, 64);
+  pi_b_le.set(pi_b_y2_le, 96);
+  const pi_b_be = convertEndianness64(pi_b_le);
+  const pi_c_x = BigInt(proof.pi_c[0]);
+  const pi_c_y = BigInt(proof.pi_c[1]);
+  const pi_c_x_le = bigintToBytes32LE(pi_c_x);
+  const pi_c_y_le = bigintToBytes32LE(pi_c_y);
+  const pi_c_le = new Uint8Array(64);
+  pi_c_le.set(pi_c_x_le, 0);
+  pi_c_le.set(pi_c_y_le, 32);
+  const pi_c_be = convertEndianness32(pi_c_le);
+  const result = new Uint8Array(256);
+  result.set(pi_a_be, 0);
+  result.set(pi_b_be, 64);
+  result.set(pi_c_be, 192);
+  return result;
+}
+function bigintToBytes32LE(n) {
+  const bytes = new Uint8Array(32);
+  let value = n % BN254_MODULUS;
+  if (value < 0) {
+    value = (value + BN254_MODULUS) % BN254_MODULUS;
+  }
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = Number(value & BigInt(255));
+    value = value >> BigInt(8);
+  }
+  return bytes;
+}
+function convertEndianness32(bytes) {
+  if (bytes.length !== 64) {
+    throw new Error("convertEndianness32 expects 64 bytes");
+  }
+  const result = new Uint8Array(64);
+  for (let i = 0; i < 32; i++) {
+    result[i] = bytes[31 - i];
+  }
+  for (let i = 0; i < 32; i++) {
+    result[32 + i] = bytes[63 - i];
+  }
+  return result;
+}
+function convertEndianness64(bytes) {
+  if (bytes.length !== 128) {
+    throw new Error("convertEndianness64 expects 128 bytes");
+  }
+  const result = new Uint8Array(128);
+  for (let i = 0; i < 64; i++) {
+    result[i] = bytes[63 - i];
+  }
+  for (let i = 0; i < 64; i++) {
+    result[64 + i] = bytes[127 - i];
+  }
+  return result;
+}
+function buildPublicInputsBytes(root, nullifier, outputsHash, publicAmount) {
+  const result = new Uint8Array(104);
+  result.set(bigintToBytes32(root), 0);
+  result.set(bigintToBytes32(nullifier), 32);
+  result.set(bigintToBytes32(outputsHash), 64);
+  const amountBytes = new Uint8Array(8);
+  let amt = publicAmount;
+  for (let i = 7; i >= 0; i--) {
+    amountBytes[i] = Number(amt & 0xffn);
+    amt = amt >> 8n;
+  }
+  result.set(amountBytes, 96);
+  return result;
+}
+
+export {
+  __require,
+  poseidonHash,
+  splitTo2Limbs,
+  pubkeyToLimbs,
+  computeMerkleRoot,
+  hexToBigint,
+  computeCommitment,
+  generateCommitmentAsync,
+  generateCommitment,
+  computeNullifier,
+  computeNullifierAsync,
+  computeNullifierSync,
+  computeOutputsHashAsync,
+  computeOutputsHash,
+  computeOutputsHashFromLimbs,
+  computeOutputsHashSync,
+  computeSwapOutputsHash,
+  computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync,
+  bigintToBytes32,
+  hexToBytes,
+  bytesToHex,
+  randomBytes,
+  isValidHex,
+  proofToBytes,
+  buildPublicInputsBytes
+};

package/dist/crypto-3TOLQOOK.js

@@ -0,0 +1,54 @@
+import {
+  bigintToBytes32,
+  buildPublicInputsBytes,
+  bytesToHex,
+  computeCommitment,
+  computeMerkleRoot,
+  computeNullifier,
+  computeNullifierAsync,
+  computeNullifierSync,
+  computeOutputsHash,
+  computeOutputsHashAsync,
+  computeOutputsHashFromLimbs,
+  computeOutputsHashSync,
+  computeSwapOutputsHash,
+  computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync,
+  generateCommitment,
+  generateCommitmentAsync,
+  hexToBigint,
+  hexToBytes,
+  isValidHex,
+  poseidonHash,
+  proofToBytes,
+  pubkeyToLimbs,
+  randomBytes,
+  splitTo2Limbs
+} from "./chunk-S76QK36U.js";
+export {
+  bigintToBytes32,
+  buildPublicInputsBytes,
+  bytesToHex,
+  computeCommitment,
+  computeMerkleRoot,
+  computeNullifier,
+  computeNullifierAsync,
+  computeNullifierSync,
+  computeOutputsHash,
+  computeOutputsHashAsync,
+  computeOutputsHashFromLimbs,
+  computeOutputsHashSync,
+  computeSwapOutputsHash,
+  computeSwapOutputsHashAsync,
+  computeSwapOutputsHashSync,
+  generateCommitment,
+  generateCommitmentAsync,
+  hexToBigint,
+  hexToBytes,
+  isValidHex,
+  poseidonHash,
+  proofToBytes,
+  pubkeyToLimbs,
+  randomBytes,
+  splitTo2Limbs
+};

package/dist/index.cjs

@@ -39,7 +39,6 @@ __export(index_exports, {
   LAMPORTS_PER_SOL: () => LAMPORTS_PER_SOL,
   LocalStorageAdapter: () => LocalStorageAdapter,
   MemoryStorageAdapter: () => MemoryStorageAdapter,
-  ProverService: () => ProverService,
   RelayService: () => RelayService,
   VARIABLE_FEE_RATE: () => VARIABLE_FEE_RATE,
   VERSION: () => VERSION,
@@ -1828,11 +1827,7 @@ async function generateWithdrawRegularProof(inputs, circuitsPath) {
     var_fee: inputs.var_fee.toString(),
     rem: inputs.rem.toString()
   };
-  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
-    circuitInputs,
-    wasmPath,
-    zkeyPath
-  );
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(circuitInputs, wasmPath, zkeyPath);
   const proofBytes = proofToBytes(proof);
   return {
     proof,
@@ -2308,17 +2303,10 @@ var CloakSDK = class {
     const feeBps = Math.ceil(protocolFee * 1e4 / note.amount);
     const distributableAmount = getDistributableAmount2(note.amount);
     validateTransfers(recipients, distributableAmount);
-    let merkleProof;
-    let merkleRoot;
-    if (note.merkleProof && note.root) {
-      merkleProof = {
-        pathElements: note.merkleProof.pathElements,
-        pathIndices: note.merkleProof.pathIndices
-      };
-      merkleRoot = note.root;
-    } else {
-      merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
-      merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+    const merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
+    const merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+    if (!merkleRoot) {
+      throw new Error("Failed to get Merkle root from indexer");
     }
     const nullifier = await computeNullifierAsync(note.sk_spend, note.leafIndex);
     const nullifierHex = nullifier.toString(16).padStart(64, "0");
@@ -2392,6 +2380,13 @@ var CloakSDK = class {
       }
       const sk = splitTo2Limbs(sk_spend_bigint);
       const r = splitTo2Limbs(r_bigint);
+      const computedCommitment = await computeCommitment(amount_bigint, r_bigint, sk_spend_bigint);
+      const noteCommitment = BigInt("0x" + note.commitment);
+      if (computedCommitment !== noteCommitment) {
+        throw new Error(
+          `Commitment mismatch! Computed: ${computedCommitment.toString(16)}, Note: ${note.commitment}. This means the note's sk_spend, r, or amount doesn't match what was deposited.`
+        );
+      }
       const proofInputs = {
         root: root_bigint,
         nullifier: nullifier_bigint,
@@ -2410,7 +2405,9 @@ var CloakSDK = class {
         var_fee: varFee,
         rem
       };
+      options?.onProgress?.("proof_generating");
       const proofResult = await generateWithdrawRegularProof(proofInputs, circuitsPath);
+      options?.onProgress?.("proof_complete");
       proofHex = Buffer.from(proofResult.proofBytes).toString("hex");
       finalPublicInputs = {
         root: merkleRoot,
@@ -2576,30 +2573,27 @@ var CloakSDK = class {
         );
       }
       let recipientAta;
-      try {
-        const splTokenModule = await import("@solana/spl-token");
-        const getAssociatedTokenAddress = splTokenModule.getAssociatedTokenAddress;
-        if (!getAssociatedTokenAddress) {
-          throw new Error("getAssociatedTokenAddress not found");
+      if (options.recipientAta) {
+        recipientAta = new import_web35.PublicKey(options.recipientAta);
+      } else {
+        try {
+          const splTokenModule = await import("@solana/spl-token");
+          const getAssociatedTokenAddress = splTokenModule.getAssociatedTokenAddress;
+          if (!getAssociatedTokenAddress) {
+            throw new Error("getAssociatedTokenAddress not found");
+          }
+          const outputMint2 = new import_web35.PublicKey(options.outputMint);
+          recipientAta = await getAssociatedTokenAddress(outputMint2, recipient);
+        } catch (error) {
+          throw new Error(
+            `Failed to get associated token account: ${error instanceof Error ? error.message : String(error)}. Please install @solana/spl-token or provide recipientAta in options.`
+          );
         }
-        const outputMint2 = new import_web35.PublicKey(options.outputMint);
-        recipientAta = await getAssociatedTokenAddress(outputMint2, recipient);
-      } catch (error) {
-        throw new Error(
-          `Failed to get associated token account: ${error instanceof Error ? error.message : String(error)}. Please install @solana/spl-token or provide recipientAta in options.`
-        );
       }
-      let merkleProof;
-      let merkleRoot;
-      if (note.merkleProof && note.root) {
-        merkleProof = {
-          pathElements: note.merkleProof.pathElements,
-          pathIndices: note.merkleProof.pathIndices
-        };
-        merkleRoot = note.root;
-      } else {
-        merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
-        merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+      const merkleProof = await this.indexer.getMerkleProof(note.leafIndex);
+      const merkleRoot = merkleProof.root || (await this.indexer.getMerkleRoot()).root;
+      if (!merkleRoot) {
+        throw new Error("Failed to get Merkle root from indexer");
       }
       const nullifier = await computeNullifierAsync(note.sk_spend, note.leafIndex);
       const nullifierHex = nullifier.toString(16).padStart(64, "0");
@@ -2635,6 +2629,13 @@ var CloakSDK = class {
         const inputMintLimbs = pubkeyToLimbs(inputMint.toBytes());
         const outputMintLimbs = pubkeyToLimbs(outputMint.toBytes());
         const recipientAtaLimbs = pubkeyToLimbs(recipientAta.toBytes());
+        const computedCommitment = await computeCommitment(amount_bigint, r_bigint, sk_spend_bigint);
+        const noteCommitment = BigInt("0x" + note.commitment);
+        if (computedCommitment !== noteCommitment) {
+          throw new Error(
+            `Commitment mismatch! Computed: ${computedCommitment.toString(16)}, Note: ${note.commitment}. This means the note's sk_spend, r, or amount doesn't match what was deposited.`
+          );
+        }
         const t = amount_bigint * 5n;
         const varFee = t / 1000n;
         const rem = t % 1000n;
@@ -2656,7 +2657,9 @@ var CloakSDK = class {
           var_fee: varFee,
           rem
         };
+        options?.onProgress?.("proof_generating");
         const proofResult = await generateWithdrawSwapProof(proofInputs, circuitsPath);
+        options?.onProgress?.("proof_complete");
         proofHex = Buffer.from(proofResult.proofBytes).toString("hex");
         finalPublicInputs = {
           root: merkleRoot,
@@ -3176,188 +3179,6 @@ function formatErrorForLogging(error) {
   return String(error);
 }
 
-// src/services/ProverService.ts
-var ProverService = class {
-  /**
-   * Create a new Prover Service client
-   *
-   * @param indexerUrl - Indexer/Prover service base URL
-   * @param timeout - Proof generation timeout in ms (default: 5 minutes)
-   */
-  constructor(indexerUrl, timeout = 5 * 60 * 1e3) {
-    this.indexerUrl = indexerUrl.replace(/\/$/, "");
-    this.timeout = timeout;
-  }
-  /**
-   * Generate a zero-knowledge proof for withdrawal
-   *
-   * This process typically takes 30-180 seconds depending on the backend.
-   *
-   * @param inputs - Circuit inputs (private + public + outputs)
-   * @param options - Optional progress tracking and callbacks
-   * @returns Proof result with hex-encoded proof and public inputs
-   *
-   * @example
-   * ```typescript
-   * const result = await prover.generateProof(inputs);
-   * if (result.success) {
-   *   console.log(`Proof: ${result.proof}`);
-   * }
-   * ```
-   * 
-   * @example
-   * ```typescript
-   * // With progress tracking
-   * const result = await prover.generateProof(inputs, {
-   *   onProgress: (progress) => console.log(`Progress: ${progress}%`),
-   *   onStart: () => console.log("Starting proof generation..."),
-   *   onSuccess: (result) => console.log("Proof generated!"),
-   *   onError: (error) => console.error("Failed:", error)
-   * });
-   * ```
-   */
-  async generateProof(inputs, options) {
-    const startTime = Date.now();
-    const actualTimeout = options?.timeout || this.timeout;
-    options?.onStart?.();
-    let progressInterval;
-    try {
-      const requestBody = {
-        private_inputs: JSON.stringify(inputs.privateInputs),
-        public_inputs: JSON.stringify(inputs.publicInputs),
-        outputs: JSON.stringify(inputs.outputs)
-      };
-      if (inputs.swapParams) {
-        requestBody.swap_params = inputs.swapParams;
-      }
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), actualTimeout);
-      if (options?.onProgress) {
-        let progress = 0;
-        progressInterval = setInterval(() => {
-          progress = Math.min(90, progress + Math.random() * 10);
-          options.onProgress(Math.floor(progress));
-        }, 2e3);
-      }
-      const response = await fetch(`${this.indexerUrl}/api/v1/prove`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody),
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (progressInterval) clearInterval(progressInterval);
-      if (!response.ok) {
-        let errorMessage = `${response.status} ${response.statusText}`;
-        try {
-          const errorText = await response.text();
-          try {
-            const errorJson = JSON.parse(errorText);
-            errorMessage = errorJson.error || errorJson.message || errorText;
-          } catch {
-            errorMessage = errorText || errorMessage;
-          }
-        } catch {
-        }
-        options?.onError?.(errorMessage);
-        return {
-          success: false,
-          generationTimeMs: Date.now() - startTime,
-          error: errorMessage
-        };
-      }
-      options?.onProgress?.(100);
-      const rawData = await response.json();
-      const result = {
-        success: rawData.success,
-        proof: rawData.proof,
-        publicInputs: rawData.public_inputs,
-        // Map snake_case
-        generationTimeMs: rawData.generation_time_ms || Date.now() - startTime,
-        error: rawData.error
-      };
-      if (!result.success && rawData.execution_report) {
-      }
-      if (!result.success && result.error) {
-        try {
-          const errorObj = typeof result.error === "string" ? JSON.parse(result.error) : result.error;
-          if (errorObj?.error && typeof errorObj.error === "string") {
-            result.error = errorObj.error;
-          } else if (typeof errorObj === "string") {
-            result.error = errorObj;
-          }
-          if (errorObj?.execution_report && typeof errorObj.execution_report === "string") {
-            result.error += `
-Execution report: ${errorObj.execution_report}`;
-          }
-          if (errorObj?.total_cycles !== void 0) {
-            result.error += `
-Total cycles: ${errorObj.total_cycles}`;
-          }
-          if (errorObj?.total_syscalls !== void 0) {
-            result.error += `
-Total syscalls: ${errorObj.total_syscalls}`;
-          }
-        } catch {
-        }
-      }
-      if (result.success) {
-        options?.onSuccess?.(result);
-      } else if (result.error) {
-        options?.onError?.(result.error);
-      }
-      return result;
-    } catch (error) {
-      const totalTime = Date.now() - startTime;
-      if (progressInterval) clearInterval(progressInterval);
-      let errorMessage;
-      if (error instanceof Error && error.name === "AbortError") {
-        errorMessage = `Proof generation timed out after ${actualTimeout}ms`;
-      } else {
-        errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-      }
-      options?.onError?.(errorMessage);
-      return {
-        success: false,
-        generationTimeMs: totalTime,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Check if the prover service is available
-   *
-   * @returns True if service is healthy
-   */
-  async healthCheck() {
-    try {
-      const response = await fetch(`${this.indexerUrl}/health`, {
-        method: "GET"
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get the configured timeout
-   */
-  getTimeout() {
-    return this.timeout;
-  }
-  /**
-   * Set a new timeout
-   */
-  setTimeout(timeout) {
-    if (timeout <= 0) {
-      throw new Error("Timeout must be positive");
-    }
-    this.timeout = timeout;
-  }
-};
-
 // src/helpers/wallet-integration.ts
 var import_web36 = require("@solana/web3.js");
 function validateWalletConnected(wallet) {
@@ -3443,7 +3264,6 @@ var VERSION = "1.0.0";
   LAMPORTS_PER_SOL,
   LocalStorageAdapter,
   MemoryStorageAdapter,
-  ProverService,
   RelayService,
   VARIABLE_FEE_RATE,
   VERSION,