feat!: switch bb over to read ACIR from nargo artifacts

barretenberg/acir_tests/flows/all_cmds.sh

@@ -2,7 +2,7 @@
 set -eu
 
 VFLAG=${VERBOSE:+-v}
-BFLAG="-b ./target/acir.gz"
+BFLAG="-b ./target/program.json"
 FLAGS="-c $CRS_PATH $VFLAG"
 
 # Test we can perform the proof/verify flow.
@@ -19,4 +19,4 @@ $BIN contract -k vk $BFLAG -o - | grep "Verification Key Hash" > /dev/null
 OUTPUT=$($BIN proof_as_fields -k vk -p proof -o - | jq .)
 [ -n "$OUTPUT" ] || exit 1
 OUTPUT=$($BIN vk_as_fields -k vk -o - | jq .)
-[ -n "$OUTPUT" ] || exit 1
+[ -n "$OUTPUT" ] || exit 1

barretenberg/acir_tests/flows/prove_and_verify.sh

@@ -5,4 +5,4 @@ VFLAG=${VERBOSE:+-v}
 
 # This is the fastest flow, because it only generates pk/vk once, gate count once, etc.
 # It may not catch all class of bugs.
-$BIN prove_and_verify $VFLAG -c $CRS_PATH -b ./target/acir.gz
+$BIN prove_and_verify $VFLAG -c $CRS_PATH -b ./target/program.json

barretenberg/acir_tests/flows/prove_and_verify_goblin.sh

@@ -3,7 +3,7 @@ set -eu
 
 VFLAG=${VERBOSE:+-v}
 
-$BIN prove_and_verify_goblin $VFLAG -c $CRS_PATH -b ./target/acir.gz
+$BIN prove_and_verify_goblin $VFLAG -c $CRS_PATH -b ./target/program.json
 
 # This command can be used to run all of the tests in sequence with the debugger
-# lldb-16 -o run -b -- $BIN prove_and_verify_goblin $VFLAG -c $CRS_PATH -b ./target/acir.gz
+# lldb-16 -o run -b -- $BIN prove_and_verify_goblin $VFLAG -c $CRS_PATH -b ./target/program.json

barretenberg/acir_tests/flows/prove_and_verify_goblin_ultra_honk.sh

@@ -3,4 +3,4 @@ set -eu
 
 VFLAG=${VERBOSE:+-v}
 
-$BIN prove_and_verify_goblin_ultra_honk $VFLAG -c $CRS_PATH -b ./target/acir.gz
+$BIN prove_and_verify_goblin_ultra_honk $VFLAG -c $CRS_PATH -b ./target/program.json

barretenberg/acir_tests/flows/prove_and_verify_ultra_honk.sh

@@ -3,4 +3,4 @@ set -eu
 
 VFLAG=${VERBOSE:+-v}
 
-$BIN prove_and_verify_ultra_honk $VFLAG -c $CRS_PATH -b ./target/acir.gz
+$BIN prove_and_verify_ultra_honk $VFLAG -c $CRS_PATH -b ./target/program.json

barretenberg/acir_tests/flows/prove_and_verify_ultra_honk_program.sh

@@ -3,4 +3,4 @@ set -eu
 
 VFLAG=${VERBOSE:+-v}
 
-$BIN prove_and_verify_ultra_honk_program $VFLAG -c $CRS_PATH -b ./target/acir.gz
+$BIN prove_and_verify_ultra_honk_program $VFLAG -c $CRS_PATH -b ./target/program.json

barretenberg/acir_tests/flows/prove_then_verify.sh

@@ -2,7 +2,7 @@
 set -eu
 
 VFLAG=${VERBOSE:+-v}
-BFLAG="-b ./target/acir.gz"
+BFLAG="-b ./target/program.json"
 FLAGS="-c $CRS_PATH $VFLAG"
 
 # Test we can perform the proof/verify flow.

barretenberg/acir_tests/flows/prove_then_verify_goblin_ultra_honk.sh

@@ -2,7 +2,7 @@
 set -eu
 
 VFLAG=${VERBOSE:+-v}
-BFLAG="-b ./target/acir.gz"
+BFLAG="-b ./target/program.json"
 FLAGS="-c $CRS_PATH $VFLAG"
 
 # Test we can perform the proof/verify flow.

barretenberg/acir_tests/flows/prove_then_verify_ultra_honk.sh

@@ -2,7 +2,7 @@
 set -eu
 
 VFLAG=${VERBOSE:+-v}
-BFLAG="-b ./target/acir.gz"
+BFLAG="-b ./target/program.json"
 FLAGS="-c $CRS_PATH $VFLAG"
 
 # Test we can perform the proof/verify flow.

barretenberg/acir_tests/flows/sol.sh

