@izi-noir/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2793 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/infra/provingSystems/Barretenberg.ts
+var Barretenberg_exports = {};
+__export(Barretenberg_exports, {
+  Barretenberg: () => Barretenberg
+});
+function stringToStream(content) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode(content));
+      controller.close();
+    }
+  });
+}
+function isNodeJs2() {
+  return typeof globalThis.process !== "undefined" && globalThis.process.versions != null && globalThis.process.versions.node != null;
+}
+async function createTempDir() {
+  if (!isNodeJs2()) {
+    return { basePath: "/", cleanup: null };
+  }
+  const fs = await import("fs/promises");
+  const os = await import("os");
+  const path = await import("path");
+  const basePath = await fs.mkdtemp(path.join(os.tmpdir(), "noir-circuit-"));
+  const cleanup = async () => {
+    await fs.rm(basePath, { recursive: true, force: true });
+  };
+  return { basePath, cleanup };
+}
+var import_noir_wasm, import_noir_js, import_bb, Barretenberg;
+var init_Barretenberg = __esm({
+  "src/infra/provingSystems/Barretenberg.ts"() {
+    "use strict";
+    import_noir_wasm = require("@noir-lang/noir_wasm");
+    import_noir_js = require("@noir-lang/noir_js");
+    import_bb = require("@aztec/bb.js");
+    Barretenberg = class {
+      async compile(noirCode) {
+        const { basePath, cleanup } = await createTempDir();
+        const fm = (0, import_noir_wasm.createFileManager)(basePath);
+        const nargoToml = `[package]
+name = "circuit"
+type = "bin"
+authors = [""]
+
+[dependencies]
+`;
+        try {
+          if (isNodeJs2()) {
+            await fm.writeFile("./src/main.nr", stringToStream(noirCode));
+            await fm.writeFile("./Nargo.toml", stringToStream(nargoToml));
+          } else {
+            fm.writeFile("./src/main.nr", stringToStream(noirCode));
+            fm.writeFile("./Nargo.toml", stringToStream(nargoToml));
+          }
+          const result = await (0, import_noir_wasm.compile)(fm);
+          const compiled = result.program;
+          if (!compiled || !compiled.bytecode) {
+            throw new Error("Compilation failed: no bytecode generated");
+          }
+          return compiled;
+        } finally {
+          if (cleanup) {
+            await cleanup();
+          }
+        }
+      }
+      async generateProof(circuit, inputs) {
+        const noir = new import_noir_js.Noir(circuit);
+        const { witness } = await noir.execute(inputs);
+        const barretenberg = await import_bb.Barretenberg.new({ threads: 1 });
+        const backend = new import_bb.UltraHonkBackend(circuit.bytecode, barretenberg);
+        try {
+          const proofData = await backend.generateProof(witness);
+          return {
+            proof: proofData.proof,
+            publicInputs: proofData.publicInputs || []
+          };
+        } finally {
+          await barretenberg.destroy();
+        }
+      }
+      async verifyProof(circuit, proof, publicInputs) {
+        const barretenberg = await import_bb.Barretenberg.new({ threads: 1 });
+        const backend = new import_bb.UltraHonkBackend(circuit.bytecode, barretenberg);
+        try {
+          return await backend.verifyProof({ proof, publicInputs });
+        } finally {
+          await barretenberg.destroy();
+        }
+      }
+    };
+  }
+});
+
+// src/infra/provingSystems/ArkworksWasm.ts
+var ArkworksWasm_exports = {};
+__export(ArkworksWasm_exports, {
+  ArkworksWasm: () => ArkworksWasm,
+  isArkworksCircuit: () => isArkworksCircuit
+});
+function stringToStream2(content) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode(content));
+      controller.close();
+    }
+  });
+}
+function isNodeJs3() {
+  return typeof globalThis.process !== "undefined" && globalThis.process.versions != null && globalThis.process.versions.node != null;
+}
+async function createTempDir2() {
+  if (!isNodeJs3()) {
+    return { basePath: "/", cleanup: null };
+  }
+  const fs = await import("fs/promises");
+  const os = await import("os");
+  const path = await import("path");
+  const basePath = await fs.mkdtemp(path.join(os.tmpdir(), "arkworks-circuit-"));
+  const cleanup = async () => {
+    await fs.rm(basePath, { recursive: true, force: true });
+  };
+  return { basePath, cleanup };
+}
+function isArkworksCircuit(circuit) {
+  return "__arkworks" in circuit && circuit.__arkworks === true;
+}
+async function initWasm() {
+  if (wasmModule) {
+    return wasmModule;
+  }
+  if (wasmInitPromise2) {
+    return wasmInitPromise2;
+  }
+  wasmInitPromise2 = (async () => {
+    try {
+      if (isNodeJs3()) {
+        const module2 = await import("../wasm/nodejs/arkworks_groth16_wasm.js");
+        wasmModule = module2;
+      } else {
+        const module2 = await import("../wasm/web/arkworks_groth16_wasm.js");
+        if (typeof module2.default === "function") {
+          await module2.default();
+        }
+        wasmModule = module2;
+      }
+      return wasmModule;
+    } catch (error) {
+      wasmInitPromise2 = null;
+      throw new Error(
+        `Failed to initialize arkworks-groth16-wasm: ${error instanceof Error ? error.message : String(error)}
+Make sure the WASM module is built: cd packages/arkworks-groth16-wasm && npm run build`
+      );
+    }
+  })();
+  return wasmInitPromise2;
+}
+function base64ToUint8Array(b64) {
+  const binaryString = atob(b64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function publicInputsToGnarkBase64(publicInputs) {
+  const FIELD_SIZE2 = 32;
+  const bytes = new Uint8Array(publicInputs.length * FIELD_SIZE2);
+  for (let i = 0; i < publicInputs.length; i++) {
+    const input = publicInputs[i];
+    const hex = input.startsWith("0x") ? input.slice(2) : input;
+    const inputBytes = hexToBytes(hex.padStart(64, "0"));
+    bytes.set(inputBytes, i * FIELD_SIZE2);
+  }
+  return uint8ArrayToBase64(bytes);
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+var import_noir_wasm2, import_noir_js2, wasmModule, wasmInitPromise2, ArkworksWasm;
+var init_ArkworksWasm = __esm({
+  "src/infra/provingSystems/ArkworksWasm.ts"() {
+    "use strict";
+    import_noir_wasm2 = require("@noir-lang/noir_wasm");
+    import_noir_js2 = require("@noir-lang/noir_js");
+    wasmModule = null;
+    wasmInitPromise2 = null;
+    ArkworksWasm = class {
+      config;
+      constructor(config = {}) {
+        this.config = {
+          keepArtifacts: false,
+          cacheKeys: true,
+          ...config
+        };
+      }
+      /**
+       * Compile Noir code to a circuit with ACIR for Groth16 proving
+       */
+      async compile(noirCode) {
+        const wasm = await initWasm();
+        const { basePath, cleanup } = await createTempDir2();
+        const fm = (0, import_noir_wasm2.createFileManager)(basePath);
+        const nargoToml = `[package]
+name = "circuit"
+type = "bin"
+authors = [""]
+
+[dependencies]
+`;
+        try {
+          if (isNodeJs3()) {
+            await fm.writeFile("./src/main.nr", stringToStream2(noirCode));
+            await fm.writeFile("./Nargo.toml", stringToStream2(nargoToml));
+          } else {
+            fm.writeFile("./src/main.nr", stringToStream2(noirCode));
+            fm.writeFile("./Nargo.toml", stringToStream2(nargoToml));
+          }
+          const result = await (0, import_noir_wasm2.compile)(fm);
+          const compiled = result.program;
+          if (!compiled || !compiled.bytecode) {
+            throw new Error("Compilation failed: no bytecode generated");
+          }
+          const acirJson = JSON.stringify({
+            functions: [
+              {
+                current_witness_index: compiled.abi.parameters.length + 1,
+                opcodes: [],
+                // Will be extracted from bytecode during prove
+                private_parameters: compiled.abi.parameters.filter((p) => p.visibility === "private").map((_, i) => i + 1),
+                public_parameters: {
+                  witnesses: compiled.abi.parameters.filter((p) => p.visibility === "public").map((_, i) => i + 1)
+                },
+                return_values: { witnesses: [] }
+              }
+            ]
+          });
+          let provingKey;
+          let verifyingKey;
+          let verifyingKeyGnark;
+          if (this.config.cacheKeys) {
+            try {
+              const setupResult = wasm.setup(acirJson);
+              provingKey = setupResult.proving_key;
+              verifyingKey = setupResult.verifying_key;
+              verifyingKeyGnark = setupResult.verifying_key_gnark;
+            } catch (error) {
+              console.warn("Deferred setup: will run during proof generation");
+            }
+          }
+          const arkworksCircuit = {
+            ...compiled,
+            __arkworks: true,
+            acirJson,
+            provingKey,
+            verifyingKey,
+            verifyingKeyGnark
+          };
+          return arkworksCircuit;
+        } finally {
+          if (cleanup) {
+            await cleanup();
+          }
+        }
+      }
+      /**
+       * Generate a Groth16 proof
+       */
+      async generateProof(circuit, inputs) {
+        const wasm = await initWasm();
+        if (!isArkworksCircuit(circuit)) {
+          throw new Error(
+            "ArkworksWasm.generateProof requires an ArkworksCompiledCircuit. Use ArkworksWasm.compile() first."
+          );
+        }
+        const noir = new import_noir_js2.Noir(circuit);
+        const { witness } = await noir.execute(inputs);
+        const witnessMap = {};
+        for (const [index, value] of witness.entries()) {
+          witnessMap[index.toString()] = String(value);
+        }
+        const witnessJson = JSON.stringify(witnessMap);
+        let provingKey = circuit.provingKey;
+        if (!provingKey) {
+          const setupResult = wasm.setup(circuit.acirJson);
+          provingKey = setupResult.proving_key;
+          circuit.provingKey = provingKey;
+          circuit.verifyingKey = setupResult.verifying_key;
+          circuit.verifyingKeyGnark = setupResult.verifying_key_gnark;
+        }
+        const proofResult = wasm.prove(provingKey, circuit.acirJson, witnessJson);
+        const proofBytes = base64ToUint8Array(proofResult.proof_gnark);
+        return {
+          proof: proofBytes,
+          publicInputs: proofResult.public_inputs
+        };
+      }
+      /**
+       * Verify a Groth16 proof
+       */
+      async verifyProof(circuit, proof, publicInputs) {
+        const wasm = await initWasm();
+        if (!isArkworksCircuit(circuit)) {
+          throw new Error(
+            "ArkworksWasm.verifyProof requires an ArkworksCompiledCircuit. Use ArkworksWasm.compile() first."
+          );
+        }
+        let verifyingKeyGnark = circuit.verifyingKeyGnark;
+        if (!verifyingKeyGnark) {
+          const setupResult = wasm.setup(circuit.acirJson);
+          circuit.provingKey = setupResult.proving_key;
+          circuit.verifyingKey = setupResult.verifying_key;
+          verifyingKeyGnark = setupResult.verifying_key_gnark;
+          circuit.verifyingKeyGnark = verifyingKeyGnark;
+        }
+        const proofB64 = uint8ArrayToBase64(proof);
+        const publicInputsGnarkB64 = publicInputsToGnarkBase64(publicInputs);
+        return wasm.verify_gnark(
+          verifyingKeyGnark,
+          proofB64,
+          publicInputsGnarkB64,
+          publicInputs.length
+        );
+      }
+      /**
+       * Get the verifying key in gnark format for on-chain deployment
+       */
+      async getVerifyingKeyGnark(circuit) {
+        const wasm = await initWasm();
+        if (!isArkworksCircuit(circuit)) {
+          throw new Error("getVerifyingKeyGnark requires an ArkworksCompiledCircuit");
+        }
+        if (!circuit.verifyingKeyGnark) {
+          const setupResult = wasm.setup(circuit.acirJson);
+          circuit.provingKey = setupResult.proving_key;
+          circuit.verifyingKey = setupResult.verifying_key;
+          circuit.verifyingKeyGnark = setupResult.verifying_key_gnark;
+        }
+        return base64ToUint8Array(circuit.verifyingKeyGnark);
+      }
+    };
+  }
+});
+
+// src/infra/chainFormatters/SolanaFormatter.ts
+var SolanaFormatter_exports = {};
+__export(SolanaFormatter_exports, {
+  SolanaFormatter: () => SolanaFormatter
+});
+var G1_SIZE, G2_SIZE, SolanaFormatter;
+var init_SolanaFormatter = __esm({
+  "src/infra/chainFormatters/SolanaFormatter.ts"() {
+    "use strict";
+    G1_SIZE = 64;
+    G2_SIZE = 128;
+    SolanaFormatter = class {
+      constructor(arkworksProvider) {
+        this.arkworksProvider = arkworksProvider;
+      }
+      chainId = "solana";
+      /**
+       * Format a generic proof for Solana on-chain verification.
+       *
+       * @param proofData - Generic proof data from Arkworks
+       * @param circuit - The compiled circuit (must be Arkworks circuit)
+       * @param metadata - Circuit metadata with public input count
+       * @returns SolanaProofData ready for on-chain verification
+       */
+      async formatProof(proofData, circuit, metadata) {
+        const vkBytes = await this.arkworksProvider.getVerifyingKeyGnark(circuit);
+        const vkBase64 = this.uint8ArrayToBase64(vkBytes);
+        const nrPublicInputs = metadata.numPublicInputs;
+        const publicInputsBytes = proofData.publicInputs.map((input) => {
+          const hex = input.startsWith("0x") ? input.slice(2) : input;
+          return this.hexToBytes(hex.padStart(64, "0"));
+        });
+        const { accountSize, estimatedRent } = this.getChainMetadata(nrPublicInputs);
+        return {
+          verifyingKey: {
+            base64: vkBase64,
+            bytes: vkBytes,
+            nrPublicInputs
+          },
+          proof: {
+            base64: this.uint8ArrayToBase64(proofData.proof),
+            bytes: proofData.proof
+          },
+          publicInputs: {
+            hex: proofData.publicInputs,
+            bytes: publicInputsBytes
+          },
+          accountSize,
+          estimatedRent
+        };
+      }
+      /**
+       * Get Solana-specific metadata for a circuit.
+       *
+       * @param publicInputCount - Number of public inputs in the circuit
+       * @returns Solana metadata with account size and rent estimates
+       */
+      getChainMetadata(publicInputCount) {
+        const accountSize = this.calculateVkAccountSize(publicInputCount);
+        const estimatedRent = this.calculateVkAccountRent(publicInputCount);
+        return {
+          chainId: "solana",
+          accountSize,
+          estimatedRent
+        };
+      }
+      /**
+       * Calculate the size of a VK account for a given number of public inputs.
+       * Matches the Rust `vk_account_size` function in the Solana program.
+       */
+      calculateVkAccountSize(nrPublicInputs) {
+        const fixedSize = 8 + 32 + 1 + G1_SIZE + G2_SIZE * 3 + 4;
+        return fixedSize + (nrPublicInputs + 1) * G1_SIZE;
+      }
+      /**
+       * Calculate the minimum rent for a VK account.
+       */
+      calculateVkAccountRent(nrPublicInputs, rentExemptionPerByte = 6960) {
+        const size = this.calculateVkAccountSize(nrPublicInputs);
+        return size * rentExemptionPerByte;
+      }
+      /**
+       * Convert Uint8Array to base64 string.
+       */
+      uint8ArrayToBase64(bytes) {
+        if (typeof btoa === "function") {
+          let binary = "";
+          for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          return btoa(binary);
+        }
+        return Buffer.from(bytes).toString("base64");
+      }
+      /**
+       * Convert hex string to Uint8Array.
+       */
+      hexToBytes(hex) {
+        const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+        const bytes = new Uint8Array(cleanHex.length / 2);
+        for (let i = 0; i < bytes.length; i++) {
+          bytes[i] = parseInt(cleanHex.substring(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AcornParser: () => AcornParser,
+  ArkworksWasm: () => ArkworksWasm,
+  Barretenberg: () => Barretenberg,
+  Chain: () => Chain,
+  CircuitRegistry: () => CircuitRegistry,
+  CreateProofUseCase: () => CreateProofUseCase,
+  IZI_NOIR_PROGRAM_ID: () => IZI_NOIR_PROGRAM_ID,
+  IziNoir: () => IziNoir,
+  NETWORK_ENDPOINTS: () => NETWORK_ENDPOINTS,
+  OffchainVerifier: () => OffchainVerifier,
+  Provider: () => Provider,
+  SolanaFormatter: () => SolanaFormatter,
+  SolanaTransactionBuilder: () => SolanaTransactionBuilder,
+  VkDeploymentManager: () => VkDeploymentManager,
+  batchVerify: () => batchVerify,
+  buildInitVkFromBytesData: () => buildInitVkFromBytesData,
+  buildVerifyProofData: () => buildVerifyProofData,
+  calculateVkAccountRent: () => calculateVkAccountRent,
+  calculateVkAccountSize: () => calculateVkAccountSize,
+  createArkworksWasmContainer: () => createArkworksWasmContainer,
+  createDefaultContainer: () => createDefaultContainer,
+  createNodeVkDeploymentManager: () => createNodeVkDeploymentManager,
+  createVerificationEndpoint: () => createVerificationEndpoint,
+  createVerifierMiddleware: () => createVerifierMiddleware,
+  defineCircuit: () => defineCircuit,
+  generateNoir: () => generateNoir,
+  getGlobalRegistry: () => getGlobalRegistry,
+  initNoirWasm: () => initNoirWasm,
+  isArkworksCircuit: () => isArkworksCircuit,
+  isWasmInitialized: () => isWasmInitialized,
+  markWasmInitialized: () => markWasmInitialized,
+  parseProof: () => parseProof,
+  parsePublicInputs: () => parsePublicInputs,
+  parseVerifyingKey: () => parseVerifyingKey
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/domain/types/chain.ts
+var Chain = /* @__PURE__ */ ((Chain2) => {
+  Chain2["Solana"] = "solana";
+  Chain2["Ethereum"] = "ethereum";
+  return Chain2;
+})(Chain || {});
+
+// src/domain/types/provider.ts
+var Provider = /* @__PURE__ */ ((Provider2) => {
+  Provider2["Barretenberg"] = "barretenberg";
+  Provider2["Arkworks"] = "arkworks";
+  Provider2["Sunspot"] = "sunspot";
+  return Provider2;
+})(Provider || {});
+
+// src/infra/wasm/wasmInit.ts
+var wasmInitPromise = null;
+var wasmInitialized = false;
+function isNodeJs() {
+  return typeof globalThis.process !== "undefined" && globalThis.process.versions != null && globalThis.process.versions.node != null;
+}
+async function initNoirWasm() {
+  if (wasmInitialized) return;
+  if (!wasmInitPromise) {
+    wasmInitPromise = initWasmInternal();
+  }
+  await wasmInitPromise;
+  wasmInitialized = true;
+}
+async function initWasmInternal() {
+  if (isNodeJs()) {
+    await import("@noir-lang/acvm_js/nodejs/acvm_js.js");
+    await import("@noir-lang/noirc_abi/nodejs/noirc_abi_wasm.js");
+  } else {
+    const [{ default: initACVM }, { default: initNoirC }] = await Promise.all([
+      import("@noir-lang/acvm_js"),
+      import("@noir-lang/noirc_abi")
+    ]);
+    await Promise.all([initACVM(), initNoirC()]);
+  }
+}
+function isWasmInitialized() {
+  return wasmInitialized;
+}
+function markWasmInitialized() {
+  wasmInitialized = true;
+}
+
+// src/IziNoir.ts
+var IziNoir = class _IziNoir {
+  provingSystem;
+  compiledCircuit = null;
+  chainFormatters = /* @__PURE__ */ new Map();
+  chain;
+  _verifyingKey;
+  _lastProof;
+  constructor(provingSystem, chain) {
+    this.provingSystem = provingSystem;
+    this.chain = chain;
+  }
+  /**
+   * Get the verifying key from the last proof generation.
+   * Only available after calling prove() with a chain configured.
+   */
+  get vk() {
+    return this._verifyingKey;
+  }
+  /**
+   * Get the configured chain, if any.
+   */
+  get targetChain() {
+    return this.chain;
+  }
+  /**
+   * Check if operating in offchain mode (no chain configured).
+   */
+  get isOffchain() {
+    return this.chain === void 0;
+  }
+  /**
+   * Register a chain formatter for chain-specific proof formatting.
+   *
+   * @param formatter - The chain formatter to register
+   */
+  registerChainFormatter(formatter) {
+    this.chainFormatters.set(formatter.chainId, formatter);
+  }
+  /**
+   * Get a registered chain formatter.
+   *
+   * @param chainId - The chain ID to get the formatter for
+   * @returns The formatter or undefined if not registered
+   */
+  getChainFormatter(chainId) {
+    return this.chainFormatters.get(chainId);
+  }
+  /**
+   * Initialize IziNoir with the specified provider and optional chain.
+   *
+   * @param config - Configuration specifying the provider, chain, and optional circuit paths
+   * @returns Initialized IziNoir instance
+   *
+   * @example
+   * ```typescript
+   * // On-chain mode (Solana)
+   * const izi = await IziNoir.init({
+   *   provider: Provider.Arkworks,
+   *   chain: Chain.Solana
+   * });
+   *
+   * // Offchain mode (no chain formatting)
+   * const iziOffchain = await IziNoir.init({
+   *   provider: Provider.Arkworks
+   * });
+   *
+   * // Barretenberg (browser-compatible, ~16KB proofs, offchain only)
+   * const bb = await IziNoir.init({ provider: Provider.Barretenberg });
+   * ```
+   */
+  static async init(config) {
+    await initNoirWasm();
+    let provingSystem;
+    switch (config.provider) {
+      case "barretenberg" /* Barretenberg */: {
+        if (config.chain) {
+          throw new Error(
+            "Barretenberg provider does not support chain formatting. Use Provider.Arkworks for on-chain proofs."
+          );
+        }
+        const { Barretenberg: Barretenberg2 } = await Promise.resolve().then(() => (init_Barretenberg(), Barretenberg_exports));
+        provingSystem = new Barretenberg2();
+        return new _IziNoir(provingSystem);
+      }
+      case "arkworks" /* Arkworks */: {
+        const { ArkworksWasm: ArkworksWasm2 } = await Promise.resolve().then(() => (init_ArkworksWasm(), ArkworksWasm_exports));
+        const arkworksInstance = new ArkworksWasm2();
+        provingSystem = arkworksInstance;
+        const instance = new _IziNoir(provingSystem, config.chain);
+        if (config.chain === "solana" /* Solana */ || !config.chain) {
+          const { SolanaFormatter: SolanaFormatter2 } = await Promise.resolve().then(() => (init_SolanaFormatter(), SolanaFormatter_exports));
+          instance.registerChainFormatter(new SolanaFormatter2(arkworksInstance));
+        }
+        return instance;
+      }
+      case "sunspot" /* Sunspot */: {
+        throw new Error(
+          'Sunspot is not available in the main entry point. Import from "@izi-noir/sdk/sunspot" for Sunspot support.'
+        );
+      }
+      default:
+        throw new Error(`Unknown provider: ${config.provider}`);
+    }
+  }
+  /**
+   * Get the underlying proving system instance.
+   * Useful for advanced use cases.
+   */
+  getProvingSystem() {
+    return this.provingSystem;
+  }
+  /**
+   * Get the currently compiled circuit, if any.
+   */
+  getCompiledCircuit() {
+    return this.compiledCircuit;
+  }
+  /**
+   * Compile Noir code into a circuit.
+   *
+   * @param noirCode - The Noir source code to compile
+   * @returns The compiled circuit
+   */
+  async compile(noirCode) {
+    this.compiledCircuit = await this.provingSystem.compile(noirCode);
+    return this.compiledCircuit;
+  }
+  /**
+   * Generate a proof for the given inputs.
+   *
+   * If a chain is configured, returns chain-formatted proof data and stores
+   * the verifying key in `this.vk`. Otherwise, returns raw proof data.
+   *
+   * @param inputs - The inputs (both public and private) for the circuit
+   * @param circuit - Optional circuit to use (defaults to last compiled circuit)
+   * @returns The proof data - type depends on configured chain
+   * @throws Error if no circuit is available
+   *
+   * @example
+   * ```typescript
+   * // With chain configured - returns SolanaProofData
+   * const izi = await IziNoir.init({ provider: Provider.Arkworks, chain: Chain.Solana });
+   * await izi.compile(noirCode);
+   * const proof = await izi.prove({ expected: '100', secret: '10' });
+   * // proof is SolanaProofData, izi.vk is available
+   *
+   * // Offchain mode - returns ProofData
+   * const iziOffchain = await IziNoir.init({ provider: Provider.Arkworks });
+   * await iziOffchain.compile(noirCode);
+   * const rawProof = await iziOffchain.prove({ expected: '100', secret: '10' });
+   * // rawProof is ProofData, iziOffchain.vk is undefined
+   * ```
+   */
+  async prove(inputs, circuit) {
+    const circuitToUse = circuit || this.compiledCircuit;
+    if (!circuitToUse) {
+      throw new Error("No circuit available. Call compile() first or provide a circuit.");
+    }
+    const rawProof = await this.provingSystem.generateProof(circuitToUse, inputs);
+    if (!this.chain) {
+      this._lastProof = rawProof;
+      return rawProof;
+    }
+    const formatter = this.chainFormatters.get(this.chain);
+    if (!formatter) {
+      throw new Error(
+        `No formatter registered for chain: ${this.chain}. This is an internal error - please report it.`
+      );
+    }
+    const metadata = {
+      numPublicInputs: rawProof.publicInputs.length
+    };
+    const formattedProof = await formatter.formatProof(rawProof, circuitToUse, metadata);
+    const chainProof = formattedProof;
+    this._verifyingKey = chainProof.verifyingKey;
+    this._lastProof = chainProof;
+    return chainProof;
+  }
+  /**
+   * Verify a proof.
+   * Available in both on-chain and offchain modes.
+   *
+   * @param proof - The proof bytes to verify
+   * @param publicInputs - The public inputs that were used
+   * @param circuit - Optional circuit to use (defaults to last compiled circuit)
+   * @returns true if the proof is valid, false otherwise
+   * @throws Error if no circuit is available
+   */
+  async verify(proof, publicInputs, circuit) {
+    const circuitToUse = circuit || this.compiledCircuit;
+    if (!circuitToUse) {
+      throw new Error("No circuit available. Call compile() first or provide a circuit.");
+    }
+    return this.provingSystem.verifyProof(circuitToUse, proof, publicInputs);
+  }
+  /**
+   * Convenience method: compile, prove, and verify in one call.
+   *
+   * @param noirCode - The Noir source code to compile
+   * @param inputs - The inputs (both public and private) for the circuit
+   * @returns Object containing proof data and verification result
+   *
+   * @example
+   * ```typescript
+   * const { proof, verified } = await izi.createProof(noirCode, {
+   *   x: '100',
+   *   y: '10',
+   * });
+   * console.log(`Verified: ${verified}`);
+   * ```
+   */
+  async createProof(noirCode, inputs) {
+    const circuit = await this.compile(noirCode);
+    const proof = await this.prove(inputs, circuit);
+    const proofBytes = "proof" in proof && proof.proof instanceof Uint8Array ? proof.proof : proof.proof.bytes;
+    const pubInputs = Array.isArray(proof.publicInputs) ? proof.publicInputs : proof.publicInputs.hex;
+    const verified = await this.verify(proofBytes, pubInputs, circuit);
+    return { proof, verified };
+  }
+  /**
+   * Get deployment data for the verifying key.
+   * Returns the data needed to deploy to the configured blockchain.
+   * Use with SolanaTransactionBuilder to build and send the transaction.
+   *
+   * @param options - Optional configuration
+   * @returns Deployment data that can be used with SolanaTransactionBuilder
+   * @throws Error if no chain is configured (offchain mode)
+   * @throws Error if prove() hasn't been called yet
+   *
+   * @example
+   * ```typescript
+   * const izi = await IziNoir.init({ provider: Provider.Arkworks, chain: Chain.Solana });
+   * await izi.compile(noirCode);
+   * await izi.prove(inputs);
+   *
+   * // Get deployment data
+   * const deployData = izi.getDeployData();
+   *
+   * // Use with SolanaTransactionBuilder in your frontend
+   * const builder = new SolanaTransactionBuilder({ programId: deployData.programId });
+   * const { initVk, rentLamports, accountSize } = builder.buildInitAndVerifyInstructions(
+   *   deployData.proofData,
+   *   vkAccountPubkey,
+   *   authority,
+   *   payer
+   * );
+   * ```
+   */
+  getDeployData(options) {
+    if (!this.chain) {
+      throw new Error("Cannot deploy in offchain mode. Initialize with a chain parameter.");
+    }
+    if (!this._verifyingKey || !this._lastProof) {
+      throw new Error("Must call prove() before getDeployData().");
+    }
+    if (this.chain !== "solana" /* Solana */) {
+      throw new Error(`Deployment for ${this.chain} is not yet supported.`);
+    }
+    return {
+      proofData: this._lastProof,
+      programId: options?.programId ?? "EYhRED7EuMyyVjx57aDXUD9h6ArnEKng64qtz8999KrS",
+      computeUnits: options?.computeUnits ?? 4e5
+    };
+  }
+};
+
+// src/index.ts
+init_SolanaFormatter();
+init_Barretenberg();
+init_ArkworksWasm();
+
+// src/infra/parser/AcornParser.ts
+var acorn = __toESM(require("acorn"), 1);
+var walk = __toESM(require("acorn-walk"), 1);
+
+// src/infra/parser/operatorMaps.ts
+var BINARY_OPERATOR_MAP = {
+  // Equality
+  "==": "==",
+  "===": "==",
+  "!=": "!=",
+  "!==": "!=",
+  // Arithmetic
+  "+": "+",
+  "-": "-",
+  "*": "*",
+  "/": "/",
+  "%": "%",
+  // Comparison
+  "<": "<",
+  ">": ">",
+  "<=": "<=",
+  ">=": ">=",
+  // Logical (JS && and || map to Noir & and |)
+  "&&": "&",
+  "||": "|"
+};
+var UNARY_OPERATOR_MAP = {
+  "!": "!",
+  "-": "-"
+};
+
+// src/infra/parser/utils.ts
+var MUT_PREFIX = "mut_";
+function stripMutPrefix(name) {
+  return name.startsWith(MUT_PREFIX) ? name.slice(MUT_PREFIX.length) : name;
+}
+function isMutable(name) {
+  return name.startsWith(MUT_PREFIX);
+}
+
+// src/infra/parser/ExpressionParser.ts
+var ExpressionParser = class {
+  /**
+   * Parses an AST node into a circuit expression.
+   * @returns The parsed expression, or null if the node type is not recognized.
+   */
+  parse(node) {
+    switch (node.type) {
+      case "Identifier":
+        return this.parseIdentifier(node);
+      case "Literal":
+        return this.parseLiteral(node);
+      case "BinaryExpression":
+      case "LogicalExpression":
+        return this.parseBinaryExpression(node);
+      case "MemberExpression":
+        return this.parseMemberExpression(node);
+      case "ArrayExpression":
+        return this.parseArrayExpression(node);
+      case "CallExpression":
+        return this.parseCallExpression(node);
+      case "UnaryExpression":
+        return this.parseUnaryExpression(node);
+      case "ConditionalExpression":
+        return this.parseConditionalExpression(node);
+      default:
+        return null;
+    }
+  }
+  parseIdentifier(node) {
+    const name = node.name;
+    return { kind: "identifier", name: stripMutPrefix(name) };
+  }
+  parseLiteral(node) {
+    return { kind: "literal", value: node.value };
+  }
+  parseBinaryExpression(node) {
+    const operator = BINARY_OPERATOR_MAP[node.operator];
+    if (!operator) {
+      throw new Error(`Unsupported operator: ${node.operator}`);
+    }
+    const left = this.parse(node.left);
+    const right = this.parse(node.right);
+    if (!left || !right) {
+      throw new Error("Could not parse binary expression operands");
+    }
+    return { kind: "binary", left, operator, right };
+  }
+  parseMemberExpression(node) {
+    const obj = node.object;
+    const prop = node.property;
+    if (node.computed) {
+      const object = this.parse(obj);
+      const index = this.parse(prop);
+      if (!object || !index) {
+        throw new Error("Could not parse member expression");
+      }
+      return {
+        kind: "member",
+        object,
+        index
+      };
+    }
+    if (prop.type === "Identifier" && prop.name === "length") {
+      const object = this.parse(obj);
+      if (!object) {
+        throw new Error("Could not parse object for .length");
+      }
+      return {
+        kind: "call",
+        callee: object,
+        method: "len",
+        args: []
+      };
+    }
+    return null;
+  }
+  parseArrayExpression(node) {
+    const elements = [];
+    for (const elem of node.elements) {
+      if (elem) {
+        const parsed = this.parse(elem);
+        if (parsed) {
+          elements.push(parsed);
+        }
+      }
+    }
+    return {
+      kind: "array_literal",
+      elements
+    };
+  }
+  parseCallExpression(node) {
+    const callee = node.callee;
+    const args = [];
+    for (const arg of node.arguments) {
+      const parsed = this.parse(arg);
+      if (parsed) {
+        args.push(parsed);
+      }
+    }
+    if (callee.type === "MemberExpression" && !callee.computed) {
+      const obj = this.parse(callee.object);
+      const method = callee.property.name;
+      if (obj) {
+        return {
+          kind: "call",
+          callee: obj,
+          method,
+          args
+        };
+      }
+    }
+    const calleeExpr = this.parse(callee);
+    if (calleeExpr) {
+      return {
+        kind: "call",
+        callee: calleeExpr,
+        args
+      };
+    }
+    return null;
+  }
+  parseUnaryExpression(node) {
+    const unaryOp = UNARY_OPERATOR_MAP[node.operator];
+    if (!unaryOp) {
+      throw new Error(`Unsupported unary operator: ${node.operator}`);
+    }
+    if (node.operator === "-" && node.argument.type === "Literal") {
+      const val = node.argument.value;
+      if (typeof val === "number" || typeof val === "bigint") {
+        return { kind: "literal", value: -val };
+      }
+    }
+    const operand = this.parse(node.argument);
+    if (!operand) {
+      throw new Error("Could not parse unary expression operand");
+    }
+    return { kind: "unary", operator: unaryOp, operand };
+  }
+  parseConditionalExpression(node) {
+    const condition = this.parse(node.test);
+    const consequent = this.parse(node.consequent);
+    const alternate = this.parse(node.alternate);
+    if (!condition || !consequent || !alternate) {
+      throw new Error("Could not parse ternary expression");
+    }
+    return {
+      kind: "if_expr",
+      condition,
+      consequent,
+      alternate
+    };
+  }
+};
+
+// src/infra/parser/StatementParser.ts
+var StatementParser = class {
+  constructor(exprParser, forLoopParser) {
+    this.exprParser = exprParser;
+    this.forLoopParser = forLoopParser;
+  }
+  /**
+   * Parses a statement AST node.
+   * @returns The parsed statement, or null if the node type is not recognized.
+   */
+  parse(node) {
+    switch (node.type) {
+      case "VariableDeclaration":
+        return this.parseVariableDeclaration(node);
+      case "ExpressionStatement":
+        return this.parseExpressionStatement(node);
+      case "IfStatement":
+        return this.parseIfStatement(node);
+      case "ForStatement":
+        return this.forLoopParser.parse(node, (n) => this.parseBlock(n));
+      default:
+        return null;
+    }
+  }
+  /**
+   * Parses a block or single statement into an array of statements.
+   */
+  parseBlock(node) {
+    if (node.type === "BlockStatement") {
+      const statements = [];
+      for (const stmt of node.body) {
+        const parsed = this.parse(stmt);
+        if (parsed) {
+          statements.push(parsed);
+        }
+      }
+      return statements;
+    } else {
+      const parsed = this.parse(node);
+      return parsed ? [parsed] : [];
+    }
+  }
+  /**
+   * Parses variable declarations: let x = 5; const y = 10;
+   * Uses mut_ prefix convention for mutable variables.
+   */
+  parseVariableDeclaration(node) {
+    const declaration = node.declarations[0];
+    if (!declaration || declaration.type !== "VariableDeclarator") {
+      throw new Error("Invalid variable declaration");
+    }
+    const id = declaration.id;
+    if (id.type !== "Identifier") {
+      throw new Error("Variable declaration must have a simple identifier");
+    }
+    const init = declaration.init;
+    if (!init) {
+      throw new Error("Variable declaration must have an initializer");
+    }
+    const initializer = this.exprParser.parse(init);
+    if (!initializer) {
+      throw new Error("Could not parse variable initializer");
+    }
+    const name = id.name;
+    return {
+      kind: "variable_declaration",
+      name: stripMutPrefix(name),
+      mutable: isMutable(name),
+      initializer
+    };
+  }
+  /**
+   * Parses expression statements: assert(), assignments.
+   */
+  parseExpressionStatement(node) {
+    const expr = node.expression;
+    if (expr.type === "CallExpression") {
+      const callee = expr.callee;
+      if (callee.type === "Identifier" && callee.name === "assert") {
+        return this.parseAssertCall(expr);
+      }
+    }
+    if (expr.type === "AssignmentExpression") {
+      return this.parseAssignment(expr);
+    }
+    return null;
+  }
+  /**
+   * Parses assert() function calls.
+   */
+  parseAssertCall(expr) {
+    const args = expr.arguments;
+    if (args.length === 0) {
+      throw new Error("assert() requires at least one argument");
+    }
+    const condition = this.exprParser.parse(args[0]);
+    if (!condition) {
+      throw new Error("Could not parse assert condition");
+    }
+    const message = args.length > 1 && args[1].type === "Literal" ? String(args[1].value) : void 0;
+    return { kind: "assert", condition, message };
+  }
+  /**
+   * Parses assignment expressions: x = 5;
+   */
+  parseAssignment(expr) {
+    const left = expr.left;
+    const right = expr.right;
+    if (left.type !== "Identifier") {
+      throw new Error("Assignment target must be an identifier");
+    }
+    const value = this.exprParser.parse(right);
+    if (!value) {
+      throw new Error("Could not parse assignment value");
+    }
+    const name = left.name;
+    return {
+      kind: "assignment",
+      target: stripMutPrefix(name),
+      value
+    };
+  }
+  /**
+   * Parses if statements: if (condition) { ... } else { ... }
+   */
+  parseIfStatement(node) {
+    const condition = this.exprParser.parse(node.test);
+    if (!condition) {
+      throw new Error("Could not parse if condition");
+    }
+    const consequent = this.parseBlock(node.consequent);
+    const alternate = node.alternate ? this.parseBlock(node.alternate) : void 0;
+    return {
+      kind: "if_statement",
+      condition,
+      consequent,
+      alternate
+    };
+  }
+};
+
+// src/infra/parser/ForLoopParser.ts
+var ForLoopParser = class {
+  constructor(exprParser) {
+    this.exprParser = exprParser;
+  }
+  /**
+   * Parses a for statement into a circuit for_statement.
+   * @param node The ForStatement AST node
+   * @param parseBlock Function to parse the loop body
+   */
+  parse(node, parseBlock) {
+    const { variable, start } = this.validateInit(node.init);
+    const { end, inclusive } = this.validateTest(node.test, variable);
+    this.validateUpdate(node.update, variable);
+    const body = parseBlock(node.body);
+    return {
+      kind: "for_statement",
+      variable,
+      start,
+      end,
+      inclusive,
+      body
+    };
+  }
+  /**
+   * Validates the for loop initializer.
+   * Must be: `let i = start`
+   */
+  validateInit(init) {
+    if (!init || init.type !== "VariableDeclaration") {
+      throw new Error("For loop init must be a variable declaration (let i = start)");
+    }
+    const declaration = init.declarations[0];
+    if (!declaration || declaration.id.type !== "Identifier") {
+      throw new Error("For loop must declare a simple variable");
+    }
+    const variable = declaration.id.name;
+    const startInit = declaration.init;
+    if (!startInit) {
+      throw new Error("For loop variable must have an initializer");
+    }
+    const start = this.exprParser.parse(startInit);
+    if (!start) {
+      throw new Error("Could not parse for loop start value");
+    }
+    return { variable, start };
+  }
+  /**
+   * Validates the for loop test condition.
+   * Must be: `i < end` or `i <= end`
+   */
+  validateTest(test, variable) {
+    if (!test || test.type !== "BinaryExpression") {
+      throw new Error("For loop test must be a comparison (i < end or i <= end)");
+    }
+    const testLeft = test.left;
+    if (testLeft.type !== "Identifier" || testLeft.name !== variable) {
+      throw new Error("For loop test must compare the loop variable");
+    }
+    const operator = test.operator;
+    if (operator !== "<" && operator !== "<=") {
+      throw new Error("For loop test must use < or <= operator");
+    }
+    const end = this.exprParser.parse(test.right);
+    if (!end) {
+      throw new Error("Could not parse for loop end value");
+    }
+    return { end, inclusive: operator === "<=" };
+  }
+  /**
+   * Validates the for loop update expression.
+   * Must be: `i++`, `++i`, or `i = i + 1`
+   */
+  validateUpdate(update, variable) {
+    if (!update) {
+      throw new Error("For loop must have an update expression");
+    }
+    if (!this.isSimpleIncrement(update, variable)) {
+      throw new Error("For loop update must be i++ or i = i + 1 or ++i");
+    }
+  }
+  /**
+   * Checks if an expression is a simple increment of the variable.
+   * Accepts: i++, ++i, i = i + 1
+   */
+  isSimpleIncrement(node, variable) {
+    if (node.type === "UpdateExpression") {
+      const arg = node.argument;
+      return node.operator === "++" && arg.type === "Identifier" && arg.name === variable;
+    }
+    if (node.type === "AssignmentExpression") {
+      const left = node.left;
+      const right = node.right;
+      if (left.type !== "Identifier" || left.name !== variable) {
+        return false;
+      }
+      if (right.type === "BinaryExpression") {
+        const binLeft = right.left;
+        const binRight = right.right;
+        return right.operator === "+" && binLeft.type === "Identifier" && binLeft.name === variable && binRight.type === "Literal" && binRight.value === 1;
+      }
+    }
+    return false;
+  }
+};
+
+// src/infra/parser/AcornParser.ts
+var AcornParser = class {
+  exprParser = new ExpressionParser();
+  forLoopParser = new ForLoopParser(this.exprParser);
+  stmtParser = new StatementParser(this.exprParser, this.forLoopParser);
+  /**
+   * Parses a circuit function into public/private parameters and statements.
+   *
+   * @param fn The circuit function with signature ([public], [private]) => { ... }
+   * @param _publicInputs Public input values (used for validation, not parsing)
+   * @param _privateInputs Private input values (used for validation, not parsing)
+   */
+  parse(fn, _publicInputs, _privateInputs) {
+    const fnSource = fn.toString();
+    const ast = acorn.parse(`(${fnSource})`, {
+      ecmaVersion: 2022,
+      sourceType: "module"
+    });
+    const fnNode = this.findFunctionNode(ast);
+    const { publicParams, privateParams } = this.extractParameters(fnNode);
+    const statements = this.parseBody(fnNode);
+    return { publicParams, privateParams, statements };
+  }
+  /**
+   * Finds the arrow function or function expression in the AST.
+   */
+  findFunctionNode(ast) {
+    let fnNode = null;
+    walk.simple(ast, {
+      ArrowFunctionExpression(node) {
+        fnNode = node;
+      },
+      FunctionExpression(node) {
+        fnNode = node;
+      }
+    });
+    if (!fnNode) {
+      throw new Error("Could not find function in source");
+    }
+    return fnNode;
+  }
+  /**
+   * Extracts public and private parameters from the function signature.
+   * Expects pattern: ([pub1, pub2], [priv1, priv2]) => { ... }
+   */
+  extractParameters(fnNode) {
+    const params = fnNode.params;
+    if (params.length !== 2) {
+      throw new Error(
+        "Circuit function must have exactly 2 parameters: (publicArgs, privateArgs)"
+      );
+    }
+    const publicParams = [];
+    const privateParams = [];
+    const pubParam = params[0];
+    if (pubParam.type === "ArrayPattern") {
+      pubParam.elements.forEach((elem, idx) => {
+        if (elem && elem.type === "Identifier") {
+          publicParams.push({ name: elem.name, index: idx });
+        }
+      });
+    }
+    const privParam = params[1];
+    if (privParam.type === "ArrayPattern") {
+      privParam.elements.forEach((elem, idx) => {
+        if (elem && elem.type === "Identifier") {
+          privateParams.push({ name: elem.name, index: idx });
+        }
+      });
+    }
+    return { publicParams, privateParams };
+  }
+  /**
+   * Parses the function body into statements.
+   */
+  parseBody(fnNode) {
+    const body = fnNode.body;
+    const statements = [];
+    if (body.type === "BlockStatement") {
+      for (const stmt of body.body) {
+        const parsed = this.stmtParser.parse(stmt);
+        if (parsed) {
+          statements.push(parsed);
+        }
+      }
+    } else {
+      const expr = this.exprParser.parse(body);
+      if (expr) {
+        statements.push({ kind: "assert", condition: expr });
+      }
+    }
+    return statements;
+  }
+};
+
+// src/container.ts
+init_Barretenberg();
+init_ArkworksWasm();
+function createDefaultContainer() {
+  return {
+    parser: new AcornParser(),
+    provingSystem: new Barretenberg()
+  };
+}
+function createArkworksWasmContainer(config) {
+  return {
+    parser: new AcornParser(),
+    provingSystem: new ArkworksWasm(config)
+  };
+}
+
+// src/application/services/NoirGenerator.ts
+function generateNoir(circuit) {
+  const params = generateParams(circuit);
+  const body = generateBody(circuit.statements);
+  return `fn main(${params}) {
+${body}
+}
+`;
+}
+function generateParams(circuit) {
+  const allParams = [];
+  for (const param of circuit.privateParams) {
+    allParams.push(`${param.name}: Field`);
+  }
+  for (const param of circuit.publicParams) {
+    allParams.push(`${param.name}: pub Field`);
+  }
+  return allParams.join(", ");
+}
+function generateBody(statements, indent = 1) {
+  const lines = [];
+  const indentStr = "    ".repeat(indent);
+  for (const stmt of statements) {
+    const generated = generateStatement(stmt, indent);
+    if (generated.includes("\n")) {
+      lines.push(generated);
+    } else {
+      lines.push(`${indentStr}${generated}`);
+    }
+  }
+  return lines.join("\n");
+}
+function generateStatement(stmt, indent = 1) {
+  const indentStr = "    ".repeat(indent);
+  switch (stmt.kind) {
+    case "assert": {
+      const condition = generateExpr(stmt.condition);
+      if (stmt.message) {
+        return `assert(${condition}, "${stmt.message}");`;
+      }
+      return `assert(${condition});`;
+    }
+    case "variable_declaration": {
+      const init = generateExpr(stmt.initializer);
+      const mutKeyword = stmt.mutable ? "let mut" : "let";
+      const typeStr = inferType(stmt.initializer);
+      return `${mutKeyword} ${stmt.name}: ${typeStr} = ${init};`;
+    }
+    case "assignment": {
+      const value = generateExpr(stmt.value);
+      return `${stmt.target} = ${value};`;
+    }
+    case "if_statement": {
+      const condition = generateExpr(stmt.condition);
+      const consequentBody = generateBody(stmt.consequent, indent + 1);
+      let result = `${indentStr}if ${condition} {
+${consequentBody}
+${indentStr}}`;
+      if (stmt.alternate && stmt.alternate.length > 0) {
+        const alternateBody = generateBody(stmt.alternate, indent + 1);
+        result += ` else {
+${alternateBody}
+${indentStr}}`;
+      }
+      return result;
+    }
+    case "for_statement": {
+      const start = generateExpr(stmt.start);
+      const end = generateExpr(stmt.end);
+      const rangeOp = stmt.inclusive ? "..=" : "..";
+      const bodyContent = generateBody(stmt.body, indent + 1);
+      return `${indentStr}for ${stmt.variable} in ${start}${rangeOp}${end} {
+${bodyContent}
+${indentStr}}`;
+    }
+  }
+}
+function generateExpr(expr) {
+  switch (expr.kind) {
+    case "identifier":
+      return expr.name;
+    case "literal":
+      return formatLiteral(expr.value);
+    case "binary": {
+      const left = generateExpr(expr.left);
+      const right = generateExpr(expr.right);
+      return `${left} ${expr.operator} ${right}`;
+    }
+    case "unary": {
+      const operand = generateExpr(expr.operand);
+      if (expr.operand.kind === "binary") {
+        return `${expr.operator}(${operand})`;
+      }
+      return `${expr.operator}${operand}`;
+    }
+    case "member": {
+      const object = generateExpr(expr.object);
+      const index = generateExpr(expr.index);
+      return `${object}[${index}]`;
+    }
+    case "array_literal": {
+      const elements = expr.elements.map((e) => generateExpr(e)).join(", ");
+      return `[${elements}]`;
+    }
+    case "call": {
+      const args = expr.args.map((a) => generateExpr(a)).join(", ");
+      if (expr.method) {
+        const callee2 = generateExpr(expr.callee);
+        return `${callee2}.${expr.method}(${args})`;
+      }
+      const callee = generateExpr(expr.callee);
+      return `${callee}(${args})`;
+    }
+    case "if_expr": {
+      const condition = generateExpr(expr.condition);
+      const consequent = generateExpr(expr.consequent);
+      const alternate = generateExpr(expr.alternate);
+      return `if ${condition} { ${consequent} } else { ${alternate} }`;
+    }
+  }
+}
+function formatLiteral(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "string" && value.startsWith("0x")) {
+    return value;
+  }
+  return `"${value}"`;
+}
+function inferType(expr) {
+  switch (expr.kind) {
+    case "array_literal":
+      const elementType = expr.elements.length > 0 ? inferType(expr.elements[0]) : "Field";
+      return `[${elementType}; ${expr.elements.length}]`;
+    case "literal":
+      if (typeof expr.value === "boolean") {
+        return "bool";
+      }
+      return "Field";
+    case "if_expr":
+      return inferType(expr.consequent);
+    default:
+      return "Field";
+  }
+}
+
+// src/application/CreateProofUseCase.ts
+var CreateProofUseCase = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async execute(publicInputs, privateInputs, circuitFn) {
+    const totalStart = performance.now();
+    const timings = {
+      parseMs: 0,
+      generateMs: 0,
+      compileMs: 0,
+      witnessMs: 0,
+      proofMs: 0,
+      verifyMs: 0,
+      totalMs: 0
+    };
+    const parseStart = performance.now();
+    const parsed = this.deps.parser.parse(circuitFn, publicInputs, privateInputs);
+    timings.parseMs = performance.now() - parseStart;
+    const generateStart = performance.now();
+    const noirCode = generateNoir(parsed);
+    timings.generateMs = performance.now() - generateStart;
+    const compileStart = performance.now();
+    const circuit = await this.deps.provingSystem.compile(noirCode);
+    timings.compileMs = performance.now() - compileStart;
+    const toNoirInput = (val) => typeof val === "bigint" ? val.toString() : val;
+    const inputs = {};
+    for (const param of parsed.privateParams) {
+      inputs[param.name] = toNoirInput(privateInputs[param.index]);
+    }
+    for (const param of parsed.publicParams) {
+      inputs[param.name] = toNoirInput(publicInputs[param.index]);
+    }
+    const witnessStart = performance.now();
+    const { proof, publicInputs: proofPublicInputs } = await this.deps.provingSystem.generateProof(circuit, inputs);
+    const proofEnd = performance.now();
+    const proveTime = proofEnd - witnessStart;
+    timings.witnessMs = proveTime * 0.1;
+    timings.proofMs = proveTime * 0.9;
+    const verifyStart = performance.now();
+    const verified = await this.deps.provingSystem.verifyProof(circuit, proof, proofPublicInputs);
+    timings.verifyMs = performance.now() - verifyStart;
+    timings.totalMs = performance.now() - totalStart;
+    return {
+      proof,
+      publicInputs: proofPublicInputs,
+      verified,
+      noirCode,
+      timings
+    };
+  }
+};
+
+// src/providers/solana.ts
+var G1_SIZE2 = 64;
+var G2_SIZE2 = 128;
+var FIELD_SIZE = 32;
+var PROOF_SIZE = 256;
+var IZI_NOIR_PROGRAM_ID = "EYhRED7EuMyyVjx57aDXUD9h6ArnEKng64qtz8999KrS";
+function parseVerifyingKey(vkBase64, nrPubinputs) {
+  const vkBytes = base64ToBytes(vkBase64);
+  const expectedLen = G1_SIZE2 + G2_SIZE2 * 3 + G1_SIZE2 * (nrPubinputs + 1);
+  if (vkBytes.length !== expectedLen) {
+    throw new Error(
+      `Invalid VK size: expected ${expectedLen} bytes for ${nrPubinputs} public inputs, got ${vkBytes.length}`
+    );
+  }
+  let offset = 0;
+  const alphaG1 = vkBytes.slice(offset, offset + G1_SIZE2);
+  offset += G1_SIZE2;
+  const betaG2 = vkBytes.slice(offset, offset + G2_SIZE2);
+  offset += G2_SIZE2;
+  const gammaG2 = vkBytes.slice(offset, offset + G2_SIZE2);
+  offset += G2_SIZE2;
+  const deltaG2 = vkBytes.slice(offset, offset + G2_SIZE2);
+  offset += G2_SIZE2;
+  const k = [];
+  for (let i = 0; i <= nrPubinputs; i++) {
+    k.push(vkBytes.slice(offset, offset + G1_SIZE2));
+    offset += G1_SIZE2;
+  }
+  return { alphaG1, betaG2, gammaG2, deltaG2, k };
+}
+function parseProof(proofBase64) {
+  const proofBytes = base64ToBytes(proofBase64);
+  if (proofBytes.length !== PROOF_SIZE) {
+    throw new Error(`Invalid proof size: expected ${PROOF_SIZE} bytes, got ${proofBytes.length}`);
+  }
+  return {
+    a: proofBytes.slice(0, G1_SIZE2),
+    b: proofBytes.slice(G1_SIZE2, G1_SIZE2 + G2_SIZE2),
+    c: proofBytes.slice(G1_SIZE2 + G2_SIZE2, PROOF_SIZE)
+  };
+}
+function parsePublicInputs(inputs) {
+  return inputs.map((input) => {
+    if (input.startsWith("0x")) {
+      const hex2 = input.slice(2).padStart(64, "0");
+      return hexToBytes2(hex2);
+    }
+    const num = BigInt(input);
+    const hex = num.toString(16).padStart(64, "0");
+    return hexToBytes2(hex);
+  });
+}
+function calculateVkAccountSize(nrPubinputs) {
+  const fixedSize = 8 + 32 + 1 + G1_SIZE2 + G2_SIZE2 * 3 + 4;
+  return fixedSize + (nrPubinputs + 1) * G1_SIZE2;
+}
+function calculateVkAccountRent(nrPubinputs, rentExemptionPerByte = 6960) {
+  const size = calculateVkAccountSize(nrPubinputs);
+  return size * rentExemptionPerByte;
+}
+function base64ToBytes(base64) {
+  if (typeof atob === "function") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function hexToBytes2(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(cleanHex.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function buildInitVkFromBytesData(nrPubinputs, vkBytes) {
+  const discriminator = new Uint8Array([
+    166,
+    58,
+    82,
+    247,
+    19,
+    129,
+    138,
+    59
+  ]);
+  const vkLen = new Uint8Array(4);
+  new DataView(vkLen.buffer).setUint32(0, vkBytes.length, true);
+  const data = new Uint8Array(discriminator.length + 1 + 4 + vkBytes.length);
+  let offset = 0;
+  data.set(discriminator, offset);
+  offset += discriminator.length;
+  data[offset] = nrPubinputs;
+  offset += 1;
+  data.set(vkLen, offset);
+  offset += 4;
+  data.set(vkBytes, offset);
+  return data;
+}
+function buildVerifyProofData(proofBytes, publicInputs) {
+  const discriminator = new Uint8Array([
+    30,
+    8,
+    242,
+    54,
+    68,
+    154,
+    75,
+    92
+  ]);
+  if (proofBytes.length !== PROOF_SIZE) {
+    throw new Error(`Invalid proof size: expected ${PROOF_SIZE}, got ${proofBytes.length}`);
+  }
+  const proofVecLen = 4 + proofBytes.length;
+  const inputsVecLen = 4 + publicInputs.length * FIELD_SIZE;
+  const totalSize = discriminator.length + proofVecLen + inputsVecLen;
+  const data = new Uint8Array(totalSize);
+  let offset = 0;
+  data.set(discriminator, offset);
+  offset += discriminator.length;
+  new DataView(data.buffer).setUint32(offset, proofBytes.length, true);
+  offset += 4;
+  data.set(proofBytes, offset);
+  offset += proofBytes.length;
+  new DataView(data.buffer).setUint32(offset, publicInputs.length, true);
+  offset += 4;
+  for (const input of publicInputs) {
+    if (input.length !== FIELD_SIZE) {
+      throw new Error(`Invalid public input size: expected ${FIELD_SIZE}, got ${input.length}`);
+    }
+    data.set(input, offset);
+    offset += FIELD_SIZE;
+  }
+  return data;
+}
+
+// src/solana/TransactionBuilder.ts
+var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+var COMPUTE_BUDGET_PROGRAM_ID = "ComputeBudget111111111111111111111111111111";
+var SolanaTransactionBuilder = class {
+  programId;
+  computeUnits;
+  priorityFee;
+  constructor(config = {}) {
+    this.programId = config.programId ?? IZI_NOIR_PROGRAM_ID;
+    this.computeUnits = config.computeUnits ?? 4e5;
+    this.priorityFee = config.priorityFee ?? 0;
+  }
+  /**
+   * Builds the instruction data for initializing a VK account.
+   *
+   * @param solanaProofData - Proof data from `izi.proveForSolana()`
+   * @param accounts - Account public keys
+   * @returns Instruction data ready for transaction building
+   *
+   * @example
+   * ```typescript
+   * const initInstruction = builder.buildInitVkInstruction(solanaProofData, {
+   *   vkAccount: vkKeypair.publicKey.toBase58(),
+   *   authority: wallet.publicKey.toBase58(),
+   *   payer: wallet.publicKey.toBase58(),
+   * });
+   * ```
+   */
+  buildInitVkInstruction(solanaProofData, accounts) {
+    const data = buildInitVkFromBytesData(
+      solanaProofData.verifyingKey.nrPublicInputs,
+      solanaProofData.verifyingKey.bytes
+    );
+    return {
+      data,
+      programId: this.programId,
+      keys: [
+        { pubkey: accounts.vkAccount, isSigner: true, isWritable: true },
+        { pubkey: accounts.authority, isSigner: true, isWritable: false },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false }
+      ]
+    };
+  }
+  /**
+   * Builds the instruction data for verifying a proof.
+   *
+   * @param proofBytes - 256-byte Groth16 proof
+   * @param publicInputs - Array of 32-byte public inputs
+   * @param accounts - Account public keys
+   * @returns Instruction data ready for transaction building
+   *
+   * @example
+   * ```typescript
+   * const verifyInstruction = builder.buildVerifyProofInstruction(
+   *   solanaProofData.proof.bytes,
+   *   solanaProofData.publicInputs.bytes,
+   *   { vkAccount: vkAccountPubkey.toBase58() }
+   * );
+   * ```
+   */
+  buildVerifyProofInstruction(proofBytes, publicInputs, accounts) {
+    const data = buildVerifyProofData(proofBytes, publicInputs);
+    return {
+      data,
+      programId: this.programId,
+      keys: [
+        { pubkey: accounts.vkAccount, isSigner: false, isWritable: false }
+      ]
+    };
+  }
+  /**
+   * Builds the instruction data for closing a VK account.
+   *
+   * @param accounts - Account public keys
+   * @returns Instruction data ready for transaction building
+   */
+  buildCloseVkInstruction(accounts) {
+    const discriminator = new Uint8Array([
+      154,
+      71,
+      2,
+      43,
+      135,
+      151,
+      132,
+      74
+    ]);
+    return {
+      data: discriminator,
+      programId: this.programId,
+      keys: [
+        { pubkey: accounts.vkAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.authority, isSigner: true, isWritable: true }
+      ]
+    };
+  }
+  /**
+   * Builds a compute budget instruction to set compute unit limit.
+   *
+   * @param units - Number of compute units (default: configured value)
+   * @returns Instruction data
+   */
+  buildSetComputeUnitLimitInstruction(units) {
+    const cu = units ?? this.computeUnits;
+    const data = new Uint8Array(5);
+    data[0] = 2;
+    new DataView(data.buffer).setUint32(1, cu, true);
+    return {
+      data,
+      programId: COMPUTE_BUDGET_PROGRAM_ID,
+      keys: []
+    };
+  }
+  /**
+   * Builds a compute budget instruction to set priority fee.
+   *
+   * @param microLamports - Priority fee in microLamports per CU
+   * @returns Instruction data
+   */
+  buildSetComputeUnitPriceInstruction(microLamports) {
+    const fee = microLamports ?? this.priorityFee;
+    const data = new Uint8Array(9);
+    data[0] = 3;
+    const view = new DataView(data.buffer);
+    view.setBigUint64(1, BigInt(fee), true);
+    return {
+      data,
+      programId: COMPUTE_BUDGET_PROGRAM_ID,
+      keys: []
+    };
+  }
+  /**
+   * Builds all instructions needed to initialize a VK and verify a proof.
+   *
+   * This is a convenience method that combines:
+   * - Compute budget instructions (if configured)
+   * - Init VK instruction
+   * - Verify proof instruction
+   *
+   * @param solanaProofData - Proof data from `izi.proveForSolana()`
+   * @param vkAccountPubkey - Public key for the new VK account
+   * @param authorityPubkey - Authority for the VK account
+   * @param payerPubkey - Payer for the transaction
+   * @returns All instruction data and metadata
+   *
+   * @example
+   * ```typescript
+   * const result = builder.buildInitAndVerifyInstructions(
+   *   solanaProofData,
+   *   vkKeypair.publicKey.toBase58(),
+   *   wallet.publicKey.toBase58(),
+   *   wallet.publicKey.toBase58()
+   * );
+   *
+   * // Use with @solana/web3.js:
+   * const transaction = new Transaction();
+   * if (result.computeBudget) {
+   *   transaction.add(toTransactionInstruction(result.computeBudget));
+   * }
+   * transaction.add(toTransactionInstruction(result.initVk));
+   * // ... sign and send
+   * ```
+   */
+  buildInitAndVerifyInstructions(solanaProofData, vkAccountPubkey, authorityPubkey, payerPubkey) {
+    const result = {
+      initVk: this.buildInitVkInstruction(solanaProofData, {
+        vkAccount: vkAccountPubkey,
+        authority: authorityPubkey,
+        payer: payerPubkey
+      }),
+      verifyProof: this.buildVerifyProofInstruction(
+        solanaProofData.proof.bytes,
+        solanaProofData.publicInputs.bytes,
+        { vkAccount: vkAccountPubkey }
+      ),
+      rentLamports: solanaProofData.estimatedRent,
+      accountSize: solanaProofData.accountSize
+    };
+    if (this.computeUnits > 0) {
+      result.computeBudget = this.buildSetComputeUnitLimitInstruction();
+    }
+    if (this.priorityFee > 0) {
+      result.priorityFee = this.buildSetComputeUnitPriceInstruction();
+    }
+    return result;
+  }
+  /**
+   * Validates that SolanaProofData has the correct format.
+   *
+   * @param data - Proof data to validate
+   * @throws Error if validation fails
+   */
+  validateSolanaProofData(data) {
+    if (data.proof.bytes.length !== PROOF_SIZE) {
+      throw new Error(
+        `Invalid proof size: expected ${PROOF_SIZE} bytes, got ${data.proof.bytes.length}`
+      );
+    }
+    const expectedVkSize = G1_SIZE2 + G2_SIZE2 * 3 + G1_SIZE2 * (data.verifyingKey.nrPublicInputs + 1);
+    if (data.verifyingKey.bytes.length !== expectedVkSize) {
+      throw new Error(
+        `Invalid VK size: expected ${expectedVkSize} bytes for ${data.verifyingKey.nrPublicInputs} public inputs, got ${data.verifyingKey.bytes.length}`
+      );
+    }
+    for (let i = 0; i < data.publicInputs.bytes.length; i++) {
+      if (data.publicInputs.bytes[i].length !== FIELD_SIZE) {
+        throw new Error(
+          `Invalid public input ${i} size: expected ${FIELD_SIZE} bytes, got ${data.publicInputs.bytes[i].length}`
+        );
+      }
+    }
+    if (data.publicInputs.bytes.length !== data.verifyingKey.nrPublicInputs) {
+      throw new Error(
+        `Public inputs count mismatch: VK expects ${data.verifyingKey.nrPublicInputs}, got ${data.publicInputs.bytes.length}`
+      );
+    }
+  }
+  /**
+   * Gets the program ID being used.
+   */
+  getProgramId() {
+    return this.programId;
+  }
+  /**
+   * Gets the configured compute units.
+   */
+  getComputeUnits() {
+    return this.computeUnits;
+  }
+  /**
+   * Gets the configured priority fee.
+   */
+  getPriorityFee() {
+    return this.priorityFee;
+  }
+};
+
+// src/deployment/VkDeploymentManager.ts
+var NETWORK_ENDPOINTS = {
+  "mainnet-beta": "https://api.mainnet-beta.solana.com",
+  devnet: "https://api.devnet.solana.com",
+  testnet: "https://api.testnet.solana.com",
+  localnet: "http://localhost:8899"
+};
+var VkDeploymentManager = class {
+  config;
+  deployments;
+  builder;
+  dirty = false;
+  constructor(config) {
+    this.config = {
+      network: config.network,
+      rpcEndpoint: config.rpcEndpoint ?? NETWORK_ENDPOINTS[config.network],
+      configDir: config.configDir ?? ".izi-noir",
+      programId: config.programId ?? "",
+      computeUnits: config.computeUnits ?? 4e5
+    };
+    this.deployments = /* @__PURE__ */ new Map();
+    this.builder = new SolanaTransactionBuilder({
+      programId: this.config.programId || void 0,
+      computeUnits: this.config.computeUnits
+    });
+  }
+  /**
+   * Loads deployment state from disk.
+   *
+   * In browser environments, this is a no-op.
+   * In Node.js, reads from {configDir}/deployments.json
+   */
+  async load() {
+  }
+  /**
+   * Loads deployment state from a JSON object.
+   */
+  loadFromJson(state) {
+    this.deployments.clear();
+    for (const deployment of state.deployments) {
+      if (deployment.network === this.config.network) {
+        const key = this.makeDeploymentKey(deployment.circuitId, deployment.vkHash);
+        this.deployments.set(key, deployment);
+      }
+    }
+    this.dirty = false;
+  }
+  /**
+   * Saves deployment state.
+   *
+   * Returns the state object for custom persistence.
+   */
+  async save() {
+    const state = this.toJson();
+    this.dirty = false;
+    return state;
+  }
+  /**
+   * Exports deployment state to JSON.
+   */
+  toJson() {
+    return {
+      version: "1.0",
+      deployments: Array.from(this.deployments.values())
+    };
+  }
+  /**
+   * Ensures a VK is deployed, skipping if already exists.
+   *
+   * @returns Deployment result with VK account address
+   */
+  async ensureDeployed(options) {
+    const { circuitName, solanaProofData, authority, payer, forceRedeploy } = options;
+    const vkHash = await this.hashVkBytes(solanaProofData.verifyingKey.bytes);
+    const deploymentKey = this.makeDeploymentKey(circuitName, vkHash);
+    const existing = this.deployments.get(deploymentKey);
+    if (existing && !forceRedeploy) {
+      return {
+        deployed: false,
+        vkAccount: existing.vkAccount,
+        deployment: existing
+      };
+    }
+    const vkAccountPubkey = this.generateVkAccountPlaceholder();
+    const instructions = [];
+    instructions.push(this.builder.buildSetComputeUnitLimitInstruction());
+    const initVk = this.builder.buildInitVkInstruction(solanaProofData, {
+      vkAccount: vkAccountPubkey,
+      authority,
+      payer
+    });
+    instructions.push(initVk);
+    const signers = [
+      { pubkey: vkAccountPubkey, isNewKeypair: true, role: "vkAccount" },
+      { pubkey: authority, isNewKeypair: false, role: "authority" }
+    ];
+    if (payer !== authority) {
+      signers.push({ pubkey: payer, isNewKeypair: false, role: "payer" });
+    }
+    const txSignature = await options.sendTransaction(instructions, signers);
+    const deployment = {
+      circuitId: circuitName,
+      vkAccount: vkAccountPubkey,
+      authority,
+      deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      txSignature,
+      network: this.config.network,
+      vkHash,
+      nrPublicInputs: solanaProofData.verifyingKey.nrPublicInputs
+    };
+    this.deployments.set(deploymentKey, deployment);
+    this.dirty = true;
+    return {
+      deployed: true,
+      vkAccount: vkAccountPubkey,
+      txSignature,
+      deployment
+    };
+  }
+  /**
+   * Gets deployment by circuit name.
+   */
+  getDeployment(circuitName) {
+    for (const [key, deployment] of this.deployments) {
+      if (deployment.circuitId === circuitName) {
+        return deployment;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Gets deployment by VK hash.
+   */
+  getDeploymentByVkHash(vkHash) {
+    for (const deployment of this.deployments.values()) {
+      if (deployment.vkHash === vkHash) {
+        return deployment;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Gets all deployments.
+   */
+  getAllDeployments() {
+    return Array.from(this.deployments.values());
+  }
+  /**
+   * Checks if there are unsaved changes.
+   */
+  isDirty() {
+    return this.dirty;
+  }
+  /**
+   * Gets the RPC endpoint.
+   */
+  getRpcEndpoint() {
+    return this.config.rpcEndpoint;
+  }
+  /**
+   * Gets the network.
+   */
+  getNetwork() {
+    return this.config.network;
+  }
+  /**
+   * Prepares instructions for deployment without sending.
+   *
+   * Useful when you need to combine with other instructions
+   * or use a specific signing flow.
+   */
+  prepareDeployment(solanaProofData, accounts) {
+    const instructions = [];
+    instructions.push(this.builder.buildSetComputeUnitLimitInstruction());
+    instructions.push(
+      this.builder.buildInitVkInstruction(solanaProofData, {
+        vkAccount: accounts.vkAccount,
+        authority: accounts.authority,
+        payer: accounts.payer
+      })
+    );
+    const signers = [
+      { pubkey: accounts.vkAccount, isNewKeypair: true, role: "vkAccount" },
+      { pubkey: accounts.authority, isNewKeypair: false, role: "authority" }
+    ];
+    if (accounts.payer !== accounts.authority) {
+      signers.push({ pubkey: accounts.payer, isNewKeypair: false, role: "payer" });
+    }
+    return {
+      instructions,
+      signers,
+      rentLamports: solanaProofData.estimatedRent
+    };
+  }
+  /**
+   * Records an external deployment (made outside this manager).
+   */
+  recordDeployment(deployment) {
+    const key = this.makeDeploymentKey(deployment.circuitId, deployment.vkHash);
+    this.deployments.set(key, deployment);
+    this.dirty = true;
+  }
+  /**
+   * Removes a deployment record.
+   */
+  removeDeployment(circuitName) {
+    for (const [key, deployment] of this.deployments) {
+      if (deployment.circuitId === circuitName) {
+        this.deployments.delete(key);
+        this.dirty = true;
+        return true;
+      }
+    }
+    return false;
+  }
+  // Private helpers
+  makeDeploymentKey(circuitId, vkHash) {
+    return `${circuitId}:${vkHash.slice(0, 16)}`;
+  }
+  async hashVkBytes(bytes) {
+    if (typeof crypto !== "undefined" && crypto.subtle) {
+      const hashBuffer = await crypto.subtle.digest("SHA-256", bytes);
+      const hashArray = new Uint8Array(hashBuffer);
+      return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    let hash = 0;
+    for (let i = 0; i < bytes.length; i++) {
+      hash = (hash << 5) - hash + bytes[i] | 0;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+  }
+  generateVkAccountPlaceholder() {
+    return "PENDING_VK_ACCOUNT_KEYPAIR";
+  }
+};
+async function createNodeVkDeploymentManager(config) {
+  const manager = new VkDeploymentManager(config);
+  await manager.load();
+  return manager;
+}
+
+// src/registry/CircuitRegistry.ts
+var CircuitRegistry = class {
+  circuits = /* @__PURE__ */ new Map();
+  /**
+   * Registers a new circuit.
+   *
+   * @param definition - Circuit definition with metadata
+   * @returns The registered circuit with computed fields
+   * @throws Error if circuit with same name and version exists
+   */
+  register(definition) {
+    const { name, version } = definition;
+    if (!/^\d+\.\d+\.\d+/.test(version)) {
+      throw new Error(
+        `Invalid version format: ${version}. Use semantic versioning (e.g., '1.0.0')`
+      );
+    }
+    if (typeof definition.jsCircuit !== "function") {
+      throw new Error("jsCircuit must be a function");
+    }
+    const existing = this.circuits.get(name) ?? [];
+    if (existing.some((c) => c.version === version)) {
+      throw new Error(
+        `Circuit '${name}' version ${version} already registered. Use a new version.`
+      );
+    }
+    const functionHash = this.hashFunction(definition.jsCircuit);
+    const registered = {
+      ...definition,
+      registeredAt: /* @__PURE__ */ new Date(),
+      id: `${name}@${version}`,
+      functionHash
+    };
+    existing.push(registered);
+    existing.sort((a, b) => this.compareVersions(b.version, a.version));
+    this.circuits.set(name, existing);
+    return registered;
+  }
+  /**
+   * Gets a circuit by name.
+   *
+   * @param name - Circuit name
+   * @param options - Lookup options (version, etc.)
+   * @returns The circuit or undefined if not found
+   */
+  get(name, options) {
+    const versions = this.circuits.get(name);
+    if (!versions || versions.length === 0) {
+      return void 0;
+    }
+    if (options?.version) {
+      return versions.find((c) => c.version === options.version);
+    }
+    return versions[0];
+  }
+  /**
+   * Gets all versions of a circuit.
+   *
+   * @param name - Circuit name
+   * @returns Array of all registered versions
+   */
+  getVersions(name) {
+    return this.circuits.get(name) ?? [];
+  }
+  /**
+   * Checks if a circuit exists.
+   *
+   * @param name - Circuit name
+   * @param version - Optional specific version
+   */
+  has(name, version) {
+    const circuit = this.get(name, version ? { version } : void 0);
+    return circuit !== void 0;
+  }
+  /**
+   * Gets all registered circuit names.
+   */
+  names() {
+    return Array.from(this.circuits.keys());
+  }
+  /**
+   * Gets all registered circuits.
+   */
+  all() {
+    const result = [];
+    for (const versions of this.circuits.values()) {
+      result.push(...versions);
+    }
+    return result;
+  }
+  /**
+   * Searches circuits by tag.
+   *
+   * @param tag - Tag to search for
+   * @returns Circuits with matching tag
+   */
+  findByTag(tag) {
+    const result = [];
+    for (const versions of this.circuits.values()) {
+      for (const circuit of versions) {
+        if (circuit.tags?.includes(tag)) {
+          result.push(circuit);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Removes a circuit from the registry.
+   *
+   * @param name - Circuit name
+   * @param version - Optional specific version (removes all if not specified)
+   * @returns true if circuit was removed
+   */
+  remove(name, version) {
+    if (!version) {
+      return this.circuits.delete(name);
+    }
+    const versions = this.circuits.get(name);
+    if (!versions) return false;
+    const index = versions.findIndex((c) => c.version === version);
+    if (index === -1) return false;
+    versions.splice(index, 1);
+    if (versions.length === 0) {
+      this.circuits.delete(name);
+    }
+    return true;
+  }
+  /**
+   * Exports the registry to a serializable format.
+   */
+  export() {
+    const circuits = [];
+    for (const [name, versions] of this.circuits) {
+      for (const circuit of versions) {
+        circuits.push({
+          name: circuit.name,
+          version: circuit.version,
+          description: circuit.description,
+          publicInputs: circuit.publicInputs,
+          privateInputs: circuit.privateInputs,
+          tags: circuit.tags,
+          author: circuit.author,
+          license: circuit.license,
+          registeredAt: circuit.registeredAt.toISOString(),
+          functionHash: circuit.functionHash
+          // Note: jsCircuit is not serializable
+        });
+      }
+    }
+    return {
+      version: "1.0",
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      circuits
+    };
+  }
+  /**
+   * Generates documentation for a circuit.
+   *
+   * @param name - Circuit name
+   * @returns Markdown documentation
+   */
+  generateDocs(name) {
+    const circuit = this.get(name);
+    if (!circuit) {
+      return `Circuit '${name}' not found.`;
+    }
+    const lines = [
+      `# ${circuit.name}`,
+      "",
+      `**Version:** ${circuit.version}`
+    ];
+    if (circuit.description) {
+      lines.push("", circuit.description);
+    }
+    if (circuit.author) {
+      lines.push("", `**Author:** ${circuit.author}`);
+    }
+    if (circuit.license) {
+      lines.push(`**License:** ${circuit.license}`);
+    }
+    if (circuit.tags && circuit.tags.length > 0) {
+      lines.push("", `**Tags:** ${circuit.tags.join(", ")}`);
+    }
+    lines.push("", "## Public Inputs", "");
+    if (circuit.publicInputs.length === 0) {
+      lines.push("None");
+    } else {
+      lines.push("| Name | Type | Description |", "|------|------|-------------|");
+      for (const input of circuit.publicInputs) {
+        lines.push(`| ${input.name} | ${input.type} | ${input.description ?? "-"} |`);
+      }
+    }
+    lines.push("", "## Private Inputs", "");
+    if (circuit.privateInputs.length === 0) {
+      lines.push("None");
+    } else {
+      lines.push("| Name | Type | Description |", "|------|------|-------------|");
+      for (const input of circuit.privateInputs) {
+        lines.push(`| ${input.name} | ${input.type} | ${input.description ?? "-"} |`);
+      }
+    }
+    lines.push("", "## Circuit Function", "", "```javascript", circuit.jsCircuit.toString(), "```");
+    return lines.join("\n");
+  }
+  /**
+   * Validates circuit inputs against the definition.
+   *
+   * @param name - Circuit name
+   * @param publicInputs - Public inputs to validate
+   * @param privateInputs - Private inputs to validate
+   * @throws Error if validation fails
+   */
+  validateInputs(name, publicInputs, privateInputs) {
+    const circuit = this.get(name);
+    if (!circuit) {
+      throw new Error(`Circuit '${name}' not found`);
+    }
+    if (publicInputs.length !== circuit.publicInputs.length) {
+      throw new Error(
+        `Expected ${circuit.publicInputs.length} public inputs, got ${publicInputs.length}`
+      );
+    }
+    if (privateInputs.length !== circuit.privateInputs.length) {
+      throw new Error(
+        `Expected ${circuit.privateInputs.length} private inputs, got ${privateInputs.length}`
+      );
+    }
+    for (let i = 0; i < publicInputs.length; i++) {
+      this.validateInput(
+        publicInputs[i],
+        circuit.publicInputs[i],
+        `public input '${circuit.publicInputs[i].name}'`
+      );
+    }
+    for (let i = 0; i < privateInputs.length; i++) {
+      this.validateInput(
+        privateInputs[i],
+        circuit.privateInputs[i],
+        `private input '${circuit.privateInputs[i].name}'`
+      );
+    }
+  }
+  // Private helpers
+  hashFunction(fn) {
+    const str = fn.toString();
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      hash = (hash << 5) - hash + str.charCodeAt(i) | 0;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+  }
+  compareVersions(a, b) {
+    const partsA = a.split(".").map((n) => parseInt(n, 10));
+    const partsB = b.split(".").map((n) => parseInt(n, 10));
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+      const numA = partsA[i] ?? 0;
+      const numB = partsB[i] ?? 0;
+      if (numA > numB) return 1;
+      if (numA < numB) return -1;
+    }
+    return 0;
+  }
+  validateInput(value, def, location) {
+    switch (def.type) {
+      case "bool":
+        if (typeof value !== "boolean" && value !== 0 && value !== 1) {
+          throw new Error(`${location}: expected boolean, got ${typeof value}`);
+        }
+        break;
+      case "Field":
+      case "u8":
+      case "u16":
+      case "u32":
+      case "u64":
+        if (typeof value !== "number" && typeof value !== "bigint") {
+          throw new Error(`${location}: expected number/bigint, got ${typeof value}`);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+};
+var globalRegistry = null;
+function getGlobalRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = new CircuitRegistry();
+  }
+  return globalRegistry;
+}
+function defineCircuit(metadata, jsCircuit) {
+  const registry = getGlobalRegistry();
+  return registry.register({ ...metadata, jsCircuit });
+}
+
+// src/server/OffchainVerifier.ts
+var OffchainVerifier = class {
+  circuits = /* @__PURE__ */ new Map();
+  compiledCircuits = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Registers a circuit for verification.
+   *
+   * @param name - Unique name for the circuit
+   * @param config - Circuit configuration
+   */
+  async registerCircuit(name, config) {
+    this.circuits.set(name, config);
+    if (config.compiledCircuit) {
+      this.compiledCircuits.set(name, config.compiledCircuit);
+      return;
+    }
+    if (this.config.compiler) {
+      const compiled = await this.config.compiler(config.jsCircuit);
+      this.compiledCircuits.set(name, compiled);
+    }
+  }
+  /**
+   * Registers a pre-compiled circuit.
+   *
+   * @param name - Unique name for the circuit
+   * @param compiled - Pre-compiled circuit
+   */
+  registerCompiledCircuit(name, compiled) {
+    this.compiledCircuits.set(name, compiled);
+  }
+  /**
+   * Verifies a ZK proof.
+   *
+   * @param request - Verification request with circuit name, proof, and public inputs
+   * @returns Verification result
+   */
+  async verify(request) {
+    const startTime = performance.now();
+    const { circuitName, proof, publicInputs } = request;
+    const compiled = this.compiledCircuits.get(circuitName);
+    if (!compiled) {
+      return {
+        verified: false,
+        circuitName,
+        verificationTimeMs: performance.now() - startTime,
+        error: `Circuit '${circuitName}' not registered`,
+        publicInputs
+      };
+    }
+    const config = this.circuits.get(circuitName);
+    if (config?.publicInputCount !== void 0) {
+      if (publicInputs.length !== config.publicInputCount) {
+        return {
+          verified: false,
+          circuitName,
+          verificationTimeMs: performance.now() - startTime,
+          error: `Expected ${config.publicInputCount} public inputs, got ${publicInputs.length}`,
+          publicInputs
+        };
+      }
+    }
+    try {
+      const proofBytes = this.toUint8Array(proof);
+      const publicInputBytes = publicInputs.map(
+        (input) => this.publicInputToBytes(input)
+      );
+      if (!this.config.verifier) {
+        return {
+          verified: false,
+          circuitName,
+          verificationTimeMs: performance.now() - startTime,
+          error: "No verifier configured. Provide a verifier in the config.",
+          publicInputs
+        };
+      }
+      const verified = await this.config.verifier(
+        compiled,
+        proofBytes,
+        publicInputBytes
+      );
+      return {
+        verified,
+        circuitName,
+        verificationTimeMs: performance.now() - startTime,
+        publicInputs
+      };
+    } catch (error) {
+      return {
+        verified: false,
+        circuitName,
+        verificationTimeMs: performance.now() - startTime,
+        error: error instanceof Error ? error.message : "Unknown verification error",
+        publicInputs
+      };
+    }
+  }
+  /**
+   * Checks if a circuit is registered.
+   *
+   * @param name - Circuit name
+   */
+  hasCircuit(name) {
+    return this.compiledCircuits.has(name);
+  }
+  /**
+   * Gets all registered circuit names.
+   */
+  getCircuitNames() {
+    return Array.from(this.compiledCircuits.keys());
+  }
+  /**
+   * Removes a circuit from the verifier.
+   *
+   * @param name - Circuit name to remove
+   */
+  removeCircuit(name) {
+    this.circuits.delete(name);
+    return this.compiledCircuits.delete(name);
+  }
+  // Private helpers
+  toUint8Array(input) {
+    if (input instanceof Uint8Array) {
+      return input;
+    }
+    const hex = input.startsWith("0x") ? input.slice(2) : input;
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  publicInputToBytes(input) {
+    let value;
+    if (typeof input === "string") {
+      value = input.startsWith("0x") ? BigInt(input) : BigInt(input);
+    } else if (typeof input === "bigint") {
+      value = input;
+    } else {
+      value = BigInt(input);
+    }
+    const bytes = new Uint8Array(32);
+    for (let i = 31; i >= 0; i--) {
+      bytes[i] = Number(value & 0xffn);
+      value >>= 8n;
+    }
+    return bytes;
+  }
+};
+function createVerifierMiddleware(verifier) {
+  return async (req, res, next) => {
+    try {
+      const { circuitName, proof, publicInputs } = req.body;
+      if (!circuitName || typeof circuitName !== "string") {
+        res.status(400).json({
+          error: "Missing or invalid circuitName"
+        });
+        return;
+      }
+      if (!proof) {
+        res.status(400).json({
+          error: "Missing proof"
+        });
+        return;
+      }
+      if (!Array.isArray(publicInputs)) {
+        res.status(400).json({
+          error: "Missing or invalid publicInputs (expected array)"
+        });
+        return;
+      }
+      if (!verifier.hasCircuit(circuitName)) {
+        res.status(404).json({
+          error: `Circuit '${circuitName}' not found`
+        });
+        return;
+      }
+      const result = await verifier.verify({
+        circuitName,
+        proof,
+        publicInputs
+      });
+      if (result.verified) {
+        res.status(200).json(result);
+      } else {
+        res.status(400).json(result);
+      }
+    } catch (error) {
+      next(error instanceof Error ? error : new Error(String(error)));
+    }
+  };
+}
+function createVerificationEndpoint(verifier, options = {}) {
+  const baseMiddleware = createVerifierMiddleware(verifier);
+  const wrappedMiddleware = async (req, res, next) => {
+    if (options.allowedCircuits && options.allowedCircuits.length > 0 && req.body.circuitName) {
+      if (!options.allowedCircuits.includes(req.body.circuitName)) {
+        res.status(403).json({
+          error: `Circuit '${req.body.circuitName}' not allowed`
+        });
+        return;
+      }
+    }
+    await baseMiddleware(req, res, next);
+  };
+  return {
+    path: options.path ?? "/verify",
+    middleware: wrappedMiddleware
+  };
+}
+async function batchVerify(verifier, requests) {
+  const startTime = performance.now();
+  const results = await Promise.all(
+    requests.map((request) => verifier.verify(request))
+  );
+  const verifiedCount = results.filter((r) => r.verified).length;
+  return {
+    results,
+    totalTimeMs: performance.now() - startTime,
+    verifiedCount,
+    failedCount: results.length - verifiedCount
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AcornParser,
+  ArkworksWasm,
+  Barretenberg,
+  Chain,
+  CircuitRegistry,
+  CreateProofUseCase,
+  IZI_NOIR_PROGRAM_ID,
+  IziNoir,
+  NETWORK_ENDPOINTS,
+  OffchainVerifier,
+  Provider,
+  SolanaFormatter,
+  SolanaTransactionBuilder,
+  VkDeploymentManager,
+  batchVerify,
+  buildInitVkFromBytesData,
+  buildVerifyProofData,
+  calculateVkAccountRent,
+  calculateVkAccountSize,
+  createArkworksWasmContainer,
+  createDefaultContainer,
+  createNodeVkDeploymentManager,
+  createVerificationEndpoint,
+  createVerifierMiddleware,
+  defineCircuit,
+  generateNoir,
+  getGlobalRegistry,
+  initNoirWasm,
+  isArkworksCircuit,
+  isWasmInitialized,
+  markWasmInitialized,
+  parseProof,
+  parsePublicInputs,
+  parseVerifyingKey
+});
+//# sourceMappingURL=index.cjs.map