Initial Noir runner implementation

Merricx · Merricx · commit 0bc8c4343086 · 2025-03-04T03:47:29.000+07:00
diff --git a/src/zkregex_fuzzer/cli.py b/src/zkregex_fuzzer/cli.py
@@ -14,6 +14,7 @@
 from zkregex_fuzzer.harness import HarnessStatus
 from zkregex_fuzzer.logger import logger
 from zkregex_fuzzer.runner.circom import CircomSubprocess, SnarkjsSubprocess, ZkRegexSubprocess
+from zkregex_fuzzer.runner.subprocess import BarretenbergSubprocess, NoirSubprocess
 
 def fuzz_parser():
     parser = argparse.ArgumentParser(
@@ -71,7 +72,7 @@ def fuzz_parser():
         help="Maximum depth of recursion in the grammar (default: 5)."
     )
     parser.add_argument(
-        "--circom-max-input-size",
+        "--max-input-size",
         type=int,
         default=600,
         help="Maximum size of the circuit input (default: 600)."
@@ -94,6 +95,19 @@ def fuzz_parser():
         type=str,
         help="Path to the ptau (powers-of-tau) file for the proving step"
     )
+
+    parser.add_argument(
+        "--noir-prove",
+        action="store_true",
+        help="Run the proving and verification step with Barretenberg."
+    )
+
+    parser.add_argument(
+        "--logger-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+        help="Set the logger level (default: INFO)."
+    )
     
 
     return parser
@@ -110,6 +124,12 @@ def reproduce_parser():
         help="Path to the target directory output that want to be reproduced (support wildcard pattern).",
         required=True
     )
+    parser.add_argument(
+        "--logger-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+        help="Set the logger level (default: INFO)."
+    )
 
     return parser
 
@@ -120,13 +140,15 @@ def do_fuzz(args):
     
     if args.target == "circom":
         try:
-            circom_version = CircomSubprocess.get_installed_version()
-            snarkjs_version = SnarkjsSubprocess.get_installed_version()
             zk_regex_version = ZkRegexSubprocess.get_installed_version()
+            circom_version = CircomSubprocess.get_installed_version()
             print("-" * 80)
-            print(f"Circom: {circom_version}")
-            print(f"SnarkJS: {snarkjs_version}")
             print(f"zk-regex: {zk_regex_version}")
+            print(f"Circom: {circom_version}")
+            if args.circom_prove:
+                snarkjs_version = SnarkjsSubprocess.get_installed_version()
+                print(f"SnarkJS: {snarkjs_version}")
+
         except ValueError as e:
             print(e)
             exit(1)
@@ -156,6 +178,20 @@ def do_fuzz(args):
                 print(f"Path to ptau file {ptau_path} does not exist.")
                 exit(1)
 
+    elif args.target == "noir":
+        try:
+            zk_regex_version = ZkRegexSubprocess.get_installed_version()
+            noir_version = NoirSubprocess.get_installed_version()
+            print("-" * 80)
+            print(f"zk-regex: {zk_regex_version}")
+            print(f"Noir: {noir_version}")
+            if args.noir_prove:
+                bb_version = BarretenbergSubprocess.get_installed_version()
+                print(f"Barretenberg: {bb_version}")
+        except ValueError as e:
+            print(e)
+            exit(1)
+
     print("-" * 80)
     print(f"Fuzzing with {args.fuzzer} fuzzer.")
     print("=" * 80)
@@ -199,12 +235,6 @@ def do_reproduce(args):
 def main():
     
     parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--logger-level",
