chore: Update formatting

circuits/cpp/barretenberg/cpp/src/barretenberg/crypto/blake3s/c_bind.cpp

@@ -1,5 +1,5 @@
-#include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/common/wasm_export.hpp"
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "blake3s.hpp"
 
 WASM_EXPORT void blake3s_to_field(uint8_t const* data, size_t length, uint8_t* r)

circuits/cpp/barretenberg/cpp/src/barretenberg/crypto/schnorr/schnorr.hpp

@@ -9,8 +9,8 @@
 #include "barretenberg/crypto/hashers/hashers.hpp"
 
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/serialize/msgpack.hpp"
 #include "barretenberg/common/streams.hpp"
+#include "barretenberg/serialize/msgpack.hpp"
 
 namespace crypto {
 namespace schnorr {

circuits/cpp/barretenberg/cpp/src/barretenberg/crypto/sha256/c_bind.cpp

@@ -1,5 +1,5 @@
-#include "sha256.hpp"
 #include "barretenberg/common/wasm_export.hpp"
+#include "sha256.hpp"
 
 WASM_EXPORT void sha256__hash(uint8_t* in, const size_t length, uint8_t* r)
 {

circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp

@@ -88,9 +88,9 @@ void create_recursion_constraints(Builder& builder,
         for (size_t i = 0; i < 4; ++i) {
             aggregation_elements[i] =
                 bn254::BaseField(field_ct::from_witness_index(&builder, aggregation_input[4 * i]),
-                             field_ct::from_witness_index(&builder, aggregation_input[4 * i + 1]),
-                             field_ct::from_witness_index(&builder, aggregation_input[4 * i + 2]),
-                             field_ct::from_witness_index(&builder, aggregation_input[4 * i + 3]));
+                                 field_ct::from_witness_index(&builder, aggregation_input[4 * i + 1]),
+                                 field_ct::from_witness_index(&builder, aggregation_input[4 * i + 2]),
+                                 field_ct::from_witness_index(&builder, aggregation_input[4 * i + 3]));
             aggregation_elements[i].assert_is_in_field();
         }
         // If we have a previous aggregation object, assign it to `previous_aggregation` so that it is included

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp

@@ -33,7 +33,7 @@ class StandardGrumpkin {
     using PolynomialHandle = std::span<FF>;
     using CommitmentKey = pcs::CommitmentKey<Curve>;
     using VerifierCommitmentKey = pcs::VerifierCommitmentKey<Curve>;
-    
+
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // The number of multivariate polynomials on which a sumcheck prover sumcheck operates (including shifts). We often
     // need containers of this size to hold related data, so we choose a name more agnostic than `NUM_POLYNOMIALS`

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/claim.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/honk/pcs/commitment_key.hpp"
+#include "barretenberg/polynomials/polynomial.hpp"
 
 namespace proof_system::honk::pcs {
 /**

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.test.hpp

@@ -46,7 +46,9 @@ template <typename CK> inline std::shared_ptr<CK> CreateCommitmentKey()
 
 template <class VK> inline std::shared_ptr<VK> CreateVerifierCommitmentKey();
 
-template <> inline std::shared_ptr<VerifierCommitmentKey<curve::BN254>> CreateVerifierCommitmentKey<VerifierCommitmentKey<curve::BN254>>()
+template <>
+inline std::shared_ptr<VerifierCommitmentKey<curve::BN254>> CreateVerifierCommitmentKey<
+    VerifierCommitmentKey<curve::BN254>>()
 {
     constexpr size_t n = 4096;
     std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> crs_factory(
@@ -55,7 +57,8 @@ template <> inline std::shared_ptr<VerifierCommitmentKey<curve::BN254>> CreateVe
 }
 // For IPA
 template <>
-inline std::shared_ptr<VerifierCommitmentKey<curve::Grumpkin>> CreateVerifierCommitmentKey<VerifierCommitmentKey<curve::Grumpkin>>()
+inline std::shared_ptr<VerifierCommitmentKey<curve::Grumpkin>> CreateVerifierCommitmentKey<
+    VerifierCommitmentKey<curve::Grumpkin>>()
 {
     constexpr size_t n = 4096;
     std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::Grumpkin>> crs_factory(

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/gemini/gemini.cpp

@@ -53,8 +53,10 @@ namespace proof_system::honk::pcs::gemini {
  * @return std::vector<Polynomial>
  */
 template <typename Curve>
-std::vector<typename barretenberg::Polynomial<typename Curve::ScalarField>> GeminiProver_<Curve>::compute_fold_polynomials(
-    std::span<const Fr> mle_opening_point, Polynomial&& batched_unshifted, Polynomial&& batched_to_be_shifted)
+std::vector<typename barretenberg::Polynomial<typename Curve::ScalarField>> GeminiProver_<
+    Curve>::compute_fold_polynomials(std::span<const Fr> mle_opening_point,
+                                     Polynomial&& batched_unshifted,
+                                     Polynomial&& batched_to_be_shifted)
 {
     const size_t num_variables = mle_opening_point.size(); // m
 
@@ -141,9 +143,8 @@ std::vector<typename barretenberg::Polynomial<typename Curve::ScalarField>> Gemi
  * @param r_challenge univariate opening challenge
  */
 template <typename Curve>
-ProverOutput<Curve> GeminiProver_<Curve>::compute_fold_polynomial_evaluations(std::span<const Fr> mle_opening_point,
-                                                                         std::vector<Polynomial>&& fold_polynomials,
-                                                                         const Fr& r_challenge)
+ProverOutput<Curve> GeminiProver_<Curve>::compute_fold_polynomial_evaluations(
+    std::span<const Fr> mle_opening_point, std::vector<Polynomial>&& fold_polynomials, const Fr& r_challenge)
 {
     const size_t num_variables = mle_opening_point.size(); // m
 
@@ -186,7 +187,6 @@ ProverOutput<Curve> GeminiProver_<Curve>::compute_fold_polynomial_evaluations(st
     return { fold_poly_opening_pairs, std::move(fold_polynomials) };
 };
 
-
 template class GeminiProver_<curve::BN254>;
 template class GeminiProver_<curve::Grumpkin>;
 }; // namespace proof_system::honk::pcs::gemini

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/gemini/gemini.test.cpp

@@ -86,10 +86,10 @@ template <class Curve> class GeminiTest : public CommitmentTest<Curve> {
         // - 2 partially evaluated Fold polynomial commitments [Fold_{r}^(0)] and [Fold_{-r}^(0)]
         // Aggregate: d+1 opening pairs and d+1 Fold poly commitments into verifier claim
         auto verifier_claim = GeminiVerifier::reduce_verification(multilinear_evaluation_point,
-                                                    batched_evaluation,
-                                                    batched_commitment_unshifted,
-                                                    batched_commitment_to_be_shifted,
-                                                    verifier_transcript);
+                                                                  batched_evaluation,
+                                                                  batched_commitment_unshifted,
+                                                                  batched_commitment_to_be_shifted,
+                                                                  verifier_transcript);
 
         // Check equality of the opening pairs computed by prover and verifier
         for (size_t i = 0; i < (log_n + 1); ++i) {

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.test.cpp

@@ -152,7 +152,8 @@ TEST_F(IPATest, GeminiShplonkIPAWithShift)
     }
 
     const Fr nu_challenge = prover_transcript.get_challenge("Shplonk:nu");
-    auto batched_quotient_Q = ShplonkProver::compute_batched_quotient(gemini_opening_pairs, gemini_witnesses, nu_challenge);
+    auto batched_quotient_Q =
+        ShplonkProver::compute_batched_quotient(gemini_opening_pairs, gemini_witnesses, nu_challenge);
     prover_transcript.send_to_verifier("Shplonk:Q", this->ck()->commit(batched_quotient_Q));
 
     const Fr z_challenge = prover_transcript.get_challenge("Shplonk:z");
@@ -164,12 +165,13 @@ TEST_F(IPATest, GeminiShplonkIPAWithShift)
     auto verifier_transcript = VerifierTranscript<Fr>::init_empty(prover_transcript);
 
     auto gemini_verifier_claim = GeminiVerifier::reduce_verification(mle_opening_point,
-                                                       batched_evaluation,
-                                                       batched_commitment_unshifted,
-                                                       batched_commitment_to_be_shifted,
-                                                       verifier_transcript);
+                                                                     batched_evaluation,
+                                                                     batched_commitment_unshifted,
+                                                                     batched_commitment_to_be_shifted,
+                                                                     verifier_transcript);
 
-    const auto shplonk_verifier_claim = ShplonkVerifier::reduce_verification(this->vk(), gemini_verifier_claim, verifier_transcript);
+    const auto shplonk_verifier_claim =
+        ShplonkVerifier::reduce_verification(this->vk(), gemini_verifier_claim, verifier_transcript);
     bool verified = IPA::verify(this->vk(), shplonk_verifier_claim, verifier_transcript);
 
     EXPECT_EQ(verified, true);

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/kzg/kzg.test.cpp

@@ -140,7 +140,8 @@ TYPED_TEST(KZGTest, GeminiShplonkKzgWithShift)
     // - opening pair: (z_challenge, 0)
     // - witness: polynomial Q - Q_z
     const Fr nu_challenge = prover_transcript.get_challenge("Shplonk:nu");
-    auto batched_quotient_Q = ShplonkProver::compute_batched_quotient(gemini_opening_pairs, gemini_witnesses, nu_challenge);
+    auto batched_quotient_Q =
+        ShplonkProver::compute_batched_quotient(gemini_opening_pairs, gemini_witnesses, nu_challenge);
     prover_transcript.send_to_verifier("Shplonk:Q", this->ck()->commit(batched_quotient_Q));
 
     const Fr z_challenge = prover_transcript.get_challenge("Shplonk:z");
@@ -158,13 +159,14 @@ TYPED_TEST(KZGTest, GeminiShplonkKzgWithShift)
     // Gemini verifier output:
     // - claim: d+1 commitments to Fold_{r}^(0), Fold_{-r}^(0), Fold^(l), d+1 evaluations a_0_pos, a_l, l = 0:d-1
     auto gemini_verifier_claim = GeminiVerifier::reduce_verification(mle_opening_point,
-                                                       batched_evaluation,
-                                                       batched_commitment_unshifted,
-                                                       batched_commitment_to_be_shifted,
-                                                       verifier_transcript);
+                                                                     batched_evaluation,
+                                                                     batched_commitment_unshifted,
+                                                                     batched_commitment_to_be_shifted,
+                                                                     verifier_transcript);
 
     // Shplonk verifier claim: commitment [Q] - [Q_z], opening point (z_challenge, 0)
-    const auto shplonk_verifier_claim = ShplonkVerifier::reduce_verification(this->vk(), gemini_verifier_claim, verifier_transcript);
+    const auto shplonk_verifier_claim =
+        ShplonkVerifier::reduce_verification(this->vk(), gemini_verifier_claim, verifier_transcript);
 
     // KZG verifier:
     // aggregates inputs [Q] - [Q_z] and [W] into an 'accumulator' (can perform pairing check on result)

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk.test.cpp

@@ -52,8 +52,9 @@ TYPED_TEST(ShplonkTest, ShplonkSimple)
     prover_transcript.send_to_verifier("Shplonk:Q", this->ck()->commit(batched_quotient_Q));
 
     const Fr z_challenge = prover_transcript.get_challenge("Shplonk:z");
-    const auto [prover_opening_pair, shplonk_prover_witness] = ShplonkProver::compute_partially_evaluated_batched_quotient(
-        opening_pairs, polynomials, std::move(batched_quotient_Q), nu_challenge, z_challenge);
+    const auto [prover_opening_pair, shplonk_prover_witness] =
+        ShplonkProver::compute_partially_evaluated_batched_quotient(
+            opening_pairs, polynomials, std::move(batched_quotient_Q), nu_challenge, z_challenge);
 
     // An intermediate check to confirm the opening of the shplonk prover witness Q
     this->verify_opening_pair(prover_opening_pair, shplonk_prover_witness);

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/verification_key.hpp

@@ -26,7 +26,7 @@ template <class Curve> class VerifierCommitmentKey;
 
 /**
  * @brief Specialization for bn254
- * 
+ *
  * @tparam curve::BN254
  */
 template <> class VerifierCommitmentKey<curve::BN254> {
@@ -44,7 +44,7 @@ template <> class VerifierCommitmentKey<curve::BN254> {
      * @param srs verifier G2 point
      */
     VerifierCommitmentKey([[maybe_unused]] size_t num_points,
-                       std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
+                          std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
         : srs(crs_factory->get_verifier_crs())
     {}
 
@@ -70,7 +70,7 @@ template <> class VerifierCommitmentKey<curve::BN254> {
 
 /**
  * @brief Specialization for Grumpkin
- * 
+ *
  * @tparam curve::Grumpkin
  */
 template <> class VerifierCommitmentKey<curve::Grumpkin> {
@@ -88,7 +88,8 @@ template <> class VerifierCommitmentKey<curve::Grumpkin> {
      * @param num_points specifies the length of the SRS
      * @param path is the location to the SRS file
      */
-    VerifierCommitmentKey(size_t num_points, std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
+    VerifierCommitmentKey(size_t num_points,
+                          std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
         : pippenger_runtime_state(num_points)
         , srs(crs_factory->get_verifier_crs(num_points))
 

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp

@@ -154,10 +154,10 @@ template <typename Flavor> bool StandardVerifier_<Flavor>::verify_proof(const pl
     // - d+1 commitments [Fold_{r}^(0)], [Fold_{-r}^(0)], and [Fold^(l)], l = 1:d-1
     // - d+1 evaluations a_0_pos, and a_l, l = 0:d-1
     auto gemini_claim = Gemini::reduce_verification(multivariate_challenge,
-                                              batched_evaluation,
-                                              batched_commitment_unshifted,
-                                              batched_commitment_to_be_shifted,
-                                              transcript);
+                                                    batched_evaluation,
+                                                    batched_commitment_unshifted,
+                                                    batched_commitment_to_be_shifted,
+                                                    transcript);
 
     // Produce a Shplonk claim: commitment [Q] - [Q_z], evaluation zero (at random challenge z)
     auto shplonk_claim = Shplonk::reduce_verification(pcs_verification_key, gemini_claim, transcript);

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/barycentric_data.test.cpp

@@ -1,5 +1,5 @@
-#include "barycentric_data.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barycentric_data.hpp"
 
 #include "barretenberg/numeric/random/engine.hpp"
 #include <gtest/gtest.h>

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp

@@ -77,8 +77,8 @@ template <typename Flavor> class SumcheckProver {
      *
      * @details
      */
-    SumcheckOutput<Flavor> prove(
-        auto full_polynomials, const RelationParameters<FF>& relation_parameters) // pass by value, not by reference
+    SumcheckOutput<Flavor> prove(auto full_polynomials,
+                                 const RelationParameters<FF>& relation_parameters) // pass by value, not by reference
     {
         auto [alpha, zeta] = transcript.get_challenges("Sumcheck:alpha", "Sumcheck:zeta");
 
@@ -176,8 +176,8 @@ template <typename Flavor> class SumcheckVerifier {
      * target sum.
      *
      * @details If verification fails, returns std::nullopt, otherwise returns SumcheckOutput
-     * @param relation_parameters 
-     * @param transcript 
+     * @param relation_parameters
+     * @param transcript
      */
     std::optional<SumcheckOutput<Flavor>> verify(const RelationParameters<FF>& relation_parameters, auto& transcript)
     {

circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.hpp

@@ -67,6 +67,7 @@ template <typename FF> class BaseTranscript {
     // TODO(Adrian): Make these tweakable
   public:
     static constexpr size_t HASH_OUTPUT_SIZE = 32;
+
   private:
     static constexpr size_t MIN_BYTES_PER_CHALLENGE = 128 / 8; // 128 bit challenges
 

circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.cpp

@@ -3,8 +3,8 @@
  * @brief Contains some functions that are shared between the various Plonk composers.
  */
 #include "composer_lib.hpp"
-#include "barretenberg/srs/factories/crs_factory.hpp"
 #include "barretenberg/honk/pcs/commitment_key.hpp"
+#include "barretenberg/srs/factories/crs_factory.hpp"
 
 namespace proof_system::plonk {