@@ -8,7 +8,7 @@ export PROOF_AS_FIELDS="$(pwd)/proof_fields.json"
 $BIN prove -o proof
 $BIN write_vk  -o vk
 $BIN proof_as_fields -k vk -c $CRS_PATH -p $PROOF
-$BIN contract -k vk -c $CRS_PATH -b ./target/acir.gz -o Key.sol
+$BIN contract -k vk -c $CRS_PATH -b ./target/program.json -o Key.sol
 
 # Export the paths to the environment variables for the js test runner
 export KEY_PATH="$(pwd)/Key.sol"
@@ -20,4 +20,4 @@ export BASE_PATH=$(realpath "../../../sol/src/ultra/BaseUltraVerifier.sol")
 # index.js will start an anvil, on a random port
 # Deploy the verifier then send a test transaction
 export TEST_NAME=$(basename $(pwd))
-node ../../sol-test/src/index.js
+node ../../sol-test/src/index.js

barretenberg/acir_tests/flows/write_contract.sh

@@ -4,4 +4,4 @@ set -eu
 export TEST_NAME=$(basename $(pwd))
 
 $BIN write_vk  -o vk
-$BIN contract -k vk -c $CRS_PATH -b ./target/acir.gz -o $TEST_NAME.sol
+$BIN contract -k vk -c $CRS_PATH -b ./target/program.json -o $TEST_NAME.sol

barretenberg/acir_tests/gen_inner_proof_inputs.sh

@@ -36,7 +36,7 @@ $BIN vk_as_fields $VFLAG -c $CRS_PATH
 echo "Generate proof to file..."
 [ -d "$PROOF_DIR" ] || mkdir $PWD/proofs
 [ -e "$PROOF_PATH" ] || touch $PROOF_PATH
-$BIN prove $VFLAG -c $CRS_PATH -b ./target/acir.gz -o "./proofs/$PROOF_NAME" $RFLAG
+$BIN prove $VFLAG -c $CRS_PATH -b ./target/program.json -o "./proofs/$PROOF_NAME" $RFLAG
 
 echo "Write proof as fields for recursion..."
 $BIN proof_as_fields $VFLAG -c $CRS_PATH -p "./proofs/$PROOF_NAME"

barretenberg/acir_tests/headless-test/src/index.ts

@@ -38,9 +38,17 @@ function formatAndPrintLog(message: string): void {
 }
 
 const readBytecodeFile = (path: string): Uint8Array => {
-  const data = fs.readFileSync(path);
-  const buffer = gunzipSync(data);
-  return buffer;
+  const extension = path.substring(path.lastIndexOf('.') + 1);
+
+  if (extension == 'json') {
+    const encodedCircuit = JSON.parse(fs.readFileSync(path, 'utf8'));
+    const decompressed = gunzipSync(Uint8Array.from(atob(encodedCircuit.bytecode), c => c.charCodeAt(0)));
+    return decompressed;
+  }
+
+  const encodedCircuit = fs.readFileSync(path);
+  const decompressed = gunzipSync(encodedCircuit);
+  return decompressed;
 };
 
 const readWitnessFile = (path: string): Uint8Array => {

barretenberg/acir_tests/run_acir_tests.sh

@@ -73,7 +73,7 @@ else
       continue
     fi
 
-    if [[ ! -f ./$TEST_NAME/target/acir.gz || ! -f ./$TEST_NAME/target/witness.gz ]]; then
+    if [[ ! -f ./$TEST_NAME/target/program.json || ! -f ./$TEST_NAME/target/witness.gz ]]; then
       echo -e "\033[33mSKIPPED\033[0m (uncompiled)"
       continue
     fi

barretenberg/cpp/src/barretenberg/bb/get_bytecode.hpp

@@ -1,11 +1,20 @@
 #pragma once
 #include "exec_pipe.hpp"
+#include <filesystem>
 
 /**
  * We can assume for now we're running on a unix like system and use the following to extract the bytecode.
  */
 inline std::vector<uint8_t> get_bytecode(const std::string& bytecodePath)
 {
+    std::filesystem::path filePath = bytecodePath;
+    if (filePath.extension() == ".json") {
+        // Try reading json files as if they are a Nargo build artifact
+        std::string command = "jq -r '.bytecode' \"" + bytecodePath + "\" | base64 -d | gunzip -c";
+        return exec_pipe(command);
+    }
+
+    // For other extensions, assume file is a raw ACIR program
     std::string command = "gunzip -c \"" + bytecodePath + "\"";
     return exec_pipe(command);
-}
+}

barretenberg/cpp/src/barretenberg/bb/main.cpp

@@ -754,7 +754,7 @@ int main(int argc, char* argv[])
 
         std::string command = args[0];
 
