refactor: bye bye shared ptrs for ultra/goblin ultra proving_keys :)

barretenberg/cpp/src/barretenberg/client_ivc/mock_kernel_pinning.test.cpp

@@ -37,7 +37,7 @@ TEST_F(MockKernelTest, PinFoldingKernelSizes)
         kernel_circuit, { func_fold_proof, ivc.vks.func_vk }, {}, kernel_acc);
 
     auto kernel_fold_proof = ivc.accumulate(kernel_circuit);
-    EXPECT_EQ(ivc.prover_instance->proving_key->log_circuit_size, 17);
+    EXPECT_EQ(ivc.prover_instance->proving_key.log_circuit_size, 17);
 
     GoblinUltraCircuitBuilder circuit_3{ ivc.goblin.op_queue };
     GoblinMockCircuits::construct_mock_function_circuit(circuit_3);
@@ -49,5 +49,5 @@ TEST_F(MockKernelTest, PinFoldingKernelSizes)
                                                                    { func_fold_proof, ivc.vks.func_vk },
                                                                    kernel_acc);
     auto instance = std::make_shared<ClientIVC::ProverInstance>(kernel_circuit);
-    EXPECT_EQ(instance->proving_key->log_circuit_size, 17);
+    EXPECT_EQ(instance->proving_key.log_circuit_size, 17);
 }

barretenberg/cpp/src/barretenberg/flavor/flavor.hpp

@@ -165,19 +165,6 @@ class VerificationKey_ : public PrecomputedCommitments {
         this->log_circuit_size = numeric::get_msb(circuit_size);
         this->num_public_inputs = num_public_inputs;
     };
-
-    template <typename ProvingKeyPtr> VerificationKey_(const ProvingKeyPtr& proving_key)
-    {
-        this->pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
-        this->circuit_size = proving_key->circuit_size;
-        this->log_circuit_size = numeric::get_msb(this->circuit_size);
-        this->num_public_inputs = proving_key->num_public_inputs;
-        this->pub_inputs_offset = proving_key->pub_inputs_offset;
-
-        for (auto [polynomial, commitment] : zip_view(proving_key->get_precomputed_polynomials(), this->get_all())) {
-            commitment = proving_key->commitment_key->commit(polynomial);
-        }
-    }
 };
 
 // Because of how Gemini is written, is importat to put the polynomials out in this order.

barretenberg/cpp/src/barretenberg/flavor/goblin_translator.hpp

@@ -1046,12 +1046,20 @@ class GoblinTranslatorFlavor {
         VerificationKey(const size_t circuit_size, const size_t num_public_inputs)
             : VerificationKey_(circuit_size, num_public_inputs)
         {}
-
-        template <typename ProvingKeyPtr>
-        VerificationKey(const ProvingKeyPtr& proving_key)
-            : VerificationKey_(proving_key)
-            , public_inputs(proving_key->public_inputs)
-        {}
+        VerificationKey(const std::shared_ptr<ProvingKey>& proving_key)
+            : public_inputs(proving_key->public_inputs)
+        {
+            this->pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
+            this->circuit_size = proving_key->circuit_size;
+            this->log_circuit_size = numeric::get_msb(this->circuit_size);
+            this->num_public_inputs = proving_key->num_public_inputs;
+            this->pub_inputs_offset = proving_key->pub_inputs_offset;
+
+            for (auto [polynomial, commitment] :
+                 zip_view(proving_key->get_precomputed_polynomials(), this->get_all())) {
+                commitment = proving_key->commitment_key->commit(polynomial);
+            }
+        }
     };
     /**
      * @brief A field element for each entity of the flavor.  These entities represent the prover polynomials

barretenberg/cpp/src/barretenberg/flavor/goblin_ultra.hpp

@@ -408,8 +408,27 @@ class GoblinUltraFlavor {
      * circuits.
      * @todo TODO(https://github.com/AztecProtocol/barretenberg/issues/876)
      */