-        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
-        default="INFO",
-        help="Set the logger level (default: INFO)."
-    )
 
     subparser = parser.add_subparsers(dest="subcommand")
     subparser.add_parser(
diff --git a/src/zkregex_fuzzer/configs.py b/src/zkregex_fuzzer/configs.py
@@ -1,11 +1,12 @@
-from zkregex_fuzzer.runner import CircomRunner, PythonReRunner
+from zkregex_fuzzer.runner import CircomRunner, PythonReRunner, NoirRunner
 from zkregex_fuzzer.grammar import REGEX_GRAMMAR
 from zkregex_fuzzer.regexgen import GrammarRegexGenerator, DatabaseRegexGenerator
 from zkregex_fuzzer.vinpgen import GrammarBasedGenerator, RstrGenerator, ExrexGenerator
 
 
 TARGETS = {
     "circom": CircomRunner,
+    "noir": NoirRunner,
     "python_re": PythonReRunner,
 }
 
diff --git a/src/zkregex_fuzzer/fuzzer.py b/src/zkregex_fuzzer/fuzzer.py
@@ -61,7 +61,7 @@ def fuzz_with_regexes(
     """
     Fuzz test with pre-seeded regexes.
     """
-    max_input_size = kwargs.get("circom_max_input_size", None)
+    max_input_size = kwargs.get("max_input_size", None)
     oracle, oracle_generator = oracle_params
     if oracle:
         generator = VALID_INPUT_GENERATORS[oracle_generator]
diff --git a/src/zkregex_fuzzer/runner/__init__.py b/src/zkregex_fuzzer/runner/__init__.py
@@ -1,3 +1,4 @@
 from .base_runner import Runner, RegexCompileError, RegexRunError
 from .python import PythonReRunner
-from .circom import CircomRunner
+from .circom import CircomRunner
+from .noir import NoirRunner
diff --git a/src/zkregex_fuzzer/runner/circom.py b/src/zkregex_fuzzer/runner/circom.py
@@ -6,227 +6,7 @@
 from pathlib import Path
 from zkregex_fuzzer.logger import logger
 from zkregex_fuzzer.runner.base_runner import Runner, RegexCompileError, RegexRunError
-
-class ZkRegexSubprocess:
-
-    @classmethod
-    def get_installed_version(cls) -> str:
-        """
-        Get the installed version of zk-regex.
-        """
-        if shutil.which("zk-regex"):
-            cmd = ["zk-regex", "--version"]
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            return result.stdout.strip()
-        else:
-            raise ValueError("zk-regex is not installed")
-
-    @classmethod
-    def compile(cls, json_file_path: str, output_file_path: str, template_name: str = "TestRegex", substr=True):
-        """
-        Compile a regex using zk-regex.
-        """
-        cmd = [
-            "zk-regex", "decomposed", 
-            "-d", json_file_path, 
-            "-c", output_file_path,
-            "-t", template_name,
-            "-g", "true" if substr else "false"
-            ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            raise RegexCompileError(f"Error compiling with zk-regex: {result.stderr}")
-        
-class CircomSubprocess:
-
-    @classmethod
-    def get_installed_version(cls) -> str:
-        """
-        Get the installed version of Circom.
-        """
-        if shutil.which("circom"):
-            cmd = ["circom", "--version"]
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            return result.stdout.strip()
-        else:
-            raise ValueError("Circom is not installed")
-
-    @classmethod
-    def compile(cls, circom_file_path: str, link_path: list[str]) -> tuple[str, str]:
-        """
-        Compile a circom file to r1cs and wasm.
-        """
-
-        base_name = Path(circom_file_path).stem
-        base_dir = Path(circom_file_path).parent
-
-        cmd = [
-            "circom", circom_file_path, "--wasm", "--r1cs", "-o", str(base_dir)
-        ]
-        for path in link_path:
-            cmd.append("-l")
-            cmd.append(path)
-
-        logger.debug(" ".join(cmd))
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            raise RegexCompileError(f"Error compiling with Circom: {result.stderr}")
-        
-        r1cs_file_path = base_dir / f"{base_name}.r1cs"
-        wasm_file_path = base_dir / f"{base_name}_js/{base_name}.wasm"
-        return str(wasm_file_path), str(r1cs_file_path)
-
-class SnarkjsSubprocess:
-
-    @classmethod
-    def get_installed_version(cls) -> str:
-        """
-        Get the installed version of SnarkJS.
-        """
-        if shutil.which("snarkjs"):
-            cmd = ["snarkjs", "--help"]
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            return result.stdout.split('\n')[0]
-        else:
-            raise ValueError("SnarkJS is not installed")
-        
-    @classmethod
-    def setup_zkey(cls, circuit_path: str, ptau_path: str) -> str:
-        """
-        Setup the circuit with the powers of tau.
-        """
-
-        base_name = Path(circuit_path).stem
-        output_path = str(Path(circuit_path).parent / f"{base_name}.zkey")
-
-        cmd = [
-            "snarkjs", "groth16", "setup", 
-            circuit_path, 
-            ptau_path,
-            output_path
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            raise RegexRunError(f"Error running with SnarkJS: {result.stderr}")
-        
-        return str(output_path)
-    
-    @classmethod
-    def export_verification_key(cls, zkey_path: str) -> str:
-        """
-        Export the verification key from the zkey.
-        """
-        
-        base_name = Path(zkey_path).stem
-        output_path = str(Path(zkey_path).parent / f"{base_name}.vkey.json")
-
-        cmd = [
-            "snarkjs", "zkey", "export", "verificationkey", 
-            zkey_path, 
-            output_path
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            raise RegexRunError(f"Error running with SnarkJS: {result.stdout}")
-        
-        return str(output_path)
-
-    @classmethod
-    def witness_gen(cls, wasm_file_path: str, input_path: str) -> str:
-        """
-        Generate a witness for the wasm file.
-        """
-
-        base_name = Path(wasm_file_path).stem
-        output_path = str(Path(input_path).parent / f"{base_name}.wtns")
-
-        cmd = [
-            "snarkjs", "wtns", "calculate", 
-            wasm_file_path, 
-            input_path, 
-            output_path
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        logger.debug(" ".join(cmd))
-        if result.returncode != 0:
-            raise RegexRunError(f"Error running with SnarkJS: {result.stdout}")
-        
-        return str(output_path)
-    
-    @classmethod
-    def prove(cls, zkey_path: str, witness_path: str) -> tuple[str, str]:
-        """
-        geenrate proof from the witness with the zkey.
-        """
-
-        base_name = Path(zkey_path).stem
-        proof_path = str(Path(witness_path).parent / f"{base_name}.proof.json")
-        public_input_path = str(Path(witness_path).parent / f"{base_name}.public.json")
-
-        cmd = [
-            "snarkjs", "groth16", "prove", 
-            zkey_path, 
-            witness_path, 
-            proof_path,
-            public_input_path
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            raise RegexRunError(f"Error running with SnarkJS: {result.stdout}")
-        
-        return proof_path, public_input_path
-    
-    @classmethod
-    def verify(cls, vkey_path: str, proof_path: str, public_input_path: str) -> bool:
-        """
-        Verify the proof with the verification key.
-        """
-
-        cmd = [
-            "snarkjs", "groth16", "verify", 
-            vkey_path, 
-            public_input_path,
-            proof_path, 
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            raise RegexRunError(f"Error running with SnarkJS: {result.stdout}")
-        
-        return "OK" in result.stdout
-    
-    @classmethod
-    def extract_witness(cls, witness_path: str) -> dict:
-        """
-        Extract the witness from the witness file.
-        """
-
-        base_name = Path(witness_path).stem
-        output_path = str(Path(witness_path).parent / f"{base_name}.json")
-
-        cmd = [
-            "snarkjs", "wtns", "export", "json",
-            witness_path, 
-            output_path, 
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        logger.debug(" ".join(cmd))
-        if result.returncode != 0:
-            logger.debug(result.stdout)
-            raise RegexRunError(f"Error running with SnarkJS: {result.stdout}")
-        
-        json_result = json.loads(open(output_path, 'r').read())
-        Path(output_path).unlink()
-
-        return json_result
-        
+from zkregex_fuzzer.runner.subprocess import ZkRegexSubprocess, CircomSubprocess, SnarkjsSubprocess
 
 class CircomRunner(Runner):
     """
@@ -244,7 +24,7 @@ def __init__(self, regex: str, kwargs: dict):
         self._run_the_prover = kwargs.get("circom_prove", False)
         self._ptau_path = kwargs.get("circom_ptau", None)
         self._link_path = kwargs.get("circom_library", [])
-        self._circom_max_input_size = kwargs.get("circom_max_input_size", 200)
+        self._circom_max_input_size = kwargs.get("max_input_size", 200)
         self._template_name = "TestRegex"
         super().__init__(regex, kwargs)
         self._runner = "Circom"
@@ -274,7 +54,7 @@ def compile(self, regex: str) -> None:
 
         # Call zk-regex to generate the circom code
         logger.debug(f"Generating circom code starts")
-        ZkRegexSubprocess.compile(json_file_path, circom_file_path, self._template_name)
+        ZkRegexSubprocess.compile_to_circom(json_file_path, circom_file_path, self._template_name)
         logger.debug(f"Generating circom code ends")
 
         # Append the circom file to include the main function
diff --git a/src/zkregex_fuzzer/runner/noir.py b/src/zkregex_fuzzer/runner/noir.py
diff --git a/src/zkregex_fuzzer/runner/subprocess.py b/src/zkregex_fuzzer/runner/subprocess.py
