@izi-noir/sdk 0.1.9 → 0.1.11

package/dist/providers/barretenberg.js

@@ -45,7 +45,9 @@ var init_Barretenberg = __esm({
   "src/infra/provingSystems/Barretenberg.ts"() {
     "use strict";
     Barretenberg = class {
-      async compile(noirCode) {
+      // Note: options parameter is accepted but not used - Barretenberg uses Noir's ACIR directly
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async compile(noirCode, _options) {
         const { basePath, cleanup } = await createTempDir();
         const fm = createFileManager(basePath);
         const nargoToml = `[package]
@@ -103,6 +105,377 @@ authors = [""]
   }
 });
 
+// src/infra/provingSystems/R1csBuilder.ts
+var R1csBuilder;
+var init_R1csBuilder = __esm({
+  "src/infra/provingSystems/R1csBuilder.ts"() {
+    "use strict";
+    R1csBuilder = class {
+      constructor(parsedCircuit) {
+        this.parsedCircuit = parsedCircuit;
+      }
+      constraints = [];
+      witnessMap = /* @__PURE__ */ new Map();
+      nextWitnessIdx = 1;
+      // w_0 = 1 is reserved
+      publicIndices = [];
+      privateIndices = [];
+      // BN254 scalar field modulus - 1 (for representing -1)
+      // Fr modulus = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
+      // -1 mod Fr = Fr - 1
+      NEG_ONE = "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000";
+      /**
+       * Build R1CS definition from the parsed circuit
+       */
+      build() {
+        this.registerInputs();
+        for (const stmt of this.parsedCircuit.statements) {
+          this.processStatement(stmt);
+        }
+        return {
+          num_witnesses: this.nextWitnessIdx,
+          public_inputs: this.publicIndices,
+          private_inputs: this.privateIndices,
+          constraints: this.constraints
+        };
+      }
+      /**
+       * Get the witness index for an input parameter name
+       */
+      getWitnessIndex(name) {
+        return this.witnessMap.get(name);
+      }
+      /**
+       * Register all circuit inputs as witnesses
+       * Public inputs come first, then private inputs
+       */
+      registerInputs() {
+        for (const param of this.parsedCircuit.publicParams) {
+          const idx = this.nextWitnessIdx++;
+          this.witnessMap.set(param.name, idx);
+          this.publicIndices.push(idx);
+        }
+        for (const param of this.parsedCircuit.privateParams) {
+          const idx = this.nextWitnessIdx++;
+          this.witnessMap.set(param.name, idx);
+          this.privateIndices.push(idx);
+        }
+      }
+      /**
+       * Process a single statement and generate constraints
+       */
+      processStatement(stmt) {
+        switch (stmt.kind) {
+          case "assert":
+            this.processAssert(stmt.condition);
+            break;
+          case "variable_declaration":
+            this.processVariableDecl(stmt.name, stmt.initializer);
+            break;
+          case "assignment":
+            this.processAssignment(stmt.target, stmt.value);
+            break;
+          case "if_statement":
+            for (const s of stmt.consequent) {
+              this.processStatement(s);
+            }
+            if (stmt.alternate) {
+              for (const s of stmt.alternate) {
+                this.processStatement(s);
+              }
+            }
+            break;
+          case "for_statement":
+            throw new Error(
+              "For loops are not yet supported in R1CS generation. Use the Barretenberg backend for complex circuits."
+            );
+        }
+      }
+      /**
+       * Process an assert statement
+       * The condition must evaluate to true for a valid proof
+       */
+      processAssert(condition) {
+        if (condition.kind === "binary") {
+          this.processBinaryAssert(condition);
+        } else if (condition.kind === "identifier") {
+          const idx = this.getOrCreateWitness(condition);
+          this.constraints.push({
+            a: [["0x1", idx]],
+            b: [["0x1", 0]],
+            // * 1
+            c: [["0x1", 0]]
+            // = 1 (w_0)
+          });
+        } else {
+          throw new Error(`Unsupported assert condition kind: ${condition.kind}`);
+        }
+      }
+      /**
+       * Process a binary expression in an assert
+       */
+      processBinaryAssert(expr) {
+        const { left, operator, right } = expr;
+        switch (operator) {
+          case "==":
+            this.processEquality(left, right);
+            break;
+          case "!=":
+            throw new Error(
+              "Inequality (!=) is not yet supported in R1CS. Use equality (==) instead."
+            );
+          case "+":
+          case "-":
+          case "*":
+          case "/":
+          case "%":
+            throw new Error(
+              `Arithmetic operator ${operator} must be part of an equality assertion. Use: assert(a ${operator} b == c)`
+            );
+          case "<":
+          case ">":
+          case "<=":
+          case ">=":
+            throw new Error(
+              `Comparison operators (${operator}) require range proofs which are not yet supported. Use the Barretenberg backend for comparison operations.`
+            );
+          case "&":
+          case "|":
+            throw new Error(
+              `Logical operator ${operator} is not yet supported in R1CS.`
+            );
+          default:
+            throw new Error(`Unsupported operator in assert: ${operator}`);
+        }
+      }
+      /**
+       * Process an equality assertion: assert(left == right)
+       */
+      processEquality(left, right) {
+        if (left.kind === "binary" && left.operator === "*") {
+          this.processMultiplicationEquality(left.left, left.right, right);
+          return;
+        }
+        if (right.kind === "binary" && right.operator === "*") {
+          this.processMultiplicationEquality(right.left, right.right, left);
+          return;
+        }
+        if (left.kind === "binary" && left.operator === "+") {
+          this.processAdditionEquality(left.left, left.right, right);
+          return;
+        }
+        if (right.kind === "binary" && right.operator === "+") {
+          this.processAdditionEquality(right.left, right.right, left);
+          return;
+        }
+        if (left.kind === "binary" && left.operator === "-") {
+          this.processSubtractionEquality(left.left, left.right, right);
+          return;
+        }
+        if (right.kind === "binary" && right.operator === "-") {
+          this.processSubtractionEquality(right.left, right.right, left);
+          return;
+        }
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          // a - b
+          b: [["0x1", 0]],
+          // * 1 (w_0 = 1)
+          c: []
+          // = 0
+        });
+      }
+      /**
+       * Process multiplication equality: assert(a * b == c)
+       * R1CS: a * b = c
+       */
+      processMultiplicationEquality(left, right, result) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const resultIdx = this.getOrCreateWitness(result);
+        this.constraints.push({
+          a: [["0x1", leftIdx]],
+          b: [["0x1", rightIdx]],
+          c: [["0x1", resultIdx]]
+        });
+      }
+      /**
+       * Process addition equality: assert(a + b == c)
+       * R1CS: (a + b - c) * 1 = 0
+       * Which is: (a + b) * 1 = c
+       */
+      processAdditionEquality(left, right, result) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const resultIdx = this.getOrCreateWitness(result);
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            ["0x1", rightIdx]
+          ],
+          // a + b
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", resultIdx]]
+          // = c
+        });
+      }
+      /**
+       * Process subtraction equality: assert(a - b == c)
+       * R1CS: (a - b) * 1 = c
+       */
+      processSubtractionEquality(left, right, result) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const resultIdx = this.getOrCreateWitness(result);
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          // a - b
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", resultIdx]]
+          // = c
+        });
+      }
+      /**
+       * Process a variable declaration: let x = expr
+       * Creates a new witness for x and adds constraint if needed
+       */
+      processVariableDecl(name, initializer) {
+        const varIdx = this.nextWitnessIdx++;
+        this.witnessMap.set(name, varIdx);
+        if (initializer.kind === "identifier") {
+          const initIdx = this.getOrCreateWitness(initializer);
+          this.constraints.push({
+            a: [
+              ["0x1", varIdx],
+              [this.NEG_ONE, initIdx]
+            ],
+            b: [["0x1", 0]],
+            c: []
+          });
+        } else if (initializer.kind === "literal") {
+        } else if (initializer.kind === "binary") {
+          this.processVariableInitBinary(varIdx, initializer);
+        } else {
+          throw new Error(
+            `Unsupported initializer kind for variable declaration: ${initializer.kind}`
+          );
+        }
+      }
+      /**
+       * Process a binary expression as variable initializer
+       */
+      processVariableInitBinary(varIdx, expr) {
+        const { left, operator, right } = expr;
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        switch (operator) {
+          case "*":
+            this.constraints.push({
+              a: [["0x1", leftIdx]],
+              b: [["0x1", rightIdx]],
+              c: [["0x1", varIdx]]
+            });
+            break;
+          case "+":
+            this.constraints.push({
+              a: [
+                ["0x1", leftIdx],
+                ["0x1", rightIdx]
+              ],
+              b: [["0x1", 0]],
+              c: [["0x1", varIdx]]
+            });
+            break;
+          case "-":
+            this.constraints.push({
+              a: [
+                ["0x1", leftIdx],
+                [this.NEG_ONE, rightIdx]
+              ],
+              b: [["0x1", 0]],
+              c: [["0x1", varIdx]]
+            });
+            break;
+          default:
+            throw new Error(
+              `Unsupported operator in variable initializer: ${operator}`
+            );
+        }
+      }
+      /**
+       * Process an assignment: x = expr
+       * Updates the witness mapping
+       */
+      processAssignment(target, value) {
+        const existingIdx = this.witnessMap.get(target);
+        if (existingIdx === void 0) {
+          throw new Error(`Assignment to undeclared variable: ${target}`);
+        }
+        if (value.kind === "identifier") {
+          const valueIdx = this.getOrCreateWitness(value);
+          this.constraints.push({
+            a: [
+              ["0x1", existingIdx],
+              [this.NEG_ONE, valueIdx]
+            ],
+            b: [["0x1", 0]],
+            c: []
+          });
+        } else if (value.kind === "binary") {
+          this.processVariableInitBinary(existingIdx, value);
+        }
+      }
+      /**
+       * Get or create a witness index for an expression
+       */
+      getOrCreateWitness(expr) {
+        if (expr.kind === "identifier") {
+          const existing = this.witnessMap.get(expr.name);
+          if (existing !== void 0) {
+            return existing;
+          }
+          const idx = this.nextWitnessIdx++;
+          this.witnessMap.set(expr.name, idx);
+          return idx;
+        }
+        if (expr.kind === "literal") {
+          const idx = this.nextWitnessIdx++;
+          return idx;
+        }
+        if (expr.kind === "binary") {
+          const idx = this.nextWitnessIdx++;
+          this.processVariableInitBinary(idx, expr);
+          return idx;
+        }
+        if (expr.kind === "unary") {
+          const operandIdx = this.getOrCreateWitness(expr.operand);
+          if (expr.operator === "-") {
+            const idx = this.nextWitnessIdx++;
+            this.constraints.push({
+              a: [[this.NEG_ONE, operandIdx]],
+              b: [["0x1", 0]],
+              c: [["0x1", idx]]
+            });
+            return idx;
+          }
+          throw new Error(`Unsupported unary operator: ${expr.operator}`);
+        }
+        throw new Error(`Unsupported expression kind: ${expr.kind}`);
+      }
+    };
+  }
+});
+
 // src/infra/provingSystems/ArkworksWasm.ts
 var ArkworksWasm_exports = {};
 __export(ArkworksWasm_exports, {
@@ -236,6 +609,7 @@ var wasmModule, wasmInitPromise2, ArkworksWasm;
 var init_ArkworksWasm = __esm({
   "src/infra/provingSystems/ArkworksWasm.ts"() {
     "use strict";
+    init_R1csBuilder();
     wasmModule = null;
     wasmInitPromise2 = null;
     ArkworksWasm = class {
@@ -249,8 +623,11 @@ var init_ArkworksWasm = __esm({
       }
       /**
        * Compile Noir code to a circuit with ACIR for Groth16 proving
+       *
+       * @param noirCode - The Noir source code to compile
+       * @param options - Optional compilation options including ParsedCircuit for dynamic R1CS
        */
-      async compile(noirCode) {
+      async compile(noirCode, options) {
         const wasm = await initWasm();
         const { basePath, cleanup } = await createTempDir2();
         const fm = createFileManager2(basePath);
@@ -275,36 +652,52 @@ authors = [""]
             throw new Error("Compilation failed: no bytecode generated");
           }
           const parameters = compiled.abi.parameters;
-          const publicR1csIndices = [];
-          const privateR1csIndices = [];
+          let r1cs;
           const witnessIndexMapping = /* @__PURE__ */ new Map();
-          parameters.forEach((p, noirIndex) => {
-            const r1csIndex = noirIndex + 1;
-            witnessIndexMapping.set(noirIndex, r1csIndex);
-            if (p.visibility === "public") {
-              publicR1csIndices.push(r1csIndex);
-            } else if (p.visibility === "private") {
-              privateR1csIndices.push(r1csIndex);
-            }
-          });
-          const r1cs = {
-            num_witnesses: parameters.length + 1,
-            // +1 for w_0
-            public_inputs: publicR1csIndices,
-            private_inputs: privateR1csIndices,
-            constraints: []
-          };
-          if (privateR1csIndices.length === 1 && publicR1csIndices.length === 1) {
-            const privateIdx = privateR1csIndices[0];
-            const publicIdx = publicR1csIndices[0];
-            r1cs.constraints.push({
-              a: [["0x1", privateIdx]],
-              // secret
-              b: [["0x1", privateIdx]],
-              // secret
-              c: [["0x1", publicIdx]]
-              // expected
+          if (options?.parsedCircuit) {
+            const builder = new R1csBuilder(options.parsedCircuit);
+            r1cs = builder.build();
+            parameters.forEach((p, noirIndex) => {
+              const r1csIndex = noirIndex + 1;
+              witnessIndexMapping.set(noirIndex, r1csIndex);
+            });
+            console.log("=== R1CS BUILDER DEBUG ===");
+            console.log("ParsedCircuit publicParams:", options.parsedCircuit.publicParams);
+            console.log("ParsedCircuit privateParams:", options.parsedCircuit.privateParams);
+            console.log("ParsedCircuit statements:", JSON.stringify(options.parsedCircuit.statements, null, 2));
+            console.log("Generated R1CS:", JSON.stringify(r1cs, null, 2));
+            console.log("==========================");
+          } else {
+            const publicR1csIndices = [];
+            const privateR1csIndices = [];
+            parameters.forEach((p, noirIndex) => {
+              const r1csIndex = noirIndex + 1;
+              witnessIndexMapping.set(noirIndex, r1csIndex);
+              if (p.visibility === "public") {
+                publicR1csIndices.push(r1csIndex);
+              } else if (p.visibility === "private") {
+                privateR1csIndices.push(r1csIndex);
+              }
             });
+            r1cs = {
+              num_witnesses: parameters.length + 1,
+              public_inputs: publicR1csIndices,
+              private_inputs: privateR1csIndices,
+              constraints: []
+            };
+            if (privateR1csIndices.length === 1 && publicR1csIndices.length === 1) {
+              const privateIdx = privateR1csIndices[0];
+              const publicIdx = publicR1csIndices[0];
+              r1cs.constraints.push({
+                a: [["0x1", privateIdx]],
+                b: [["0x1", privateIdx]],
+                c: [["0x1", publicIdx]]
+              });
+            }
+            console.log("=== R1CS HARDCODED DEBUG ===");
+            console.log("Using hardcoded R1CS pattern (no ParsedCircuit provided)");
+            console.log("R1CS:", JSON.stringify(r1cs, null, 2));
+            console.log("============================");
           }
           const r1csJson = JSON.stringify(r1cs);
           let provingKey;
@@ -321,7 +714,7 @@ authors = [""]
             }
           }
           const acirJson = JSON.stringify({
-            functions: [{ current_witness_index: parameters.length, opcodes: [], private_parameters: privateR1csIndices, public_parameters: { witnesses: publicR1csIndices }, return_values: { witnesses: [] } }]
+            functions: [{ current_witness_index: parameters.length, opcodes: [], private_parameters: r1cs.private_inputs, public_parameters: { witnesses: r1cs.public_inputs }, return_values: { witnesses: [] } }]
           });
           const arkworksCircuit = {
             ...compiled,
@@ -369,6 +762,7 @@ authors = [""]
           circuit.verifyingKey = setupResult.verifying_key;
           circuit.verifyingKeyGnark = setupResult.verifying_key_gnark;
         }
+        const toHex = (arr) => Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
         console.log("=== ARKWORKS PROVE DEBUG ===");
         console.log("Witness JSON:", witnessJson);
         console.log("R1CS JSON:", circuit.r1csJson);
@@ -377,7 +771,7 @@ authors = [""]
         console.log("Proof gnark base64 length:", proofResult.proof_gnark.length);
         const proofBytes = base64ToUint8Array(proofResult.proof_gnark);
         console.log("Proof bytes length:", proofBytes.length);
-        console.log("Proof bytes hex:", Buffer.from(proofBytes).toString("hex"));
+        console.log("Proof bytes hex:", toHex(proofBytes));
         console.log("============================");
         return {
           proof: proofBytes,
@@ -1037,16 +1431,20 @@ var IziNoir = class _IziNoir {
    * After compile(), the verifying key is available via `this.vk`.
    *
    * @param noirCode - The Noir source code to compile
+   * @param options - Optional compilation options including ParsedCircuit for dynamic R1CS
    * @returns CompileResult with circuit and verifying key
    *
    * @example
    * ```typescript
+   * // Basic usage
    * const { circuit, verifyingKey } = await izi.compile(noirCode);
-   * console.log('VK:', izi.vk);  // Available immediately after compile
+   *
+   * // With ParsedCircuit for dynamic R1CS generation
+   * const { circuit } = await izi.compile(noirCode, { parsedCircuit });
    * ```
    */
-  async compile(noirCode) {
-    this.compiledCircuit = await this.provingSystem.compile(noirCode);
+  async compile(noirCode, options) {
+    this.compiledCircuit = await this.provingSystem.compile(noirCode, options);
     const vk = await this.extractVerifyingKey(this.compiledCircuit);
     if (vk) {
       this._verifyingKey = vk;
@@ -1261,14 +1659,15 @@ var IziNoir = class _IziNoir {
     const connection = new Connection(networkConfig.rpcUrl, "confirmed");
     const vkKeypair = Keypair.generate();
     const authority = wallet.publicKey;
+    const toHex = (arr) => Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
     console.log("=== DEPLOY VK DEBUG ===");
     console.log("VK nrPublicInputs:", proofData.verifyingKey.nrPublicInputs);
     console.log("VK bytes length:", proofData.verifyingKey.bytes.length);
-    console.log("VK bytes (first 64 - alpha_g1):", Buffer2.from(proofData.verifyingKey.bytes.slice(0, 64)).toString("hex"));
-    console.log("VK bytes (64-192 - beta_g2):", Buffer2.from(proofData.verifyingKey.bytes.slice(64, 192)).toString("hex"));
-    console.log("VK bytes (192-320 - gamma_g2):", Buffer2.from(proofData.verifyingKey.bytes.slice(192, 320)).toString("hex"));
-    console.log("VK bytes (320-448 - delta_g2):", Buffer2.from(proofData.verifyingKey.bytes.slice(320, 448)).toString("hex"));
-    console.log("VK bytes (448+ - k elements):", Buffer2.from(proofData.verifyingKey.bytes.slice(448)).toString("hex"));
+    console.log("VK bytes (first 64 - alpha_g1):", toHex(proofData.verifyingKey.bytes.slice(0, 64)));
+    console.log("VK bytes (64-192 - beta_g2):", toHex(proofData.verifyingKey.bytes.slice(64, 192)));
+    console.log("VK bytes (192-320 - gamma_g2):", toHex(proofData.verifyingKey.bytes.slice(192, 320)));
+    console.log("VK bytes (320-448 - delta_g2):", toHex(proofData.verifyingKey.bytes.slice(320, 448)));
+    console.log("VK bytes (448+ - k elements):", toHex(proofData.verifyingKey.bytes.slice(448)));
     console.log("=======================");
     const builder = new SolanaTransactionBuilder({
       programId: networkConfig.programId,
@@ -1360,16 +1759,17 @@ var IziNoir = class _IziNoir {
         `VK account ${vk} has invalid data (${accountInfo.data.length} bytes). Expected at least 8 bytes for a valid account.`
       );
     }
+    const toHex = (arr) => Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
     console.log("=== VERIFY ON-CHAIN DEBUG ===");
     console.log("VK Account:", vk);
     console.log("VK Account data length:", accountInfo.data.length, "bytes");
     console.log("Proof size:", proofData.proof.bytes.length, "bytes");
-    console.log("Proof (first 64 bytes - A point):", Buffer2.from(proofData.proof.bytes.slice(0, 64)).toString("hex"));
-    console.log("Proof (bytes 64-192 - B point):", Buffer2.from(proofData.proof.bytes.slice(64, 192)).toString("hex"));
-    console.log("Proof (bytes 192-256 - C point):", Buffer2.from(proofData.proof.bytes.slice(192, 256)).toString("hex"));
+    console.log("Proof (first 64 bytes - A point):", toHex(proofData.proof.bytes.slice(0, 64)));
+    console.log("Proof (bytes 64-192 - B point):", toHex(proofData.proof.bytes.slice(64, 192)));
+    console.log("Proof (bytes 192-256 - C point):", toHex(proofData.proof.bytes.slice(192, 256)));
     console.log("Public inputs count:", proofData.publicInputs.bytes.length);
     proofData.publicInputs.bytes.forEach((input, i) => {
-      console.log(`  Public input[${i}]:`, Buffer2.from(input).toString("hex"));
+      console.log(`  Public input[${i}]:`, toHex(input));
     });
     console.log("Public inputs hex:", proofData.publicInputs.hex);
     console.log("VK nrPublicInputs:", proofData.verifyingKey.nrPublicInputs);

package/dist/providers/sunspot.d.cts

@@ -1,5 +1,5 @@
-import { I as IProvingSystem, C as CircuitPaths } from '../IProvingSystem-BpI0rmve.cjs';
-export { a as IziNoirConfig, P as Provider } from '../IProvingSystem-BpI0rmve.cjs';
+import { I as IProvingSystem, C as CircuitPaths } from '../IProvingSystem-SfzgcbqH.cjs';
+export { a as IziNoirConfig, P as Provider } from '../IProvingSystem-SfzgcbqH.cjs';
 import { P as ProofData } from '../types-CxkI04bP.cjs';
 import { CompiledCircuit, InputMap } from '@noir-lang/types';
 export { CompiledCircuit, InputMap } from '@noir-lang/types';

package/dist/providers/sunspot.d.ts

@@ -1,5 +1,5 @@
-import { I as IProvingSystem, C as CircuitPaths } from '../IProvingSystem-D0X9Rp3W.js';
-export { a as IziNoirConfig, P as Provider } from '../IProvingSystem-D0X9Rp3W.js';
+import { I as IProvingSystem, C as CircuitPaths } from '../IProvingSystem-BKgFRl27.js';
+export { a as IziNoirConfig, P as Provider } from '../IProvingSystem-BKgFRl27.js';
 import { P as ProofData } from '../types-CxkI04bP.js';
 import { CompiledCircuit, InputMap } from '@noir-lang/types';
 export { CompiledCircuit, InputMap } from '@noir-lang/types';

package/dist/{wasmInit-oOZwkgo_.d.ts → wasmInit-D3RyRKIC.d.ts}

@@ -1,4 +1,4 @@
-import { b as ChainId, c as CircuitMetadata, d as ChainMetadataFor, N as Network, e as Chain, a as IziNoirConfig, I as IProvingSystem } from './IProvingSystem-D0X9Rp3W.js';
+import { b as ChainId, c as CircuitMetadata, d as ChainMetadataFor, N as Network, e as Chain, a as IziNoirConfig, I as IProvingSystem, f as CompileOptions } from './IProvingSystem-BKgFRl27.js';
 import { P as ProofData, S as SolanaProofData, V as VerifyingKeyData, C as CompileResult } from './types-CxkI04bP.js';
 import { CompiledCircuit, InputMap } from '@noir-lang/types';
 
@@ -229,15 +229,19 @@ declare class IziNoir {
      * After compile(), the verifying key is available via `this.vk`.
      *
      * @param noirCode - The Noir source code to compile
+     * @param options - Optional compilation options including ParsedCircuit for dynamic R1CS
      * @returns CompileResult with circuit and verifying key
      *
      * @example
      * ```typescript
+     * // Basic usage
      * const { circuit, verifyingKey } = await izi.compile(noirCode);
-     * console.log('VK:', izi.vk);  // Available immediately after compile
+     *
+     * // With ParsedCircuit for dynamic R1CS generation
+     * const { circuit } = await izi.compile(noirCode, { parsedCircuit });
      * ```
      */
-    compile(noirCode: string): Promise<CompileResult>;
+    compile(noirCode: string, options?: CompileOptions): Promise<CompileResult>;
     /**
      * Extract verifying key from compiled circuit.
      * Works for Arkworks circuits that have VK cached after setup.

package/dist/{wasmInit-D615cpte.d.cts → wasmInit-Wyynuk6r.d.cts}

@@ -1,4 +1,4 @@
-import { b as ChainId, c as CircuitMetadata, d as ChainMetadataFor, N as Network, e as Chain, a as IziNoirConfig, I as IProvingSystem } from './IProvingSystem-BpI0rmve.cjs';
+import { b as ChainId, c as CircuitMetadata, d as ChainMetadataFor, N as Network, e as Chain, a as IziNoirConfig, I as IProvingSystem, f as CompileOptions } from './IProvingSystem-SfzgcbqH.cjs';
 import { P as ProofData, S as SolanaProofData, V as VerifyingKeyData, C as CompileResult } from './types-CxkI04bP.cjs';
 import { CompiledCircuit, InputMap } from '@noir-lang/types';
 
@@ -229,15 +229,19 @@ declare class IziNoir {
      * After compile(), the verifying key is available via `this.vk`.
      *
      * @param noirCode - The Noir source code to compile
+     * @param options - Optional compilation options including ParsedCircuit for dynamic R1CS
      * @returns CompileResult with circuit and verifying key
      *
      * @example
      * ```typescript
+     * // Basic usage
      * const { circuit, verifyingKey } = await izi.compile(noirCode);
-     * console.log('VK:', izi.vk);  // Available immediately after compile
+     *
+     * // With ParsedCircuit for dynamic R1CS generation
+     * const { circuit } = await izi.compile(noirCode, { parsedCircuit });
      * ```
      */
-    compile(noirCode: string): Promise<CompileResult>;
+    compile(noirCode: string, options?: CompileOptions): Promise<CompileResult>;
     /**
      * Extract verifying key from compiled circuit.
      * Works for Arkworks circuits that have VK cached after setup.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izi-noir/sdk",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Write ZK circuits in JavaScript/TypeScript, generate Noir code and proofs automatically",
   "type": "module",
   "main": "./dist/index.cjs",