@izi-noir/sdk 0.1.10 → 0.1.11

package/dist/index.cjs

@@ -67,7 +67,9 @@ var init_Barretenberg = __esm({
     import_noir_js = require("@noir-lang/noir_js");
     import_bb = require("@aztec/bb.js");
     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 = (0, import_noir_wasm.createFileManager)(basePath);
         const nargoToml = `[package]
@@ -125,6 +127,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, {
@@ -258,6 +631,7 @@ var init_ArkworksWasm = __esm({
     import_noir_wasm2 = require("@noir-lang/noir_wasm");
     import_noir_js2 = require("@noir-lang/noir_js");
     import_acvm_js = require("@noir-lang/acvm_js");
+    init_R1csBuilder();
     import_meta = {};
     wasmModule = null;
     wasmInitPromise2 = null;
@@ -272,8 +646,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 = (0, import_noir_wasm2.createFileManager)(basePath);
@@ -298,36 +675,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;
@@ -344,7 +737,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,
@@ -580,6 +973,7 @@ __export(index_exports, {
   Network: () => Network,
   OffchainVerifier: () => OffchainVerifier,
   Provider: () => Provider,
+  R1csBuilder: () => R1csBuilder,
   SolanaFormatter: () => SolanaFormatter,
   SolanaTransactionBuilder: () => SolanaTransactionBuilder,
   VkDeploymentManager: () => VkDeploymentManager,
@@ -1193,16 +1587,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;
@@ -1625,6 +2023,7 @@ Check on explorer: ${getExplorerTxUrl(this._network, signature)}`
 init_SolanaFormatter();
 init_Barretenberg();
 init_ArkworksWasm();
+init_R1csBuilder();
 
 // src/infra/parser/AcornParser.ts
 var acorn = __toESM(require("acorn"), 1);
@@ -3169,6 +3568,7 @@ function defineConfig(config) {
   Network,
   OffchainVerifier,
   Provider,
+  R1csBuilder,
   SolanaFormatter,
   SolanaTransactionBuilder,
   VkDeploymentManager,