-    using VerificationKey = VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey>;
+    // using VerificationKey = VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey>;
+    class VerificationKey : public VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey> {
+      public:
+        VerificationKey() = default;
+        VerificationKey(const size_t circuit_size, const size_t num_public_inputs)
+            : VerificationKey_(circuit_size, num_public_inputs)
+        {}
 
+        VerificationKey(ProvingKey& proving_key)
+        {
+            this->pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
+            this->circuit_size = proving_key.circuit_size;
+            this->log_circuit_size = numeric::get_msb(this->circuit_size);
+            this->num_public_inputs = proving_key.num_public_inputs;
+            this->pub_inputs_offset = proving_key.pub_inputs_offset;
+
+            for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) {
+                commitment = proving_key.commitment_key->commit(polynomial);
+            }
+        }
+    };
     /**
      * @brief A container for storing the partially evaluated multivariates produced by sumcheck.
      */
@@ -452,6 +471,7 @@ class GoblinUltraFlavor {
      */
     class ProverPolynomials : public AllEntities<Polynomial> {
       public:
+        // TODO(https://github.com/AztecProtocol/barretenberg/issues/925), proving_key could be const ref
         ProverPolynomials(ProvingKey& proving_key)
         {
             for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key.get_all())) {
@@ -463,17 +483,6 @@ class GoblinUltraFlavor {
                 prover_poly = key_poly.shifted();
             }
         }
-        ProverPolynomials(std::shared_ptr<ProvingKey>& proving_key)
-        {
-            for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key->get_all())) {
-                ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(*proving_key, key_poly));
-                prover_poly = key_poly.share();
-            }
-            for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key->get_to_be_shifted())) {
-                ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(*proving_key, key_poly) + "_shift"));
-                prover_poly = key_poly.shifted();
-            }
-        }
         // Define all operations as default, except move construction/assignment
         ProverPolynomials() = default;
         ProverPolynomials& operator=(const ProverPolynomials&) = delete;

barretenberg/cpp/src/barretenberg/flavor/ultra.hpp

