feat: bb faster init

barretenberg/acir_tests/flows/all_cmds.sh

@@ -19,6 +19,8 @@ $BIN verify -k vk -p proof $FLAGS
 # Check supplemental functions.
 # Grep to determine success.
 $BIN contract -k vk $BFLAG -o - | grep "Verification Key Hash" > /dev/null
-# Use jq to determine success.
-$BIN proof_as_fields -k vk -p proof -o - | jq . > /dev/null
-$BIN vk_as_fields -k vk -o - > vk_as_fields | jq . > /dev/null
+# Use jq to determine success, and also check result not empty.
+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

barretenberg/cpp/src/barretenberg/bb/file_io.hpp

@@ -1,9 +1,10 @@
 #pragma once
 #include <barretenberg/common/log.hpp>
 #include <fstream>
+#include <ios>
 #include <vector>
 
-inline std::vector<uint8_t> read_file(const std::string& filename)
+inline std::vector<uint8_t> read_file(const std::string& filename, size_t bytes = 0)
 {
     // Open the file in binary mode and move to the end.
     std::ifstream file(filename, std::ios::binary | std::ios::ate);
@@ -12,7 +13,7 @@ inline std::vector<uint8_t> read_file(const std::string& filename)
     }
 
     // Get the file size.
-    std::streamsize size = file.tellg();
+    std::streamsize size = bytes == 0 ? (std::streamsize)file.tellg() : (std::streamsize)bytes;
     if (size <= 0) {
         throw std::runtime_error("File is empty or there's an error reading it: " + filename);
     }

barretenberg/cpp/src/barretenberg/bb/get_crs.hpp

