chore: field_conversion clean-up/int audit

barretenberg/cpp/src/barretenberg/dsl/acir_format/civc_recursion_constraints.cpp

@@ -111,7 +111,7 @@ create_civc_recursion_constraints(Builder& builder,
     }
 
     // Recursively verify CIVC proof
-    auto mega_vk = std::make_shared<VerificationKey>(builder, key_fields);
+    auto mega_vk = std::make_shared<VerificationKey>(key_fields);
     auto mega_vk_and_hash = std::make_shared<RecursiveVKAndHash>(mega_vk, vk_hash);
     ClientIVCRecursiveVerifier::StdlibProof stdlib_proof(proof_fields, input.public_inputs.size());
 

barretenberg/cpp/src/barretenberg/dsl/acir_format/honk_recursion_constraint.cpp

@@ -141,7 +141,7 @@ HonkRecursionConstraintOutput<typename Flavor::CircuitBuilder> create_honk_recur
     }
 
     // Recursively verify the proof
-    auto vkey = std::make_shared<RecursiveVerificationKey>(builder, key_fields);
+    auto vkey = std::make_shared<RecursiveVerificationKey>(key_fields);
     auto vk_and_hash = std::make_shared<RecursiveVKAndHash>(vkey, vk_hash);
     RecursiveVerifier verifier(&builder, vk_and_hash);
     UltraRecursiveVerifierOutput<Builder> verifier_output = verifier.template verify_proof<IO>(proof_fields);

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

@@ -140,18 +140,18 @@ template <typename BuilderType> class MegaRecursiveFlavor_ {
          * @param builder
          * @param elements
          */
-        VerificationKey(CircuitBuilder& builder, std::span<FF> elements)
+        VerificationKey(std::span<FF> elements)
         {
             using namespace bb::stdlib::field_conversion;
 
             size_t num_frs_read = 0;
 
-            this->log_circuit_size = deserialize_from_frs<FF>(builder, elements, num_frs_read);
-            this->num_public_inputs = deserialize_from_frs<FF>(builder, elements, num_frs_read);
-            this->pub_inputs_offset = deserialize_from_frs<FF>(builder, elements, num_frs_read);
+            this->log_circuit_size = deserialize_from_frs<FF>(elements, num_frs_read);
+            this->num_public_inputs = deserialize_from_frs<FF>(elements, num_frs_read);
+            this->pub_inputs_offset = deserialize_from_frs<FF>(elements, num_frs_read);
 
             for (Commitment& commitment : this->get_all()) {
-                commitment = deserialize_from_frs<Commitment>(builder, elements, num_frs_read);
+                commitment = deserialize_from_frs<Commitment>(elements, num_frs_read);
             }
 
             if (num_frs_read != elements.size()) {
@@ -174,7 +174,7 @@ template <typename BuilderType> class MegaRecursiveFlavor_ {
             for (const auto& idx : witness_indices) {
                 vk_fields.emplace_back(FF::from_witness_index(&builder, idx));
             }
-            return VerificationKey(builder, vk_fields);
+            return VerificationKey(vk_fields);
         }
 
         /**

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

@@ -140,18 +140,18 @@ template <typename BuilderType> class UltraRecursiveFlavor_ {
          * @param builder
          * @param elements
          */
-        VerificationKey(CircuitBuilder& builder, std::span<FF> elements)
+        VerificationKey(std::span<FF> elements)
         {
             using namespace bb::stdlib::field_conversion;
 
             size_t num_frs_read = 0;
 
-            this->log_circuit_size = deserialize_from_frs<FF>(builder, elements, num_frs_read);
-            this->num_public_inputs = deserialize_from_frs<FF>(builder, elements, num_frs_read);
-            this->pub_inputs_offset = deserialize_from_frs<FF>(builder, elements, num_frs_read);
+            this->log_circuit_size = deserialize_from_frs<FF>(elements, num_frs_read);
+            this->num_public_inputs = deserialize_from_frs<FF>(elements, num_frs_read);
+            this->pub_inputs_offset = deserialize_from_frs<FF>(elements, num_frs_read);
 
             for (Commitment& commitment : this->get_all()) {
-                commitment = deserialize_from_frs<Commitment>(builder, elements, num_frs_read);
+                commitment = deserialize_from_frs<Commitment>(elements, num_frs_read);
             }
         }
 
@@ -170,7 +170,7 @@ template <typename BuilderType> class UltraRecursiveFlavor_ {
             for (const auto& idx : witness_indices) {
                 vk_fields.emplace_back(FF::from_witness_index(&builder, idx));
             }
-            return VerificationKey(builder, vk_fields);
+            return VerificationKey(vk_fields);
         }
     };
 

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

@@ -86,18 +86,18 @@ template <typename BuilderType> class UltraRollupRecursiveFlavor_ : public Ultra
          * @param builder
          * @param elements
          */
-        VerificationKey(CircuitBuilder& builder, std::span<FF> elements)
+        VerificationKey(std::span<FF> elements)
         {
             using namespace bb::stdlib::field_conversion;
 
             size_t num_frs_read = 0;
 
-            this->log_circuit_size = deserialize_from_frs<FF>(builder, elements, num_frs_read);
-            this->num_public_inputs = deserialize_from_frs<FF>(builder, elements, num_frs_read);
-            this->pub_inputs_offset = deserialize_from_frs<FF>(builder, elements, num_frs_read);
+            this->log_circuit_size = deserialize_from_frs<FF>(elements, num_frs_read);
+            this->num_public_inputs = deserialize_from_frs<FF>(elements, num_frs_read);
+            this->pub_inputs_offset = deserialize_from_frs<FF>(elements, num_frs_read);
 
             for (Commitment& commitment : this->get_all()) {
-                commitment = deserialize_from_frs<Commitment>(builder, elements, num_frs_read);
+                commitment = deserialize_from_frs<Commitment>(elements, num_frs_read);
             }
         }
 
@@ -116,7 +116,7 @@ template <typename BuilderType> class UltraRollupRecursiveFlavor_ : public Ultra
             for (const auto& idx : witness_indices) {
                 vk_fields.emplace_back(FF::from_witness_index(&builder, idx));
             }
-            return VerificationKey(builder, vk_fields);
+            return VerificationKey(vk_fields);
         }
     };
 

barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp

@@ -95,6 +95,8 @@ class ECCVMRecursiveTests : public ::testing::Test {
         auto [opening_claim, ipa_transcript] = verifier.verify_proof(proof);
         stdlib::recursion::PairingPoints<OuterBuilder>::add_default_to_public_inputs(outer_circuit);
 
+        const size_t fixed_size = 218783;
+        info("Fixed size ", fixed_size);
         info("Recursive Verifier: num gates = ", outer_circuit.get_estimated_num_finalized_gates());
 
         // Check for a failure flag in the recursive verifier circuit

barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/ultra_recursive_verifier.test.cpp

@@ -291,7 +291,7 @@ template <typename RecursiveFlavor> class RecursiveVerifierTest : public testing
         }
         // Check the size of the recursive verifier
         if constexpr (std::same_as<RecursiveFlavor, MegaZKRecursiveFlavor_<UltraCircuitBuilder>>) {
-            uint32_t NUM_GATES_EXPECTED = 796978;
+            uint32_t NUM_GATES_EXPECTED = 803143;
             ASSERT_EQ(static_cast<uint32_t>(outer_circuit.get_num_finalized_gates()), NUM_GATES_EXPECTED)
                 << "MegaZKHonk Recursive verifier changed in Ultra gate count! Update this value if you "
                    "are sure this is expected.";

barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.hpp

@@ -45,6 +45,7 @@ template <class Builder_, class Fq, class Fr, class NativeGroup> class element {
     element();
     element(const typename NativeGroup::affine_element& input);
     element(const Fq& x, const Fq& y);
+    element(const Fq& x, const Fq& y, const bool_ct& is_infinity);
 
     element(const element& other);
     element(element&& other) noexcept;

barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_goblin.hpp

@@ -56,6 +56,11 @@ template <class Builder_, class Fq, class Fr, class NativeGroup> class goblin_el
         , y(y)
         , _is_infinity(false)
     {}
+    goblin_element(const Fq& x, const Fq& y, const bool_ct is_infinity)
+        : x(x)
+        , y(y)
+        , _is_infinity(is_infinity)
+    {}
     goblin_element(const goblin_element& other) = default;
     goblin_element(goblin_element&& other) noexcept = default;
     goblin_element& operator=(const goblin_element& other) = default;

barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_impl.hpp

@@ -36,6 +36,13 @@ element<C, Fq, Fr, G>::element(const Fq& x_in, const Fq& y_in)
     , _is_infinity(x.get_context() ? x.get_context() : y.get_context(), false)
 {}
 
+template <typename C, class Fq, class Fr, class G>
+element<C, Fq, Fr, G>::element(const Fq& x_in, const Fq& y_in, const bool_ct& is_infinity)
+    : x(x_in)
+    , y(y_in)
+    , _is_infinity(is_infinity)
+{}
+
 template <typename C, class Fq, class Fr, class G>
 element<C, Fq, Fr, G>::element(const element& other)
     : x(other.x)

barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field_conversion.cpp

@@ -5,46 +5,44 @@
 // =====================
 
 #include "barretenberg/stdlib/primitives/field/field_conversion.hpp"
-#include "barretenberg/common/assert.hpp"
-
 namespace bb::stdlib::field_conversion {
 
 /**
- * @brief Converts a challenge to a fq<Builder>
- * @details We sometimes need challenges that are a bb::fq element, so we need to convert the bb::fr challenge to a
- * bb::fq type. We do this by in a similar fashion to the convert_from_bn254_frs function that converts to a
- * fq<Builder>. In fact, we do call that function that the end, but we first have to split the fr<Builder> into two
- * pieces, one that is the 136 lower bits and one that is the 118 higher bits. Then, we can split these two pieces into
- * their bigfield limbs through convert_from_bn254_frs, which is actually just a bigfield constructor that takes in two
- * two-limb frs.
+ * @brief Converts an in-circuit `fr`element to an `fq`, i.e. `field_t` --> `bigfield`.
  *
- * TODO(https://github.com/AztecProtocol/barretenberg/issues/850): audit this function more carefully
+ * @details Our circuit builders are `fr`-native, which results in challenges being `field_t` elements. However,
+ * ECCVMRecursiveVerifier and IPA Recursive Verification need challenges that are `bigfield` elements. We do this in
+ * a similar fashion to the `convert_from_bn254_frs` function that converts to a `bigfield`. We split the `field_t`
+ * into two pieces, one that is the 136 lower bits and one that is the 118 higher bits, assert the correctness of the
+ * decomposition, and invoke the `bigfield` constructor.
  * @tparam Builder
  */
-template <typename Builder> fq<Builder> convert_to_grumpkin_fr(Builder& builder, const fr<Builder>& f)
+template <typename Builder> fq<Builder> convert_to_grumpkin_fr(Builder& builder, const fr<Builder>& fr_element)
 {
-    constexpr uint64_t NUM_BITS_IN_TWO_LIMBS = 2 * NUM_LIMB_BITS;                // 136
-    constexpr uint64_t UPPER_TWO_LIMB_BITS = TOTAL_BITS - NUM_BITS_IN_TWO_LIMBS; // 118
+    static constexpr uint64_t NUM_LIMB_BITS = fq<Builder>::NUM_LIMB_BITS;
+
+    constexpr uint64_t NUM_BITS_IN_TWO_LIMBS = 2 * NUM_LIMB_BITS; // 136
+
     constexpr uint256_t shift = (uint256_t(1) << NUM_BITS_IN_TWO_LIMBS);
     // split f into low_bits_in and high_bits_in
     constexpr uint256_t LIMB_MASK = shift - 1; // mask for upper 128 bits
-    const uint256_t value = f.get_value();
+    const uint256_t value = fr_element.get_value();
     const uint256_t low_val = static_cast<uint256_t>(value & LIMB_MASK);
     const uint256_t hi_val = static_cast<uint256_t>(value >> NUM_BITS_IN_TWO_LIMBS);
 
     fr<Builder> low{ witness_t<Builder>(&builder, low_val) };
     fr<Builder> hi{ witness_t<Builder>(&builder, hi_val) };
-    // range constrain low to 136 bits and hi to 118 bits
-    builder.create_range_constraint(low.witness_index, NUM_BITS_IN_TWO_LIMBS, "create_range_constraint");
-    builder.create_range_constraint(hi.witness_index, UPPER_TWO_LIMB_BITS, "create_range_constraint");
 
-    BB_ASSERT_EQ(static_cast<uint256_t>(low_val) + (static_cast<uint256_t>(hi_val) << NUM_BITS_IN_TWO_LIMBS), value);
+    constrain_bigfield_limbs(low, hi);
+
+    BB_ASSERT_EQ(static_cast<uint256_t>(low_val) + (static_cast<uint256_t>(hi_val) << NUM_BITS_IN_TWO_LIMBS),
+                 value,
+                 "field_conversion: limb decomposition");
     // checks this decomposition low + hi * 2^64 = value with an assert_equal
-    auto sum = low + hi * shift;
-    builder.assert_equal(f.witness_index, sum.witness_index, "assert_equal");
+    const fr<Builder> zero = fr<Builder>::from_witness_index(&builder, 0);
+    fr<Builder>::evaluate_linear_identity(hi * shift, low, -fr_element, zero);
 
-    std::vector<fr<Builder>> fr_vec{ low, hi };
-    return convert_from_bn254_frs<Builder, fq<Builder>>(builder, fr_vec);
+    return fq<Builder>(low, hi);
 }
 
 template fq<UltraCircuitBuilder> convert_to_grumpkin_fr<UltraCircuitBuilder>(UltraCircuitBuilder& builder,