@@ -396,8 +396,26 @@ class UltraFlavor {
      * that, and split out separate PrecomputedPolynomials/Commitments data for clarity but also for portability of our
      * circuits.
      */
-    using VerificationKey = VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey>;
-
+    // using VerificationKey = VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey>;
+    class VerificationKey : public VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey> {
+      public:
+        VerificationKey() = default;
+        VerificationKey(const size_t circuit_size, const size_t num_public_inputs)
+            : VerificationKey_(circuit_size, num_public_inputs)
+        {}
+        VerificationKey(ProvingKey& proving_key)
+        {
+            this->pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
+            this->circuit_size = proving_key.circuit_size;
+            this->log_circuit_size = numeric::get_msb(this->circuit_size);
+            this->num_public_inputs = proving_key.num_public_inputs;
+            this->pub_inputs_offset = proving_key.pub_inputs_offset;
+
+            for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) {
+                commitment = proving_key.commitment_key->commit(polynomial);
+            }
+        }
+    };
     /**
      * @brief A field element for each entity of the flavor. These entities represent the prover polynomials
      * evaluated at one point.
@@ -424,17 +442,6 @@ class UltraFlavor {
                 prover_poly = key_poly.shifted();
             }
         }
-        ProverPolynomials(std::shared_ptr<ProvingKey>& proving_key)
-        {
-            for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key->get_all())) {
-                ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(*proving_key, key_poly));
-                prover_poly = key_poly.share();
-            }
-            for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key->get_to_be_shifted())) {
-                ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(*proving_key, key_poly) + "_shift"));
-                prover_poly = key_poly.shifted();
-            }
-        }
         // Define all operations as default, except move construction/assignment
         ProverPolynomials() = default;
         ProverPolynomials& operator=(const ProverPolynomials&) = delete;

barretenberg/cpp/src/barretenberg/goblin/mock_circuits_pinning.test.cpp

@@ -25,9 +25,9 @@ TEST_F(MockCircuitsPinning, FunctionSizes)
         GoblinMockCircuits::construct_mock_function_circuit(app_circuit, large);
         auto instance = std::make_shared<ProverInstance>(app_circuit);
         if (large) {
-            EXPECT_EQ(instance->proving_key->log_circuit_size, 19);
+            EXPECT_EQ(instance->proving_key.log_circuit_size, 19);
         } else {
-            EXPECT_EQ(instance->proving_key->log_circuit_size, 17);
+            EXPECT_EQ(instance->proving_key.log_circuit_size, 17);
         };
     };
     run_test(true);
@@ -51,9 +51,9 @@ TEST_F(MockCircuitsPinning, RecursionKernelSizes)
 
             auto instance = std::make_shared<ProverInstance>(kernel_circuit);
             if (large) {
-                EXPECT_EQ(instance->proving_key->log_circuit_size, 17);
+                EXPECT_EQ(instance->proving_key.log_circuit_size, 17);
             } else {
-                EXPECT_EQ(instance->proving_key->log_circuit_size, 17);
+                EXPECT_EQ(instance->proving_key.log_circuit_size, 17);
             };
         }
     };

barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.cpp

@@ -41,7 +41,7 @@ std::shared_ptr<plonk::proving_key> StandardComposer::compute_proving_key(Circui
         subgroup_size, circuit_constructor.public_inputs.size(), crs, CircuitType::STANDARD);
 
     // Construct and add to proving key the wire, selector and copy constraint polynomials
-    Trace::populate(circuit_constructor, circuit_proving_key);
+    Trace::populate(circuit_constructor, *circuit_proving_key);
 
     // Make all selectors nonzero
     enforce_nonzero_selector_polynomials(circuit_constructor, circuit_proving_key.get());

barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp

@@ -166,7 +166,7 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key(CircuitBuilder&
         std::make_shared<plonk::proving_key>(subgroup_size, circuit.public_inputs.size(), crs, CircuitType::ULTRA);
 
     // Construct and add to proving key the wire, selector and copy constraint polynomials
-    Trace::populate(circuit, circuit_proving_key);
+    Trace::populate(circuit, *circuit_proving_key);
 
     enforce_nonzero_selector_polynomials(circuit, circuit_proving_key.get());
 

barretenberg/cpp/src/barretenberg/proof_system/execution_trace/execution_trace.cpp

@@ -6,11 +6,10 @@
 namespace bb {
 
 template <class Flavor>
-void ExecutionTrace_<Flavor>::populate(Builder& builder,
-                                       const std::shared_ptr<typename Flavor::ProvingKey>& proving_key)
+void ExecutionTrace_<Flavor>::populate(Builder& builder, typename Flavor::ProvingKey& proving_key)
 {
     // Construct wire polynomials, selector polynomials, and copy cycles from raw circuit data
-    auto trace_data = construct_trace_data(builder, proving_key->circuit_size);
+    auto trace_data = construct_trace_data(builder, proving_key.circuit_size);
 
     add_wires_and_selectors_to_proving_key(trace_data, builder, proving_key);
 
@@ -23,45 +22,47 @@ void ExecutionTrace_<Flavor>::populate(Builder& builder,
     }
 
     // Compute the permutation argument polynomials (sigma/id) and add them to proving key
-    compute_permutation_argument_polynomials<Flavor>(builder, proving_key.get(), trace_data.copy_cycles);
+    compute_permutation_argument_polynomials<Flavor>(builder, &proving_key, trace_data.copy_cycles);
 }
 
 template <class Flavor>
-void ExecutionTrace_<Flavor>::add_wires_and_selectors_to_proving_key(
-    TraceData& trace_data, Builder& builder, const std::shared_ptr<typename Flavor::ProvingKey>& proving_key)
+void ExecutionTrace_<Flavor>::add_wires_and_selectors_to_proving_key(TraceData& trace_data,
+                                                                     Builder& builder,
+                                                                     typename Flavor::ProvingKey& proving_key)
 {
     if constexpr (IsHonkFlavor<Flavor>) {
-        for (auto [pkey_wire, trace_wire] : zip_view(proving_key->get_wires(), trace_data.wires)) {
+        for (auto [pkey_wire, trace_wire] : zip_view(proving_key.get_wires(), trace_data.wires)) {
             pkey_wire = trace_wire.share();
         }
-        for (auto [pkey_selector, trace_selector] : zip_view(proving_key->get_selectors(), trace_data.selectors)) {
+        for (auto [pkey_selector, trace_selector] : zip_view(proving_key.get_selectors(), trace_data.selectors)) {
             pkey_selector = trace_selector.share();
         }
     } else if constexpr (IsPlonkFlavor<Flavor>) {
         for (size_t idx = 0; idx < trace_data.wires.size(); ++idx) {
             std::string wire_tag = "w_" + std::to_string(idx + 1) + "_lagrange";
-            proving_key->polynomial_store.put(wire_tag, std::move(trace_data.wires[idx]));
+            proving_key.polynomial_store.put(wire_tag, std::move(trace_data.wires[idx]));
         }
         for (size_t idx = 0; idx < trace_data.selectors.size(); ++idx) {
-            proving_key->polynomial_store.put(builder.selector_names[idx] + "_lagrange",
-                                              std::move(trace_data.selectors[idx]));
+            proving_key.polynomial_store.put(builder.selector_names[idx] + "_lagrange",
+                                             std::move(trace_data.selectors[idx]));
         }
     }
 }
 
 template <class Flavor>
-void ExecutionTrace_<Flavor>::add_memory_records_to_proving_key(
-    TraceData& trace_data, Builder& builder, const std::shared_ptr<typename Flavor::ProvingKey>& proving_key)
+void ExecutionTrace_<Flavor>::add_memory_records_to_proving_key(TraceData& trace_data,
+                                                                Builder& builder,
+                                                                typename Flavor::ProvingKey& proving_key)
     requires IsUltraPlonkOrHonk<Flavor>
 {
-    ASSERT(proving_key->memory_read_records.empty() && proving_key->memory_write_records.empty());
+    ASSERT(proving_key.memory_read_records.empty() && proving_key.memory_write_records.empty());
 
     // Update indices of RAM/ROM reads/writes based on where block containing these gates sits in the trace
     for (auto& index : builder.memory_read_records) {
-        proving_key->memory_read_records.emplace_back(index + trace_data.ram_rom_offset);
+        proving_key.memory_read_records.emplace_back(index + trace_data.ram_rom_offset);
     }
     for (auto& index : builder.memory_write_records) {
-        proving_key->memory_write_records.emplace_back(index + trace_data.ram_rom_offset);
+        proving_key.memory_write_records.emplace_back(index + trace_data.ram_rom_offset);
     }
 }
 
@@ -130,33 +131,33 @@ template <class Flavor> void ExecutionTrace_<Flavor>::populate_public_inputs_blo
 }
 
 template <class Flavor>
-void ExecutionTrace_<Flavor>::add_ecc_op_wires_to_proving_key(
-    Builder& builder, const std::shared_ptr<typename Flavor::ProvingKey>& proving_key)
+void ExecutionTrace_<Flavor>::add_ecc_op_wires_to_proving_key(Builder& builder,
+                                                              typename Flavor::ProvingKey& proving_key)
     requires IsGoblinFlavor<Flavor>
 {
     // Initialize the ecc op wire polynomials to zero on the whole domain
     std::array<Polynomial, NUM_WIRES> op_wire_polynomials;
     for (auto& poly : op_wire_polynomials) {
-        poly = Polynomial{ proving_key->circuit_size };
+        poly = Polynomial{ proving_key.circuit_size };
     }
-    Polynomial ecc_op_selector{ proving_key->circuit_size };
+    Polynomial ecc_op_selector{ proving_key.circuit_size };
 
     // Copy the ecc op data from the conventional wires into the op wires over the range of ecc op gates
     const size_t op_wire_offset = Flavor::has_zero_row ? 1 : 0;
-    for (auto [ecc_op_wire, wire] : zip_view(op_wire_polynomials, proving_key->get_wires())) {
+    for (auto [ecc_op_wire, wire] : zip_view(op_wire_polynomials, proving_key.get_wires())) {
         for (size_t i = 0; i < builder.num_ecc_op_gates; ++i) {
             size_t idx = i + op_wire_offset;
             ecc_op_wire[idx] = wire[idx];
             ecc_op_selector[idx] = 1; // construct the selector as the indicator on the ecc op block
         }
     }
 
-    proving_key->num_ecc_op_gates = builder.num_ecc_op_gates;
-    proving_key->ecc_op_wire_1 = op_wire_polynomials[0].share();
-    proving_key->ecc_op_wire_2 = op_wire_polynomials[1].share();
-    proving_key->ecc_op_wire_3 = op_wire_polynomials[2].share();
-    proving_key->ecc_op_wire_4 = op_wire_polynomials[3].share();
-    proving_key->lagrange_ecc_op = ecc_op_selector.share();
+    proving_key.num_ecc_op_gates = builder.num_ecc_op_gates;
+    proving_key.ecc_op_wire_1 = op_wire_polynomials[0].share();
+    proving_key.ecc_op_wire_2 = op_wire_polynomials[1].share();
+    proving_key.ecc_op_wire_3 = op_wire_polynomials[2].share();
+    proving_key.ecc_op_wire_4 = op_wire_polynomials[3].share();
+    proving_key.lagrange_ecc_op = ecc_op_selector.share();
 }
 
 template class ExecutionTrace_<UltraFlavor>;

barretenberg/cpp/src/barretenberg/proof_system/execution_trace/execution_trace.hpp

@@ -42,7 +42,7 @@ template <class Flavor> class ExecutionTrace_ {
      *
      * @param builder
      */
