chore: Use global crs in more places. Less pain.

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

@@ -53,11 +53,11 @@ acir_format::acir_format get_constraint_system(std::string const& bytecode_path)
  */
 bool proveAndVerify(const std::string& bytecodePath, const std::string& witnessPath, bool recursive)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
     auto witness = get_witness(witnessPath);
-    auto proof = acir_composer->create_proof(srs::get_crs_factory(), constraint_system, witness, recursive);
-    auto verified = acir_composer->verify_proof(proof, recursive);
+    auto proof = acir_composer.create_proof(constraint_system, witness, recursive);
+    auto verified = acir_composer.verify_proof(proof, recursive);
 
     vinfo("verified: ", verified);
     return verified;
@@ -80,10 +80,10 @@ void prove(const std::string& bytecodePath,
            bool recursive,
            const std::string& outputPath)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
     auto witness = get_witness(witnessPath);
-    auto proof = acir_composer->create_proof(srs::get_crs_factory(), constraint_system, witness, recursive);
+    auto proof = acir_composer.create_proof(constraint_system, witness, recursive);
 
     if (outputPath == "-") {
         writeRawBytesToStdout(proof);
@@ -104,10 +104,10 @@ void prove(const std::string& bytecodePath,
  */
 void gateCount(const std::string& bytecodePath)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
-    acir_composer->create_circuit(constraint_system);
-    auto gate_count = acir_composer->get_total_circuit_size();
+    acir_composer.create_circuit(constraint_system);
+    auto gate_count = acir_composer.get_total_circuit_size();
 
     writeUint64AsRawBytesToStdout(static_cast<uint64_t>(gate_count));
     vinfo("gate count: ", gate_count);
@@ -131,10 +131,10 @@ void gateCount(const std::string& bytecodePath)
  */
 bool verify(const std::string& proof_path, bool recursive, const std::string& vk_path)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto vk_data = from_buffer<plonk::verification_key_data>(read_file(vk_path));
-    acir_composer->load_verification_key(barretenberg::srs::get_crs_factory(), std::move(vk_data));
-    auto verified = acir_composer->verify_proof(read_file(proof_path), recursive);
+    acir_composer.load_verification_key(std::move(vk_data));
+    auto verified = acir_composer.verify_proof(read_file(proof_path), recursive);
 
     vinfo("verified: ", verified);
 
@@ -153,10 +153,10 @@ bool verify(const std::string& proof_path, bool recursive, const std::string& vk
  */
 void writeVk(const std::string& bytecodePath, const std::string& outputPath)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto constraint_system = get_constraint_system(bytecodePath);
-    acir_composer->init_proving_key(srs::get_crs_factory(), constraint_system);
-    auto vk = acir_composer->init_verification_key();
+    acir_composer.init_proving_key(constraint_system);
+    auto vk = acir_composer.init_verification_key();
     auto serialized_vk = to_buffer(*vk);
     if (outputPath == "-") {
         writeRawBytesToStdout(serialized_vk);
@@ -182,10 +182,10 @@ void writeVk(const std::string& bytecodePath, const std::string& outputPath)
  */
 void contract(const std::string& output_path, const std::string& vk_path)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto vk_data = from_buffer<plonk::verification_key_data>(read_file(vk_path));
-    acir_composer->load_verification_key(barretenberg::srs::get_crs_factory(), std::move(vk_data));
-    auto contract = acir_composer->get_solidity_verifier();
+    acir_composer.load_verification_key(std::move(vk_data));
+    auto contract = acir_composer.get_solidity_verifier();
 
     if (output_path == "-") {
         writeStringToStdout(contract);
@@ -223,9 +223,9 @@ 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)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     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 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, "\""); })), "]");
 
     if (output_path == "-") {
@@ -252,10 +252,10 @@ 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)
 {
-    auto acir_composer = new acir_proofs::AcirComposer(MAX_CIRCUIT_SIZE, verbose);
+    acir_proofs::AcirComposer acir_composer(MAX_CIRCUIT_SIZE, verbose);
     auto vk_data = from_buffer<plonk::verification_key_data>(read_file(vk_path));
-    acir_composer->load_verification_key(barretenberg::srs::get_crs_factory(), std::move(vk_data));
-    auto data = acir_composer->serialize_verification_key_into_fields();
+    acir_composer.load_verification_key(std::move(vk_data));
+    auto data = acir_composer.serialize_verification_key_into_fields();
 
     // We need to move vk_hash to the front...
     std::rotate(data.begin(), data.end() - 1, data.end());

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

@@ -31,9 +31,7 @@ void AcirComposer::create_circuit(acir_format::acir_format& constraint_system)
     size_hint_ = circuit_subgroup_size_;
 }
 
