chore!: depositAmount and minimumStake naming (#16148)

Addressing feedback from @benesjan. Also using his prompt idea to see
how well it works.

---

This PR refactors validator staking terminology throughout the Aztec
codebase to improve clarity and better reflect the purpose of key
staking parameters. The main changes involve renaming `depositAmount` to
`activationThreshold` and `minimumStake` to `ejectionThreshold`, along
with related library and method renames.

- **`depositAmount` → `activationThreshold`**: The amount of tokens
required to activate a validator and join the validator set
- **`minimumStake` → `ejectionThreshold`**: The minimum token balance
below which a validator is ejected from the active set

- **Solidity Contracts**: Updated all references in `Rollup.sol`,
`IStaking.sol`, `GSE.sol`, and related contracts
- **Libraries**:
- `UserLib` → `CheckpointedUintLib` (more descriptive name for
checkpoint management)
  - `DelegationLib` → `StakeDelegationLib` (clearer purpose indication)
- **Methods**: `finaliseHelper()` → `finaliseWithdraw()` in GSE contract
for better clarity

- Updated environment variables:
  - `AZTEC_DEPOSIT_AMOUNT` → `AZTEC_ACTIVATION_THRESHOLD`
  - `AZTEC_MINIMUM_STAKE` → `AZTEC_EJECTION_THRESHOLD`
- Updated all configuration files, test constants, and deployment
scripts

- Updated CLI reference documentation to reflect new parameter names
- Updated all code comments to use the new terminology

1. **Improved Clarity**: The new names clearly indicate the purpose of
each parameter - one for entering the validator set, one for being
removed from it
2. **Better Developer Experience**: Developers can immediately
understand what these thresholds represent without needing additional
context
3. **Consistency**: Uniform terminology across the entire codebase
reduces confusion
4. **Future-Proof**: The new names are more generic and adaptable to
potential future staking mechanism changes

⚠️ **This is a breaking change** that affects:

1. **Environment Variables**: Any deployment or configuration using the
old environment variable names (`AZTEC_DEPOSIT_AMOUNT`,
`AZTEC_MINIMUM_STAKE`) must be updated
2. **Contract Interfaces**: External systems calling
`getDepositAmount()`, `getMinimumStake()`, or `finaliseHelper()` must
update to use the new method names
3. **Configuration Files**: Any JSON/YAML configuration files using the
old parameter names need updates
4. **Deployment Scripts**: Custom deployment scripts referencing the old
names will need modification

- Replace `depositAmount` with `activationThreshold` in all
configurations
- Replace `minimumStake` with `ejectionThreshold` in all configurations
- Update contract calls:
  - `getDepositAmount()` → `getActivationThreshold()`
  - `getMinimumStake()` → `getEjectionThreshold()`
  - `finaliseHelper()` → `finaliseWithdraw()`

feat(sol): vk hashing (#16015)

Perform vk hashing in the solidity verifier

Takes a different approach to the traditional verifiers.
As the vk is fixed ahead of time, we hash it and include it in the
precompiled contract, therefore it is preprocessed
and does not need to be recomputed by the verifier.

chore: minor fixes and docs improvements in governance (#16039)

When doing my internal review of governance contracts I stumbled upon
plenty of small and uncontroversial issues with which it didn't really
make sense to clutter my review document.

---------

Co-authored-by: LHerskind <16536249+LHerskind@users.noreply.github.com>

chore: updated fmt settings foundry.toml (#16155)

Updated the `foundry.toml` to also wrap the comments and use the default
line_length of 120 instead of the previous 100. Threw some thousands
separators in there as well for constant values.

```toml
[fmt]
line_length = 120
tab_width = 2
variable_override_spacing=false
wrap_comments = true
number_underscore = "thousands"
override_spacing = false
```

chore: address comments (#16175)

Please read [contributing guidelines](CONTRIBUTING.md) and remove this
line.

For audit-related pull requests, please use the [audit PR
template](?expand=1&template=audit.md).

chore: invert check (#16181)

Looks like this condition should have been inverted. [Nightly CI
logs](https://github.com/AztecProtocol/aztec-packages/actions/runs/16712826743/job/47300588722)

```
03:18:35 + case "$cmd" in
03:18:35 + release
03:18:35 + semver check v1.0.0-nightly.20250804
03:18:35 + echo_stderr 'Release tag must be a valid semver version. Found: v1.0.0-nightly.20250804'
03:18:35 + echo Release tag must be a valid semver version. Found: v1.0.0-nightly.20250804
03:18:35 Release tag must be a valid semver version. Found: v1.0.0-nightly.20250804
03:18:35 + exit 1
```

chore: remove `uint` (#16062)

Removed `uint` module from `stdlib`. Had to change two modules that used
`uint`:
1. `edcsa`: an ecdsa signature contains a byte `v` and we were using
`uint8` to represent it in circuits. Replaced that with `byte_array` (of
size 1).
2. `keccak`: variable length keccak (i.e., the number of bytes being
hashed is a circuit-variable) was using `uint32` to represent
`num_bytes`. We are not using this version of keccak anywhere so its
better to get rid of than to maintain/audit.

feat(bb): allow for different transcript types depending on the flavor (#16017)

This change changes the transcript type in the solidity verifier case to
be a uint256 instead of serialising as field elements

It should reduce the size of the proof by 2368 bytes.
This significantly reduces hashing costs + calldata costs, and should
amount to a gas savings in the region of 50k

This pr just performs the plumbing into bb that makes these changes, and
does not apply the changes - changing the TranscriptType to uint256_t
and does not make the changes to solidity. Expect this in a follow on

**Note: still needs a cleanup but leaving this here for review from
others on the approach**

chore: remove `decompose_into_bits()` function from `field_t` class (#15795)

Since we're removing the merkle membership circuit implementation from
cpp code, we no longer use the function `decompose_into_bits()` in the
`field_t` class. Best to remove it instead of maintaining.

chore: Standardise native public input handling (#16050)

Public inputs in `stdlib` are handled via the special public input
mechanisms: we have classes (`KernelIO`, `DefaultIO`, `HidingKernelIO`,
`RollupIO`) that set public inputs, reconstruct them, create defaults,
etc. Native public inputs have a similar mechanism, but the mechanism
has many hacks built-in as native structures are used in more
extensively than their `stdlib` counterparts (e.g., we use `field` also
to construct the base/scalar field of `secp256k1`, which we never need
to deserialise from public inputs).

This PR standardises usage of native public inputs by creating a
structure similar to the one used in `stdlib`: we define a
`PublicInputComponent` class that works as a wrapper around classes that
can be deserialised from the public inputs, and we use this wrapper
class to reconstruct special public inputs (pairing points, IPA claims,
etc.).

To use the class, we make choices about how elements that are not
currently used in circuit should be serialised. This pertains to
base/scalar fields of `secp256k1` and `secp256r1` (and therefore to
affine points on these curves). For consistency with the base field of
`BN254`, we set `PUBLIC_INPUTS_SIZE = 4` for an element in each of these
fields.

This PR also cleans up the usage of the constants `PAIRING_POINTS_SIZE`
and `IPA_CLAIM_SIZE`, as they can now be extracted from the respective
classes `PairingPoints` and `OpeningClaim<Curve>` where `Curve` is
`Grumpkin` (either native or `stdlib`)

Closes AztecProtocol/barretenberg#1478

---------

Co-authored-by: AztecBot <tech@aztecprotocol.com>
Co-authored-by: Suyash Bagad <suyash@aztecprotocol.com>
Co-authored-by: Jonathan Hao <jonathan@aztec-labs.com>
Co-authored-by: ledwards2225 <98505400+ledwards2225@users.noreply.github.com>
Co-authored-by: sergei iakovenko <105737703+iakovenkos@users.noreply.github.com>
Co-authored-by: ludamad <adam.domurad@gmail.com>
Co-authored-by: Raju Krishnamoorthy <krishnamoorthy@gmail.com>
Co-authored-by: notnotraju <raju@aztec-labs.com>
Co-authored-by: Lucas Xia <lucasxia01@gmail.com>
Co-authored-by: Khashayar Barooti <khashayar@aztecprotocol.com>
Co-authored-by: Jean M <132435771+jeanmon@users.noreply.github.com>
Co-authored-by: Alex Gherghisan <alexghr@users.noreply.github.com>
Co-authored-by: Santiago Palladino <spalladino@users.noreply.github.com>
Co-authored-by: Santiago Palladino <santiago@aztec-labs.com>
Co-authored-by: ludamad <domuradical@gmail.com>
Co-authored-by: maramihali <mara@aztecprotocol.com>
Co-authored-by: Sarkoxed <75146596+Sarkoxed@users.noreply.github.com>

Author: 16 people

barretenberg/cpp/src/barretenberg/acir_formal_proofs/helpers.test.cpp

@@ -3,7 +3,6 @@
 #include "barretenberg/smt_verification/circuit/ultra_circuit.hpp"
 #include "barretenberg/smt_verification/solver/solver.hpp"
 #include "barretenberg/smt_verification/util/smt_util.hpp"
-#include "barretenberg/stdlib/primitives/uint/uint.hpp"
 #include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
 
 using namespace bb;

barretenberg/cpp/src/barretenberg/api/api_ultra_honk.cpp

@@ -10,7 +10,7 @@
 #include "barretenberg/dsl/acir_proofs/honk_contract.hpp"
 #include "barretenberg/dsl/acir_proofs/honk_zk_contract.hpp"
 #include "barretenberg/honk/proof_system/types/proof.hpp"
-#include "barretenberg/honk/types/aggregation_object_type.hpp"
+#include "barretenberg/special_public_inputs/special_public_inputs.hpp"
 #include "barretenberg/srs/global_crs.hpp"
 
 namespace bb {
@@ -56,20 +56,24 @@ std::shared_ptr<DeciderProvingKey_<Flavor>> _compute_proving_key(const std::stri
 }
 
 template <typename Flavor>
-PubInputsProofAndKey<typename Flavor::VerificationKey> _compute_vk(const std::filesystem::path& bytecode_path,
-                                                                   const std::filesystem::path& witness_path)
+PubInputsProofAndKey<Flavor> _compute_vk(const std::filesystem::path& bytecode_path,
+                                         const std::filesystem::path& witness_path)
 {
+    using Proof = typename Flavor::Transcript::Proof;
+
     auto proving_key = _compute_proving_key<Flavor>(bytecode_path.string(), witness_path.string());
     auto vk = std::make_shared<typename Flavor::VerificationKey>(proving_key->get_precomputed());
-    return { PublicInputsVector{}, HonkProof{}, vk, vk->hash() };
+    return { PublicInputsVector{}, Proof{}, vk, vk->hash() };
 }
 
 template <typename Flavor>
-PubInputsProofAndKey<typename Flavor::VerificationKey> _prove(const bool compute_vk,
-                                                              const std::filesystem::path& bytecode_path,
-                                                              const std::filesystem::path& witness_path,
-                                                              const std::filesystem::path& vk_path)
+PubInputsProofAndKey<Flavor> _prove(const bool compute_vk,
+                                    const std::filesystem::path& bytecode_path,
+                                    const std::filesystem::path& witness_path,
+                                    const std::filesystem::path& vk_path)
 {
+    using Proof = typename Flavor::Transcript::Proof;
+
     auto proving_key = _compute_proving_key<Flavor>(bytecode_path.string(), witness_path.string());
     std::shared_ptr<typename Flavor::VerificationKey> vk;
     if (compute_vk) {
@@ -82,24 +86,30 @@ PubInputsProofAndKey<typename Flavor::VerificationKey> _prove(const bool compute
 
     UltraProver_<Flavor> prover{ proving_key, vk };
 
-    HonkProof concat_pi_and_proof = prover.construct_proof();
-    size_t num_inner_public_inputs = prover.proving_key->num_public_inputs();
-    // Loose check that the public inputs contain a pairing point accumulator, doesn't catch everything.
-    BB_ASSERT_GTE(prover.proving_key->num_public_inputs(),
-                  PAIRING_POINTS_SIZE,
-                  "Public inputs should contain a pairing point accumulator.");
-    num_inner_public_inputs -= PAIRING_POINTS_SIZE;
-    if constexpr (HasIPAAccumulator<Flavor>) {
-        BB_ASSERT_GTE(num_inner_public_inputs, IPA_CLAIM_SIZE, "Public inputs should contain an IPA claim.");
-        num_inner_public_inputs -= IPA_CLAIM_SIZE;
-    }
+    Proof concat_pi_and_proof = prover.construct_proof();
+    // Compute number of inner public inputs. Perform loose checks that the public inputs contain enough data.
+    auto num_inner_public_inputs = [&]() {
+        size_t num_public_inputs = prover.proving_key->num_public_inputs();
+        if constexpr (HasIPAAccumulator<Flavor>) {
+            BB_ASSERT_GTE(num_public_inputs,
+                          RollupIO::PUBLIC_INPUTS_SIZE,
+                          "Public inputs should contain a pairing point accumulator and an IPA claim.");
+            return num_public_inputs - RollupIO::PUBLIC_INPUTS_SIZE;
+        } else {
+            BB_ASSERT_GTE(num_public_inputs,
+                          DefaultIO::PUBLIC_INPUTS_SIZE,
+                          "Public inputs should contain a pairing point accumulator.");
+            return num_public_inputs - DefaultIO::PUBLIC_INPUTS_SIZE;
+        }
+    }();
+
     // We split the inner public inputs, which are stored at the front of the proof, from the rest of the proof. Now,
     // the "proof" refers to everything except the inner public inputs.
-    PublicInputsAndProof public_inputs_and_proof{
+    PublicInputsAndProof<Proof> public_inputs_and_proof{
         PublicInputsVector(concat_pi_and_proof.begin(),
                            concat_pi_and_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs)),
-        HonkProof(concat_pi_and_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs),
-                  concat_pi_and_proof.end())
+        Proof(concat_pi_and_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs),
+              concat_pi_and_proof.end())
     };
     return { public_inputs_and_proof.public_inputs, public_inputs_and_proof.proof, vk, vk->hash() };
 }
@@ -112,12 +122,15 @@ bool _verify(const bool ipa_accumulation,
 {
     using VerificationKey = typename Flavor::VerificationKey;
     using Verifier = UltraVerifier_<Flavor>;
+    using Transcript = typename Flavor::Transcript;
+    using DataType = typename Transcript::DataType;
+    using Proof = typename Transcript::Proof;
 
     auto vk = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(read_file(vk_path)));
-    auto public_inputs = many_from_buffer<bb::fr>(read_file(public_inputs_path));
-    auto proof = many_from_buffer<bb::fr>(read_file(proof_path));
+    auto public_inputs = many_from_buffer<DataType>(read_file(public_inputs_path));
+    auto proof = many_from_buffer<DataType>(read_file(proof_path));
     // concatenate public inputs and proof
-    std::vector<fr> complete_proof = public_inputs;
+    std::vector<DataType> complete_proof = public_inputs;
     complete_proof.insert(complete_proof.end(), proof.begin(), proof.end());
 
     VerifierCommitmentKey<curve::Grumpkin> ipa_verification_key;
@@ -137,9 +150,9 @@ bool _verify(const bool ipa_accumulation,
                      "Honk proof has incorrect length while verifying.");
         const std::ptrdiff_t honk_proof_with_pub_inputs_length =
             static_cast<std::ptrdiff_t>(HONK_PROOF_LENGTH + num_public_inputs);
-        auto ipa_proof = HonkProof(complete_proof.begin() + honk_proof_with_pub_inputs_length, complete_proof.end());
+        auto ipa_proof = Proof(complete_proof.begin() + honk_proof_with_pub_inputs_length, complete_proof.end());
         auto tube_honk_proof =
-            HonkProof(complete_proof.begin(), complete_proof.begin() + honk_proof_with_pub_inputs_length);
+            Proof(complete_proof.begin(), complete_proof.begin() + honk_proof_with_pub_inputs_length);
         verified = verifier.verify_proof(complete_proof, ipa_proof);
     } else {
         verified = verifier.verify_proof(complete_proof);

barretenberg/cpp/src/barretenberg/api/prove_tube.cpp

@@ -3,6 +3,7 @@
 #include "barretenberg/common/map.hpp"
 #include "barretenberg/honk/proof_system/types/proof.hpp"
 #include "barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.hpp"
+#include "barretenberg/stdlib/special_public_inputs/special_public_inputs.hpp"
 
 namespace bb {
 /**
@@ -17,6 +18,8 @@ void prove_tube(const std::string& output_path, const std::string& vk_path)
 
     using Builder = UltraCircuitBuilder;
     using StdlibProof = ClientIVCRecursiveVerifier::StdlibProof;
+    using HidingKernelIO = stdlib::recursion::honk::HidingKernelIO<Builder>;
+    using RollupIO = stdlib::recursion::honk::RollupIO;
 
     std::string proof_path = output_path + "/proof";
 
@@ -34,7 +37,7 @@ void prove_tube(const std::string& output_path, const std::string& vk_path)
     // The public inputs in the proof are propagated to the base rollup by making them public inputs of this circuit.
     // Exclude the public inputs of the Hiding Kernel: the pairing points are handled separately, the ecc op tables are
     // not needed after this point
-    auto num_inner_public_inputs = vk.mega->num_public_inputs - HidingKernelIO<Builder>::PUBLIC_INPUTS_SIZE;
+    auto num_inner_public_inputs = vk.mega->num_public_inputs - HidingKernelIO::PUBLIC_INPUTS_SIZE;
     for (size_t i = 0; i < num_inner_public_inputs; i++) {
         stdlib_proof.mega_proof[i].set_public();
     }
@@ -54,14 +57,13 @@ void prove_tube(const std::string& output_path, const std::string& vk_path)
     auto proving_key = std::make_shared<DeciderProvingKey_<UltraRollupFlavor>>(*builder);
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1201): Precompute tube vk and pass it in.
     info("WARNING: computing tube vk in prove_tube, but a precomputed vk should be passed in.");
-    auto tube_verification_key =
-        std::make_shared<typename UltraRollupFlavor::VerificationKey>(proving_key->get_precomputed());
+    auto tube_verification_key = std::make_shared<UltraRollupFlavor::VerificationKey>(proving_key->get_precomputed());
 
     Prover tube_prover{ proving_key, tube_verification_key };
     auto tube_proof = tube_prover.construct_proof();
     std::string tubePublicInputsPath = output_path + "/public_inputs";
     std::string tubeProofPath = output_path + "/proof";
-    PublicInputsAndProof public_inputs_and_proof{
+    PublicInputsAndProof<HonkProof> public_inputs_and_proof{
         PublicInputsVector(tube_proof.begin(),
                            tube_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs)),
         HonkProof(tube_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs), tube_proof.end())

barretenberg/cpp/src/barretenberg/api/write_prover_output.hpp

@@ -24,13 +24,21 @@ inline std::string field_elements_to_json(const std::vector<bb::fr>& fields)
     return ss.str();
 }
 
-template <typename VK> struct PubInputsProofAndKey {
+template <typename Flavor> struct PubInputsProofAndKey {
     PublicInputsVector public_inputs;
-    HonkProof proof;
-    std::shared_ptr<VK> key;
+    typename Flavor::Transcript::Proof proof;
+    std::shared_ptr<typename Flavor::VerificationKey> key;
     fr vk_hash;
 };
 
+template <typename T> std::string to_json(const std::vector<T>& data)
+{
+    if (data.empty()) {
+        return std::string("[]");
+    }
+    return format("[", join(transform::map(data, [](const T& el) { return format("\"", el, "\""); })), "]");
+}
+
 template <typename ProverOutput>
 void write(const ProverOutput& prover_output,
            const std::string& output_format,
@@ -40,12 +48,6 @@ void write(const ProverOutput& prover_output,
     enum class ObjectToWrite : size_t { PUBLIC_INPUTS, PROOF, VK, VK_HASH };
     const bool output_to_stdout = output_dir == "-";
 
-    const auto to_json = [](const std::vector<bb::fr>& data) {
-        if (data.empty()) {
-            return std::string("[]");
-        }
-        return format("[", join(transform::map(data, [](auto fr) { return format("\"", fr, "\""); })), "]");
-    };
     const auto to_json_fr = [](const bb::fr& fr) { return format("\"", fr, "\""); };
 
     const auto write_bytes = [&](const ObjectToWrite& obj) {

barretenberg/cpp/src/barretenberg/bb/cli.cpp

@@ -25,7 +25,6 @@
 #include "barretenberg/bbapi/c_bind.hpp"
 #include "barretenberg/common/thread.hpp"
 #include "barretenberg/flavor/ultra_rollup_flavor.hpp"
-#include "barretenberg/honk/types/aggregation_object_type.hpp"
 #include "barretenberg/srs/factories/native_crs_factory.hpp"
 #include "barretenberg/srs/global_crs.hpp"
 #include <fstream>

barretenberg/cpp/src/barretenberg/bbapi/bbapi_ultra_honk.cpp

@@ -7,7 +7,6 @@
 #include "barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp"
 #include "barretenberg/dsl/acir_format/serde/witness_stack.hpp"
 #include "barretenberg/flavor/mega_flavor.hpp"
-#include "barretenberg/honk/types/aggregation_object_type.hpp"
 #include "barretenberg/ultra_honk/decider_proving_key.hpp"
 #include "barretenberg/ultra_honk/ultra_prover.hpp"
 #include "barretenberg/ultra_honk/ultra_verifier.hpp"

barretenberg/cpp/src/barretenberg/commitment_schemes/claim.hpp

@@ -7,7 +7,6 @@
 #pragma once
 
 #include "barretenberg/commitment_schemes/commitment_key.hpp"
-#include "barretenberg/honk/types/aggregation_object_type.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/stdlib/primitives/curves/grumpkin.hpp"
 
@@ -64,8 +63,10 @@ template <typename Curve> class OpeningClaim {
     // commitment to univariate polynomial p(X)
     Commitment commitment;
 
-    // Size of public inputs representation of an opening claim over Grumpkin
-    static constexpr size_t PUBLIC_INPUTS_SIZE = IPA_CLAIM_SIZE;
+    static constexpr bool IS_GRUMPKIN =
+        std::is_same_v<Curve, curve::Grumpkin> || std::is_same_v<Curve, stdlib::grumpkin<UltraCircuitBuilder>>;
+    // Size of public inputs representation of an opening claim over Grumpkin: 2 * 4 + 2 = 10
+    static constexpr size_t PUBLIC_INPUTS_SIZE = IS_GRUMPKIN ? GRUMPKIN_OPENING_CLAIM_SIZE : INVALID_PUBLIC_INPUTS_SIZE;
 
     /**
      * @brief Set the witness indices for the opening claim to public
@@ -91,8 +92,6 @@ template <typename Curve> class OpeningClaim {
         const std::span<const stdlib::field_t<Builder>, PUBLIC_INPUTS_SIZE>& limbs)
         requires(std::is_same_v<Curve, stdlib::grumpkin<UltraCircuitBuilder>>)
     {
-        BB_ASSERT_EQ(2 * Fr::PUBLIC_INPUTS_SIZE + Commitment::PUBLIC_INPUTS_SIZE, PUBLIC_INPUTS_SIZE);
-
         const size_t FIELD_SIZE = Fr::PUBLIC_INPUTS_SIZE;
         const size_t COMMITMENT_SIZE = Commitment::PUBLIC_INPUTS_SIZE;
         std::span<const stdlib::field_t<Builder>, FIELD_SIZE> challenge_limbs{ limbs.data(), FIELD_SIZE };
@@ -111,19 +110,18 @@ template <typename Curve> class OpeningClaim {
      * @note Implemented for native curve::Grumpkin for use with IPA.
      *
      */
-    static OpeningClaim<Curve> reconstruct_from_public(const std::span<const bb::fr, IPA_CLAIM_SIZE>& ipa_claim_limbs)
+    static OpeningClaim<Curve> reconstruct_from_public(const std::span<const bb::fr, PUBLIC_INPUTS_SIZE>& limbs)
         requires(std::is_same_v<Curve, curve::Grumpkin>)
     {
-        size_t index = 0;
-        std::span<const bb::fr> challenge_limbs = ipa_claim_limbs.subspan(index, FQ_PUBLIC_INPUT_SIZE);
-        index += FQ_PUBLIC_INPUT_SIZE;
-        std::span<const bb::fr> evaluation_limbs = ipa_claim_limbs.subspan(index, FQ_PUBLIC_INPUT_SIZE);
-        index += FQ_PUBLIC_INPUT_SIZE;
-        std::span<const bb::fr> point_limbs = ipa_claim_limbs.subspan(index, 2 * FR_PUBLIC_INPUTS_SIZE);
-
-        auto challenge = fq::reconstruct_from_public(challenge_limbs);
-        auto evaluation = fq::reconstruct_from_public(evaluation_limbs);
-        typename Curve::AffineElement commitment = Curve::AffineElement::reconstruct_from_public(point_limbs);
+        const size_t FIELD_SIZE = Fr::PUBLIC_INPUTS_SIZE;
+        const size_t COMMITMENT_SIZE = Commitment::PUBLIC_INPUTS_SIZE;
+        std::span<const bb::fr, FIELD_SIZE> challenge_limbs{ limbs.data(), FIELD_SIZE };
+        std::span<const bb::fr, FIELD_SIZE> evaluation_limbs{ limbs.data() + FIELD_SIZE, FIELD_SIZE };
+        std::span<const bb::fr, COMMITMENT_SIZE> commitment_limbs{ limbs.data() + 2 * FIELD_SIZE, COMMITMENT_SIZE };
+
+        Fr challenge = Fr::reconstruct_from_public(challenge_limbs);
+        Fr evaluation = Fr::reconstruct_from_public(evaluation_limbs);
+        Commitment commitment = Commitment::reconstruct_from_public(commitment_limbs);
 
         return OpeningClaim<Curve>{ { challenge, evaluation }, commitment };
     }

barretenberg/cpp/src/barretenberg/commitment_schemes/pairing_points.hpp

@@ -8,7 +8,6 @@
 
 #include "barretenberg/commitment_schemes/commitment_key.hpp"
 #include "barretenberg/commitment_schemes/verification_key.hpp"
-#include "barretenberg/honk/types/aggregation_object_type.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/stdlib/primitives/curves/grumpkin.hpp"
 
@@ -30,6 +29,8 @@ class PairingPoints {
     using VerifierCK = VerifierCommitmentKey<curve::BN254>;
 
   public:
+    static constexpr size_t PUBLIC_INPUTS_SIZE = PAIRING_POINTS_SIZE;
+
     Point P0 = Point::infinity();
     Point P1 = Point::infinity();
 
@@ -43,10 +44,13 @@ class PairingPoints {
      * @brief Reconstruct the pairing points from limbs stored on the public inputs.
      *
      */
-    static PairingPoints reconstruct_from_public(const std::span<const Fr, PAIRING_POINTS_SIZE>& limbs_in)
+    static PairingPoints reconstruct_from_public(const std::span<const Fr, PUBLIC_INPUTS_SIZE>& limbs_in)
     {
-        Point P0 = Point::reconstruct_from_public(limbs_in.subspan(0, 2 * FQ_PUBLIC_INPUT_SIZE));
-        Point P1 = Point::reconstruct_from_public(limbs_in.subspan(2 * FQ_PUBLIC_INPUT_SIZE, 2 * FQ_PUBLIC_INPUT_SIZE));
+        const std::span<const bb::fr, Point::PUBLIC_INPUTS_SIZE> P0_limbs(limbs_in.data(), Point::PUBLIC_INPUTS_SIZE);
+        const std::span<const bb::fr, Point::PUBLIC_INPUTS_SIZE> P1_limbs(limbs_in.data() + Point::PUBLIC_INPUTS_SIZE,
+                                                                          Point::PUBLIC_INPUTS_SIZE);
+        Point P0 = Point::reconstruct_from_public(P0_limbs);
+        Point P1 = Point::reconstruct_from_public(P1_limbs);
 
         return PairingPoints{ P0, P1 };
     }

barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp

@@ -60,11 +60,11 @@ void create_ecdsa_k1_verify_constraints(Builder& builder,
 
     std::vector<uint8_t> rr(new_sig.r.begin(), new_sig.r.end());
     std::vector<uint8_t> ss(new_sig.s.begin(), new_sig.s.end());
-    uint8_t vv = new_sig.v;
+    std::vector<uint8_t> vv = { new_sig.v };
 
     stdlib::ecdsa_signature<Builder> sig{ stdlib::byte_array<Builder>(&builder, rr),
                                           stdlib::byte_array<Builder>(&builder, ss),
-                                          stdlib::uint8<Builder>(&builder, vv) };
+                                          stdlib::byte_array<Builder>(&builder, vv) };
 
     pub_key_x_fq.assert_is_in_field();
     pub_key_y_fq.assert_is_in_field();

barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.cpp

@@ -58,11 +58,11 @@ void create_ecdsa_r1_verify_constraints(Builder& builder,
 
     std::vector<uint8_t> rr(new_sig.r.begin(), new_sig.r.end());
     std::vector<uint8_t> ss(new_sig.s.begin(), new_sig.s.end());
-    uint8_t vv = new_sig.v;
+    std::vector<uint8_t> vv = { new_sig.v };
 
     stdlib::ecdsa_signature<Builder> sig{ stdlib::byte_array<Builder>(&builder, rr),
                                           stdlib::byte_array<Builder>(&builder, ss),
-                                          stdlib::uint8<Builder>(&builder, vv) };
+                                          stdlib::byte_array<Builder>(&builder, vv) };
 
     pub_key_x_fq.assert_is_in_field();
     pub_key_y_fq.assert_is_in_field();