-    static void populate(Builder& builder, const std::shared_ptr<ProvingKey>&);
+    static void populate(Builder& builder, ProvingKey&);
 
   private:
     /**
@@ -54,7 +54,7 @@ template <class Flavor> class ExecutionTrace_ {
      */
     static void add_wires_and_selectors_to_proving_key(TraceData& trace_data,
                                                        Builder& builder,
-                                                       const std::shared_ptr<typename Flavor::ProvingKey>& proving_key);
+                                                       typename Flavor::ProvingKey& proving_key);
 
     /**
      * @brief Add the memory records indicating which rows correspond to RAM/ROM reads/writes
@@ -70,7 +70,7 @@ template <class Flavor> class ExecutionTrace_ {
      */
     static void add_memory_records_to_proving_key(TraceData& trace_data,
                                                   Builder& builder,
-                                                  const std::shared_ptr<typename Flavor::ProvingKey>& proving_key)
+                                                  typename Flavor::ProvingKey& proving_key)
         requires IsUltraPlonkOrHonk<Flavor>;
 
     /**
@@ -98,8 +98,7 @@ template <class Flavor> class ExecutionTrace_ {
      * @param builder
      * @param proving_key
      */
-    static void add_ecc_op_wires_to_proving_key(Builder& builder,
-                                                const std::shared_ptr<typename Flavor::ProvingKey>& proving_key)
+    static void add_ecc_op_wires_to_proving_key(Builder& builder, typename Flavor::ProvingKey& proving_key)
         requires IsGoblinFlavor<Flavor>;
 };
 

barretenberg/cpp/src/barretenberg/proof_system/instance_inspector.hpp

@@ -49,7 +49,7 @@ void print_databus_info(auto& prover_instance)
 {
     info("\nInstance Inspector: Printing databus gate info.");
     auto& key = prover_instance->proving_key;
-    for (size_t idx = 0; idx < prover_instance->proving_key->circuit_size; ++idx) {
+    for (size_t idx = 0; idx < prover_instance->proving_key.circuit_size; ++idx) {
         if (key->q_busread[idx] == 1) {
             info("idx = ", idx);
             info("q_busread = ", key->q_busread[idx]);