-void AcirComposer::init_proving_key(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
-    acir_format::acir_format& constraint_system)
+void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system)
 {
     vinfo("building circuit... ", size_hint_);
     builder_ = acir_format::Builder(size_hint_);
@@ -47,16 +45,14 @@ void AcirComposer::init_proving_key(
     total_circuit_size_ = builder_.get_total_circuit_size();
     circuit_subgroup_size_ = builder_.get_circuit_subgroup_size(total_circuit_size_);
 
-    composer_ = acir_format::Composer(crs_factory);
+    composer_ = acir_format::Composer();
     vinfo("computing proving key...");
     proving_key_ = composer_.compute_proving_key(builder_);
 }
 
-std::vector<uint8_t> AcirComposer::create_proof(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
-    acir_format::acir_format& constraint_system,
-    acir_format::WitnessVector& witness,
-    bool is_recursive)
+std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constraint_system,
+                                                acir_format::WitnessVector& witness,
+                                                bool is_recursive)
 {
     // Release prior memory first.
     composer_ = acir_format::Composer(/*p_key=*/0, /*v_key=*/0);
@@ -67,12 +63,10 @@ std::vector<uint8_t> AcirComposer::create_proof(
 
     composer_ = [&]() {
         if (proving_key_) {
-            auto composer = acir_format::Composer(proving_key_, verification_key_);
-            // You can't produce the verification key unless you manually set the crs. Which seems like a bug.
-            composer_.crs_factory_ = crs_factory;
+            auto composer = acir_format::Composer(proving_key_, nullptr);
             return composer;
         } else {
-            return acir_format::Composer(crs_factory);
+            return acir_format::Composer();
         }
     }();
     if (!proving_key_) {
@@ -108,12 +102,10 @@ std::shared_ptr<proof_system::plonk::verification_key> AcirComposer::init_verifi
     return verification_key_;
 }
 
-void AcirComposer::load_verification_key(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
-    proof_system::plonk::verification_key_data&& data)
+void AcirComposer::load_verification_key(proof_system::plonk::verification_key_data&& data)
 {
-    verification_key_ =
-        std::make_shared<proof_system::plonk::verification_key>(std::move(data), crs_factory->get_verifier_crs());
+    verification_key_ = std::make_shared<proof_system::plonk::verification_key>(
+        std::move(data), srs::get_crs_factory()->get_verifier_crs());
     composer_ = acir_format::Composer(proving_key_, verification_key_);
 }
 

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

@@ -14,18 +14,13 @@ class AcirComposer {
 
     void create_circuit(acir_format::acir_format& constraint_system);
 
-    void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
-                          acir_format::acir_format& constraint_system);
-
-    std::vector<uint8_t> create_proof(
-        std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
-        acir_format::acir_format& constraint_system,
-        acir_format::WitnessVector& witness,
-        bool is_recursive);
-
-    void load_verification_key(
-        std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
-        proof_system::plonk::verification_key_data&& data);
+    void init_proving_key(acir_format::acir_format& constraint_system);
+
+    std::vector<uint8_t> create_proof(acir_format::acir_format& constraint_system,
+                                      acir_format::WitnessVector& witness,
+                                      bool is_recursive);
+
+    void load_verification_key(proof_system::plonk::verification_key_data&& data);
 
     std::shared_ptr<proof_system::plonk::verification_key> init_verification_key();
 

barretenberg/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp

@@ -35,7 +35,7 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr, uint8_t const*
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto constraint_system = acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec));
 