@@ -65,7 +65,7 @@ inline std::vector<barretenberg::g1::affine_element> get_g1_data(const std::file
     }
     if (size >= num_points) {
         vinfo("using cached crs at: ", path);
-        auto data = read_file(path / "g1.dat");
+        auto data = read_file(path / "g1.dat", 28 + num_points * 64);
         auto points = std::vector<barretenberg::g1::affine_element>(num_points);
         auto size_of_points_in_bytes = num_points * 64;
         barretenberg::srs::IO<curve::BN254>::read_affine_elements_from_buffer(

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

@@ -13,17 +13,29 @@
 #include <vector>
 
 using namespace barretenberg;
-// Transcript downloading code only supports fetching and parsing the first transcript file.
-const uint32_t MAX_CIRCUIT_SIZE = 1 << 22;
 std::string CRS_PATH = "./crs";
 bool verbose = false;
 
-void init()
+acir_proofs::AcirComposer init(acir_format::acir_format& constraint_system)
 {
+    acir_proofs::AcirComposer acir_composer(0, verbose);
+    acir_composer.create_circuit(constraint_system);
+    auto subgroup_size = acir_composer.get_circuit_subgroup_size();
+
     // Must +1!
-    auto g1_data = get_g1_data(CRS_PATH, MAX_CIRCUIT_SIZE + 1);
+    auto g1_data = get_g1_data(CRS_PATH, subgroup_size + 1);
     auto g2_data = get_g2_data(CRS_PATH);
     srs::init_crs_factory(g1_data, g2_data);
+
+    return acir_composer;
+}
+
+acir_proofs::AcirComposer init()
+{
+    acir_proofs::AcirComposer acir_composer(0, verbose);
+    auto g2_data = get_g2_data(CRS_PATH);
+    srs::init_crs_factory({}, g2_data);
+    return acir_composer;
 }
 
 acir_format::WitnessVector get_witness(std::string const& witness_path)
@@ -53,9 +65,10 @@ acir_format::acir_format get_constraint_system(std::string const& bytecode_path)
  */
 bool proveAndVerify(const std::string& bytecodePath, const std::string& witnessPath, bool recursive)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
     auto witness = get_witness(witnessPath);
+    auto acir_composer = init(constraint_system);
+
     auto proof = acir_composer.create_proof(constraint_system, witness, recursive);
     auto verified = acir_composer.verify_proof(proof, recursive);
 
@@ -80,9 +93,9 @@ void prove(const std::string& bytecodePath,
            bool recursive,
            const std::string& outputPath)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
     auto witness = get_witness(witnessPath);
+    auto acir_composer = init(constraint_system);
     auto proof = acir_composer.create_proof(constraint_system, witness, recursive);
 
     if (outputPath == "-") {
@@ -104,9 +117,8 @@ void prove(const std::string& bytecodePath,
  */
 void gateCount(const std::string& bytecodePath)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
-    acir_composer.create_circuit(constraint_system);
+    auto acir_composer = init(constraint_system);
     auto gate_count = acir_composer.get_total_circuit_size();
 
     writeUint64AsRawBytesToStdout(static_cast<uint64_t>(gate_count));
@@ -131,7 +143,7 @@ void gateCount(const std::string& bytecodePath)
  */
 bool verify(const std::string& proof_path, bool recursive, const std::string& vk_path)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
+    auto acir_composer = init();
     auto vk_data = from_buffer<plonk::verification_key_data>(read_file(vk_path));
     acir_composer.load_verification_key(std::move(vk_data));
     auto verified = acir_composer.verify_proof(read_file(proof_path), recursive);
@@ -153,8 +165,8 @@ bool verify(const std::string& proof_path, bool recursive, const std::string& vk
  */
 void writeVk(const std::string& bytecodePath, const std::string& outputPath)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
+    auto acir_composer = init(constraint_system);
     acir_composer.init_proving_key(constraint_system);
     auto vk = acir_composer.init_verification_key();
     auto serialized_vk = to_buffer(*vk);
@@ -182,7 +194,7 @@ void writeVk(const std::string& bytecodePath, const std::string& outputPath)
  */
 void contract(const std::string& output_path, const std::string& vk_path)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
+    auto acir_composer = init();
     auto vk_data = from_buffer<plonk::verification_key_data>(read_file(vk_path));
     acir_composer.load_verification_key(std::move(vk_data));
     auto contract = acir_composer.get_solidity_verifier();
@@ -223,7 +235,7 @@ void contract(const std::string& output_path, const std::string& vk_path)
  */
 void proofAsFields(const std::string& proof_path, std::string const& vk_path, const std::string& output_path)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
+    auto acir_composer = init();
     auto vk_data = from_buffer<plonk::verification_key_data>(read_file(vk_path));
     auto data = acir_composer.serialize_proof_into_fields(read_file(proof_path), vk_data.num_public_inputs);
     auto json = format("[", join(map(data, [](auto fr) { return format("\"", fr, "\""); })), "]");
@@ -252,7 +264,7 @@ void proofAsFields(const std::string& proof_path, std::string const& vk_path, co
  */
 void vkAsFields(const std::string& vk_path, const std::string& output_path)
 {
-    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
+    auto acir_composer = init();
     auto vk_data = from_buffer<plonk::verification_key_data>(read_file(vk_path));
     acir_composer.load_verification_key(std::move(vk_data));
     auto data = acir_composer.serialize_verification_key_into_fields();
@@ -338,17 +350,17 @@ int main(int argc, char* argv[])
         if (command == "--version") {
             writeStringToStdout(BB_VERSION);
             return 0;
-        } else if (command == "info") {
+        }
+        if (command == "info") {
             std::string output_path = getOption(args, "-o", "info.json");
             acvmInfo(output_path);
             return 0;
         }
 
-        init();
-
         if (command == "prove_and_verify") {
             return proveAndVerify(bytecode_path, witness_path, recursive) ? 0 : 1;
-        } else if (command == "prove") {
+        }
+        if (command == "prove") {
             std::string output_path = getOption(args, "-o", "./proofs/proof");
             prove(bytecode_path, witness_path, recursive, output_path);
         } else if (command == "gates") {

barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp

@@ -58,6 +58,7 @@ std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constr
     composer_ = acir_format::Composer(/*p_key=*/0, /*v_key=*/0);
 
     vinfo("building circuit...");
+    builder_ = acir_format::Builder(size_hint_);
     create_circuit_with_witness(builder_, constraint_system, witness);
     vinfo("gates: ", builder_.get_total_circuit_size());
 

barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp

@@ -29,6 +29,7 @@ class AcirComposer {
     std::string get_solidity_verifier();
     size_t get_exact_circuit_size() { return exact_circuit_size_; };
     size_t get_total_circuit_size() { return total_circuit_size_; };
+    size_t get_circuit_subgroup_size() { return circuit_subgroup_size_; };
 
     std::vector<barretenberg::fr> serialize_proof_into_fields(std::vector<uint8_t> const& proof,
                                                               size_t num_inner_public_inputs);