-        std::string bytecode_path = get_option(args, "-b", "./target/acir.gz");
+        std::string bytecode_path = get_option(args, "-b", "./target/program.json");
         std::string witness_path = get_option(args, "-w", "./target/witness.gz");
         std::string proof_path = get_option(args, "-p", "./proofs/proof");
         std::string vk_path = get_option(args, "-k", "./target/vk");

barretenberg/ts/src/main.ts

@@ -21,6 +21,14 @@ const MAX_CIRCUIT_SIZE = 2 ** 19;
 const threads = +process.env.HARDWARE_CONCURRENCY! || undefined;
 
 function getBytecode(bytecodePath: string) {
+  const extension = bytecodePath.substring(bytecodePath.lastIndexOf('.') + 1);
+
+  if (extension == 'json') {
+    const encodedCircuit = JSON.parse(readFileSync(bytecodePath, 'utf8'));
+    const decompressed = gunzipSync(Buffer.from(encodedCircuit.bytecode, 'base64'));
+    return decompressed;
+  }
+
   const encodedCircuit = readFileSync(bytecodePath);
   const decompressed = gunzipSync(encodedCircuit);
   return decompressed;

noir/noir-repo/compiler/noirc_driver/src/lib.rs

@@ -84,10 +84,6 @@ pub struct CompileOptions {
     #[arg(long, conflicts_with = "deny_warnings")]
     pub silence_warnings: bool,
 
-    /// Output ACIR gzipped bytecode instead of the JSON artefact
-    #[arg(long, hide = true)]
-    pub only_acir: bool,
-
     /// Disables the builtin Aztec macros being used in the compiler
     #[arg(long, hide = true)]
     pub disable_macros: bool,

noir/noir-repo/test_programs/execution_success/unit_value/Nargo.toml

@@ -1,7 +1,7 @@
 [package]
-name = "short"
+name = "unit_value"
 type = "bin"
 authors = [""]
 compiler_version = ">=0.23.0"
 
-[dependencies]
+[dependencies]

noir/noir-repo/test_programs/rebuild.sh

@@ -16,13 +16,14 @@ process_dir() {
     if [ -d ./target/ ]; then
       rm -r ./target/
     fi
-    nargo compile --only-acir && nargo execute witness
+    nargo execute witness
 
     if [ -d "$current_dir/acir_artifacts/$dir_name/target" ]; then
       rm -r "$current_dir/acir_artifacts/$dir_name/target"
     fi
     mkdir $current_dir/acir_artifacts/$dir_name/target
 
+    mv ./target/$dir_name.json $current_dir/acir_artifacts/$dir_name/target/program.json
     mv ./target/*.gz $current_dir/acir_artifacts/$dir_name/target/
 
     cd $current_dir
@@ -70,4 +71,4 @@ if [ ! -z "$exit_status" ]; then
     echo "Rebuild failed!"
     exit $exit_status
 fi
-echo "Rebuild Succeeded!"
+echo "Rebuild Succeeded!"

noir/noir-repo/tooling/backend_interface/src/cli/contract.rs

@@ -48,15 +48,15 @@ fn contract_command() -> Result<(), BackendError> {
 
     let temp_directory = tempdir().expect("could not create a temporary directory");
     let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
+    let artifact_path = temp_directory_path.join("program.json");
     let vk_path = temp_directory_path.join("vk");
 
     let crs_path = backend.backend_directory();
 
-    std::fs::File::create(&bytecode_path).expect("file should be created");
+    std::fs::File::create(&artifact_path).expect("file should be created");
 
     let write_vk_command = super::WriteVkCommand {
-        bytecode_path,
+        artifact_path,
         vk_path_output: vk_path.clone(),
         crs_path: crs_path.clone(),
     };

noir/noir-repo/tooling/backend_interface/src/cli/gates.rs

@@ -10,7 +10,7 @@ use super::string_from_stderr;
 /// for the given bytecode.
 pub(crate) struct GatesCommand {
     pub(crate) crs_path: PathBuf,
-    pub(crate) bytecode_path: PathBuf,
+    pub(crate) artifact_path: PathBuf,
 }
 
 #[derive(Deserialize)]
@@ -31,7 +31,7 @@ impl GatesCommand {
             .arg("-c")
             .arg(self.crs_path)
             .arg("-b")
-            .arg(self.bytecode_path)
+            .arg(self.artifact_path)
             .output()?;
 
         if !output.status.success() {
@@ -53,12 +53,12 @@ fn gate_command() -> Result<(), BackendError> {
 
     let temp_directory = tempdir().expect("could not create a temporary directory");
     let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
+    let artifact_path = temp_directory_path.join("program.json");
     let crs_path = backend.backend_directory();
 
-    std::fs::File::create(&bytecode_path).expect("file should be created");
+    std::fs::File::create(&artifact_path).expect("file should be created");
 
-    let gate_command = GatesCommand { crs_path, bytecode_path };
+    let gate_command = GatesCommand { crs_path, artifact_path };
 
     let output = gate_command.run(backend.binary_path())?;
     // Mock backend always returns zero gates.

noir/noir-repo/tooling/backend_interface/src/cli/prove.rs

@@ -13,7 +13,7 @@ use super::string_from_stderr;
 /// The proof will be written to the specified output file.
 pub(crate) struct ProveCommand {
     pub(crate) crs_path: PathBuf,
-    pub(crate) bytecode_path: PathBuf,
+    pub(crate) artifact_path: PathBuf,
     pub(crate) witness_path: PathBuf,
 }
 
@@ -26,7 +26,7 @@ impl ProveCommand {
             .arg("-c")
             .arg(self.crs_path)
             .arg("-b")
-            .arg(self.bytecode_path)
+            .arg(self.artifact_path)
             .arg("-w")
             .arg(self.witness_path)
             .arg("-o")
@@ -49,14 +49,14 @@ fn prove_command() -> Result<(), BackendError> {
 
     let temp_directory = tempdir().expect("could not create a temporary directory");
     let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
+    let artifact_path = temp_directory_path.join("acir.gz");
     let witness_path = temp_directory_path.join("witness.tr");
 
-    std::fs::File::create(&bytecode_path).expect("file should be created");
+    std::fs::File::create(&artifact_path).expect("file should be created");
     std::fs::File::create(&witness_path).expect("file should be created");
 
     let crs_path = backend.backend_directory();
-    let prove_command = ProveCommand { crs_path, bytecode_path, witness_path };
+    let prove_command = ProveCommand { crs_path, artifact_path, witness_path };
 
     let proof = prove_command.run(backend.binary_path())?;
     assert_eq!(proof, "proof".as_bytes());

noir/noir-repo/tooling/backend_interface/src/cli/verify.rs

@@ -41,25 +41,25 @@ fn verify_command() -> Result<(), BackendError> {
 
     let temp_directory = tempdir().expect("could not create a temporary directory");
     let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
+    let artifact_path = temp_directory_path.join("acir.json");
     let witness_path = temp_directory_path.join("witness.tr");
     let proof_path = temp_directory_path.join("1_mul.proof");
     let vk_path_output = temp_directory_path.join("vk");
 
     let crs_path = backend.backend_directory();
 
-    std::fs::File::create(&bytecode_path).expect("file should be created");
+    std::fs::File::create(&artifact_path).expect("file should be created");
     std::fs::File::create(&witness_path).expect("file should be created");
 
     let write_vk_command = WriteVkCommand {
-        bytecode_path: bytecode_path.clone(),
+        artifact_path: artifact_path.clone(),
         crs_path: crs_path.clone(),
         vk_path_output: vk_path_output.clone(),
     };
 
     write_vk_command.run(backend.binary_path())?;
 
-    let prove_command = ProveCommand { crs_path: crs_path.clone(), bytecode_path, witness_path };
+    let prove_command = ProveCommand { crs_path: crs_path.clone(), artifact_path, witness_path };
     let proof = prove_command.run(backend.binary_path())?;
 
     write_to_file(&proof, &proof_path);

noir/noir-repo/tooling/backend_interface/src/cli/write_vk.rs

@@ -7,7 +7,7 @@ use crate::BackendError;
 /// to write a verification key to a file
 pub(crate) struct WriteVkCommand {
     pub(crate) crs_path: PathBuf,
-    pub(crate) bytecode_path: PathBuf,
+    pub(crate) artifact_path: PathBuf,
     pub(crate) vk_path_output: PathBuf,
 }
 
@@ -21,7 +21,7 @@ impl WriteVkCommand {
             .arg("-c")
             .arg(self.crs_path)
             .arg("-b")
-            .arg(self.bytecode_path)
+            .arg(self.artifact_path)
             .arg("-o")
             .arg(self.vk_path_output);
 
@@ -42,14 +42,14 @@ fn write_vk_command() -> Result<(), BackendError> {
 
     let temp_directory = tempdir().expect("could not create a temporary directory");
     let temp_directory_path = temp_directory.path();
-    let bytecode_path = temp_directory_path.join("acir.gz");
+    let artifact_path = temp_directory_path.join("program.json");
     let vk_path_output = temp_directory.path().join("vk");
 
     let crs_path = backend.backend_directory();
 
-    std::fs::File::create(&bytecode_path).expect("file should be created");
+    std::fs::File::create(&artifact_path).expect("file should be created");
 
-    let write_vk_command = WriteVkCommand { bytecode_path, crs_path, vk_path_output };
+    let write_vk_command = WriteVkCommand { artifact_path, crs_path, vk_path_output };
 
     write_vk_command.run(backend.binary_path())?;
     drop(temp_directory);