Merge branch 'next' into mc/check-blob-overflow-inside-absorb-end-marker

Author: iAmMichaelConnor

.github/workflows/ensure-funded-environments.yml

@@ -25,7 +25,6 @@ concurrency:
 
 jobs:
   fund:
-    continue-on-error: true
     strategy:
       # we can only run one funding operation at a time because all jobs fund from the same address
       max-parallel: 1

barretenberg/cpp/src/barretenberg/commitment_schemes/commitment_key.hpp

@@ -106,7 +106,8 @@ template <class Curve> class CommitmentKey {
     };
     /**
      * @brief Batch commitment to multiple polynomials
-     * @details Uses batch_multi_scalar_mul for more efficient processing when committing to multiple polynomials
+     * @details Uses batch_multi_scalar_mul for more efficient processing when committing to multiple polynomials.
+     *          The input polynomials are not const because batch_mul modifies them and then restores them back.
      *
      * @param polynomials vector of polynomial spans to commit to
      * @return std::vector<Commitment> vector of commitments, one for each polynomial

barretenberg/cpp/src/barretenberg/commitment_schemes/gemini/gemini.hpp

@@ -74,7 +74,7 @@ namespace gemini {
  * @param num_powers
  * @return std::vector<Fr>
  */
-template <class Fr> inline std::vector<Fr> powers_of_rho(const Fr rho, const size_t num_powers)
+template <class Fr> inline std::vector<Fr> powers_of_rho(const Fr& rho, const size_t num_powers)
 {
     std::vector<Fr> rhos = { Fr(1), rho };
     rhos.reserve(num_powers);
@@ -91,7 +91,7 @@ template <class Fr> inline std::vector<Fr> powers_of_rho(const Fr rho, const siz
  * @param num_squares The number of foldings
  * @return std::vector<typename Curve::ScalarField>
  */
-template <class Fr> inline std::vector<Fr> powers_of_evaluation_challenge(const Fr r, const size_t num_squares)
+template <class Fr> inline std::vector<Fr> powers_of_evaluation_challenge(const Fr& r, const size_t num_squares)
 {
     std::vector<Fr> squares = { r };
     squares.reserve(num_squares);
@@ -301,7 +301,7 @@ template <typename Curve> class GeminiProver_ {
                                                                   const Fr& r_challenge);
 
     template <typename Transcript>
-    static std::vector<Claim> prove(const Fr circuit_size,
+    static std::vector<Claim> prove(size_t circuit_size,
                                     PolynomialBatcher& polynomial_batcher,
                                     std::span<Fr> multilinear_challenge,
                                     const CommitmentKey<Curve>& commitment_key,

barretenberg/cpp/src/barretenberg/commitment_schemes/gemini/gemini_impl.hpp

@@ -48,7 +48,7 @@ namespace bb {
 template <typename Curve>
 template <typename Transcript>
 std::vector<typename GeminiProver_<Curve>::Claim> GeminiProver_<Curve>::prove(
-    Fr circuit_size,
+    size_t circuit_size,
     PolynomialBatcher& polynomial_batcher,
     std::span<Fr> multilinear_challenge,
     const CommitmentKey<Curve>& commitment_key,
@@ -57,7 +57,7 @@ std::vector<typename GeminiProver_<Curve>::Claim> GeminiProver_<Curve>::prove(
 {
     // To achieve fixed proof size in Ultra and Mega, the multilinear opening challenge is be padded to a fixed size.
     const size_t virtual_log_n = multilinear_challenge.size();
-    const size_t log_n = numeric::get_msb(static_cast<uint32_t>(circuit_size));
+    const size_t log_n = numeric::get_msb(circuit_size);
 
     // Get the batching challenge
     const Fr rho = transcript->template get_challenge<Fr>("rho");

barretenberg/cpp/src/barretenberg/commitment_schemes/shplonk/shplemini.hpp

@@ -33,7 +33,7 @@ template <typename Curve> class ShpleminiProver_ {
     using PolynomialBatcher = GeminiProver::PolynomialBatcher;
 
     template <typename Transcript>
-    static OpeningClaim prove(const FF circuit_size,
+    static OpeningClaim prove(size_t circuit_size,
                               PolynomialBatcher& polynomial_batcher,
                               std::span<FF> multilinear_challenge,
                               const CommitmentKey<Curve>& commitment_key,
@@ -110,15 +110,15 @@ template <typename Curve> class ShpleminiProver_ {
      *
      */
     static std::vector<OpeningClaim> compute_sumcheck_round_claims(
-        const FF circuit_size,
+        size_t circuit_size,
         std::span<FF> multilinear_challenge,
         const std::vector<Polynomial>& sumcheck_round_univariates,
         const std::vector<std::array<FF, 3>>& sumcheck_round_evaluations)
     {
         OpeningClaim new_claim;
         std::vector<OpeningClaim> sumcheck_round_claims = {};
 
-        const size_t log_n = numeric::get_msb(static_cast<uint32_t>(circuit_size));
+        const size_t log_n = numeric::get_msb(circuit_size);
         for (size_t idx = 0; idx < log_n; idx++) {
             const std::vector<FF> evaluation_points = { FF(0), FF(1), multilinear_challenge[idx] };
             size_t eval_idx = 0;
@@ -135,6 +135,7 @@ template <typename Curve> class ShpleminiProver_ {
         return sumcheck_round_claims;
     }
 };
+
 /**
  * \brief An efficient verifier for the evaluation proofs of multilinear polynomials and their shifts.
  *

barretenberg/cpp/src/barretenberg/ecc/scalar_multiplication/scalar_multiplication.cpp

@@ -749,7 +749,8 @@ void MSM<Curve>::consume_point_schedule(std::span<const uint64_t> point_schedule
  *          This is because this method will be able to dispatch equal work to all threads without splitting the input
  *          msms up so much.
  *          The Pippenger algorithm runtime is O(N/log(N)) so there will be slight gains as each inner-thread MSM will
- *          have a larger N
+ *          have a larger N.
+ *          The input scalars are not const because the algorithm converts them out of Montgomery form and then back.
  *
  * @tparam Curve
  * @param points

barretenberg/cpp/src/barretenberg/polynomials/polynomial.cpp

@@ -221,13 +221,13 @@ template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator-=(PolynomialSpan
     return *this;
 }
 
-template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator*=(const Fr scaling_factor)
+template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator*=(const Fr& scaling_factor)
 {
     parallel_for([scaling_factor, this](const ThreadChunk& chunk) { multiply_chunk(chunk, scaling_factor); });
     return *this;
 }
 
-template <typename Fr> void Polynomial<Fr>::multiply_chunk(const ThreadChunk& chunk, const Fr scaling_factor)
+template <typename Fr> void Polynomial<Fr>::multiply_chunk(const ThreadChunk& chunk, const Fr& scaling_factor)
 {
     for (size_t i : chunk.range(size())) {
         data()[i] *= scaling_factor;
@@ -255,7 +255,7 @@ template <typename Fr> Polynomial<Fr> Polynomial<Fr>::full() const
     return result;
 }
 
-template <typename Fr> void Polynomial<Fr>::add_scaled(PolynomialSpan<const Fr> other, Fr scaling_factor) &
+template <typename Fr> void Polynomial<Fr>::add_scaled(PolynomialSpan<const Fr> other, const Fr& scaling_factor)
 {
     BB_ASSERT_LTE(start_index(), other.start_index);
     BB_ASSERT_GTE(end_index(), other.end_index());
@@ -264,7 +264,9 @@ template <typename Fr> void Polynomial<Fr>::add_scaled(PolynomialSpan<const Fr>
 }
 
 template <typename Fr>
-void Polynomial<Fr>::add_scaled_chunk(const ThreadChunk& chunk, PolynomialSpan<const Fr> other, Fr scaling_factor) &
+void Polynomial<Fr>::add_scaled_chunk(const ThreadChunk& chunk,
+                                      PolynomialSpan<const Fr> other,
+                                      const Fr& scaling_factor)
 {
     // Iterate over the chunk of the other polynomial's range
     for (size_t offset : chunk.range(other.size())) {

barretenberg/cpp/src/barretenberg/polynomials/polynomial.hpp

@@ -232,9 +232,9 @@ template <typename Fr> class Polynomial {
      * @param other q(X)
      * @param scaling_factor scaling factor by which all coefficients of q(X) are multiplied
      */
-    void add_scaled(PolynomialSpan<const Fr> other, Fr scaling_factor) &;
+    void add_scaled(PolynomialSpan<const Fr> other, const Fr& scaling_factor);
 
-    void add_scaled_chunk(const ThreadChunk& chunk, PolynomialSpan<const Fr> other, Fr scaling_factor) &;
+    void add_scaled_chunk(const ThreadChunk& chunk, PolynomialSpan<const Fr> other, const Fr& scaling_factor);
 
     /**
      * @brief adds the polynomial q(X) 'other'.
@@ -255,9 +255,9 @@ template <typename Fr> class Polynomial {
      *
      * @param scaling_factor s
      */
-    Polynomial& operator*=(Fr scaling_factor);
+    Polynomial& operator*=(const Fr& scaling_factor);
 
-    void multiply_chunk(const ThreadChunk& chunk, Fr scaling_factor);
+    void multiply_chunk(const ThreadChunk& chunk, const Fr& scaling_factor);
 
     /**
      * @brief Add random values to the coefficients of a polynomial. In practice, this is used for ensuring the

barretenberg/cpp/src/barretenberg/vm2/constraining/avm_fixed_vk.test.cpp

@@ -22,7 +22,7 @@ TEST(AvmFixedVKTests, FixedVKCommitments)
     auto polynomials = compute_polynomials(trace);
     auto proving_key = proving_key_from_polynomials(polynomials);
 
-    AvmVerifier::VerificationKey vk_computed(proving_key);
+    auto vk_computed = AvmVerifier::VerificationKey::from_proving_key(*proving_key);
     auto vk_computed_commitments = vk_computed.get_all();
 
     // Get the fixed VK commitments

barretenberg/cpp/src/barretenberg/vm2/constraining/flavor.hpp

@@ -233,20 +233,23 @@ class AvmFlavor {
 
         VerificationKey() = default;
 
-        VerificationKey(const std::shared_ptr<ProvingKey>& proving_key)
+        VerificationKey(std::array<Commitment, NUM_PRECOMPUTED_COMMITMENTS> const& precomputed_cmts)
         {
             this->log_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
-            for (auto [polynomial, commitment] : zip_view(proving_key->get_precomputed(), this->get_all())) {
-                commitment = proving_key->commitment_key.commit(polynomial);
+            for (auto [vk_cmt, cmt] : zip_view(this->get_all(), precomputed_cmts)) {
+                vk_cmt = cmt;
             }
         }
 
-        VerificationKey(std::array<Commitment, NUM_PRECOMPUTED_COMMITMENTS> const& precomputed_cmts)
+        // NOTE: This should not be used in production. You should use the fixed VK instead.
+        static VerificationKey from_proving_key(const ProvingKey& proving_key)
         {
-            this->log_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
-            for (auto [vk_cmt, cmt] : zip_view(this->get_all(), precomputed_cmts)) {
-                vk_cmt = cmt;
+            VerificationKey vk;
+            vk.log_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
+            for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed(), vk.get_all())) {
+                commitment = proving_key.commitment_key.commit(polynomial);
             }
+            return vk;
         }
 
         /**