@izi-noir/sdk 0.1.0

package/dist/providers/arkworks.js

@@ -0,0 +1,791 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// src/infra/provingSystems/ArkworksWasm.ts
+var ArkworksWasm_exports = {};
+__export(ArkworksWasm_exports, {
+  ArkworksWasm: () => ArkworksWasm,
+  isArkworksCircuit: () => isArkworksCircuit
+});
+import { compile, createFileManager } from "@noir-lang/noir_wasm";
+import { Noir } from "@noir-lang/noir_js";
+function stringToStream(content) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode(content));
+      controller.close();
+    }
+  });
+}
+function isNodeJs() {
+  return typeof globalThis.process !== "undefined" && globalThis.process.versions != null && globalThis.process.versions.node != null;
+}
+async function createTempDir() {
+  if (!isNodeJs()) {
+    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 (wasmInitPromise) {
+    return wasmInitPromise;
+  }
+  wasmInitPromise = (async () => {
+    try {
+      if (isNodeJs()) {
+        const module = await import("../wasm/nodejs/arkworks_groth16_wasm.js");
+        wasmModule = module;
+      } else {
+        const module = await import("../wasm/web/arkworks_groth16_wasm.js");
+        if (typeof module.default === "function") {
+          await module.default();
+        }
+        wasmModule = module;
+      }
+      return wasmModule;
+    } catch (error) {
+      wasmInitPromise = 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 wasmInitPromise;
+}
+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_SIZE = 32;
+  const bytes = new Uint8Array(publicInputs.length * FIELD_SIZE);
+  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_SIZE);
+  }
+  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 wasmModule, wasmInitPromise, ArkworksWasm;
+var init_ArkworksWasm = __esm({
+  "src/infra/provingSystems/ArkworksWasm.ts"() {
+    "use strict";
+    wasmModule = null;
+    wasmInitPromise = 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 createTempDir();
+        const fm = createFileManager(basePath);
+        const nargoToml = `[package]
+name = "circuit"
+type = "bin"
+authors = [""]
+
+[dependencies]
+`;
+        try {
+          if (isNodeJs()) {
+            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 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 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/provingSystems/Barretenberg.ts
+var Barretenberg_exports = {};
+__export(Barretenberg_exports, {
+  Barretenberg: () => Barretenberg
+});
+import { compile as compile2, createFileManager as createFileManager2 } from "@noir-lang/noir_wasm";
+import { Noir as Noir2 } from "@noir-lang/noir_js";
+import { Barretenberg as BarretenbergBackend, UltraHonkBackend } from "@aztec/bb.js";
+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(), "noir-circuit-"));
+  const cleanup = async () => {
+    await fs.rm(basePath, { recursive: true, force: true });
+  };
+  return { basePath, cleanup };
+}
+var Barretenberg;
+var init_Barretenberg = __esm({
+  "src/infra/provingSystems/Barretenberg.ts"() {
+    "use strict";
+    Barretenberg = class {
+      async compile(noirCode) {
+        const { basePath, cleanup } = await createTempDir2();
+        const fm = createFileManager2(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 compile2(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 Noir2(circuit);
+        const { witness } = await noir.execute(inputs);
+        const barretenberg = await BarretenbergBackend.new({ threads: 1 });
+        const backend = new 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 BarretenbergBackend.new({ threads: 1 });
+        const backend = new UltraHonkBackend(circuit.bytecode, barretenberg);
+        try {
+          return await backend.verifyProof({ proof, publicInputs });
+        } finally {
+          await barretenberg.destroy();
+        }
+      }
+    };
+  }
+});
+
+// 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/providers/arkworks.ts
+init_ArkworksWasm();
+
+// 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 wasmInitPromise2 = null;
+var wasmInitialized = false;
+function isNodeJs2() {
+  return typeof globalThis.process !== "undefined" && globalThis.process.versions != null && globalThis.process.versions.node != null;
+}
+async function initNoirWasm() {
+  if (wasmInitialized) return;
+  if (!wasmInitPromise2) {
+    wasmInitPromise2 = initWasmInternal();
+  }
+  await wasmInitPromise2;
+  wasmInitialized = true;
+}
+async function initWasmInternal() {
+  if (isNodeJs2()) {
+    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;
+}
+
+// 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
+    };
+  }
+};
+export {
+  ArkworksWasm,
+  IziNoir,
+  Provider,
+  initNoirWasm,
+  isArkworksCircuit,
+  isWasmInitialized
+};
+//# sourceMappingURL=arkworks.js.map