-    acir_composer->init_proving_key(barretenberg::srs::get_crs_factory(), constraint_system);
+    acir_composer->init_proving_key(constraint_system);
 }
 
 WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
@@ -48,16 +48,15 @@ WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
     auto constraint_system = acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec));
     auto witness = acir_format::witness_buf_to_witness_data(from_buffer<std::vector<uint8_t>>(witness_vec));
 
-    auto proof_data =
-        acir_composer->create_proof(barretenberg::srs::get_crs_factory(), constraint_system, witness, *is_recursive);
+    auto proof_data = acir_composer->create_proof(constraint_system, witness, *is_recursive);
     *out = to_heap_buffer(proof_data);
 }
 
 WASM_EXPORT void acir_load_verification_key(in_ptr acir_composer_ptr, uint8_t const* vk_buf)
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto vk_data = from_buffer<plonk::verification_key_data>(vk_buf);
-    acir_composer->load_verification_key(barretenberg::srs::get_crs_factory(), std::move(vk_data));
+    acir_composer->load_verification_key(std::move(vk_data));
 }
 
 WASM_EXPORT void acir_init_verification_key(in_ptr acir_composer_ptr)

barretenberg/cpp/src/barretenberg/examples/c_bind.cpp

@@ -6,7 +6,7 @@ using namespace proof_system::plonk::stdlib::types;
 
 WASM_EXPORT void examples_simple_create_and_verify_proof(bool* valid)
 {
-    auto ptrs = examples::simple::create_builder_and_composer(barretenberg::srs::get_crs_factory());
+    auto ptrs = examples::simple::create_builder_and_composer();
     auto proof = examples::simple::create_proof(ptrs);
     *valid = examples::simple::verify_proof(ptrs, proof);
     examples::simple::delete_builder_and_composer(ptrs);

barretenberg/cpp/src/barretenberg/examples/simple/simple.cpp

@@ -19,8 +19,7 @@ void build_circuit(Builder& builder)
     }
 }
 
-BuilderComposerPtrs create_builder_and_composer(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory)
+BuilderComposerPtrs create_builder_and_composer()
 {
     // WARNING: Size hint is essential to perform 512k circuits!
     auto builder = std::make_unique<Builder>(CIRCUIT_SIZE);
@@ -36,7 +35,7 @@ BuilderComposerPtrs create_builder_and_composer(
     info("composer gates: ", builder->get_num_gates());
 
     info("computing proving key...");
-    auto composer = std::make_unique<Composer>(crs_factory);
+    auto composer = std::make_unique<Composer>();
     auto pk = composer->compute_proving_key(*builder);
 
     return { builder.release(), composer.release() };

barretenberg/cpp/src/barretenberg/examples/simple/simple.hpp

@@ -12,8 +12,7 @@ struct BuilderComposerPtrs {
     Composer* composer;
 };
 
-BuilderComposerPtrs create_builder_and_composer(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory);
+BuilderComposerPtrs create_builder_and_composer();
 
 proof create_proof(BuilderComposerPtrs pair);
 

barretenberg/cpp/src/barretenberg/examples/simple/simple.test.cpp

@@ -8,8 +8,8 @@ namespace examples::simple {
 TEST(examples_simple, create_proof)
 {
     auto srs_path = std::filesystem::absolute("../srs_db/ignition");
-    auto crs_factory = std::make_shared<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>(srs_path);
-    auto ptrs = create_builder_and_composer(crs_factory);
+    srs::init_crs_factory(srs_path);
+    auto ptrs = create_builder_and_composer();
     auto proof = create_proof(ptrs);
     bool valid = verify_proof(ptrs, proof);
     delete_builder_and_composer(ptrs);

barretenberg/cpp/src/barretenberg/join_split_example/proofs/compute_circuit_data.hpp

@@ -56,9 +56,9 @@ circuit_data get_circuit_data(std::string const& name,
     circuit_data data;
     data.srs = srs;
     data.mock = mock;
-    Composer composer(srs);
+    Composer composer;
     Builder builder;
-    Composer mock_proof_composer(srs);
+    Composer mock_proof_composer;
     Builder mock_builder;
     BenchmarkInfoCollator benchmark_collator;