From 69eba2d0cd4df1e1cf9446be0c40b6f74900e74a Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Thu, 13 Apr 2023 17:29:41 +0200
Subject: [PATCH 01/64] Added recursion constraint into dsl + tests

---
 .../dsl/acir_format/acir_format.cpp           |  23 +++
 .../dsl/acir_format/acir_format.hpp           |   3 +
 .../dsl/acir_format/recursion_constraint.cpp  |  77 ++++++++
 .../dsl/acir_format/recursion_constraint.hpp  |  64 +++++++
 .../acir_format/recursion_constraint.test.cpp | 172 ++++++++++++++++++
 5 files changed, 339 insertions(+)
 create mode 100644 cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
 create mode 100644 cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
 create mode 100644 cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
index c702ec980a..2b7b9526b6 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
@@ -86,6 +86,11 @@ void create_circuit(Composer& composer, const acir_format& constraint_system)
     for (const auto& constraint : constraint_system.hash_to_field_constraints) {
         create_hash_to_field_constraints(composer, constraint);
     }
+
+    // Add recursion constraints
+    for (const auto& constraint : constraint_system.recursion_constraints) {
+        create_recursion_constraints(composer, constraint);
+    }
 }
 
 Composer create_circuit(const acir_format& constraint_system,
@@ -165,6 +170,11 @@ Composer create_circuit(const acir_format& constraint_system,
         create_hash_to_field_constraints(composer, constraint);
     }
 
+    // Add recursion constraints
+    for (const auto& constraint : constraint_system.recursion_constraints) {
+        create_recursion_constraints(composer, constraint);
+    }
+
     return composer;
 }
 
@@ -249,6 +259,10 @@ Composer create_circuit_with_witness(const acir_format& constraint_system,
         create_hash_to_field_constraints(composer, constraint);
     }
 
+    // Add recursion constraints
+    for (const auto& constraint : constraint_system.recursion_constraints) {
+        create_recursion_constraints(composer, constraint);
+    }
     return composer;
 }
 Composer create_circuit_with_witness(const acir_format& constraint_system, std::vector<fr> witness)
@@ -330,6 +344,10 @@ Composer create_circuit_with_witness(const acir_format& constraint_system, std::
         create_hash_to_field_constraints(composer, constraint);
     }
 
+    // Add recursion constraints
+    for (const auto& constraint : constraint_system.recursion_constraints) {
+        create_recursion_constraints(composer, constraint);
+    }
     return composer;
 }
 void create_circuit_with_witness(Composer& composer, const acir_format& constraint_system, std::vector<fr> witness)
@@ -408,6 +426,11 @@ void create_circuit_with_witness(Composer& composer, const acir_format& constrai
     for (const auto& constraint : constraint_system.hash_to_field_constraints) {
         create_hash_to_field_constraints(composer, constraint);
     }
+
+    // Add recursion constraints
+    for (const auto& constraint : constraint_system.recursion_constraints) {
+        create_recursion_constraints(composer, constraint);
+    }
 }
 
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
index 55d5ee969e..12592c6a32 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
@@ -7,6 +7,7 @@
 #include "schnorr_verify.hpp"
 #include "ecdsa_secp256k1.hpp"
 #include "merkle_membership_constraint.hpp"
+#include "recursion_constraint.hpp"
 #include "pedersen.hpp"
 #include "hash_to_field.hpp"
 #include "barretenberg/stdlib/types/types.hpp"
@@ -29,6 +30,8 @@ struct acir_format {
     std::vector<HashToFieldConstraint> hash_to_field_constraints;
     std::vector<PedersenConstraint> pedersen_constraints;
     std::vector<MerkleMembershipConstraint> merkle_membership_constraints;
+    std::vector<RecursionConstraint> recursion_constraints;
+
     // A standard plonk arithmetic constraint, as defined in the poly_triple struct, consists of selector values
     // for q_M,q_L,q_R,q_O,q_C and indices of three variables taking the role of left, right and output wire
     std::vector<poly_triple> constraints;
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
new file mode 100644
index 0000000000..b6abe2e5fc
--- /dev/null
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -0,0 +1,77 @@
+#include "recursion_constraint.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+#include "barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp"
+#include "barretenberg/stdlib/recursion/verifier/verifier.hpp"
+
+using namespace proof_system::plonk::stdlib::types;
+
+using verification_key_ct = proof_system::plonk::stdlib::recursion::verification_key<bn254>;
+using aggregation_state_ct = proof_system::plonk::stdlib::recursion::aggregation_state<bn254>;
+using noir_recursive_settings = proof_system::plonk::stdlib::recursion::recursive_ultra_verifier_settings<bn254>;
+namespace acir_format {
+
+/**
+ * @brief Add constraints required to recursively verify an UltraPlonk proof
+ *
+ * @param composer
+ * @param input
+ */
+void create_recursion_constraints(Composer& composer, const RecursionConstraint& input)
+{
+    // The env_crs should be ok, we use this when generating the constraint system in dsl
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+
+    // Construct an in-circuit representation of the verification key.
+    // For now, the v-key is a circuit constant and is fixed for the circuit.
+    // (We may need a separate recursion opcode for this to vary, or add more config witnesses to this opcode)
+    auto data_clone = input.verification_key_data;
+    std::shared_ptr<plonk::verification_key> key =
+        std::make_shared<plonk::verification_key>(std::move(data_clone), env_crs->get_verifier_crs());
+    std::shared_ptr<verification_key_ct> circuit_key = verification_key_ct::from_constants(&composer, key);
+    const auto& aggregation_input = input.input_aggregation_object;
+    aggregation_state_ct previous_aggregation;
+
+    // If we have previously recursively verified proofs, `is_aggregation_object_nonzero = true`
+    // For now this is a complile-time constant i.e. whether this is true/false is fixed for the circuit!
+    if (input.is_aggregation_object_nonzero) {
+        std::array<bn254::fq_ct, 4> aggregation_elements;
+        for (size_t i = 0; i < 4; ++i) {
+            aggregation_elements[i] =
+                bn254::fq_ct(field_ct::from_witness_index(&composer, aggregation_input[4 * i]),
+                             field_ct::from_witness_index(&composer, aggregation_input[4 * i + 1]),
+                             field_ct::from_witness_index(&composer, aggregation_input[4 * i + 2]),
+                             field_ct::from_witness_index(&composer, 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
+        // in stdlib::recursion::verify_proof
+        previous_aggregation.P0 = bn254::g1_ct(aggregation_elements[0], aggregation_elements[1]);
+        previous_aggregation.P1 = bn254::g1_ct(aggregation_elements[2], aggregation_elements[3]);
+        previous_aggregation.has_data = true;
+    } else {
+        previous_aggregation.has_data = false;
+    }
+
+    transcript::Manifest manifest = Composer::create_unrolled_manifest(1);
+
+    // recursively verify the proof
+    aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof<bn254, noir_recursive_settings>(
+        &composer, circuit_key, manifest, input.proof, previous_aggregation);
+
+    // Assign the output aggregation object to the proof public inputs (16 field elements representing two G1 points)
+    result.add_proof_outputs_as_public_inputs();
+
+    ASSERT(result.public_inputs.size() == 1);
+
+    // Assign the `public_input` field to the public input of the inner proof
+    result.public_inputs[0].assert_equal(field_ct::from_witness_index(&composer, input.public_input));
+
+    // Assign the recursive proof outputs to `output_aggregation_object`
+    for (size_t i = 0; i < result.proof_witness_indices.size(); ++i) {
+        const auto lhs = field_ct::from_witness_index(&composer, result.proof_witness_indices[i]);
+        const auto rhs = field_ct::from_witness_index(&composer, input.output_aggregation_object[i]);
+        lhs.assert_equal(rhs);
+    }
+}
+
+} // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
new file mode 100644
index 0000000000..c67dacb10f
--- /dev/null
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -0,0 +1,64 @@
+#pragma once
+#include <vector>
+#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/plonk/proof_system//verification_key/verification_key.hpp"
+
+namespace acir_format {
+
+/**
+ * @brief RecursionConstraint struct contains information required to recursively verify a proof!
+ *
+ * @details The recursive verifier algorithm produces an 'aggregation object' representing 2 G1 points, expressed as 16
+ * witness values. The smart contract Verifier must be aware of this aggregation object in order to complete the full
+ * recursive verification. If the circuit verifies more than 1 proof, the recursion algorithm will update a pre-existing
+ * aggregation object (`input_aggregation_object`).
+ *
+ * @details We currently require that the inner circuit being verified only has a single public input. If more are
+ * required, the outer circuit can hash them down to 1 input.
+ *
+ * @param verification_key_data The inner circuit vkey. Is converted into circuit witness values (internal to the
+ * backend)
+ * @param proof The plonk proof. Is converted into circuit witness values (internal to the backend)
+ * @param is_aggregation_object_nonzero A flag to tell us whether the circuit has already recursively verified proofs
+ * (and therefore an aggregation object is present)
+ * @param public_input The index of the single public input
+ * @param input_aggregation_object Witness indices of pre-existing aggregation object (if it exists)
+ * @param output_aggregation_object Witness indecies of the aggregation object produced by recursive verification
+ */
+struct RecursionConstraint {
+    static constexpr size_t AGGREGATION_OBJECT_SIZE = 16; // 16 field elements
+    plonk::verification_key_data verification_key_data;
+    plonk::proof proof;
+    bool is_aggregation_object_nonzero;
+    uint32_t public_input;
+    std::array<uint32_t, AGGREGATION_OBJECT_SIZE> input_aggregation_object;
+    std::array<uint32_t, AGGREGATION_OBJECT_SIZE> output_aggregation_object;
+
+    friend bool operator==(RecursionConstraint const& lhs, RecursionConstraint const& rhs) = default;
+};
+
+void create_recursion_constraints(plonk::stdlib::types::Composer& composer, const RecursionConstraint& input);
+
+template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
+{
+    using serialize::read;
+    read(buf, constraint.verification_key_data);
+    read(buf, constraint.proof);
+    read(buf, constraint.is_aggregation_object_nonzero);
+    read(buf, constraint.public_input);
+    read(buf, constraint.input_aggregation_object);
+    read(buf, constraint.output_aggregation_object);
+}
+
+template <typename B> inline void write(B& buf, RecursionConstraint const& constraint)
+{
+    using serialize::write;
+    write(buf, constraint.verification_key_data);
+    write(buf, constraint.proof);
+    write(buf, constraint.is_aggregation_object_nonzero);
+    write(buf, constraint.public_input);
+    write(buf, constraint.input_aggregation_object);
+    write(buf, constraint.output_aggregation_object);
+}
+
+} // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
new file mode 100644
index 0000000000..911e36c8eb
--- /dev/null
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -0,0 +1,172 @@
+#include "acir_format.hpp"
+#include "recursion_constraint.hpp"
+#include "barretenberg/plonk/proof_system/types/proof.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+
+#include <gtest/gtest.h>
+#include <vector>
+
+using namespace proof_system::plonk::stdlib::types;
+
+Composer create_inner_circuit()
+{
+    /**
+     * constraints produced by Noir program:
+     * fn main(x : u32, y : pub u32) {
+     * let z = x ^ y;
+     *
+     * constrain z != 10;
+     * }
+     **/
+    acir_format::RangeConstraint range_a{
+        .witness = 1,
+        .num_bits = 32,
+    };
+    acir_format::RangeConstraint range_b{
+        .witness = 2,
+        .num_bits = 32,
+    };
+
+    acir_format::LogicConstraint logic_constraint{
+        .a = 1,
+        .b = 2,
+        .result = 3,
+        .num_bits = 32,
+        .is_xor_gate = 1,
+    };
+    poly_triple expr_a{
+        .a = 3,
+        .b = 4,
+        .c = 0,
+        .q_m = 0,
+        .q_l = 1,
+        .q_r = -1,
+        .q_o = 0,
+        .q_c = -10,
+    };
+    poly_triple expr_b{
+        .a = 4,
+        .b = 5,
+        .c = 6,
+        .q_m = 1,
+        .q_l = 0,
+        .q_r = 0,
+        .q_o = -1,
+        .q_c = 0,
+    };
+    poly_triple expr_c{
+        .a = 4,
+        .b = 6,
+        .c = 4,
+        .q_m = 1,
+        .q_l = 0,
+        .q_r = 0,
+        .q_o = -1,
+        .q_c = 0,
+
+    };
+    poly_triple expr_d{
+        .a = 6,
+        .b = 0,
+        .c = 0,
+        .q_m = 0,
+        .q_l = -1,
+        .q_r = 0,
+        .q_o = 0,
+        .q_c = 1,
+    };
+    // EXPR [ (1, _4, _5) (-1, _6) 0 ]
+    // EXPR [ (1, _4, _6) (-1, _4) 0 ]
+    // EXPR [ (-1, _6) 1 ]
+
+    acir_format::acir_format constraint_system{
+        .varnum = 7,
+        .public_inputs = { 2 },
+        .fixed_base_scalar_mul_constraints = {},
+        .logic_constraints = { logic_constraint },
+        .range_constraints = { range_a, range_b },
+        .schnorr_constraints = {},
+        .ecdsa_constraints = {},
+        .sha256_constraints = {},
+        .blake2s_constraints = {},
+        .hash_to_field_constraints = {},
+        .pedersen_constraints = {},
+        .merkle_membership_constraints = {},
+        .constraints = { expr_a, expr_b, expr_c, expr_d },
+    };
+
+    uint256_t inverse_of_five = fr(5).invert();
+    auto composer = acir_format::create_circuit_with_witness(constraint_system,
+                                                             {
+                                                                 5,
+                                                                 10,
+                                                                 15,
+                                                                 5,
+                                                                 inverse_of_five,
+                                                                 1,
+                                                             });
+
+    return composer;
+}
+
+TEST(RecursionConstraint, TestRecursionConstraint)
+{
+    auto inner_composer = create_inner_circuit();
+
+    auto inner_prover = inner_composer.create_prover();
+    auto inner_proof = inner_prover.construct_proof();
+    auto inner_verifier = inner_composer.create_verifier();
+
+    std::vector<uint8_t> keybuf;
+    write(keybuf, *(inner_verifier.key));
+
+    std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_vars;
+    for (size_t i = 0; i < 16; ++i) {
+        // variable idx 1 = public input
+        // variable idx 2-18 = output_vars
+        output_vars[i] = (static_cast<uint32_t>(i + 2));
+    }
+    verification_key_data keydata;
+    uint8_t const* vk_buf = &keybuf[0];
+    read(vk_buf, keydata);
+
+    acir_format::RecursionConstraint recursion_constraint{
+        .verification_key_data = keydata,
+        .proof = inner_proof,
+        .is_aggregation_object_nonzero = false,
+        .public_input = 1,
+        .input_aggregation_object = {},
+        .output_aggregation_object = output_vars,
+    };
+
+    std::vector<fr> witness;
+    for (size_t i = 0; i < 18; ++i) {
+        witness.emplace_back(0);
+    }
+
+    acir_format::acir_format constraint_system{
+        .varnum = 18,
+        .public_inputs = { 1 },
+        .fixed_base_scalar_mul_constraints = {},
+        .logic_constraints = {},
+        .range_constraints = {},
+        .schnorr_constraints = {},
+        .ecdsa_constraints = {},
+        .sha256_constraints = {},
+        .blake2s_constraints = {},
+        .hash_to_field_constraints = {},
+        .pedersen_constraints = {},
+        .merkle_membership_constraints = {},
+        .recursion_constraints = { recursion_constraint },
+        .constraints = {},
+    };
+
+    auto composer = acir_format::create_circuit_with_witness(constraint_system, witness);
+    auto prover = composer.create_prover();
+
+    auto proof = prover.construct_proof();
+    auto verifier = composer.create_verifier();
+    EXPECT_EQ(verifier.verify_proof(proof), true);
+
+    EXPECT_EQ(composer.get_variable(1), 10);
+}

From 7a80056b0e7ae8e150c719295d83f0c1bea7d614 Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Fri, 14 Apr 2023 00:15:35 +0200
Subject: [PATCH 02/64] fix dsl ecdsa constraint. Added ecdsa dsl tests

---
 .../dsl/acir_format/ecdsa_secp256k1.cpp       |  23 ++-
 .../dsl/acir_format/ecdsa_secp256k1.test.cpp  | 145 ++++++++++++++++++
 .../stdlib/encryption/ecdsa/ecdsa.hpp         |   5 +
 .../stdlib/encryption/ecdsa/ecdsa.test.cpp    |  87 +++++++++++
 .../stdlib/encryption/ecdsa/ecdsa_impl.hpp    |  87 ++++++++++-
 5 files changed, 338 insertions(+), 9 deletions(-)
 create mode 100644 cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp

diff --git a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp
index d81a670cb0..291245d3d5 100644
--- a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp
@@ -102,17 +102,24 @@ void create_ecdsa_verify_constraints(Composer& composer, const EcdsaSecp256k1Con
 
     pub_key_x_fq.assert_is_in_field();
     pub_key_y_fq.assert_is_in_field();
-
     secp256k1_ct::g1_bigfr_ct public_key = secp256k1_ct::g1_bigfr_ct(pub_key_x_fq, pub_key_y_fq);
+    for (size_t i = 0; i < 32; ++i) {
+        sig.r[i].assert_equal(field_ct::from_witness_index(&composer, input.signature[i]));
+        sig.s[i].assert_equal(field_ct::from_witness_index(&composer, input.signature[i + 32]));
+        pub_key_x_byte_arr[i].assert_equal(field_ct::from_witness_index(&composer, input.pub_x_indices[i]));
+        pub_key_y_byte_arr[i].assert_equal(field_ct::from_witness_index(&composer, input.pub_y_indices[i]));
+    }
+    for (size_t i = 0; i < input.message.size(); ++i) {
+        message[i].assert_equal(field_ct::from_witness_index(&composer, input.message[i]));
+    }
 
-    bool_ct signature_result = stdlib::ecdsa::verify_signature<Composer,
-                                                               secp256k1_ct,
-                                                               secp256k1_ct::fq_ct,
-                                                               secp256k1_ct::bigfr_ct,
-                                                               secp256k1_ct::g1_bigfr_ct>(message, public_key, sig);
-
+    bool_ct signature_result =
+        stdlib::ecdsa::verify_signature_noassert<Composer,
+                                                 secp256k1_ct,
+                                                 secp256k1_ct::fq_ct,
+                                                 secp256k1_ct::bigfr_ct,
+                                                 secp256k1_ct::g1_bigfr_ct>(message, public_key, sig);
     bool_ct signature_result_normalized = signature_result.normalize();
-
     composer.assert_equal(signature_result_normalized.witness_index, input.result);
 }
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
new file mode 100644
index 0000000000..57f9af0a1c
--- /dev/null
+++ b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
@@ -0,0 +1,145 @@
+#include "acir_format.hpp"
+#include "ecdsa_secp256k1.hpp"
+#include "barretenberg/plonk/proof_system/types/proof.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+#include "barretenberg/crypto/ecdsa/ecdsa.hpp"
+
+#include <gtest/gtest.h>
+#include <vector>
+
+using namespace proof_system::plonk::stdlib::types;
+using curve = stdlib::secp256k1<Composer>;
+
+size_t generate_ecdsa_constraint(acir_format::EcdsaSecp256k1Constraint& ecdsa_constraint,
+                                 std::vector<fr>& witness_values)
+{
+    std::string message_string = "Instructions unclear, ask again later.";
+
+    crypto::ecdsa::key_pair<curve::fr, curve::g1> account;
+    account.private_key = curve::fr::random_element();
+    account.public_key = curve::g1::one * account.private_key;
+
+    crypto::ecdsa::signature signature =
+        crypto::ecdsa::construct_signature<Sha256Hasher, curve::fq, curve::fr, curve::g1>(message_string, account);
+
+    uint256_t pub_x_value = account.public_key.x;
+    uint256_t pub_y_value = account.public_key.y;
+
+    std::vector<uint32_t> message_in;
+    std::vector<uint32_t> pub_x_indices_in;
+    std::vector<uint32_t> pub_y_indices_in;
+    std::vector<uint32_t> signature_in;
+    size_t offset = 1;
+    for (size_t i = 0; i < message_string.size(); ++i) {
+        message_in.emplace_back(i + offset);
+        const auto byte = static_cast<uint8_t>(message_string[i]);
+        witness_values.emplace_back(byte);
+    }
+    offset += message_in.size();
+
+    for (size_t i = 0; i < 32; ++i) {
+        pub_x_indices_in.emplace_back(i + offset);
+        witness_values.emplace_back(pub_x_value.slice(248 - i * 8, 256 - i * 8));
+    }
+    offset += pub_x_indices_in.size();
+    for (size_t i = 0; i < 32; ++i) {
+        pub_y_indices_in.emplace_back(i + offset);
+        witness_values.emplace_back(pub_y_value.slice(248 - i * 8, 256 - i * 8));
+    }
+    offset += pub_y_indices_in.size();
+    for (size_t i = 0; i < 32; ++i) {
+        signature_in.emplace_back(i + offset);
+        witness_values.emplace_back(signature.r[i]);
+    }
+    offset += signature.r.size();
+    for (size_t i = 0; i < 32; ++i) {
+        signature_in.emplace_back(i + offset);
+        witness_values.emplace_back(signature.s[i]);
+    }
+    offset += signature.s.size();
+
+    witness_values.emplace_back(1);
+    const auto result_in = static_cast<uint32_t>(offset);
+    offset += 1;
+    witness_values.emplace_back(1);
+
+    ecdsa_constraint = acir_format::EcdsaSecp256k1Constraint{
+        .message = message_in,
+        .pub_x_indices = pub_x_indices_in,
+        .pub_y_indices = pub_y_indices_in,
+        .result = result_in,
+        .signature = signature_in,
+    };
+    return offset;
+}
+
+TEST(ECDSASecp256k1, TestECDSAConstraintSucceed)
+{
+    acir_format::EcdsaSecp256k1Constraint ecdsa_constraint;
+    std::vector<fr> witness_values;
+    size_t num_variables = generate_ecdsa_constraint(ecdsa_constraint, witness_values);
+    acir_format::acir_format constraint_system{
+        .varnum = static_cast<uint32_t>(num_variables),
+        .public_inputs = {},
+        .fixed_base_scalar_mul_constraints = {},
+        .logic_constraints = {},
+        .range_constraints = {},
+        .schnorr_constraints = {},
+        .ecdsa_constraints = { ecdsa_constraint },
+        .sha256_constraints = {},
+        .blake2s_constraints = {},
+        .hash_to_field_constraints = {},
+        .pedersen_constraints = {},
+        .merkle_membership_constraints = {},
+        .recursion_constraints = {},
+        .constraints = {},
+    };
+
+    auto composer = acir_format::create_circuit_with_witness(constraint_system, witness_values);
+
+    EXPECT_EQ(composer.get_variable(ecdsa_constraint.result), 1);
+    auto prover = composer.create_prover();
+
+    auto proof = prover.construct_proof();
+    auto verifier = composer.create_verifier();
+    EXPECT_EQ(verifier.verify_proof(proof), true);
+}
+
+TEST(ECDSASecp256k1, TestECDSAConstraintFail)
+{
+    acir_format::EcdsaSecp256k1Constraint ecdsa_constraint;
+    std::vector<fr> witness_values;
+    size_t num_variables = generate_ecdsa_constraint(ecdsa_constraint, witness_values);
+
+    // set result value to be false
+    witness_values[witness_values.size() - 1] = 0;
+
+    // tamper with signature
+    witness_values[witness_values.size() - 20] += 1;
+
+    acir_format::acir_format constraint_system{
+        .varnum = static_cast<uint32_t>(num_variables),
+        .public_inputs = {},
+        .fixed_base_scalar_mul_constraints = {},
+        .logic_constraints = {},
+        .range_constraints = {},
+        .schnorr_constraints = {},
+        .ecdsa_constraints = { ecdsa_constraint },
+        .sha256_constraints = {},
+        .blake2s_constraints = {},
+        .hash_to_field_constraints = {},
+        .pedersen_constraints = {},
+        .merkle_membership_constraints = {},
+        .recursion_constraints = {},
+        .constraints = {},
+    };
+
+    auto composer = acir_format::create_circuit_with_witness(constraint_system, witness_values);
+
+    EXPECT_EQ(composer.get_variable(ecdsa_constraint.result), 0);
+    auto prover = composer.create_prover();
+
+    auto proof = prover.construct_proof();
+    auto verifier = composer.create_verifier();
+    EXPECT_EQ(verifier.verify_proof(proof), true);
+}
diff --git a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
index 1864557af4..e4fa1b217a 100644
--- a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
+++ b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
@@ -18,6 +18,11 @@ bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
                                   const G1& public_key,
                                   const signature<Composer>& sig);
 
+template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Composer> verify_signature_noassert(const stdlib::byte_array<Composer>& message,
+                                           const G1& public_key,
+                                           const signature<Composer>& sig);
+
 template <typename Composer>
 static signature<Composer> from_witness(Composer* ctx, const crypto::ecdsa::signature& input)
 {
diff --git a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
index b1edc24d84..91101df01e 100644
--- a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
+++ b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
@@ -54,4 +54,91 @@ TEST(stdlib_ecdsa, verify_signature)
     bool proof_result = verifier.verify_proof(proof);
     EXPECT_EQ(proof_result, true);
 }
+
+TEST(stdlib_ecdsa, verify_signature_noassert_succeed)
+{
+    Composer composer = Composer();
+
+    // whaaablaghaaglerijgeriij
+    std::string message_string = "Instructions unclear, ask again later.";
+
+    crypto::ecdsa::key_pair<curve::fr, curve::g1> account;
+    account.private_key = curve::fr::random_element();
+    account.public_key = curve::g1::one * account.private_key;
+
+    crypto::ecdsa::signature signature =
+        crypto::ecdsa::construct_signature<Sha256Hasher, curve::fq, curve::fr, curve::g1>(message_string, account);
+
+    bool first_result = crypto::ecdsa::verify_signature<Sha256Hasher, curve::fq, curve::fr, curve::g1>(
+        message_string, account.public_key, signature);
+    EXPECT_EQ(first_result, true);
+
+    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&composer, account.public_key);
+
+    std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
+    std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
+
+    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr), curve::byte_array_ct(&composer, ss) };
+
+    curve::byte_array_ct message(&composer, message_string);
+
+    curve::bool_ct signature_result =
+        stdlib::ecdsa::verify_signature_noassert<Composer, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
+            message, public_key, sig);
+
+    EXPECT_EQ(signature_result.get_value(), true);
+
+    std::cerr << "composer gates = " << composer.get_num_gates() << std::endl;
+    benchmark_info("UltraComposer", "ECDSA", "Signature Verification Test", "Gate Count", composer.get_num_gates());
+    auto prover = composer.create_prover();
+    auto verifier = composer.create_verifier();
+    auto proof = prover.construct_proof();
+    bool proof_result = verifier.verify_proof(proof);
+    EXPECT_EQ(proof_result, true);
+}
+
+TEST(stdlib_ecdsa, verify_signature_noassert_fail)
+{
+    Composer composer = Composer();
+
+    // whaaablaghaaglerijgeriij
+    std::string message_string = "Instructions unclear, ask again later.";
+
+    crypto::ecdsa::key_pair<curve::fr, curve::g1> account;
+    account.private_key = curve::fr::random_element();
+    account.public_key = curve::g1::one * account.private_key;
+
+    crypto::ecdsa::signature signature =
+        crypto::ecdsa::construct_signature<Sha256Hasher, curve::fq, curve::fr, curve::g1>(message_string, account);
+
+    // tamper w. signature to make fail
+    signature.r[0] += 1;
+
+    bool first_result = crypto::ecdsa::verify_signature<Sha256Hasher, curve::fq, curve::fr, curve::g1>(
+        message_string, account.public_key, signature);
+    EXPECT_EQ(first_result, false);
+
+    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&composer, account.public_key);
+
+    std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
+    std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
+
+    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr), curve::byte_array_ct(&composer, ss) };
+
+    curve::byte_array_ct message(&composer, message_string);
+
+    curve::bool_ct signature_result =
+        stdlib::ecdsa::verify_signature_noassert<Composer, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
+            message, public_key, sig);
+
+    EXPECT_EQ(signature_result.get_value(), false);
+
+    std::cerr << "composer gates = " << composer.get_num_gates() << std::endl;
+    benchmark_info("UltraComposer", "ECDSA", "Signature Verification Test", "Gate Count", composer.get_num_gates());
+    auto prover = composer.create_prover();
+    auto verifier = composer.create_verifier();
+    auto proof = prover.construct_proof();
+    bool proof_result = verifier.verify_proof(proof);
+    EXPECT_EQ(proof_result, true);
+}
 } // namespace test_stdlib_ecdsa
diff --git a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp
index 12355453d6..411afa2c1d 100644
--- a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp
+++ b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp
@@ -6,6 +6,19 @@ namespace proof_system::plonk {
 namespace stdlib {
 namespace ecdsa {
 
+/**
+ * @brief Verify ECDSA signature. Produces unsatisfiable constraints if signature fails
+ *
+ * @tparam Composer
+ * @tparam Curve
+ * @tparam Fq
+ * @tparam Fr
+ * @tparam G1
+ * @param message
+ * @param public_key
+ * @param sig
+ * @return bool_t<Composer>
+ */
 template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
 bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
                                   const G1& public_key,
@@ -62,10 +75,82 @@ bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
     result_mod_r.binary_basis_limbs[2].element.assert_equal(r.binary_basis_limbs[2].element);
     result_mod_r.binary_basis_limbs[3].element.assert_equal(r.binary_basis_limbs[3].element);
     result_mod_r.prime_basis_limb.assert_equal(r.prime_basis_limb);
-
     return bool_t<Composer>(ctx, true);
 }
 
+/**
+ * @brief Verify ECDSA signature. Returns 0 if signature fails (i.e. does not produce unsatisfiable constraints)
+ *
+ * @tparam Composer
+ * @tparam Curve
+ * @tparam Fq
+ * @tparam Fr
+ * @tparam G1
+ * @param message
+ * @param public_key
+ * @param sig
+ * @return bool_t<Composer>
+ */
+template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Composer> verify_signature_noassert(const stdlib::byte_array<Composer>& message,
+                                           const G1& public_key,
+                                           const signature<Composer>& sig)
+{
+    Composer* ctx = message.get_context() ? message.get_context() : public_key.x.context;
+
+    stdlib::byte_array<Composer> hashed_message =
+        static_cast<stdlib::byte_array<Composer>>(stdlib::sha256<Composer>(message));
+
+    Fr z(hashed_message);
+    z.assert_is_in_field();
+
+    Fr r(sig.r);
+    // force r to be < secp256k1 group modulus, so we can compare with `result_mod_r` below
+    r.assert_is_in_field();
+
+    Fr s(sig.s);
+
+    // r and s should not be zero
+    r.assert_is_not_equal(Fr::zero());
+    s.assert_is_not_equal(Fr::zero());
+
+    Fr u1 = z / s;
+    Fr u2 = r / s;
+
+    G1 result;
+    if constexpr (Composer::type == ComposerType::PLOOKUP) {
+        ASSERT(Curve::type == proof_system::CurveType::SECP256K1);
+        public_key.validate_on_curve();
+        result = G1::secp256k1_ecdsa_mul(public_key, u1, u2);
+    } else {
+        result = G1::batch_mul({ G1::one(ctx), public_key }, { u1, u2 });
+    }
+    result.x.self_reduce();
+
+    // transfer Fq value x to an Fr element and reduce mod r
+    Fr result_mod_r(ctx, 0);
+    result_mod_r.binary_basis_limbs[0].element = result.x.binary_basis_limbs[0].element;
+    result_mod_r.binary_basis_limbs[1].element = result.x.binary_basis_limbs[1].element;
+    result_mod_r.binary_basis_limbs[2].element = result.x.binary_basis_limbs[2].element;
+    result_mod_r.binary_basis_limbs[3].element = result.x.binary_basis_limbs[3].element;
+    result_mod_r.binary_basis_limbs[0].maximum_value = result.x.binary_basis_limbs[0].maximum_value;
+    result_mod_r.binary_basis_limbs[1].maximum_value = result.x.binary_basis_limbs[1].maximum_value;
+    result_mod_r.binary_basis_limbs[2].maximum_value = result.x.binary_basis_limbs[2].maximum_value;
+    result_mod_r.binary_basis_limbs[3].maximum_value = result.x.binary_basis_limbs[3].maximum_value;
+
+    result_mod_r.prime_basis_limb = result.x.prime_basis_limb;
+
+    result_mod_r.assert_is_in_field();
+
+    bool_t<Composer> output(ctx, true);
+    output &= result_mod_r.binary_basis_limbs[0].element == (r.binary_basis_limbs[0].element);
+    output &= result_mod_r.binary_basis_limbs[1].element == (r.binary_basis_limbs[1].element);
+    output &= result_mod_r.binary_basis_limbs[2].element == (r.binary_basis_limbs[2].element);
+    output &= result_mod_r.binary_basis_limbs[3].element == (r.binary_basis_limbs[3].element);
+    output &= result_mod_r.prime_basis_limb == (r.prime_basis_limb);
+    return output;
+}
+
 } // namespace ecdsa
 } // namespace stdlib
 } // namespace proof_system::plonk
\ No newline at end of file

From 2436dcf59516a1e49286ba602236dbe5016c8b67 Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Sun, 16 Apr 2023 11:15:25 +0200
Subject: [PATCH 03/64] changed dsl recursion to pass proof/key as witnesses

---
 .../dsl/acir_format/recursion_constraint.cpp  | 16 +++--
 .../dsl/acir_format/recursion_constraint.hpp  |  8 +--
 .../acir_format/recursion_constraint.test.cpp | 42 ++++++++++---
 .../dsl/acir_proofs/acir_proofs.cpp           | 12 ++++
 .../verification_key/verification_key.cpp     | 60 +++++++++++++++++++
 .../verification_key/verification_key.hpp     |  5 ++
 .../recursion/transcript/transcript.hpp       | 48 +++++++++++++++
 .../verification_key/verification_key.hpp     | 57 ++++++++++++++++++
 .../stdlib/recursion/verifier/verifier.hpp    | 43 ++++++++++++-
 .../transcript/transcript_wrappers.hpp        | 40 +++++++++++++
 10 files changed, 312 insertions(+), 19 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index b6abe2e5fc..373ee3c15a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -24,10 +24,6 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     // Construct an in-circuit representation of the verification key.
     // For now, the v-key is a circuit constant and is fixed for the circuit.
     // (We may need a separate recursion opcode for this to vary, or add more config witnesses to this opcode)
-    auto data_clone = input.verification_key_data;
-    std::shared_ptr<plonk::verification_key> key =
-        std::make_shared<plonk::verification_key>(std::move(data_clone), env_crs->get_verifier_crs());
-    std::shared_ptr<verification_key_ct> circuit_key = verification_key_ct::from_constants(&composer, key);
     const auto& aggregation_input = input.input_aggregation_object;
     aggregation_state_ct previous_aggregation;
 
@@ -53,10 +49,20 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 
     transcript::Manifest manifest = Composer::create_unrolled_manifest(1);
+    std::vector<field_ct> key_fields;
+    key_fields.reserve(input.key.size());
+    for (const auto& idx : input.key) {
+        key_fields.emplace_back(field_ct::from_witness_index(&composer, idx));
+    }
+    std::vector<field_ct> proof_fields;
+    proof_fields.reserve(input.proof.size());
+    for (const auto& idx : input.proof) {
+        proof_fields.emplace_back(field_ct::from_witness_index(&composer, idx));
+    }
 
     // recursively verify the proof
     aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof<bn254, noir_recursive_settings>(
-        &composer, circuit_key, manifest, input.proof, previous_aggregation);
+        &composer, manifest, env_crs->get_verifier_crs(), key_fields, proof_fields, previous_aggregation);
 
     // Assign the output aggregation object to the proof public inputs (16 field elements representing two G1 points)
     result.add_proof_outputs_as_public_inputs();
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index c67dacb10f..0e794f3f73 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -27,8 +27,8 @@ namespace acir_format {
  */
 struct RecursionConstraint {
     static constexpr size_t AGGREGATION_OBJECT_SIZE = 16; // 16 field elements
-    plonk::verification_key_data verification_key_data;
-    plonk::proof proof;
+    std::vector<uint32_t> key;
+    std::vector<uint32_t> proof;
     bool is_aggregation_object_nonzero;
     uint32_t public_input;
     std::array<uint32_t, AGGREGATION_OBJECT_SIZE> input_aggregation_object;
@@ -42,7 +42,7 @@ void create_recursion_constraints(plonk::stdlib::types::Composer& composer, cons
 template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 {
     using serialize::read;
-    read(buf, constraint.verification_key_data);
+    read(buf, constraint.key);
     read(buf, constraint.proof);
     read(buf, constraint.is_aggregation_object_nonzero);
     read(buf, constraint.public_input);
@@ -53,7 +53,7 @@ template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 template <typename B> inline void write(B& buf, RecursionConstraint const& constraint)
 {
     using serialize::write;
-    write(buf, constraint.verification_key_data);
+    write(buf, constraint.key);
     write(buf, constraint.proof);
     write(buf, constraint.is_aggregation_object_nonzero);
     write(buf, constraint.public_input);
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index 911e36c8eb..7154fdd23e 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -117,8 +117,8 @@ TEST(RecursionConstraint, TestRecursionConstraint)
     auto inner_proof = inner_prover.construct_proof();
     auto inner_verifier = inner_composer.create_verifier();
 
-    std::vector<uint8_t> keybuf;
-    write(keybuf, *(inner_verifier.key));
+    // std::vector<uint8_t> keybuf;
+    // write(keybuf, *(inner_verifier.key));
 
     std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_vars;
     for (size_t i = 0; i < 16; ++i) {
@@ -126,13 +126,31 @@ TEST(RecursionConstraint, TestRecursionConstraint)
         // variable idx 2-18 = output_vars
         output_vars[i] = (static_cast<uint32_t>(i + 2));
     }
-    verification_key_data keydata;
-    uint8_t const* vk_buf = &keybuf[0];
-    read(vk_buf, keydata);
+    // verification_key_data keydata;
+    // uint8_t const* vk_buf = &keybuf[0];
+    // read(vk_buf, keydata);
 
+    transcript::StandardTranscript transcript(
+        inner_proof.proof_data, Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
+
+    const std::vector<barretenberg::fr> proof_witnesses = transcript.export_transcript_in_recursion_format();
+    const std::vector<barretenberg::fr> key_witnesses = inner_verifier.key->export_transcript_in_recursion_format();
+
+    std::vector<uint32_t> proof_indices;
+    const size_t proof_size = proof_witnesses.size();
+
+    for (size_t i = 0; i < proof_size; ++i) {
+        proof_indices.emplace_back(static_cast<uint32_t>(i + 18));
+    }
+
+    std::vector<uint32_t> key_indices;
+    const size_t key_size = key_witnesses.size();
+    for (size_t i = 0; i < key_size; ++i) {
+        key_indices.emplace_back(static_cast<uint32_t>(i + 18 + proof_size));
+    }
     acir_format::RecursionConstraint recursion_constraint{
-        .verification_key_data = keydata,
-        .proof = inner_proof,
+        .key = key_indices,
+        .proof = proof_indices,
         .is_aggregation_object_nonzero = false,
         .public_input = 1,
         .input_aggregation_object = {},
@@ -140,12 +158,18 @@ TEST(RecursionConstraint, TestRecursionConstraint)
     };
 
     std::vector<fr> witness;
-    for (size_t i = 0; i < 18; ++i) {
+    for (size_t i = 0; i < 17; ++i) {
         witness.emplace_back(0);
     }
+    for (const auto& wit : proof_witnesses) {
+        witness.emplace_back(wit);
+    }
+    for (const auto& wit : key_witnesses) {
+        witness.emplace_back(wit);
+    }
 
     acir_format::acir_format constraint_system{
-        .varnum = 18,
+        .varnum = static_cast<uint32_t>(witness.size() + 1),
         .public_inputs = { 1 },
         .fixed_base_scalar_mul_constraints = {},
         .logic_constraints = {},
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 21585f6df4..9b899aa69f 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -93,6 +93,18 @@ size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const*
     return buffer.size();
 }
 
+// void serialize_proof_into_field_elements(uint8_t** proof_data_buf)
+// {
+// }
+
+// void serialize_verification_key_into_field_elements(uint8_t** vk_buf)
+// {
+//     plonk::verification_key key;
+//     read(vk_buf, key);
+
+//     // do the serialize thing...
+// }
+
 size_t new_proof(void* pippenger,
                  uint8_t const* g2x,
                  uint8_t const* pk_buf,
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
index f6cf92bd73..56f4a52cf5 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
@@ -107,6 +107,31 @@ verification_key::verification_key(const size_t num_gates,
     , polynomial_manifest(composer_type)
 {}
 
+verification_key::verification_key(const std::vector<barretenberg::fr>& key_as_fields,
+                                   std::shared_ptr<VerifierReferenceString> const& crs,
+                                   uint32_t composer_type_)
+{
+    composer_type = composer_type_;
+    polynomial_manifest = PolynomialManifest(composer_type);
+    reference_string = crs;
+    // std::cout << "key as field = " << key_as_fields[3] << std::endl;
+    // for (const auto& f : key_as_fields) {
+    //     std::cout << "f : " << f << std::endl;
+    // }
+    circuit_size = static_cast<size_t>(uint256_t(key_as_fields[3]));
+
+    std::cout << "circuit size = " << circuit_size << std::endl;
+
+    log_circuit_size = numeric::get_msb(circuit_size);
+    num_public_inputs = static_cast<size_t>(uint256_t(key_as_fields[4]));
+    contains_recursive_proof = static_cast<size_t>(uint256_t(key_as_fields[5]));
+    domain = evaluation_domain(circuit_size);
+
+    // ADD THE COMITMENTS DERP DERP DERP
+    // AS WELL AS RECURSIVE PROOF PUBLIC INPUT INDICES?
+    //
+}
+
 verification_key::verification_key(verification_key_data&& data, std::shared_ptr<VerifierReferenceString> const& crs)
     : composer_type(data.composer_type)
     , circuit_size(data.circuit_size)
@@ -178,4 +203,39 @@ sha256::hash verification_key::sha256_hash()
     return sha256::sha256(to_buffer(vk_data));
 }
 
+std::vector<barretenberg::fr> verification_key::export_transcript_in_recursion_format()
+{
+    std::vector<fr> output;
+    output.emplace_back(domain.root);
+    output.emplace_back(domain.domain);
+    output.emplace_back(domain.generator);
+    output.emplace_back(circuit_size);
+    output.emplace_back(num_public_inputs);
+    output.emplace_back(contains_recursive_proof);
+
+    for (auto& commitment_entry : commitments) {
+        std::cout << "key = " << commitment_entry.first << std::endl;
+        std::cout << "value = " << commitment_entry.second << std::endl;
+    }
+    for (const auto& descriptor : polynomial_manifest.get()) {
+        if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
+            std::cout << "key =  " << descriptor.commitment_label << std::endl;
+            const auto element = commitments.at(std::string(descriptor.commitment_label));
+            std::cout << "read" << std::endl;
+            const uint256_t x = element.x;
+            const uint256_t y = element.y;
+            const barretenberg::fr x_lo = x.slice(0, 136);
+            const barretenberg::fr x_hi = x.slice(136, 272);
+            const barretenberg::fr y_lo = y.slice(0, 136);
+            const barretenberg::fr y_hi = y.slice(136, 272);
+            output.emplace_back(x_lo);
+            output.emplace_back(x_hi);
+            output.emplace_back(y_lo);
+            output.emplace_back(y_hi);
+        }
+    }
+
+    return output;
+}
+
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
index 709eea6ee7..3165ed9923 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
@@ -55,6 +55,10 @@ struct verification_key {
                      const size_t num_inputs,
                      std::shared_ptr<VerifierReferenceString> const& crs,
                      uint32_t composer_type);
+    verification_key(const std::vector<barretenberg::fr>& key_as_fields,
+                     std::shared_ptr<VerifierReferenceString> const& crs,
+                     uint32_t composer_type_);
+
     verification_key(const verification_key& other);
     verification_key(verification_key&& other);
     verification_key& operator=(verification_key&& other);
@@ -62,6 +66,7 @@ struct verification_key {
     ~verification_key() = default;
 
     sha256::hash sha256_hash();
+    std::vector<barretenberg::fr> export_transcript_in_recursion_format();
 
     uint32_t composer_type;
     size_t circuit_size;
diff --git a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
index 73055fb376..db3d95c51b 100644
--- a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
@@ -48,6 +48,54 @@ template <typename Composer> class Transcript {
         // }
     }
 
+    /**
+     * @brief Construct a new Transcript object using a proof represented as a field_pt vector
+     *
+     * N.B. If proof is represented as a uint8_t vector, Transcript will convert into witnesses in-situ.
+     * Use this constructor method if the proof is *already present* as circuit witnesses!
+     * @param in_context
+     * @param input_manifest
+     * @param field_buffer
+     * @param num_public_inputs
+     */
+    Transcript(Composer* in_context,
+               const transcript::Manifest input_manifest,
+               const std::vector<field_pt>& field_buffer,
+               const size_t num_public_inputs)
+        : context(in_context)
+        , transcript_base(input_manifest, transcript::HashType::PedersenBlake3s, 16)
+        , current_challenge(in_context)
+    {
+        size_t count = 0;
+
+        const auto num_rounds = input_manifest.get_num_rounds();
+        for (size_t i = 0; i < num_rounds; ++i) {
+            for (auto manifest_element : input_manifest.get_round_manifest(i).elements) {
+                if (!manifest_element.derived_by_verifier) {
+                    if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
+                        add_field_element(manifest_element.name, field_buffer[count++]);
+                    } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
+                        const auto x_lo = field_buffer[count++];
+                        const auto x_hi = field_buffer[count++];
+                        const auto y_lo = field_buffer[count++];
+                        const auto y_hi = field_buffer[count++];
+                        fq_pt x(x_lo, x_hi);
+                        fq_pt y(y_lo, y_hi);
+                        group_pt element(x, y);
+                        add_group_element(manifest_element.name, element);
+                    } else {
+                        ASSERT(manifest_element.name == "public_inputs");
+                        std::vector<field_pt> public_inputs;
+                        for (size_t i = 0; i < num_public_inputs; ++i) {
+                            public_inputs.emplace_back(field_buffer[count++]);
+                        }
+                        add_field_element_vector(manifest_element.name, public_inputs);
+                    }
+                }
+            }
+        }
+    }
+
     transcript::Manifest get_manifest() const { return transcript_base.get_manifest(); }
 
     int check_field_element_cache(const std::string& element_name) const
diff --git a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index 57b8a39207..2c982f6074 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -25,6 +25,19 @@ namespace stdlib {
 namespace recursion {
 
 template <typename Composer> struct evaluation_domain {
+    static evaluation_domain from_field_pt_vector(const std::vector<field_t<Composer>>& fields)
+    {
+        evaluation_domain domain;
+        domain.root = fields[0];
+        domain.root_inverse = domain.root.invert();
+        domain.domain = fields[1];
+        domain.domain_inverse = domain.domain.invert();
+        domain.generator = fields[2];
+        domain.generator_inverse = domain.generator.invert();
+        domain.size = domain.domain;
+        return domain;
+    }
+
     static evaluation_domain from_witness(Composer* ctx, const barretenberg::evaluation_domain& input)
     {
         evaluation_domain domain;
@@ -105,6 +118,50 @@ template <typename Composer> struct evaluation_domain {
  */
 template <typename Curve> struct verification_key {
     using Composer = typename Curve::Composer;
+
+    static std::shared_ptr<verification_key> from_field_pt_vector(Composer* ctx,
+                                                                  std::shared_ptr<VerifierReferenceString> const& crs,
+                                                                  const std::vector<field_t<Composer>>& fields)
+    {
+        std::vector<fr> fields_raw;
+        for (const auto& f : fields) {
+            fields_raw.emplace_back(f.get_value());
+            std::cout << "f: " << f.get_value() << std::endl;
+        }
+        std::cout << "a" << std::endl;
+        std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
+        std::cout << "b" << std::endl;
+        key->context = ctx;
+        key->base_key = std::make_shared<proof_system::plonk::verification_key>(fields_raw, crs, Composer::type);
+        std::cout << "c" << std::endl;
+
+        key->reference_string = key->base_key->reference_string;
+        key->polynomial_manifest = PolynomialManifest(Composer::type);
+        key->domain = evaluation_domain<Composer>::from_field_pt_vector({ fields[0], fields[1], fields[2] });
+
+        key->n = fields[3];
+        key->num_public_inputs = fields[4];
+        key->contains_recursive_proof = bool_t<Composer>(fields[5]);
+
+        size_t count = 6;
+        for (const auto& descriptor : key->polynomial_manifest.get()) {
+            if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
+
+                const auto x_lo = fields[count++];
+                const auto x_hi = fields[count++];
+                const auto y_lo = fields[count++];
+                const auto y_hi = fields[count++];
+                const typename Curve::fq_ct x(x_lo, x_hi);
+                const typename Curve::fq_ct y(y_lo, y_hi);
+                const typename Curve::g1_ct element(x, y);
+
+                key->commitments.insert({ std::string(descriptor.commitment_label), element });
+            }
+        }
+        std::cout << "d" << std::endl;
+        return key;
+    }
+
     static std::shared_ptr<verification_key> from_witness(Composer* ctx,
                                                           const std::shared_ptr<plonk::verification_key>& input_key)
     {
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
index aa185e34d7..5c59bf9580 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
@@ -182,6 +182,48 @@ aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
                                       const transcript::Manifest& manifest,
                                       const plonk::proof& proof,
                                       const aggregation_state<Curve> previous_output = aggregation_state<Curve>())
+{
+    using Composer = typename Curve::Composer;
+
+    key->program_width = program_settings::program_width;
+
+    Transcript<Composer> transcript = Transcript<Composer>(context, proof.proof_data, manifest);
+
+    return verify_proof_<Curve, program_settings>(context, key, transcript, previous_output);
+}
+
+/**
+ * Refer to src/barretenberg/plonk/proof_system/verifier/verifier.cpp verify_proof() for the native implementation,
+ * which includes detailed comments.
+ */
+template <typename Curve, typename program_settings>
+aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
+                                      const transcript::Manifest& manifest,
+                                      std::shared_ptr<VerifierReferenceString> const& crs,
+                                      const std::vector<typename Curve::fr_ct>& key,
+                                      const std::vector<typename Curve::fr_ct>& proof,
+                                      const aggregation_state<Curve> previous_output = aggregation_state<Curve>())
+{
+    using Composer = typename Curve::Composer;
+
+    std::shared_ptr<verification_key<Curve>> vkey = verification_key<Curve>::from_field_pt_vector(context, crs, key);
+    vkey->program_width = program_settings::program_width;
+
+    const size_t num_public_inputs = static_cast<size_t>(uint256_t(vkey->num_public_inputs.get_value()).data[0]);
+    Transcript<Composer> transcript = Transcript<Composer>(context, manifest, proof, num_public_inputs);
+
+    return verify_proof_<Curve, program_settings>(context, vkey, transcript, previous_output);
+}
+
+/**
+ * Refer to src/barretenberg/plonk/proof_system/verifier/verifier.cpp verify_proof() for the native implementation,
+ * which includes detailed comments.
+ */
+template <typename Curve, typename program_settings>
+aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
+                                       std::shared_ptr<verification_key<Curve>> key,
+                                       Transcript<typename Curve::Composer>& transcript,
+                                       const aggregation_state<Curve> previous_output = aggregation_state<Curve>())
 {
     using fr_ct = typename Curve::fr_ct;
     using fq_ct = typename Curve::fq_ct;
@@ -190,7 +232,6 @@ aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
 
     key->program_width = program_settings::program_width;
 
-    Transcript<Composer> transcript = Transcript<Composer>(context, proof.proof_data, manifest);
     std::map<std::string, g1_ct> kate_g1_elements;
     std::map<std::string, fr_ct> kate_fr_elements_at_zeta;
     std::map<std::string, fr_ct> kate_fr_elements_at_zeta_large;
diff --git a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
index bd33eff800..ab0b02d4c6 100644
--- a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
+++ b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
@@ -56,6 +56,46 @@ class StandardTranscript : public Transcript {
 
     // TODO(luke): temporary function for debugging
     barretenberg::fr get_mock_challenge() { return barretenberg::fr::random_element(); };
+
+    /**
+     * @brief Returns transcript represented as a vector of barretenberg::fr.
+     *        Used to represent recursive proofs (i.e. proof represented as circuit-native field elements)
+     *
+     * @return std::vector<barretenberg::fr>
+     */
+    std::vector<barretenberg::fr> export_transcript_in_recursion_format()
+    {
+        std::vector<barretenberg::fr> fields;
+        const auto num_rounds = get_manifest().get_num_rounds();
+        for (size_t i = 0; i < num_rounds; ++i) {
+            for (auto manifest_element : get_manifest().get_round_manifest(i).elements) {
+                if (!manifest_element.derived_by_verifier) {
+                    if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
+                        fields.emplace_back(get_field_element(manifest_element.name));
+                    } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
+                        const auto group_element = get_group_element(manifest_element.name);
+                        const uint256_t x = group_element.x;
+                        const uint256_t y = group_element.y;
+                        const barretenberg::fr x_lo = x.slice(0, 136);
+                        const barretenberg::fr x_hi = x.slice(136, 272);
+                        const barretenberg::fr y_lo = y.slice(0, 136);
+                        const barretenberg::fr y_hi = y.slice(136, 272);
+                        fields.emplace_back(x_lo);
+                        fields.emplace_back(x_hi);
+                        fields.emplace_back(y_lo);
+                        fields.emplace_back(y_hi);
+                    } else {
+                        ASSERT(manifest_element.name == "public_inputs");
+                        const auto public_inputs_vector = get_field_element_vector(manifest_element.name);
+                        for (const auto& ele : public_inputs_vector) {
+                            fields.emplace_back(ele);
+                        }
+                    }
+                }
+            }
+        }
+        return fields;
+    }
 };
 
 } // namespace transcript

From 292f6265b862847af71df13e5c5eecaf73954ad6 Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Sun, 16 Apr 2023 11:40:42 +0200
Subject: [PATCH 04/64] recursive verification key no longer encapsulates a
 native key

recursive verification key no longer encapsulates a reference string

(neither were fundamentally needed!)
---
 .../dsl/acir_format/recursion_constraint.cpp  |  3 +-
 .../acir_format/recursion_constraint.test.cpp |  2 +-
 .../verification_key/verification_key.cpp     | 47 ++++++-----------
 .../verification_key/verification_key.hpp     |  5 +-
 .../verification_key/verification_key.hpp     | 51 ++++++++-----------
 .../stdlib/recursion/verifier/verifier.hpp    | 41 +++++++--------
 6 files changed, 57 insertions(+), 92 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 373ee3c15a..4c9d08a32a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -1,5 +1,4 @@
 #include "recursion_constraint.hpp"
-#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
 #include "barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp"
 #include "barretenberg/stdlib/recursion/verifier/verifier.hpp"
 
@@ -62,7 +61,7 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
 
     // recursively verify the proof
     aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof<bn254, noir_recursive_settings>(
-        &composer, manifest, env_crs->get_verifier_crs(), key_fields, proof_fields, previous_aggregation);
+        &composer, manifest, key_fields, proof_fields, previous_aggregation);
 
     // Assign the output aggregation object to the proof public inputs (16 field elements representing two G1 points)
     result.add_proof_outputs_as_public_inputs();
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index 7154fdd23e..f36446e3db 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -134,7 +134,7 @@ TEST(RecursionConstraint, TestRecursionConstraint)
         inner_proof.proof_data, Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
 
     const std::vector<barretenberg::fr> proof_witnesses = transcript.export_transcript_in_recursion_format();
-    const std::vector<barretenberg::fr> key_witnesses = inner_verifier.key->export_transcript_in_recursion_format();
+    const std::vector<barretenberg::fr> key_witnesses = inner_verifier.key->export_key_in_recursion_format();
 
     std::vector<uint32_t> proof_indices;
     const size_t proof_size = proof_witnesses.size();
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
index 56f4a52cf5..7ba7af5175 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
@@ -107,31 +107,6 @@ verification_key::verification_key(const size_t num_gates,
     , polynomial_manifest(composer_type)
 {}
 
-verification_key::verification_key(const std::vector<barretenberg::fr>& key_as_fields,
-                                   std::shared_ptr<VerifierReferenceString> const& crs,
-                                   uint32_t composer_type_)
-{
-    composer_type = composer_type_;
-    polynomial_manifest = PolynomialManifest(composer_type);
-    reference_string = crs;
-    // std::cout << "key as field = " << key_as_fields[3] << std::endl;
-    // for (const auto& f : key_as_fields) {
-    //     std::cout << "f : " << f << std::endl;
-    // }
-    circuit_size = static_cast<size_t>(uint256_t(key_as_fields[3]));
-
-    std::cout << "circuit size = " << circuit_size << std::endl;
-
-    log_circuit_size = numeric::get_msb(circuit_size);
-    num_public_inputs = static_cast<size_t>(uint256_t(key_as_fields[4]));
-    contains_recursive_proof = static_cast<size_t>(uint256_t(key_as_fields[5]));
-    domain = evaluation_domain(circuit_size);
-
-    // ADD THE COMITMENTS DERP DERP DERP
-    // AS WELL AS RECURSIVE PROOF PUBLIC INPUT INDICES?
-    //
-}
-
 verification_key::verification_key(verification_key_data&& data, std::shared_ptr<VerifierReferenceString> const& crs)
     : composer_type(data.composer_type)
     , circuit_size(data.circuit_size)
@@ -203,7 +178,14 @@ sha256::hash verification_key::sha256_hash()
     return sha256::sha256(to_buffer(vk_data));
 }
 
-std::vector<barretenberg::fr> verification_key::export_transcript_in_recursion_format()
+/**
+ * @brief When recursively verifying proofs, we represent the verification key using field elements.
+ *        This method exports the key formatted in the manner our recursive verifier expects.
+ *        NOTE: only used by the dsl at the moment. Might be cleaner to make this a dsl function?
+ *
+ * @return std::vector<barretenberg::fr>
+ */
+std::vector<barretenberg::fr> verification_key::export_key_in_recursion_format()
 {
     std::vector<fr> output;
     output.emplace_back(domain.root);
@@ -212,16 +194,17 @@ std::vector<barretenberg::fr> verification_key::export_transcript_in_recursion_f
     output.emplace_back(circuit_size);
     output.emplace_back(num_public_inputs);
     output.emplace_back(contains_recursive_proof);
-
-    for (auto& commitment_entry : commitments) {
-        std::cout << "key = " << commitment_entry.first << std::endl;
-        std::cout << "value = " << commitment_entry.second << std::endl;
+    for (size_t i = 0; i < 16; ++i) {
+        if (recursive_proof_public_input_indices.size() > i) {
+            output.emplace_back(recursive_proof_public_input_indices[i]);
+        } else {
+            output.emplace_back(0);
+            ASSERT(contains_recursive_proof == false);
+        }
     }
     for (const auto& descriptor : polynomial_manifest.get()) {
         if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
-            std::cout << "key =  " << descriptor.commitment_label << std::endl;
             const auto element = commitments.at(std::string(descriptor.commitment_label));
-            std::cout << "read" << std::endl;
             const uint256_t x = element.x;
             const uint256_t y = element.y;
             const barretenberg::fr x_lo = x.slice(0, 136);
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
index 3165ed9923..aa240f52c9 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
@@ -55,9 +55,6 @@ struct verification_key {
                      const size_t num_inputs,
                      std::shared_ptr<VerifierReferenceString> const& crs,
                      uint32_t composer_type);
-    verification_key(const std::vector<barretenberg::fr>& key_as_fields,
-                     std::shared_ptr<VerifierReferenceString> const& crs,
-                     uint32_t composer_type_);
 
     verification_key(const verification_key& other);
     verification_key(verification_key&& other);
@@ -66,7 +63,7 @@ struct verification_key {
     ~verification_key() = default;
 
     sha256::hash sha256_hash();
-    std::vector<barretenberg::fr> export_transcript_in_recursion_format();
+    std::vector<barretenberg::fr> export_key_in_recursion_format();
 
     uint32_t composer_type;
     size_t circuit_size;
diff --git a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index 2c982f6074..c297973dbb 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -120,30 +120,32 @@ template <typename Curve> struct verification_key {
     using Composer = typename Curve::Composer;
 
     static std::shared_ptr<verification_key> from_field_pt_vector(Composer* ctx,
-                                                                  std::shared_ptr<VerifierReferenceString> const& crs,
                                                                   const std::vector<field_t<Composer>>& fields)
     {
         std::vector<fr> fields_raw;
-        for (const auto& f : fields) {
-            fields_raw.emplace_back(f.get_value());
-            std::cout << "f: " << f.get_value() << std::endl;
-        }
-        std::cout << "a" << std::endl;
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
-        std::cout << "b" << std::endl;
         key->context = ctx;
-        key->base_key = std::make_shared<proof_system::plonk::verification_key>(fields_raw, crs, Composer::type);
-        std::cout << "c" << std::endl;
 
-        key->reference_string = key->base_key->reference_string;
         key->polynomial_manifest = PolynomialManifest(Composer::type);
         key->domain = evaluation_domain<Composer>::from_field_pt_vector({ fields[0], fields[1], fields[2] });
 
         key->n = fields[3];
         key->num_public_inputs = fields[4];
-        key->contains_recursive_proof = bool_t<Composer>(fields[5]);
 
-        size_t count = 6;
+        // NOTE: For now `contains_recursive_proof` and `recursive_proof_public_input_indices` need to be circuit
+        // constants!
+        key->contains_recursive_proof = static_cast<bool>(uint256_t(fields[5].get_value()));
+        for (size_t i = 0; i < 16; ++i) {
+            const uint32_t idx = static_cast<uint32_t>(uint256_t(fields[6 + i].get_value()));
+            key->recursive_proof_public_input_indices.emplace_back(idx);
+        }
+        // Apply constraints to force the recursive proof information to be circuit constants
+        fields[5].assert_equal(key->contains_recursive_proof);
+        for (size_t i = 0; i < 16; ++i) {
+            fields[6 + i].assert_equal(key->recursive_proof_public_input_indices[i]);
+        }
+
+        size_t count = 22;
         for (const auto& descriptor : key->polynomial_manifest.get()) {
             if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
 
@@ -158,7 +160,6 @@ template <typename Curve> struct verification_key {
                 key->commitments.insert({ std::string(descriptor.commitment_label), element });
             }
         }
-        std::cout << "d" << std::endl;
         return key;
     }
 
@@ -168,16 +169,14 @@ template <typename Curve> struct verification_key {
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
         // Native data:
         key->context = ctx;
-        key->base_key = input_key;
-        key->reference_string = input_key->reference_string;
         key->polynomial_manifest = input_key->polynomial_manifest;
 
         // Circuit types:
         key->n = witness_t<Composer>(ctx, barretenberg::fr(input_key->circuit_size));
         key->num_public_inputs = witness_t<Composer>(ctx, input_key->num_public_inputs);
         key->domain = evaluation_domain<Composer>::from_witness(ctx, input_key->domain);
-        key->contains_recursive_proof = witness_t<Composer>(ctx, input_key->contains_recursive_proof);
-
+        key->contains_recursive_proof = input_key->contains_recursive_proof;
+        key->recursive_proof_public_input_indices = input_key->recursive_proof_public_input_indices;
         for (const auto& [tag, value] : input_key->commitments) {
             key->commitments.insert({ tag, Curve::g1_ct::from_witness(ctx, value) });
         }
@@ -190,15 +189,13 @@ template <typename Curve> struct verification_key {
     {
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
         key->context = ctx;
-        key->base_key = input_key;
         key->n = field_t<Composer>(ctx, input_key->circuit_size);
         key->num_public_inputs = field_t<Composer>(ctx, input_key->num_public_inputs);
-        key->contains_recursive_proof = bool_t<Composer>(ctx, input_key->contains_recursive_proof);
+        key->contains_recursive_proof = input_key->contains_recursive_proof;
+        key->recursive_proof_public_input_indices = input_key->recursive_proof_public_input_indices;
 
         key->domain = evaluation_domain<Composer>::from_constants(ctx, input_key->domain);
 
-        key->reference_string = input_key->reference_string;
-
         for (const auto& [tag, value] : input_key->commitments) {
             key->commitments.insert({ tag, typename Curve::g1_ct(value) });
         }
@@ -321,23 +318,17 @@ template <typename Curve> struct verification_key {
     field_t<Composer> num_public_inputs;
     field_t<Composer> z_pow_n;
 
-    // NOTE: This does not strictly need to be a circuit type. It can be used to check in the circuit
-    // if a proof contains any aggregated state.
-    bool_t<Composer> contains_recursive_proof;
-
     evaluation_domain<Composer> domain;
 
     std::map<std::string, typename Curve::g1_ct> commitments;
 
     // Native data:
 
-    std::shared_ptr<VerifierReferenceString> reference_string;
-
     PolynomialManifest polynomial_manifest;
-
+    // Used to check in the circuit if a proof contains any aggregated state.
+    bool contains_recursive_proof = false;
+    std::vector<uint32_t> recursive_proof_public_input_indices;
     size_t program_width = 4;
-
-    std::shared_ptr<plonk::verification_key> base_key;
     Composer* context;
 };
 
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
index 5c59bf9580..f3b4004218 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
@@ -199,14 +199,13 @@ aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
 template <typename Curve, typename program_settings>
 aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
                                       const transcript::Manifest& manifest,
-                                      std::shared_ptr<VerifierReferenceString> const& crs,
                                       const std::vector<typename Curve::fr_ct>& key,
                                       const std::vector<typename Curve::fr_ct>& proof,
                                       const aggregation_state<Curve> previous_output = aggregation_state<Curve>())
 {
     using Composer = typename Curve::Composer;
 
-    std::shared_ptr<verification_key<Curve>> vkey = verification_key<Curve>::from_field_pt_vector(context, crs, key);
+    std::shared_ptr<verification_key<Curve>> vkey = verification_key<Curve>::from_field_pt_vector(context, key);
     vkey->program_width = program_settings::program_width;
 
     const size_t num_public_inputs = static_cast<size_t>(uint256_t(vkey->num_public_inputs.get_value()).data[0]);
@@ -366,10 +365,6 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
         rhs_scalars.push_back(random_separator);
     }
 
-    // Check if recursive proof information is correctly set.
-    key->contains_recursive_proof.assert_equal(key->base_key->contains_recursive_proof,
-                                               "contains_recursive_proof is incorrectly set");
-
     /**
      * N.B. if this key contains a recursive proof, then ALL potential verification keys being verified by the outer
      *circuit must ALSO contain a recursive proof (this is not a concern if the key is being generated from circuit
@@ -377,7 +372,7 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
      *code path should be used with extreme caution if the verification key is not being generated from circuit
      *constants
      **/
-    if (key->base_key->contains_recursive_proof) {
+    if (key->contains_recursive_proof) {
         const auto public_inputs = transcript.get_field_element_vector("public_inputs");
         const auto recover_fq_from_public_inputs =
             [&public_inputs](const size_t idx0, const size_t idx1, const size_t idx2, const size_t idx3) {
@@ -390,22 +385,22 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
 
         fr_ct recursion_separator_challenge = transcript.get_challenge_field_element("separator", 2);
 
-        const auto x0 = recover_fq_from_public_inputs(key->base_key->recursive_proof_public_input_indices[0],
-                                                      key->base_key->recursive_proof_public_input_indices[1],
-                                                      key->base_key->recursive_proof_public_input_indices[2],
-                                                      key->base_key->recursive_proof_public_input_indices[3]);
-        const auto y0 = recover_fq_from_public_inputs(key->base_key->recursive_proof_public_input_indices[4],
-                                                      key->base_key->recursive_proof_public_input_indices[5],
-                                                      key->base_key->recursive_proof_public_input_indices[6],
-                                                      key->base_key->recursive_proof_public_input_indices[7]);
-        const auto x1 = recover_fq_from_public_inputs(key->base_key->recursive_proof_public_input_indices[8],
-                                                      key->base_key->recursive_proof_public_input_indices[9],
-                                                      key->base_key->recursive_proof_public_input_indices[10],
-                                                      key->base_key->recursive_proof_public_input_indices[11]);
-        const auto y1 = recover_fq_from_public_inputs(key->base_key->recursive_proof_public_input_indices[12],
-                                                      key->base_key->recursive_proof_public_input_indices[13],
-                                                      key->base_key->recursive_proof_public_input_indices[14],
-                                                      key->base_key->recursive_proof_public_input_indices[15]);
+        const auto x0 = recover_fq_from_public_inputs(key->recursive_proof_public_input_indices[0],
+                                                      key->recursive_proof_public_input_indices[1],
+                                                      key->recursive_proof_public_input_indices[2],
+                                                      key->recursive_proof_public_input_indices[3]);
+        const auto y0 = recover_fq_from_public_inputs(key->recursive_proof_public_input_indices[4],
+                                                      key->recursive_proof_public_input_indices[5],
+                                                      key->recursive_proof_public_input_indices[6],
+                                                      key->recursive_proof_public_input_indices[7]);
+        const auto x1 = recover_fq_from_public_inputs(key->recursive_proof_public_input_indices[8],
+                                                      key->recursive_proof_public_input_indices[9],
+                                                      key->recursive_proof_public_input_indices[10],
+                                                      key->recursive_proof_public_input_indices[11]);
+        const auto y1 = recover_fq_from_public_inputs(key->recursive_proof_public_input_indices[12],
+                                                      key->recursive_proof_public_input_indices[13],
+                                                      key->recursive_proof_public_input_indices[14],
+                                                      key->recursive_proof_public_input_indices[15]);
 
         opening_elements.push_back(g1_ct(x0, y0));
         opening_scalars.push_back(recursion_separator_challenge);

From bc02eff9b63c92453575846d8b409ea5c6639e33 Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Sun, 16 Apr 2023 16:53:40 +0200
Subject: [PATCH 05/64] added serialization test for acir_proofs

---
 .../dsl/acir_proofs/acir_proofs.test.cpp      | 140 ++++++++++++++++++
 1 file changed, 140 insertions(+)
 create mode 100644 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
new file mode 100644
index 0000000000..ce28fe62df
--- /dev/null
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -0,0 +1,140 @@
+#include "acir_proofs.hpp"
+#include "../acir_format/acir_format.hpp"
+#include "barretenberg/srs/io.hpp"
+#include <gtest/gtest.h>
+#include <vector>
+
+using namespace proof_system::plonk::stdlib::types;
+
+void create_inner_circuit(acir_format::acir_format& constraint_system, std::vector<fr>& witness)
+{
+    /**
+     * constraints produced by Noir program:
+     * fn main(x : u32, y : pub u32) {
+     * let z = x ^ y;
+     *
+     * constrain z != 10;
+     * }
+     **/
+    acir_format::RangeConstraint range_a{
+        .witness = 1,
+        .num_bits = 32,
+    };
+    acir_format::RangeConstraint range_b{
+        .witness = 2,
+        .num_bits = 32,
+    };
+
+    acir_format::LogicConstraint logic_constraint{
+        .a = 1,
+        .b = 2,
+        .result = 3,
+        .num_bits = 32,
+        .is_xor_gate = 1,
+    };
+    poly_triple expr_a{
+        .a = 3,
+        .b = 4,
+        .c = 0,
+        .q_m = 0,
+        .q_l = 1,
+        .q_r = -1,
+        .q_o = 0,
+        .q_c = -10,
+    };
+    poly_triple expr_b{
+        .a = 4,
+        .b = 5,
+        .c = 6,
+        .q_m = 1,
+        .q_l = 0,
+        .q_r = 0,
+        .q_o = -1,
+        .q_c = 0,
+    };
+    poly_triple expr_c{
+        .a = 4,
+        .b = 6,
+        .c = 4,
+        .q_m = 1,
+        .q_l = 0,
+        .q_r = 0,
+        .q_o = -1,
+        .q_c = 0,
+
+    };
+    poly_triple expr_d{
+        .a = 6,
+        .b = 0,
+        .c = 0,
+        .q_m = 0,
+        .q_l = -1,
+        .q_r = 0,
+        .q_o = 0,
+        .q_c = 1,
+    };
+
+    constraint_system = acir_format::acir_format{
+        .varnum = 7,
+        .public_inputs = { 2 },
+        .fixed_base_scalar_mul_constraints = {},
+        .logic_constraints = { logic_constraint },
+        .range_constraints = { range_a, range_b },
+        .schnorr_constraints = {},
+        .ecdsa_constraints = {},
+        .sha256_constraints = {},
+        .blake2s_constraints = {},
+        .hash_to_field_constraints = {},
+        .pedersen_constraints = {},
+        .merkle_membership_constraints = {},
+        .constraints = { expr_a, expr_b, expr_c, expr_d },
+    };
+
+    uint256_t inverse_of_five = fr(5).invert();
+
+    witness.emplace_back(5);
+    witness.emplace_back(10);
+    witness.emplace_back(15);
+    witness.emplace_back(5);
+    witness.emplace_back(inverse_of_five);
+    witness.emplace_back(1);
+}
+
+static acir_format::acir_format constraint_system;
+static std::vector<fr> witness;
+
+TEST(AcirProofs, TestSerialization)
+{
+    create_inner_circuit(constraint_system, witness);
+
+    std::vector<uint8_t> witness_buf;           // = to_buffer(witness);
+    std::vector<uint8_t> constraint_system_buf; //
+    write(constraint_system_buf, constraint_system);
+    write(witness_buf, witness);
+
+    uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
+    uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+    auto verifier_crs = env_crs->get_verifier_crs();
+
+    uint8_t const* pk_buf = nullptr;
+    acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
+    barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
+
+    auto* pippenger_ptr_base = new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
+    void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
+
+    std::vector<uint8_t> g2x_buffer(128);
+    io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
+
+    uint8_t const* vk_buf = nullptr;
+    acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
+
+    uint8_t* proof_data_buf = nullptr;
+    size_t proof_length = acir_proofs::new_proof(
+        pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf);
+
+    bool verified = acir_proofs::verify_proof(
+        &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
+    EXPECT_EQ(verified, true);
+}

From d9656e9c5fcfca6e3a8df7fbab352f531e0f4fec Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Tue, 18 Apr 2023 13:46:51 +0200
Subject: [PATCH 06/64] Added serialization methods into dsl for recursive
 proof composition

Added passing serialization tests

Fixed format of RecursionConstraint to be compatible with existing ACIR formatting
---
 .../dsl/acir_format/acir_format.cpp           |  10 +-
 .../dsl/acir_format/acir_format.hpp           |   2 +
 .../dsl/acir_format/recursion_constraint.cpp  |  62 +++++-
 .../dsl/acir_format/recursion_constraint.hpp  |  16 +-
 .../acir_format/recursion_constraint.test.cpp |   4 -
 .../dsl/acir_proofs/acir_proofs.cpp           |  92 +++++++--
 .../dsl/acir_proofs/acir_proofs.hpp           |   6 +
 .../dsl/acir_proofs/acir_proofs.test.cpp      | 192 +++++++++++++++++-
 .../types/polynomial_manifest.hpp             |   2 +-
 .../verification_key/verification_key.cpp     |  45 ++++
 .../verification_key/verification_key.hpp     |   2 +
 .../verification_key/verification_key.hpp     |  13 +-
 .../stdlib/recursion/verifier/verifier.hpp    |   5 +-
 .../transcript/transcript_wrappers.hpp        |  43 +++-
 14 files changed, 453 insertions(+), 41 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
index 2b7b9526b6..65313934a6 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
@@ -89,7 +89,7 @@ void create_circuit(Composer& composer, const acir_format& constraint_system)
 
     // Add recursion constraints
     for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints(composer, constraint);
+        create_recursion_constraints<false, false>(composer, constraint);
     }
 }
 
@@ -172,7 +172,7 @@ Composer create_circuit(const acir_format& constraint_system,
 
     // Add recursion constraints
     for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints(composer, constraint);
+        create_recursion_constraints<false, false>(composer, constraint);
     }
 
     return composer;
@@ -261,7 +261,7 @@ Composer create_circuit_with_witness(const acir_format& constraint_system,
 
     // Add recursion constraints
     for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints(composer, constraint);
+        create_recursion_constraints<true, false>(composer, constraint);
     }
     return composer;
 }
@@ -346,7 +346,7 @@ Composer create_circuit_with_witness(const acir_format& constraint_system, std::
 
     // Add recursion constraints
     for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints(composer, constraint);
+        create_recursion_constraints<true, false>(composer, constraint);
     }
     return composer;
 }
@@ -429,7 +429,7 @@ void create_circuit_with_witness(Composer& composer, const acir_format& constrai
 
     // Add recursion constraints
     for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints(composer, constraint);
+        create_recursion_constraints<true, false>(composer, constraint);
     }
 }
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
index 12592c6a32..950de43460 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
@@ -73,6 +73,7 @@ template <typename B> inline void read(B& buf, acir_format& data)
     read(buf, data.pedersen_constraints);
     read(buf, data.hash_to_field_constraints);
     read(buf, data.fixed_base_scalar_mul_constraints);
+    read(buf, data.recursion_constraints);
     read(buf, data.constraints);
 }
 
@@ -91,6 +92,7 @@ template <typename B> inline void write(B& buf, acir_format const& data)
     write(buf, data.pedersen_constraints);
     write(buf, data.hash_to_field_constraints);
     write(buf, data.fixed_base_scalar_mul_constraints);
+    write(buf, data.recursion_constraints);
     write(buf, data.constraints);
 }
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 4c9d08a32a..d6af1512f3 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -1,6 +1,8 @@
 #include "recursion_constraint.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
 #include "barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp"
 #include "barretenberg/stdlib/recursion/verifier/verifier.hpp"
+#include "barretenberg/transcript/transcript_wrappers.hpp"
 
 using namespace proof_system::plonk::stdlib::types;
 
@@ -9,14 +11,54 @@ using aggregation_state_ct = proof_system::plonk::stdlib::recursion::aggregation
 using noir_recursive_settings = proof_system::plonk::stdlib::recursion::recursive_ultra_verifier_settings<bn254>;
 namespace acir_format {
 
+void generate_dummy_proof() {}
 /**
  * @brief Add constraints required to recursively verify an UltraPlonk proof
  *
  * @param composer
  * @param input
+ * @tparam has_valid_witness_assignment. Do we have witnesses or are we just generating keys?
+ * @tparam inner_proof_contains_recursive_proof. Do we expect the inner proof to also have performed recursive
+ * verification? We need to know this at circuit-compile time.
+ *
+ * @note We currently only support RecursionConstraint where inner_proof_contains_recursive_proof = false.
+ *       We would either need a separate ACIR opcode where inner_proof_contains_recursive_proof = true,
+ *       or we need non-witness data to be provided as metadata in the ACIR opcode
  */
+template <bool has_valid_witness_assignment, bool inner_proof_contains_recursive_proof>
 void create_recursion_constraints(Composer& composer, const RecursionConstraint& input)
 {
+
+    // If we do not have a witness, we must ensure that our dummy witness will not trigger
+    // on-curve errors and inverting-zero errors
+    {
+        // get a fake key/proof that satisfies on-curve + inversion-zero checks
+        const std::vector<fr> dummy_key = plonk::verification_key::export_dummy_key_in_recursion_format(
+            PolynomialManifest(Composer::type), inner_proof_contains_recursive_proof);
+        const auto manifest = Composer::create_unrolled_manifest(1);
+        const std::vector<barretenberg::fr> dummy_proof =
+            transcript::StandardTranscript::export_dummy_transcript_in_recursion_format(manifest);
+        for (size_t i = 0; i < input.proof.size(); ++i) {
+            const auto proof_field_idx = input.proof[i];
+            // if we do NOT have a witness assignment (i.e. are just building the proving/verification keys),
+            // we add our dummy proof values as Composer variables.
+            // if we DO have a valid witness assignment, we use the real witness assignment
+            barretenberg::fr dummy_field =
+                has_valid_witness_assignment ? composer.get_variable(proof_field_idx) : dummy_proof[i];
+            // Create a copy constraint between our dummy field and the witness index provided by RecursionConstraint.
+            // This will make the RecursionConstraint idx equal to `dummy_field`.
+            // In the case of a valid witness assignment, this does nothing (as dummy_field = real value)
+            // In the case of no valid witness assignment, this makes sure that the RecursionConstraint witness indices
+            // will not trigger basic errors (check inputs are on-curve, check we are not inverting 0)
+            composer.assert_equal(composer.add_variable(dummy_field), proof_field_idx);
+        }
+        for (size_t i = 0; i < input.key.size(); ++i) {
+            const auto key_field_idx = input.key[i];
+            barretenberg::fr dummy_field =
+                has_valid_witness_assignment ? composer.get_variable(key_field_idx) : dummy_key[i];
+            composer.assert_equal(composer.add_variable(dummy_field), key_field_idx);
+        }
+    }
     // The env_crs should be ok, we use this when generating the constraint system in dsl
     auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
 
@@ -28,7 +70,11 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
 
     // If we have previously recursively verified proofs, `is_aggregation_object_nonzero = true`
     // For now this is a complile-time constant i.e. whether this is true/false is fixed for the circuit!
-    if (input.is_aggregation_object_nonzero) {
+    bool inner_aggregation_indices_all_zero = true;
+    for (const auto& idx : aggregation_input) {
+        inner_aggregation_indices_all_zero &= (idx == 0);
+    }
+    if (!inner_aggregation_indices_all_zero) {
         std::array<bn254::fq_ct, 4> aggregation_elements;
         for (size_t i = 0; i < 4; ++i) {
             aggregation_elements[i] =
@@ -60,10 +106,11 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 
     // recursively verify the proof
-    aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof<bn254, noir_recursive_settings>(
-        &composer, manifest, key_fields, proof_fields, previous_aggregation);
-
-    // Assign the output aggregation object to the proof public inputs (16 field elements representing two G1 points)
+    aggregation_state_ct result = proof_system::plonk::stdlib::recursion::
+        verify_proof<bn254, noir_recursive_settings, inner_proof_contains_recursive_proof>(
+            &composer, manifest, key_fields, proof_fields, previous_aggregation);
+    // Assign the output aggregation object to the proof public inputs (16 field elements representing two
+    // G1 points)
     result.add_proof_outputs_as_public_inputs();
 
     ASSERT(result.public_inputs.size() == 1);
@@ -79,4 +126,9 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 }
 
+template void create_recursion_constraints<false, false>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<false, true>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<true, false>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<true, true>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
+
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index 0e794f3f73..f94ec453d4 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -24,12 +24,14 @@ namespace acir_format {
  * @param public_input The index of the single public input
  * @param input_aggregation_object Witness indices of pre-existing aggregation object (if it exists)
  * @param output_aggregation_object Witness indecies of the aggregation object produced by recursive verification
+ *
+ * @note If input_aggregation_object witness indices are all zero, we interpret this to mean that the inner proof does
+ * NOT contai
  */
 struct RecursionConstraint {
     static constexpr size_t AGGREGATION_OBJECT_SIZE = 16; // 16 field elements
     std::vector<uint32_t> key;
     std::vector<uint32_t> proof;
-    bool is_aggregation_object_nonzero;
     uint32_t public_input;
     std::array<uint32_t, AGGREGATION_OBJECT_SIZE> input_aggregation_object;
     std::array<uint32_t, AGGREGATION_OBJECT_SIZE> output_aggregation_object;
@@ -37,14 +39,23 @@ struct RecursionConstraint {
     friend bool operator==(RecursionConstraint const& lhs, RecursionConstraint const& rhs) = default;
 };
 
+template <bool has_valid_witness_assignment = false, bool inner_proof_contains_recursive_proof = false>
 void create_recursion_constraints(plonk::stdlib::types::Composer& composer, const RecursionConstraint& input);
 
+extern template void create_recursion_constraints<false, false>(plonk::stdlib::types::Composer&,
+                                                                const RecursionConstraint&);
+extern template void create_recursion_constraints<false, true>(plonk::stdlib::types::Composer&,
+                                                               const RecursionConstraint&);
+extern template void create_recursion_constraints<true, false>(plonk::stdlib::types::Composer&,
+                                                               const RecursionConstraint&);
+extern template void create_recursion_constraints<true, true>(plonk::stdlib::types::Composer&,
+                                                              const RecursionConstraint&);
+
 template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 {
     using serialize::read;
     read(buf, constraint.key);
     read(buf, constraint.proof);
-    read(buf, constraint.is_aggregation_object_nonzero);
     read(buf, constraint.public_input);
     read(buf, constraint.input_aggregation_object);
     read(buf, constraint.output_aggregation_object);
@@ -55,7 +66,6 @@ template <typename B> inline void write(B& buf, RecursionConstraint const& const
     using serialize::write;
     write(buf, constraint.key);
     write(buf, constraint.proof);
-    write(buf, constraint.is_aggregation_object_nonzero);
     write(buf, constraint.public_input);
     write(buf, constraint.input_aggregation_object);
     write(buf, constraint.output_aggregation_object);
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index f36446e3db..b5d3a9fa69 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -126,9 +126,6 @@ TEST(RecursionConstraint, TestRecursionConstraint)
         // variable idx 2-18 = output_vars
         output_vars[i] = (static_cast<uint32_t>(i + 2));
     }
-    // verification_key_data keydata;
-    // uint8_t const* vk_buf = &keybuf[0];
-    // read(vk_buf, keydata);
 
     transcript::StandardTranscript transcript(
         inner_proof.proof_data, Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
@@ -151,7 +148,6 @@ TEST(RecursionConstraint, TestRecursionConstraint)
     acir_format::RecursionConstraint recursion_constraint{
         .key = key_indices,
         .proof = proof_indices,
-        .is_aggregation_object_nonzero = false,
         .public_input = 1,
         .input_aggregation_object = {},
         .output_aggregation_object = output_vars,
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 9b899aa69f..733b652463 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -52,6 +52,8 @@ size_t init_proving_key(uint8_t const* constraint_system_buf, uint8_t const** pk
 {
     auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
 
+    // constraint_system.recursion_constraints[0].
+
     // We know that we don't actually need any CRS to create a proving key, so just feed in a nothing.
     // Hacky, but, right now it needs *something*.
     auto crs_factory = std::make_unique<ReferenceStringFactory>();
@@ -93,17 +95,81 @@ size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const*
     return buffer.size();
 }
 
-// void serialize_proof_into_field_elements(uint8_t** proof_data_buf)
-// {
-// }
-
-// void serialize_verification_key_into_field_elements(uint8_t** vk_buf)
-// {
-//     plonk::verification_key key;
-//     read(vk_buf, key);
+/**
+ * @brief Takes in a proof buffer and converts into a vector of field elements.
+ *        The Recursion opcode requires the proof serialized as a vector of witnesses.
+ *        Use this method to get the witness values!
+ *
+ * @param proof_data_buf
+ * @param serialized_proof_data_buf
+ */
+size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                           uint8_t** serialized_proof_data_buf,
+                                           size_t proof_data_length)
+{
+    plonk::proof proof = { std::vector<uint8_t>(proof_data_buf, &proof_data_buf[proof_data_length]) };
+
+    transcript::StandardTranscript transcript(
+        proof.proof_data, Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
+
+    std::vector<barretenberg::fr> output = transcript.export_transcript_in_recursion_format();
+
+    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
+    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr);
+    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
+    // NOTE: currently we dump the fr values into memory in Mongtomery form
+    // This is so we don't have to re-convert into Montgomery form when we read these back in.
+    // I think this makes it easier to handle the data in barretenberg-sys / aztec-backend.
+    // If this is not the case, the commented out serialize code will convert out of Montgomery form before writing to
+    // the buffer
+    // for (size_t i = 0; i < output.size(); ++i) {
+    //     barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
+    // }
+    // for (size_t i = 0; i < output.size(); ++i) {
+    //     barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
+    // }
+    memcpy(raw_buf, (void*)output.data(), output_size_bytes);
+    *serialized_proof_data_buf = raw_buf;
+
+    return output_size_bytes;
+}
 
-//     // do the serialize thing...
-// }
+/**
+ * @brief Takes in a verification key buffer and converts into a vector of field elements.
+ *        The Recursion opcode requires the vk serialized as a vector of witnesses.
+ *        Use this method to get the witness values!
+ *
+ * @param vk_buf
+ * @param serialized_vk_buf
+ */
+size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                      uint8_t const* vk_buf,
+                                                      uint8_t** serialized_vk_buf)
+{
+    auto crs = std::make_shared<VerifierMemReferenceString>(g2x);
+    plonk::verification_key_data vk_data;
+    read(vk_buf, vk_data);
+    auto vkey = std::make_shared<proof_system::plonk::verification_key>(std::move(vk_data), crs);
+
+    std::vector<barretenberg::fr> output = vkey->export_key_in_recursion_format();
+
+    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
+    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr);
+    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
+    // NOTE: currently we dump the fr values into memory in Mongtomery form
+    // This is so we don't have to re-convert into Montgomery form when we read these back in.
+    // I think this makes it easier to handle the data in barretenberg-sys / aztec-backend.
+    // If this is not the case, the commented out serialize code will convert out of Montgomery form before writing to
+    // the buffer
+    // for (size_t i = 0; i < output.size(); ++i) {
+    //     barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
+    // }
+    memcpy(raw_buf, (void*)output.data(), output_size_bytes);
+
+    *serialized_vk_buf = raw_buf;
+
+    return output_size_bytes;
+}
 
 size_t new_proof(void* pippenger,
                  uint8_t const* g2x,
@@ -125,12 +191,12 @@ size_t new_proof(void* pippenger,
         reinterpret_cast<scalar_multiplication::Pippenger*>(pippenger), g2x);
     proving_key->reference_string = crs_factory->get_prover_crs(proving_key->circuit_size);
 
-    Composer composer(proving_key, nullptr);
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
 
-    create_circuit_with_witness(composer, constraint_system, witness);
+    auto composer = acir_format::create_circuit_with_witness(constraint_system, witness);
 
     auto prover = composer.create_prover();
-
+    auto verifier = composer.create_verifier();
     auto heapProver = new stdlib::types::Prover(std::move(prover));
     auto& proof_data = heapProver->construct_proof().proof_data;
     *proof_data_buf = proof_data.data();
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
index 4bd126aae9..180da3fec8 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
@@ -8,6 +8,12 @@ uint32_t get_exact_circuit_size(uint8_t const* constraint_system_buf);
 uint32_t get_total_circuit_size(uint8_t const* constraint_system_buf);
 size_t init_proving_key(uint8_t const* constraint_system_buf, uint8_t const** pk_buf);
 size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const* pk_buf, uint8_t const** vk_buf);
+size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                      uint8_t const* vk_buf,
+                                                      uint8_t** serialized_vk_buf);
+size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                           uint8_t** serialized_proof_data_buf,
+                                           size_t proof_data_length);
 size_t new_proof(void* pippenger,
                  uint8_t const* g2x,
                  uint8_t const* pk_buf,
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index ce28fe62df..a31ad76d52 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -100,11 +100,10 @@ void create_inner_circuit(acir_format::acir_format& constraint_system, std::vect
     witness.emplace_back(1);
 }
 
-static acir_format::acir_format constraint_system;
-static std::vector<fr> witness;
-
 TEST(AcirProofs, TestSerialization)
 {
+    acir_format::acir_format constraint_system;
+    std::vector<fr> witness;
     create_inner_circuit(constraint_system, witness);
 
     std::vector<uint8_t> witness_buf;           // = to_buffer(witness);
@@ -138,3 +137,190 @@ TEST(AcirProofs, TestSerialization)
         &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
     EXPECT_EQ(verified, true);
 }
+
+TEST(AcirProofs, TestSerializationWithRecursion)
+{
+    uint8_t* proof_data_fields = nullptr;
+    uint8_t* vk_fields = nullptr;
+    size_t proof_fields_size = 0;
+    size_t vk_fields_size = 0;
+
+    // inner circuit
+    {
+        acir_format::acir_format constraint_system;
+        std::vector<fr> witness;
+        create_inner_circuit(constraint_system, witness);
+
+        std::vector<uint8_t> witness_buf;           // = to_buffer(witness);
+        std::vector<uint8_t> constraint_system_buf; //
+        write(constraint_system_buf, constraint_system);
+        write(witness_buf, witness);
+
+        uint8_t const* pk_buf = nullptr;
+        acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
+
+        uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
+        uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+        auto verifier_crs = env_crs->get_verifier_crs();
+        barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
+
+        auto* pippenger_ptr_base =
+            new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
+        void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
+
+        std::vector<uint8_t> g2x_buffer(128);
+        io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
+
+        uint8_t const* vk_buf = nullptr;
+        acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
+
+        uint8_t* proof_data_buf = nullptr;
+        size_t proof_length = acir_proofs::new_proof(
+            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf);
+        proof_fields_size =
+            acir_proofs::serialize_proof_into_field_elements(proof_data_buf, &proof_data_fields, proof_length);
+        vk_fields_size =
+            acir_proofs::serialize_verification_key_into_field_elements(&g2x_buffer[0], vk_buf, &vk_fields);
+
+        bool verified = acir_proofs::verify_proof(
+            &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
+        EXPECT_EQ(verified, true);
+
+        delete pippenger_ptr_base;
+        // free((void*)vk_buf);
+        // free((void*)pk_buf);
+    }
+    // outer circuit
+    {
+        std::vector<fr> proof_witnesses(proof_fields_size / 32);
+        std::vector<fr> key_witnesses(vk_fields_size / 32);
+        memcpy(proof_witnesses.data(), (void*)proof_data_fields, proof_fields_size);
+        memcpy(&key_witnesses[0], (void*)vk_fields, vk_fields_size);
+
+        std::vector<uint32_t> proof_indices;
+
+        const size_t proof_size = proof_witnesses.size();
+
+        for (size_t i = 0; i < proof_size; ++i) {
+            proof_indices.emplace_back(static_cast<uint32_t>(i + 18));
+        }
+
+        std::vector<uint32_t> key_indices;
+        const size_t key_size = key_witnesses.size();
+        for (size_t i = 0; i < key_size; ++i) {
+            key_indices.emplace_back(static_cast<uint32_t>(i + 18 + proof_size));
+        }
+
+        std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_vars;
+        for (size_t i = 0; i < acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE; ++i) {
+            // variable idx 1 = public input
+            // variable idx 2-18 = output_vars
+            output_vars[i] = (static_cast<uint32_t>(i + 2));
+        }
+        acir_format::RecursionConstraint recursion_constraint{
+            .key = key_indices,
+            .proof = proof_indices,
+            .public_input = 1,
+            .input_aggregation_object = {},
+            .output_aggregation_object = output_vars,
+        };
+
+        //     {
+        //   std::vector<fr> witness;
+        //     for (size_t i = 0; i < 17; ++i) {
+        //         witness.emplace_back(0);
+        //     }
+        //     for (const auto& wit : proof_witnesses) {
+        //         witness.emplace_back(wit);
+        //     }
+        //     for (const auto& wit : key_witnesses) {
+        //         witness.emplace_back(wit);
+        //     }
+
+        //             acir_format::acir_format constraint_system{
+        //         .varnum = static_cast<uint32_t>(witness.size() + 1),
+        //         .public_inputs = { 1 },
+        //         .fixed_base_scalar_mul_constraints = {},
+        //         .logic_constraints = {},
+        //         .range_constraints = {},
+        //         .schnorr_constraints = {},
+        //         .ecdsa_constraints = {},
+        //         .sha256_constraints = {},
+        //         .blake2s_constraints = {},
+        //         .hash_to_field_constraints = {},
+        //         .pedersen_constraints = {},
+        //         .merkle_membership_constraints = {},
+        //         .recursion_constraints = { recursion_constraint },
+        //         .constraints = {},
+        //     };
+        //         auto composer = acir_format::create_circuit_with_witness(constraint_system, witness);
+        // auto prover = composer.create_prover();
+
+        // auto proof = prover.construct_proof();
+        // auto verifier = composer.create_verifier();
+        // EXPECT_EQ(verifier.verify_proof(proof), true);
+
+        // EXPECT_EQ(composer.get_variable(1), 10);
+
+        //     }
+        std::vector<fr> witness;
+        for (size_t i = 0; i < 17; ++i) {
+            witness.emplace_back(0);
+        }
+        for (const auto& wit : proof_witnesses) {
+            witness.emplace_back(wit);
+        }
+        for (const auto& wit : key_witnesses) {
+            witness.emplace_back(wit);
+        }
+
+        acir_format::acir_format constraint_system{
+            .varnum = static_cast<uint32_t>(witness.size() + 1),
+            .public_inputs = { 1 },
+            .fixed_base_scalar_mul_constraints = {},
+            .logic_constraints = {},
+            .range_constraints = {},
+            .schnorr_constraints = {},
+            .ecdsa_constraints = {},
+            .sha256_constraints = {},
+            .blake2s_constraints = {},
+            .hash_to_field_constraints = {},
+            .pedersen_constraints = {},
+            .merkle_membership_constraints = {},
+            .recursion_constraints = { recursion_constraint },
+            .constraints = {},
+        };
+
+        std::vector<uint8_t> witness_buf;
+        std::vector<uint8_t> constraint_system_buf;
+        write(constraint_system_buf, constraint_system);
+        write(witness_buf, witness);
+        uint8_t const* pk_buf = nullptr;
+        acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
+
+        uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
+        uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+        auto verifier_crs = env_crs->get_verifier_crs();
+        barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
+
+        auto* pippenger_ptr_base =
+            new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
+        void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
+
+        std::vector<uint8_t> g2x_buffer(128);
+        io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
+
+        uint8_t const* vk_buf = nullptr;
+        acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
+
+        uint8_t* proof_data_buf = nullptr;
+        size_t proof_length = acir_proofs::new_proof(
+            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf);
+
+        bool verified = acir_proofs::verify_proof(
+            &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
+        EXPECT_EQ(verified, true);
+    }
+}
diff --git a/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp b/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp
index aefd348ff9..65911eba38 100644
--- a/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp
@@ -200,7 +200,7 @@ class PolynomialManifest {
         };
     }
 
-    const std::vector<PolynomialDescriptor>& get() { return manifest; };
+    const std::vector<PolynomialDescriptor>& get() const { return manifest; };
 
     size_t size() const { return manifest.size(); }
 
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
index 7ba7af5175..d355e6fc7e 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
@@ -221,4 +221,49 @@ std::vector<barretenberg::fr> verification_key::export_key_in_recursion_format()
     return output;
 }
 
+/**
+ * @brief When recursively verifying proofs, we represent the verification key using field elements.
+ *        This method exports the key formatted in the manner our recursive verifier expects.
+ *        A dummy key is used when building a circuit without a valid witness assignment.
+ *        We want the transcript to contain valid G1 points to prevent on-curve errors being thrown.
+ *        We want a non-zero circuit size as this element will be inverted by the circuit
+ *        and we do not want an "inverting 0" error thrown
+ *
+ * @return std::vector<barretenberg::fr>
+ */
+std::vector<barretenberg::fr> verification_key::export_dummy_key_in_recursion_format(
+    const PolynomialManifest& polynomial_manifest, const bool contains_recursive_proof)
+{
+    std::vector<fr> output;
+    output.emplace_back(1); // domain.domain (will be inverted)
+    output.emplace_back(1); // domain.root (will be inverted)
+    output.emplace_back(1); // domain.generator (will be inverted)
+
+    output.emplace_back(1); // circuit size
+    output.emplace_back(1); // num public inputs
+
+    output.emplace_back(contains_recursive_proof); // contains_recursive_proof
+    for (size_t i = 0; i < 16; ++i) {
+        output.emplace_back(0); // recursive_proof_public_input_indices
+    }
+
+    for (const auto& descriptor : polynomial_manifest.get()) {
+        if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
+            const auto element = barretenberg::g1::affine_one;
+            const uint256_t x = element.x;
+            const uint256_t y = element.y;
+            const barretenberg::fr x_lo = x.slice(0, 136);
+            const barretenberg::fr x_hi = x.slice(136, 272);
+            const barretenberg::fr y_lo = y.slice(0, 136);
+            const barretenberg::fr y_hi = y.slice(136, 272);
+            output.emplace_back(x_lo);
+            output.emplace_back(x_hi);
+            output.emplace_back(y_lo);
+            output.emplace_back(y_hi);
+        }
+    }
+
+    return output;
+}
+
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
index aa240f52c9..974ada27b1 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
@@ -64,6 +64,8 @@ struct verification_key {
 
     sha256::hash sha256_hash();
     std::vector<barretenberg::fr> export_key_in_recursion_format();
+    static std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(
+        const PolynomialManifest& polynomial_manifest, bool contains_recursive_proof = 0);
 
     uint32_t composer_type;
     size_t circuit_size;
diff --git a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index c297973dbb..48ce7c81ae 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -29,6 +29,7 @@ template <typename Composer> struct evaluation_domain {
     {
         evaluation_domain domain;
         domain.root = fields[0];
+
         domain.root_inverse = domain.root.invert();
         domain.domain = fields[1];
         domain.domain_inverse = domain.domain.invert();
@@ -119,8 +120,11 @@ template <typename Composer> struct evaluation_domain {
 template <typename Curve> struct verification_key {
     using Composer = typename Curve::Composer;
 
-    static std::shared_ptr<verification_key> from_field_pt_vector(Composer* ctx,
-                                                                  const std::vector<field_t<Composer>>& fields)
+    template <bool inner_proof_contains_recursive_proof = false>
+    static std::shared_ptr<verification_key> from_field_pt_vector(
+        Composer* ctx,
+        const std::vector<field_t<Composer>>& fields,
+        std::array<uint32_t, 16> recursive_proof_public_input_indices = {})
     {
         std::vector<fr> fields_raw;
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
@@ -140,9 +144,9 @@ template <typename Curve> struct verification_key {
             key->recursive_proof_public_input_indices.emplace_back(idx);
         }
         // Apply constraints to force the recursive proof information to be circuit constants
-        fields[5].assert_equal(key->contains_recursive_proof);
+        fields[5].assert_equal(inner_proof_contains_recursive_proof);
         for (size_t i = 0; i < 16; ++i) {
-            fields[6 + i].assert_equal(key->recursive_proof_public_input_indices[i]);
+            fields[6 + i].assert_equal(recursive_proof_public_input_indices[i]);
         }
 
         size_t count = 22;
@@ -160,6 +164,7 @@ template <typename Curve> struct verification_key {
                 key->commitments.insert({ std::string(descriptor.commitment_label), element });
             }
         }
+
         return key;
     }
 
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
index f3b4004218..b841491bfd 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
@@ -196,7 +196,7 @@ aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
  * Refer to src/barretenberg/plonk/proof_system/verifier/verifier.cpp verify_proof() for the native implementation,
  * which includes detailed comments.
  */
-template <typename Curve, typename program_settings>
+template <typename Curve, typename program_settings, bool inner_proof_contains_recursive_proof>
 aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
                                       const transcript::Manifest& manifest,
                                       const std::vector<typename Curve::fr_ct>& key,
@@ -205,7 +205,8 @@ aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
 {
     using Composer = typename Curve::Composer;
 
-    std::shared_ptr<verification_key<Curve>> vkey = verification_key<Curve>::from_field_pt_vector(context, key);
+    std::shared_ptr<verification_key<Curve>> vkey =
+        verification_key<Curve>::template from_field_pt_vector<inner_proof_contains_recursive_proof>(context, key);
     vkey->program_width = program_settings::program_width;
 
     const size_t num_public_inputs = static_cast<size_t>(uint256_t(vkey->num_public_inputs.get_value()).data[0]);
diff --git a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
index ab0b02d4c6..ad849889cc 100644
--- a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
+++ b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
@@ -68,7 +68,7 @@ class StandardTranscript : public Transcript {
         std::vector<barretenberg::fr> fields;
         const auto num_rounds = get_manifest().get_num_rounds();
         for (size_t i = 0; i < num_rounds; ++i) {
-            for (auto manifest_element : get_manifest().get_round_manifest(i).elements) {
+            for (const auto& manifest_element : get_manifest().get_round_manifest(i).elements) {
                 if (!manifest_element.derived_by_verifier) {
                     if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
                         fields.emplace_back(get_field_element(manifest_element.name));
@@ -96,6 +96,47 @@ class StandardTranscript : public Transcript {
         }
         return fields;
     }
+
+    /**
+     * @brief Get a dummy fake proof for recursion. All elliptic curve group elements are still valid points to prevent
+     * errors being thrown.
+     *
+     * @param manifest
+     * @return std::vector<barretenberg::fr>
+     */
+    static std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const Manifest& manifest)
+    {
+        std::vector<barretenberg::fr> fields;
+        const auto num_rounds = manifest.get_num_rounds();
+        for (size_t i = 0; i < num_rounds; ++i) {
+            for (const auto& manifest_element : manifest.get_round_manifest(i).elements) {
+                if (!manifest_element.derived_by_verifier) {
+                    if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
+                        fields.emplace_back(0);
+                    } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
+                        const auto group_element = barretenberg::g1::affine_one;
+                        const uint256_t x = group_element.x;
+                        const uint256_t y = group_element.y;
+                        const barretenberg::fr x_lo = x.slice(0, 136);
+                        const barretenberg::fr x_hi = x.slice(136, 272);
+                        const barretenberg::fr y_lo = y.slice(0, 136);
+                        const barretenberg::fr y_hi = y.slice(136, 272);
+                        fields.emplace_back(x_lo);
+                        fields.emplace_back(x_hi);
+                        fields.emplace_back(y_lo);
+                        fields.emplace_back(y_hi);
+                    } else {
+                        ASSERT(manifest_element.name == "public_inputs");
+                        const size_t num_public_inputs = manifest_element.num_bytes / 32;
+                        for (size_t j = 0; j < num_public_inputs; ++j) {
+                            fields.emplace_back(0);
+                        }
+                    }
+                }
+            }
+        }
+        return fields;
+    }
 };
 
 } // namespace transcript

From 209f81335bd7e3b2f33f5eb5ec4a3b351180b589 Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Tue, 18 Apr 2023 14:54:08 +0200
Subject: [PATCH 07/64] added verificaiton key hash into RecursionConstraint

Can be used by backend to force recursive verification key to be a specific value (it is represented via witnesses and therefore is not by-default constraint to represent a specific circuit)
---
 .../dsl/acir_format/recursion_constraint.cpp  | 15 +++-
 .../dsl/acir_format/recursion_constraint.hpp  |  3 +
 .../acir_format/recursion_constraint.test.cpp |  9 ++-
 .../dsl/acir_proofs/acir_proofs.cpp           | 14 +++-
 .../dsl/acir_proofs/acir_proofs.hpp           |  3 +-
 .../dsl/acir_proofs/acir_proofs.test.cpp      | 81 ++++++++-----------
 .../verification_key/verification_key.cpp     | 10 +++
 .../stdlib/recursion/verifier/verifier.hpp    | 23 ------
 8 files changed, 77 insertions(+), 81 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index d6af1512f3..895c27f99c 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -9,6 +9,8 @@ using namespace proof_system::plonk::stdlib::types;
 using verification_key_ct = proof_system::plonk::stdlib::recursion::verification_key<bn254>;
 using aggregation_state_ct = proof_system::plonk::stdlib::recursion::aggregation_state<bn254>;
 using noir_recursive_settings = proof_system::plonk::stdlib::recursion::recursive_ultra_verifier_settings<bn254>;
+using Transcript_ct = proof_system::plonk::stdlib::recursion::Transcript<Composer>;
+
 namespace acir_format {
 
 void generate_dummy_proof() {}
@@ -106,9 +108,16 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 
     // recursively verify the proof
-    aggregation_state_ct result = proof_system::plonk::stdlib::recursion::
-        verify_proof<bn254, noir_recursive_settings, inner_proof_contains_recursive_proof>(
-            &composer, manifest, key_fields, proof_fields, previous_aggregation);
+    std::shared_ptr<verification_key_ct> vkey =
+        verification_key_ct::template from_field_pt_vector<inner_proof_contains_recursive_proof>(&composer, key_fields);
+    vkey->program_width = noir_recursive_settings::program_width;
+    Transcript_ct transcript(&composer, manifest, proof_fields, 1);
+    aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof_<bn254, noir_recursive_settings>(
+        &composer, vkey, transcript, previous_aggregation);
+
+    // Assign correct witness value to the verification key hash
+    vkey->compress().assert_equal(field_ct::from_witness_index(&composer, input.key_hash));
+
     // Assign the output aggregation object to the proof public inputs (16 field elements representing two
     // G1 points)
     result.add_proof_outputs_as_public_inputs();
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index f94ec453d4..3a24727d01 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -33,6 +33,7 @@ struct RecursionConstraint {
     std::vector<uint32_t> key;
     std::vector<uint32_t> proof;
     uint32_t public_input;
+    uint32_t key_hash;
     std::array<uint32_t, AGGREGATION_OBJECT_SIZE> input_aggregation_object;
     std::array<uint32_t, AGGREGATION_OBJECT_SIZE> output_aggregation_object;
 
@@ -57,6 +58,7 @@ template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
     read(buf, constraint.key);
     read(buf, constraint.proof);
     read(buf, constraint.public_input);
+    read(buf, constraint.key_hash);
     read(buf, constraint.input_aggregation_object);
     read(buf, constraint.output_aggregation_object);
 }
@@ -67,6 +69,7 @@ template <typename B> inline void write(B& buf, RecursionConstraint const& const
     write(buf, constraint.key);
     write(buf, constraint.proof);
     write(buf, constraint.public_input);
+    write(buf, constraint.key_hash);
     write(buf, constraint.input_aggregation_object);
     write(buf, constraint.output_aggregation_object);
 }
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index b5d3a9fa69..cfd564f7f6 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -124,7 +124,7 @@ TEST(RecursionConstraint, TestRecursionConstraint)
     for (size_t i = 0; i < 16; ++i) {
         // variable idx 1 = public input
         // variable idx 2-18 = output_vars
-        output_vars[i] = (static_cast<uint32_t>(i + 2));
+        output_vars[i] = (static_cast<uint32_t>(i + 3));
     }
 
     transcript::StandardTranscript transcript(
@@ -137,24 +137,25 @@ TEST(RecursionConstraint, TestRecursionConstraint)
     const size_t proof_size = proof_witnesses.size();
 
     for (size_t i = 0; i < proof_size; ++i) {
-        proof_indices.emplace_back(static_cast<uint32_t>(i + 18));
+        proof_indices.emplace_back(static_cast<uint32_t>(i + 19));
     }
 
     std::vector<uint32_t> key_indices;
     const size_t key_size = key_witnesses.size();
     for (size_t i = 0; i < key_size; ++i) {
-        key_indices.emplace_back(static_cast<uint32_t>(i + 18 + proof_size));
+        key_indices.emplace_back(static_cast<uint32_t>(i + 19 + proof_size));
     }
     acir_format::RecursionConstraint recursion_constraint{
         .key = key_indices,
         .proof = proof_indices,
         .public_input = 1,
+        .key_hash = 2,
         .input_aggregation_object = {},
         .output_aggregation_object = output_vars,
     };
 
     std::vector<fr> witness;
-    for (size_t i = 0; i < 17; ++i) {
+    for (size_t i = 0; i < 18; ++i) {
         witness.emplace_back(0);
     }
     for (const auto& wit : proof_witnesses) {
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 733b652463..4d01512eca 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -144,7 +144,8 @@ size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
  */
 size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
                                                       uint8_t const* vk_buf,
-                                                      uint8_t** serialized_vk_buf)
+                                                      uint8_t** serialized_vk_buf,
+                                                      uint8_t** serialized_vk_hash_buf)
 {
     auto crs = std::make_shared<VerifierMemReferenceString>(g2x);
     plonk::verification_key_data vk_data;
@@ -154,7 +155,8 @@ size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
     std::vector<barretenberg::fr> output = vkey->export_key_in_recursion_format();
 
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
-    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr);
+    // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o
+    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr) - 32;
     auto raw_buf = (uint8_t*)malloc(output_size_bytes);
     // NOTE: currently we dump the fr values into memory in Mongtomery form
     // This is so we don't have to re-convert into Montgomery form when we read these back in.
@@ -164,10 +166,16 @@ size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
     // for (size_t i = 0; i < output.size(); ++i) {
     //     barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
     // }
-    memcpy(raw_buf, (void*)output.data(), output_size_bytes);
 
+    // copy all but the vkey hash into raw_buf
+    memcpy(raw_buf, (void*)output.data(), output_size_bytes);
     *serialized_vk_buf = raw_buf;
 
+    // copy the vkey hash into vk_hash_raw_buf
+    auto vk_hash_raw_buf = (uint8_t*)malloc(32);
+    memcpy(vk_hash_raw_buf, (void*)&output[output.size() - 1], 32);
+    *serialized_vk_hash_buf = vk_hash_raw_buf;
+
     return output_size_bytes;
 }
 
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
index 180da3fec8..ced41993c3 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
@@ -10,7 +10,8 @@ size_t init_proving_key(uint8_t const* constraint_system_buf, uint8_t const** pk
 size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const* pk_buf, uint8_t const** vk_buf);
 size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
                                                       uint8_t const* vk_buf,
-                                                      uint8_t** serialized_vk_buf);
+                                                      uint8_t** serialized_vk_buf,
+                                                      uint8_t** serialized_vk_hash_buf);
 size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
                                            uint8_t** serialized_proof_data_buf,
                                            size_t proof_data_length);
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index a31ad76d52..de011de21e 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -142,6 +142,7 @@ TEST(AcirProofs, TestSerializationWithRecursion)
 {
     uint8_t* proof_data_fields = nullptr;
     uint8_t* vk_fields = nullptr;
+    uint8_t* vk_hash_buf = nullptr;
     size_t proof_fields_size = 0;
     size_t vk_fields_size = 0;
 
@@ -180,92 +181,70 @@ TEST(AcirProofs, TestSerializationWithRecursion)
             pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf);
         proof_fields_size =
             acir_proofs::serialize_proof_into_field_elements(proof_data_buf, &proof_data_fields, proof_length);
-        vk_fields_size =
-            acir_proofs::serialize_verification_key_into_field_elements(&g2x_buffer[0], vk_buf, &vk_fields);
+        vk_fields_size = acir_proofs::serialize_verification_key_into_field_elements(
+            &g2x_buffer[0], vk_buf, &vk_fields, &vk_hash_buf);
 
         bool verified = acir_proofs::verify_proof(
             &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
         EXPECT_EQ(verified, true);
 
         delete pippenger_ptr_base;
-        // free((void*)vk_buf);
-        // free((void*)pk_buf);
+        free((void*)vk_buf);
+        free((void*)pk_buf);
+        free((void*)proof_data_buf);
     }
     // outer circuit
     {
+        fr vk_hash_value;
         std::vector<fr> proof_witnesses(proof_fields_size / 32);
         std::vector<fr> key_witnesses(vk_fields_size / 32);
         memcpy(proof_witnesses.data(), (void*)proof_data_fields, proof_fields_size);
         memcpy(&key_witnesses[0], (void*)vk_fields, vk_fields_size);
+        memcpy(&vk_hash_value, (void*)vk_hash_buf, 32);
 
         std::vector<uint32_t> proof_indices;
 
         const size_t proof_size = proof_witnesses.size();
 
         for (size_t i = 0; i < proof_size; ++i) {
-            proof_indices.emplace_back(static_cast<uint32_t>(i + 18));
+            proof_indices.emplace_back(static_cast<uint32_t>(i + 19));
         }
 
         std::vector<uint32_t> key_indices;
         const size_t key_size = key_witnesses.size();
         for (size_t i = 0; i < key_size; ++i) {
-            key_indices.emplace_back(static_cast<uint32_t>(i + 18 + proof_size));
+            key_indices.emplace_back(static_cast<uint32_t>(i + 19 + proof_size));
         }
 
         std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_vars;
         for (size_t i = 0; i < acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE; ++i) {
             // variable idx 1 = public input
             // variable idx 2-18 = output_vars
-            output_vars[i] = (static_cast<uint32_t>(i + 2));
+            output_vars[i] = (static_cast<uint32_t>(i + 3));
         }
         acir_format::RecursionConstraint recursion_constraint{
             .key = key_indices,
             .proof = proof_indices,
             .public_input = 1,
+            .key_hash = 2,
             .input_aggregation_object = {},
             .output_aggregation_object = output_vars,
         };
 
-        //     {
-        //   std::vector<fr> witness;
-        //     for (size_t i = 0; i < 17; ++i) {
-        //         witness.emplace_back(0);
-        //     }
-        //     for (const auto& wit : proof_witnesses) {
-        //         witness.emplace_back(wit);
-        //     }
-        //     for (const auto& wit : key_witnesses) {
-        //         witness.emplace_back(wit);
-        //     }
-
-        //             acir_format::acir_format constraint_system{
-        //         .varnum = static_cast<uint32_t>(witness.size() + 1),
-        //         .public_inputs = { 1 },
-        //         .fixed_base_scalar_mul_constraints = {},
-        //         .logic_constraints = {},
-        //         .range_constraints = {},
-        //         .schnorr_constraints = {},
-        //         .ecdsa_constraints = {},
-        //         .sha256_constraints = {},
-        //         .blake2s_constraints = {},
-        //         .hash_to_field_constraints = {},
-        //         .pedersen_constraints = {},
-        //         .merkle_membership_constraints = {},
-        //         .recursion_constraints = { recursion_constraint },
-        //         .constraints = {},
-        //     };
-        //         auto composer = acir_format::create_circuit_with_witness(constraint_system, witness);
-        // auto prover = composer.create_prover();
-
-        // auto proof = prover.construct_proof();
-        // auto verifier = composer.create_verifier();
-        // EXPECT_EQ(verifier.verify_proof(proof), true);
-
-        // EXPECT_EQ(composer.get_variable(1), 10);
-
-        //     }
+        // Add a constraint that fixes the vk hash to be the expected value!
+        poly_triple vk_equality_constraint{
+            .a = recursion_constraint.key_hash,
+            .b = 0,
+            .c = 0,
+            .q_m = 0,
+            .q_l = 1,
+            .q_r = 0,
+            .q_o = 0,
+            .q_c = -vk_hash_value,
+        };
+
         std::vector<fr> witness;
-        for (size_t i = 0; i < 17; ++i) {
+        for (size_t i = 0; i < 18; ++i) {
             witness.emplace_back(0);
         }
         for (const auto& wit : proof_witnesses) {
@@ -289,7 +268,7 @@ TEST(AcirProofs, TestSerializationWithRecursion)
             .pedersen_constraints = {},
             .merkle_membership_constraints = {},
             .recursion_constraints = { recursion_constraint },
-            .constraints = {},
+            .constraints = { vk_equality_constraint },
         };
 
         std::vector<uint8_t> witness_buf;
@@ -322,5 +301,13 @@ TEST(AcirProofs, TestSerializationWithRecursion)
         bool verified = acir_proofs::verify_proof(
             &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
         EXPECT_EQ(verified, true);
+
+        delete pippenger_ptr_base;
+        free((void*)vk_buf);
+        free((void*)pk_buf);
+        free((void*)proof_data_buf);
+        free((void*)proof_data_fields);
+        free((void*)vk_fields);
+        free((void*)vk_hash_buf);
     }
 }
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
index d355e6fc7e..743f563770 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
@@ -218,6 +218,15 @@ std::vector<barretenberg::fr> verification_key::export_key_in_recursion_format()
         }
     }
 
+    verification_key_data vkey_data{
+        .composer_type = composer_type,
+        .circuit_size = static_cast<uint32_t>(circuit_size),
+        .num_public_inputs = static_cast<uint32_t>(num_public_inputs),
+        .commitments = commitments,
+        .contains_recursive_proof = contains_recursive_proof,
+        .recursive_proof_public_input_indices = recursive_proof_public_input_indices,
+    };
+    output.emplace_back(vkey_data.compress_native(0)); // key_hash
     return output;
 }
 
@@ -262,6 +271,7 @@ std::vector<barretenberg::fr> verification_key::export_dummy_key_in_recursion_fo
             output.emplace_back(y_hi);
         }
     }
+    output.emplace_back(0); // key_hash
 
     return output;
 }
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
index b841491bfd..a99325cc86 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
@@ -192,29 +192,6 @@ aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
     return verify_proof_<Curve, program_settings>(context, key, transcript, previous_output);
 }
 
-/**
- * Refer to src/barretenberg/plonk/proof_system/verifier/verifier.cpp verify_proof() for the native implementation,
- * which includes detailed comments.
- */
-template <typename Curve, typename program_settings, bool inner_proof_contains_recursive_proof>
-aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
-                                      const transcript::Manifest& manifest,
-                                      const std::vector<typename Curve::fr_ct>& key,
-                                      const std::vector<typename Curve::fr_ct>& proof,
-                                      const aggregation_state<Curve> previous_output = aggregation_state<Curve>())
-{
-    using Composer = typename Curve::Composer;
-
-    std::shared_ptr<verification_key<Curve>> vkey =
-        verification_key<Curve>::template from_field_pt_vector<inner_proof_contains_recursive_proof>(context, key);
-    vkey->program_width = program_settings::program_width;
-
-    const size_t num_public_inputs = static_cast<size_t>(uint256_t(vkey->num_public_inputs.get_value()).data[0]);
-    Transcript<Composer> transcript = Transcript<Composer>(context, manifest, proof, num_public_inputs);
-
-    return verify_proof_<Curve, program_settings>(context, vkey, transcript, previous_output);
-}
-
 /**
  * Refer to src/barretenberg/plonk/proof_system/verifier/verifier.cpp verify_proof() for the native implementation,
  * which includes detailed comments.

From 6496228698d9cfb1ac2eebc28518f495096bf3e3 Mon Sep 17 00:00:00 2001
From: zac-williamson <blorktronics@gmail.com>
Date: Tue, 18 Apr 2023 20:13:47 +0200
Subject: [PATCH 08/64] fixed compiler errors in stdlib_recursion_tests

---
 .../dsl/acir_format/recursion_constraint.hpp  |  2 +-
 .../recursion/verifier/verifier.test.cpp      | 22 +++++++++++++------
 .../verifier/verifier_turbo.test.cpp          | 20 ++++++++++++-----
 3 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index 3a24727d01..45abd037c2 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -26,7 +26,7 @@ namespace acir_format {
  * @param output_aggregation_object Witness indecies of the aggregation object produced by recursive verification
  *
  * @note If input_aggregation_object witness indices are all zero, we interpret this to mean that the inner proof does
- * NOT contai
+ * NOT contain
  */
 struct RecursionConstraint {
     static constexpr size_t AGGREGATION_OBJECT_SIZE = 16; // 16 field elements
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
index 82e8042b02..ad28907bfb 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
@@ -277,6 +277,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
   public:
     static void test_recursive_proof_composition()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
         InnerComposer inner_composer = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
         std::vector<barretenberg::fr> inner_inputs{ barretenberg::fr::random_element(),
@@ -294,7 +295,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs[1]);
@@ -326,6 +327,8 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
     static void test_recursive_proof_composition_ultra_no_tables()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+
         InnerComposer inner_composer = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
 
@@ -342,7 +345,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -375,6 +378,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             return; // We only care about running this test for turbo and ultra outer circuits, since in practice the
                     // only circuits which verify >1 proof are ultra or turbo circuits. Standard uses so many gates
                     // (16m) that it's a waste of time testing it.
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
 
         InnerComposer inner_composer_a = InnerComposer("../srs_db/ignition");
         InnerComposer inner_composer_b = InnerComposer("../srs_db/ignition");
@@ -396,7 +400,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs[1]);
@@ -434,6 +438,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         std::vector<barretenberg::fr> inner_inputs_b{ barretenberg::fr::random_element(),
                                                       barretenberg::fr::random_element(),
                                                       barretenberg::fr::random_element() };
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
 
         create_inner_circuit(inner_composer_a, inner_inputs_a);
         create_alternate_inner_circuit(inner_composer_b, inner_inputs_b);
@@ -447,7 +452,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_a[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_a[1]);
@@ -487,6 +492,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         auto circuit_output =
             create_outer_circuit_with_variable_inner_circuit(inner_composer_a, inner_composer_b, outer_composer, false);
         g1::affine_element P[2];
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
 
         P[0].x = barretenberg::fq(circuit_output.aggregation_state.P0.x.get_value().lo);
         P[0].y = barretenberg::fq(circuit_output.aggregation_state.P0.y.get_value().lo);
@@ -494,7 +500,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_b[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_b[1]);
@@ -529,6 +535,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
         create_inner_circuit(inner_composer_a, inner_inputs_a);
         create_alternate_inner_circuit(inner_composer_b, inner_inputs_b);
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
 
         auto circuit_output = create_outer_circuit_with_variable_inner_circuit(
             inner_composer_a, inner_composer_b, outer_composer, true, true);
@@ -539,7 +546,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_a[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_a[1]);
@@ -561,6 +568,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
     static void test_recursive_proof_composition_with_constant_verification_key()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
         InnerComposer inner_composer_a = InnerComposer("../srs_db/ignition");
         InnerComposer inner_composer_b = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
@@ -584,7 +592,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_a[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_a[1]);
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier_turbo.test.cpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier_turbo.test.cpp
index 1f4410148b..fee90bd030 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier_turbo.test.cpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier_turbo.test.cpp
@@ -165,6 +165,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
   public:
     static void test_recursive_proof_composition()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
         InnerComposer inner_composer = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
         std::vector<barretenberg::fr> inner_inputs{ barretenberg::fr::random_element(),
@@ -181,7 +182,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs[1]);
@@ -209,6 +210,8 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
 
     static void test_double_verification()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+
         if constexpr (std::is_same<OuterComposer, plonk::StandardComposer>::value)
             return; // We only care about running this test for turbo and ultra outer circuits, since in practice the
                     // only circuits which verify >1 proof are ultra or turbo circuits. Standard uses so many gates
@@ -234,7 +237,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs[1]);
@@ -262,6 +265,8 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
     // variable circuits
     static void test_recursive_proof_composition_with_variable_verification_key_a()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+
         InnerComposer inner_composer_a = InnerComposer("../srs_db/ignition");
         InnerComposer inner_composer_b = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
@@ -285,7 +290,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_a[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_a[1]);
@@ -309,6 +314,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
     // variable circuits
     static void test_recursive_proof_composition_with_variable_verification_key_b()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
         InnerComposer inner_composer_a = InnerComposer("../srs_db/ignition");
         InnerComposer inner_composer_b = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
@@ -332,7 +338,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_b[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_b[1]);
@@ -354,6 +360,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
 
     static void test_recursive_proof_composition_with_variable_verification_key_failure_case()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
         InnerComposer inner_composer_a = InnerComposer("../srs_db/ignition");
         InnerComposer inner_composer_b = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
@@ -377,7 +384,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_a[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_a[1]);
@@ -399,6 +406,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
 
     static void test_recursive_proof_composition_with_constant_verification_key()
     {
+        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
         InnerComposer inner_composer_a = InnerComposer("../srs_db/ignition");
         InnerComposer inner_composer_b = InnerComposer("../srs_db/ignition");
         OuterComposer outer_composer = OuterComposer("../srs_db/ignition");
@@ -422,7 +430,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
+            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[0].get_value(), inner_inputs_a[0]);
         EXPECT_EQ(circuit_output.aggregation_state.public_inputs[1].get_value(), inner_inputs_a[1]);

From 5f21e220586ada20a376684b6e52cd6d5d4be90b Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 25 Apr 2023 14:14:03 +0100
Subject: [PATCH 09/64] feat(dsl)!: Noir recursion updates (#379)

* merge master in zw/noir-recursion

* add dsl files to commit

* namespace stuff and debugging

* c bind functions

* constraint test and comment removal

* revert some changes to RecursionConstraint while debugging serialization issues

* dispaly error when trying to use create_circuit_with_witness

* is_recursive flag as part of new_proof and verify_proof, new RecursiveProver type in dsl, and serialization changes for recursion acir_proofs methods

* remove debug output from TestSerializationWithRecursion
---
 cpp/CMakeLists.txt                            |    8 +-
 .../crypto/generators/generator_data.cpp      |   10 +-
 .../dsl/acir_format/acir_format.cpp           |    3 +-
 .../dsl/acir_format/acir_format.hpp           |   23 +-
 .../dsl/acir_format/acir_format.test.cpp      |   52 +-
 .../dsl/acir_format/blake2s_constraint.cpp    |    2 -
 .../dsl/acir_format/blake2s_constraint.hpp    |    4 +-
 .../dsl/acir_format/ecdsa_secp256k1.cpp       |    4 +-
 .../dsl/acir_format/ecdsa_secp256k1.hpp       |    4 +-
 .../dsl/acir_format/ecdsa_secp256k1.test.cpp  |    4 +-
 .../dsl/acir_format/fixed_base_scalar_mul.cpp |    2 -
 .../dsl/acir_format/fixed_base_scalar_mul.hpp |    4 +-
 .../dsl/acir_format/hash_to_field.cpp         |    6 +-
 .../dsl/acir_format/hash_to_field.hpp         |    4 +-
 .../dsl/acir_format/logic_constraint.cpp      |    4 +-
 .../dsl/acir_format/logic_constraint.hpp      |   13 +-
 .../merkle_membership_constraint.cpp          |    7 +-
 .../merkle_membership_constraint.hpp          |    5 +-
 .../barretenberg/dsl/acir_format/pedersen.cpp |    9 +-
 .../barretenberg/dsl/acir_format/pedersen.hpp |    4 +-
 .../dsl/acir_format/recursion_constraint.cpp  |   19 +-
 .../dsl/acir_format/recursion_constraint.hpp  |   19 +-
 .../acir_format/recursion_constraint.test.cpp |   10 +-
 .../dsl/acir_format/schnorr_verify.cpp        |    9 +-
 .../dsl/acir_format/schnorr_verify.hpp        |    4 +-
 .../dsl/acir_format/sha256_constraint.cpp     |    3 +-
 .../dsl/acir_format/sha256_constraint.hpp     |    4 +-
 .../dsl/acir_proofs/acir_proofs.cpp           |  106 +-
 .../dsl/acir_proofs/acir_proofs.hpp           |   11 +-
 .../dsl/acir_proofs/acir_proofs.test.cpp      |   40 +-
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   |   32 +-
 .../barretenberg/dsl/acir_proofs/c_bind.hpp   |   18 +-
 cpp/src/barretenberg/dsl/types.hpp            |   74 ++
 cpp/src/barretenberg/ecc/fields/field.hpp     |    4 +
 .../standard_honk_composer_helper.cpp         |    1 +
 .../ultra_honk_composer_helper.cpp            |  356 ++++++
 .../ultra_honk_composer_helper.hpp            |   72 ++
 .../composer/standard_honk_composer.test.cpp  |  103 --
 .../honk/composer/ultra_honk_composer.hpp     |  470 ++++++++
 .../composer/ultra_honk_composer.test.cpp     | 1036 +++++++++++++++++
 cpp/src/barretenberg/honk/flavor/flavor.hpp   |   56 +-
 .../honk/proof_system/prover_library.cpp      |   10 +-
 .../honk/proof_system/prover_library.test.cpp |   34 +-
 .../honk/proof_system/ultra_prover.cpp        |   56 +
 .../honk/proof_system/ultra_prover.hpp        |   63 +
 .../honk/proof_system/verifier.cpp            |    1 -
 .../honk/proof_system/verifier.test.cpp       |    1 -
 .../grand_product_computation_relation.hpp    |   87 ++
 .../grand_product_initialization_relation.hpp |   44 +
 .../honk/sumcheck/relations/relation.hpp      |    1 -
 ...test.cpp => relation_consistency.test.cpp} |  232 +++-
 .../relations/relation_correctness.test.cpp   |  258 ++++
 .../relations/ultra_arithmetic_relation.hpp   |   87 ++
 .../ultra_arithmetic_relation_secondary.hpp   |   67 ++
 .../proofs/join_split/c_bind.cpp              |   32 +-
 .../join_split/compute_circuit_data.cpp       |    3 +-
 .../proofs/join_split/join_split.cpp          |   16 +-
 .../proofs/join_split/join_split.hpp          |    5 +-
 .../proofs/join_split/join_split.test.cpp     |   22 +-
 .../proofs/join_split/join_split_circuit.cpp  |   17 +-
 .../proofs/join_split/join_split_circuit.hpp  |   13 +-
 .../proofs/join_split/join_split_tx.hpp       |    8 +-
 .../proofs/mock/mock_circuit.test.cpp         |    4 +-
 .../notes/circuit/account/account_note.hpp    |    5 +-
 .../proofs/notes/circuit/account/commit.hpp   |    6 +-
 .../proofs/notes/circuit/asset_id.cpp         |    4 +-
 .../proofs/notes/circuit/asset_id.hpp         |    4 +-
 .../proofs/notes/circuit/bridge_call_data.hpp |    4 +-
 .../proofs/notes/circuit/claim/claim_note.hpp |    5 +-
 .../claim/complete_partial_commitment.hpp     |    5 +-
 .../notes/circuit/claim/compute_nullifier.hpp |    5 +-
 .../claim/create_partial_commitment.hpp       |    4 +-
 .../notes/circuit/claim/witness_data.hpp      |    5 +-
 .../value/complete_partial_commitment.hpp     |    6 +-
 .../notes/circuit/value/compute_nullifier.cpp |    4 +-
 .../notes/circuit/value/compute_nullifier.hpp |    5 +-
 .../circuit/value/compute_nullifier.test.cpp  |    6 +-
 .../value/create_partial_commitment.hpp       |    6 +-
 .../proofs/notes/circuit/value/value_note.hpp |    4 +-
 .../notes/circuit/value/value_note.test.cpp   |    8 +-
 .../notes/circuit/value/witness_data.hpp      |    5 +-
 .../barretenberg/join_split_example/types.hpp |   50 +
 .../plonk/composer/ultra_composer.cpp         |   58 +
 .../plonk/composer/ultra_composer.hpp         |    3 +
 .../plonk/composer/ultra_composer.test.cpp    |  256 ++--
 .../kate_commitment_scheme.cpp                |    1 +
 .../kate_commitment_scheme.hpp                |    1 +
 .../plonk/proof_system/constants.hpp          |   12 +-
 .../plonk/proof_system/prover/c_bind.cpp      |    5 +-
 .../proof_system/prover/c_bind_unrolled.cpp   |  110 --
 .../plonk/proof_system/prover/prover.cpp      |    2 +
 .../plonk/proof_system/prover/prover.hpp      |    1 +
 .../types/polynomial_manifest.hpp             |    2 +-
 .../proof_system/types/program_settings.hpp   |   16 +
 .../proof_system/types/prover_settings.hpp    |    8 +
 .../verification_key.test.cpp                 |   27 +-
 .../plonk/proof_system/verifier/verifier.cpp  |    1 +
 .../plonk/proof_system/verifier/verifier.hpp  |    3 +-
 .../composer/permutation_helper.hpp           |   54 +-
 .../encryption/schnorr/schnorr.test.cpp       |   45 +-
 .../stdlib/hash/blake2s/blake2s.test.cpp      |   32 +-
 .../stdlib/hash/sha256/sha256.bench.cpp       |   18 +-
 .../stdlib/hash/sha256/sha256.test.cpp        |   88 +-
 .../barretenberg/stdlib/merkle_tree/hash.hpp  |   24 +-
 .../stdlib/merkle_tree/hash.test.cpp          |   30 +-
 .../stdlib/merkle_tree/membership.test.cpp    |   42 +-
 .../stdlib/merkle_tree/merkle_tree.test.cpp   |   12 +-
 .../primitives/biggroup/biggroup.test.cpp     |    1 -
 .../primitives/byte_array/byte_array.test.cpp |    3 +-
 .../stdlib/primitives/group/group.test.cpp    |    7 +-
 .../packed_byte_array.test.cpp                |   11 +-
 .../primitives/safe_uint/safe_uint.test.cpp   |    4 +-
 .../verification_key.test.cpp                 |   12 +-
 cpp/src/barretenberg/stdlib/types/types.hpp   |  100 --
 114 files changed, 3775 insertions(+), 1035 deletions(-)
 create mode 100644 cpp/src/barretenberg/dsl/types.hpp
 create mode 100644 cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp
 create mode 100644 cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.hpp
 create mode 100644 cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp
 create mode 100644 cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp
 create mode 100644 cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp
 create mode 100644 cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
 rename cpp/src/barretenberg/honk/sumcheck/relations/{relation.test.cpp => relation_consistency.test.cpp} (57%)
 create mode 100644 cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
 create mode 100644 cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp
 create mode 100644 cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp
 create mode 100644 cpp/src/barretenberg/join_split_example/types.hpp
 delete mode 100644 cpp/src/barretenberg/plonk/proof_system/prover/c_bind_unrolled.cpp
 delete mode 100644 cpp/src/barretenberg/stdlib/types/types.hpp

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 582d728537..4f719a0335 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -22,14 +22,8 @@ option(SERIALIZE_CANARY "Build with serialize canary" OFF)
 option(ENABLE_ASAN "Address sanitizer for debugging tricky memory corruption" OFF)
 option(ENABLE_HEAVY_TESTS "Enable heavy tests when collecting coverage" OFF)
 option(INSTALL_BARRETENBERG "Enable installation of barretenberg. (Projects embedding barretenberg may want to turn this OFF.)" ON)
-option(USE_TURBO "Enable the use of TurboPlonk in barretenberg." OFF)
 
-if(USE_TURBO)
-    message(STATUS "Building barretenberg for TurboPlonk Composer.")
-    add_definitions(-DUSE_TURBO)
-else()
-    message(STATUS "Building barretenberg for UltraPlonk Composer.")
-endif()
+message(STATUS "Building barretenberg for UltraPlonk Composer.")
 
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
     message(STATUS "Compiling for ARM.")
diff --git a/cpp/src/barretenberg/crypto/generators/generator_data.cpp b/cpp/src/barretenberg/crypto/generators/generator_data.cpp
index 7970dfe659..1ad6127923 100644
--- a/cpp/src/barretenberg/crypto/generators/generator_data.cpp
+++ b/cpp/src/barretenberg/crypto/generators/generator_data.cpp
@@ -6,18 +6,14 @@ namespace {
 
 // The number of unique base points with default main index with precomputed ladders
 #ifdef __wasm__
-constexpr size_t num_default_generators = 64;
-constexpr size_t num_generators_per_hash_index = 16;
-constexpr size_t num_hash_indices = 32;
-// TODO need to resolve memory out of bounds when these are too high
+constexpr size_t num_default_generators = 32;
 #else
 constexpr size_t num_default_generators = 2048;
-constexpr size_t num_hash_indices = 32;
-constexpr size_t num_generators_per_hash_index = 128;
 #endif
 
 constexpr size_t hash_indices_generator_offset = 2048;
-
+constexpr size_t num_hash_indices = 16;
+constexpr size_t num_generators_per_hash_index = 8;
 constexpr size_t num_indexed_generators = num_hash_indices * num_generators_per_hash_index;
 constexpr size_t size_of_generator_data_array = hash_indices_generator_offset + num_indexed_generators;
 constexpr size_t num_generator_types = 3;
diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
index 65313934a6..e4f524869c 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
@@ -1,8 +1,6 @@
 #include "acir_format.hpp"
 #include "barretenberg/common/log.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
 void read_witness(Composer& composer, std::vector<barretenberg::fr> witness)
@@ -114,6 +112,7 @@ Composer create_circuit(const acir_format& constraint_system,
             composer.add_variable(0);
         }
     }
+
     // Add arithmetic gates
     for (const auto& constraint : constraint_system.constraints) {
         composer.create_poly_gate(constraint);
diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
index 950de43460..39940e7f3a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
@@ -10,7 +10,7 @@
 #include "recursion_constraint.hpp"
 #include "pedersen.hpp"
 #include "hash_to_field.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -39,23 +39,20 @@ struct acir_format {
     friend bool operator==(acir_format const& lhs, acir_format const& rhs) = default;
 };
 
-void read_witness(plonk::stdlib::types::Composer& composer, std::vector<barretenberg::fr> witness);
+void read_witness(Composer& composer, std::vector<barretenberg::fr> witness);
 
-void create_circuit(plonk::stdlib::types::Composer& composer, const acir_format& constraint_system);
+void create_circuit(Composer& composer, const acir_format& constraint_system);
 
-plonk::stdlib::types::Composer create_circuit(const acir_format& constraint_system,
-                                              std::unique_ptr<proof_system::ReferenceStringFactory>&& crs_factory);
+Composer create_circuit(const acir_format& constraint_system,
+                        std::unique_ptr<proof_system::ReferenceStringFactory>&& crs_factory);
 
-plonk::stdlib::types::Composer create_circuit_with_witness(const acir_format& constraint_system,
-                                                           std::vector<fr> witness,
-                                                           std::unique_ptr<ReferenceStringFactory>&& crs_factory);
+Composer create_circuit_with_witness(const acir_format& constraint_system,
+                                     std::vector<fr> witness,
+                                     std::unique_ptr<ReferenceStringFactory>&& crs_factory);
 
-plonk::stdlib::types::Composer create_circuit_with_witness(const acir_format& constraint_system,
-                                                           std::vector<fr> witness);
+Composer create_circuit_with_witness(const acir_format& constraint_system, std::vector<fr> witness);
 
-void create_circuit_with_witness(plonk::stdlib::types::Composer& composer,
-                                 const acir_format& constraint_system,
-                                 std::vector<fr> witness);
+void create_circuit_with_witness(Composer& composer, const acir_format& constraint_system, std::vector<fr> witness);
 
 // Serialisation
 template <typename B> inline void read(B& buf, acir_format& data)
diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
index ff957c6b9b..5c17c353c1 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
@@ -4,6 +4,46 @@
 #include <vector>
 #include "barretenberg/common/streams.hpp"
 
+TEST(acir_format, test_a_single_constraint_no_pub_inputs)
+{
+
+    poly_triple constraint{
+        .a = 1,
+        .b = 2,
+        .c = 3,
+        .q_m = 0,
+        .q_l = 1,
+        .q_r = 1,
+        .q_o = -1,
+        .q_c = 0,
+    };
+
+    acir_format::acir_format constraint_system{
+        .varnum = 4,
+        .public_inputs = {},
+        .fixed_base_scalar_mul_constraints = {},
+        .logic_constraints = {},
+        .range_constraints = {},
+        .schnorr_constraints = {},
+        .ecdsa_constraints = {},
+        .sha256_constraints = {},
+        .blake2s_constraints = {},
+        .hash_to_field_constraints = {},
+        .pedersen_constraints = {},
+        .merkle_membership_constraints = {},
+        .constraints = { constraint },
+    };
+
+    auto composer = acir_format::create_circuit_with_witness(constraint_system, { 0, 0, 1 });
+
+    auto prover = composer.create_ultra_with_keccak_prover();
+    auto proof = prover.construct_proof();
+
+    auto verifier = composer.create_ultra_with_keccak_verifier();
+
+    EXPECT_EQ(verifier.verify_proof(proof), false);
+}
+
 TEST(acir_format, test_logic_gate_from_noir_circuit)
 {
     /**
@@ -105,10 +145,10 @@ TEST(acir_format, test_logic_gate_from_noir_circuit)
 
     std::cout << "made composer" << std::endl;
 
-    auto prover = composer.create_prover();
+    auto prover = composer.create_ultra_with_keccak_prover();
     auto proof = prover.construct_proof();
 
-    auto verifier = composer.create_verifier();
+    auto verifier = composer.create_ultra_with_keccak_verifier();
 
     EXPECT_EQ(verifier.verify_proof(proof), true);
 }
@@ -174,10 +214,10 @@ TEST(acir_format, test_schnorr_verify_pass)
           67, 16,  37,  128, 85,  76,  19,  253, 30,  77,  192,   53,    138, 205, 69, 33,  236, 163, 83,  194,
           84, 137, 184, 221, 176, 121, 179, 27,  63,  70,  54,    16,    176, 250, 39, 239, 1,   0,   0,   0 });
 
-    auto prover = composer.create_prover();
+    auto prover = composer.create_ultra_with_keccak_prover();
     auto proof = prover.construct_proof();
 
-    auto verifier = composer.create_verifier();
+    auto verifier = composer.create_ultra_with_keccak_verifier();
 
     EXPECT_EQ(verifier.verify_proof(proof), true);
 }
@@ -243,10 +283,10 @@ TEST(acir_format, test_schnorr_verify_small_range)
           67, 16,  37,  128, 85,  76,  19,  253, 30,  77,  192,   53,    138, 205, 69, 33,  236, 163, 83,  194,
           84, 137, 184, 221, 176, 121, 179, 27,  63,  70,  54,    16,    176, 250, 39, 239, 1,   0,   0,   0 });
 
-    auto prover = composer.create_prover();
+    auto prover = composer.create_ultra_with_keccak_prover();
     auto proof = prover.construct_proof();
 
-    auto verifier = composer.create_verifier();
+    auto verifier = composer.create_ultra_with_keccak_verifier();
 
     EXPECT_EQ(verifier.verify_proof(proof), true);
 }
\ No newline at end of file
diff --git a/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.cpp
index 03deb176f6..8cd00269af 100644
--- a/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.cpp
@@ -1,8 +1,6 @@
 #include "blake2s_constraint.hpp"
 #include "round.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
 void create_blake2s_constraints(Composer& composer, const Blake2sConstraint& constraint)
diff --git a/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.hpp
index 643eb1e39b..f68bf2019a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/blake2s_constraint.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include <cstdint>
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -19,7 +19,7 @@ struct Blake2sConstraint {
     friend bool operator==(Blake2sConstraint const& lhs, Blake2sConstraint const& rhs) = default;
 };
 
-void create_blake2s_constraints(plonk::stdlib::types::Composer& composer, const Blake2sConstraint& constraint);
+void create_blake2s_constraints(Composer& composer, const Blake2sConstraint& constraint);
 
 template <typename B> inline void read(B& buf, Blake2sInput& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp
index 291245d3d5..87a873dc16 100644
--- a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.cpp
@@ -2,10 +2,10 @@
 #include "barretenberg/crypto/ecdsa/ecdsa.hpp"
 #include "barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
+using namespace proof_system::plonk;
+
 crypto::ecdsa::signature ecdsa_convert_signature(Composer& composer, std::vector<uint32_t> signature)
 {
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.hpp b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.hpp
index 9fee1b035a..55d8f6c16d 100644
--- a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -28,7 +28,7 @@ struct EcdsaSecp256k1Constraint {
     friend bool operator==(EcdsaSecp256k1Constraint const& lhs, EcdsaSecp256k1Constraint const& rhs) = default;
 };
 
-void create_ecdsa_verify_constraints(plonk::stdlib::types::Composer& composer, const EcdsaSecp256k1Constraint& input);
+void create_ecdsa_verify_constraints(Composer& composer, const EcdsaSecp256k1Constraint& input);
 
 template <typename B> inline void read(B& buf, EcdsaSecp256k1Constraint& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
index 57f9af0a1c..875fc4d589 100644
--- a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
@@ -7,8 +7,8 @@
 #include <gtest/gtest.h>
 #include <vector>
 
-using namespace proof_system::plonk::stdlib::types;
-using curve = stdlib::secp256k1<Composer>;
+using namespace proof_system::plonk;
+using curve = stdlib::secp256k1<acir_format::Composer>;
 
 size_t generate_ecdsa_constraint(acir_format::EcdsaSecp256k1Constraint& ecdsa_constraint,
                                  std::vector<fr>& witness_values)
diff --git a/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.cpp b/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.cpp
index 81251944e6..453ab56f47 100644
--- a/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.cpp
@@ -1,7 +1,5 @@
 #include "fixed_base_scalar_mul.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
 void create_fixed_base_constraint(Composer& composer, const FixedBaseScalarMul& input)
diff --git a/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.hpp b/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.hpp
index 2b61305a5c..80e52e03db 100644
--- a/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/fixed_base_scalar_mul.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <cstdint>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -12,7 +12,7 @@ struct FixedBaseScalarMul {
     friend bool operator==(FixedBaseScalarMul const& lhs, FixedBaseScalarMul const& rhs) = default;
 };
 
-void create_fixed_base_constraint(plonk::stdlib::types::Composer& composer, const FixedBaseScalarMul& input);
+void create_fixed_base_constraint(Composer& composer, const FixedBaseScalarMul& input);
 
 template <typename B> inline void read(B& buf, FixedBaseScalarMul& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/hash_to_field.cpp b/cpp/src/barretenberg/dsl/acir_format/hash_to_field.cpp
index 998b414cd4..afc3e2cf9f 100644
--- a/cpp/src/barretenberg/dsl/acir_format/hash_to_field.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/hash_to_field.cpp
@@ -1,10 +1,10 @@
 #include "hash_to_field.hpp"
 #include "round.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
+using namespace proof_system::plonk;
+
 void create_hash_to_field_constraints(Composer& composer, const HashToFieldConstraint constraint)
 {
 
@@ -30,7 +30,7 @@ void create_hash_to_field_constraints(Composer& composer, const HashToFieldConst
     // Hash To Field using blake2s.
     // Note: It does not need to be blake2s in the future
 
-    byte_array_ct out_bytes = proof_system::plonk::stdlib::blake2s<Composer>(arr);
+    byte_array_ct out_bytes = stdlib::blake2s<Composer>(arr);
 
     field_ct out(out_bytes);
     field_ct normalised_out = out.normalize();
diff --git a/cpp/src/barretenberg/dsl/acir_format/hash_to_field.hpp b/cpp/src/barretenberg/dsl/acir_format/hash_to_field.hpp
index 275ce3fd0d..504493ce3e 100644
--- a/cpp/src/barretenberg/dsl/acir_format/hash_to_field.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/hash_to_field.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include <cstdint>
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -19,7 +19,7 @@ struct HashToFieldConstraint {
     friend bool operator==(HashToFieldConstraint const& lhs, HashToFieldConstraint const& rhs) = default;
 };
 
-void create_hash_to_field_constraints(plonk::stdlib::types::Composer& composer, HashToFieldConstraint constraint);
+void create_hash_to_field_constraints(Composer& composer, HashToFieldConstraint constraint);
 
 template <typename B> inline void read(B& buf, HashToFieldInput& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/logic_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/logic_constraint.cpp
index ca14b7cbc4..09990fe04b 100644
--- a/cpp/src/barretenberg/dsl/acir_format/logic_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/logic_constraint.cpp
@@ -1,10 +1,10 @@
 #include "logic_constraint.hpp"
 #include "barretenberg/stdlib/primitives/logic/logic.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
+using namespace proof_system::plonk;
+
 void create_logic_gate(Composer& composer,
                        const uint32_t a,
                        const uint32_t b,
diff --git a/cpp/src/barretenberg/dsl/acir_format/logic_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/logic_constraint.hpp
index 0a194838ad..964f84f5af 100644
--- a/cpp/src/barretenberg/dsl/acir_format/logic_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/logic_constraint.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <cstdint>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -14,16 +14,11 @@ struct LogicConstraint {
     friend bool operator==(LogicConstraint const& lhs, LogicConstraint const& rhs) = default;
 };
 
-void create_logic_gate(plonk::stdlib::types::Composer& composer,
-                       uint32_t a,
-                       uint32_t b,
-                       uint32_t result,
-                       size_t num_bits,
-                       bool is_xor_gate);
+void create_logic_gate(Composer& composer, uint32_t a, uint32_t b, uint32_t result, size_t num_bits, bool is_xor_gate);
 
-void xor_gate(plonk::stdlib::types::Composer& composer, uint32_t a, uint32_t b, uint32_t result);
+void xor_gate(Composer& composer, uint32_t a, uint32_t b, uint32_t result);
 
-void and_gate(plonk::stdlib::types::Composer& composer, uint32_t a, uint32_t b, uint32_t result);
+void and_gate(Composer& composer, uint32_t a, uint32_t b, uint32_t result);
 
 template <typename B> inline void read(B& buf, LogicConstraint& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.cpp
index 3f30a61fcb..780373f5be 100644
--- a/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.cpp
@@ -1,9 +1,6 @@
 #include "merkle_membership_constraint.hpp"
 #include "barretenberg/stdlib/merkle_tree/membership.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-using namespace proof_system::plonk::stdlib::merkle_tree;
-
 namespace acir_format {
 
 void create_merkle_check_membership_constraint(Composer& composer, const MerkleMembershipConstraint& input)
@@ -22,7 +19,7 @@ void create_merkle_check_membership_constraint(Composer& composer, const MerkleM
     // We are given the HashPath as a Vec<fr>
     // We want to first convert it into a Vec<(fr, fr)> then cast this to hash_path
     // struct which requires the method create_witness_hashpath
-    hash_path<Composer> hash_path;
+    hash_path_ct hash_path;
 
     // In Noir we accept a hash path that only contains one hash per tree level
     // It is ok to reuse the leaf as it will be overridden in check_subtree_membership when computing the current root
@@ -39,7 +36,7 @@ void create_merkle_check_membership_constraint(Composer& composer, const MerkleM
         }
     }
 
-    auto exists = check_subtree_membership(root, hash_path, leaf, index_bits, 0);
+    auto exists = plonk::stdlib::merkle_tree::check_subtree_membership(root, hash_path, leaf, index_bits, 0);
     composer.assert_equal_constant(exists.witness_index, fr::one());
 }
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.hpp
index 1fa1481e88..25bfcd0404 100644
--- a/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/merkle_membership_constraint.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -14,8 +14,7 @@ struct MerkleMembershipConstraint {
     friend bool operator==(MerkleMembershipConstraint const& lhs, MerkleMembershipConstraint const& rhs) = default;
 };
 
-void create_merkle_check_membership_constraint(plonk::stdlib::types::Composer& composer,
-                                               const MerkleMembershipConstraint& input);
+void create_merkle_check_membership_constraint(Composer& composer, const MerkleMembershipConstraint& input);
 
 template <typename B> inline void read(B& buf, MerkleMembershipConstraint& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp b/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp
index 3ac7951ec9..d272a3a8ed 100644
--- a/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp
@@ -1,9 +1,9 @@
 #include "pedersen.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
+using namespace proof_system::plonk;
+
 void create_pedersen_constraint(Composer& composer, const PedersenConstraint& input)
 {
     std::vector<field_ct> scalars;
@@ -13,12 +13,9 @@ void create_pedersen_constraint(Composer& composer, const PedersenConstraint& in
         field_ct scalar_as_field = field_ct::from_witness_index(&composer, scalar);
         scalars.push_back(scalar_as_field);
     }
-#ifdef USE_TURBO
-    auto point = pedersen_commitment::commit(scalars);
-#else
+
     // TODO: Does Noir need additive homomorphic Pedersen hash? If so, using plookup version won't help.
     auto point = stdlib::pedersen_plookup_commitment<Composer>::commit(scalars);
-#endif
 
     composer.assert_equal(point.x.witness_index, input.result_x);
     composer.assert_equal(point.y.witness_index, input.result_y);
diff --git a/cpp/src/barretenberg/dsl/acir_format/pedersen.hpp b/cpp/src/barretenberg/dsl/acir_format/pedersen.hpp
index b801d2a8f2..3144359b2f 100644
--- a/cpp/src/barretenberg/dsl/acir_format/pedersen.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/pedersen.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -13,7 +13,7 @@ struct PedersenConstraint {
     friend bool operator==(PedersenConstraint const& lhs, PedersenConstraint const& rhs) = default;
 };
 
-void create_pedersen_constraint(plonk::stdlib::types::Composer& composer, const PedersenConstraint& input);
+void create_pedersen_constraint(Composer& composer, const PedersenConstraint& input);
 
 template <typename B> inline void read(B& buf, PedersenConstraint& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 895c27f99c..441b47c2d8 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -4,15 +4,10 @@
 #include "barretenberg/stdlib/recursion/verifier/verifier.hpp"
 #include "barretenberg/transcript/transcript_wrappers.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
-using verification_key_ct = proof_system::plonk::stdlib::recursion::verification_key<bn254>;
-using aggregation_state_ct = proof_system::plonk::stdlib::recursion::aggregation_state<bn254>;
-using noir_recursive_settings = proof_system::plonk::stdlib::recursion::recursive_ultra_verifier_settings<bn254>;
-using Transcript_ct = proof_system::plonk::stdlib::recursion::Transcript<Composer>;
-
 namespace acir_format {
 
+using namespace proof_system::plonk;
+
 void generate_dummy_proof() {}
 /**
  * @brief Add constraints required to recursively verify an UltraPlonk proof
@@ -61,8 +56,6 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
             composer.assert_equal(composer.add_variable(dummy_field), key_field_idx);
         }
     }
-    // The env_crs should be ok, we use this when generating the constraint system in dsl
-    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
 
     // Construct an in-circuit representation of the verification key.
     // For now, the v-key is a circuit constant and is fixed for the circuit.
@@ -135,9 +128,9 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 }
 
-template void create_recursion_constraints<false, false>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
-template void create_recursion_constraints<false, true>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
-template void create_recursion_constraints<true, false>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
-template void create_recursion_constraints<true, true>(plonk::stdlib::types::Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<false, false>(Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<false, true>(Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<true, false>(Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<true, true>(Composer&, const RecursionConstraint&);
 
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index 45abd037c2..cfc0116349 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -1,7 +1,8 @@
 #pragma once
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
-#include "barretenberg/plonk/proof_system//verification_key/verification_key.hpp"
+// #include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
 
 namespace acir_format {
 
@@ -41,16 +42,12 @@ struct RecursionConstraint {
 };
 
 template <bool has_valid_witness_assignment = false, bool inner_proof_contains_recursive_proof = false>
-void create_recursion_constraints(plonk::stdlib::types::Composer& composer, const RecursionConstraint& input);
+void create_recursion_constraints(Composer& composer, const RecursionConstraint& input);
 
-extern template void create_recursion_constraints<false, false>(plonk::stdlib::types::Composer&,
-                                                                const RecursionConstraint&);
-extern template void create_recursion_constraints<false, true>(plonk::stdlib::types::Composer&,
-                                                               const RecursionConstraint&);
-extern template void create_recursion_constraints<true, false>(plonk::stdlib::types::Composer&,
-                                                               const RecursionConstraint&);
-extern template void create_recursion_constraints<true, true>(plonk::stdlib::types::Composer&,
-                                                              const RecursionConstraint&);
+extern template void create_recursion_constraints<false, false>(Composer&, const RecursionConstraint&);
+extern template void create_recursion_constraints<false, true>(Composer&, const RecursionConstraint&);
+extern template void create_recursion_constraints<true, false>(Composer&, const RecursionConstraint&);
+extern template void create_recursion_constraints<true, true>(Composer&, const RecursionConstraint&);
 
 template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index cfd564f7f6..2b23dcfa07 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -6,9 +6,9 @@
 #include <gtest/gtest.h>
 #include <vector>
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk;
 
-Composer create_inner_circuit()
+acir_format::Composer create_inner_circuit()
 {
     /**
      * constraints produced by Noir program:
@@ -127,8 +127,10 @@ TEST(RecursionConstraint, TestRecursionConstraint)
         output_vars[i] = (static_cast<uint32_t>(i + 3));
     }
 
-    transcript::StandardTranscript transcript(
-        inner_proof.proof_data, Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
+    transcript::StandardTranscript transcript(inner_proof.proof_data,
+                                              acir_format::Composer::create_manifest(1),
+                                              transcript::HashType::PlookupPedersenBlake3s,
+                                              16);
 
     const std::vector<barretenberg::fr> proof_witnesses = transcript.export_transcript_in_recursion_format();
     const std::vector<barretenberg::fr> key_witnesses = inner_verifier.key->export_key_in_recursion_format();
diff --git a/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.cpp b/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.cpp
index f92176bd08..cb717ed99a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.cpp
@@ -1,10 +1,11 @@
 #include "schnorr_verify.hpp"
+#include "barretenberg/stdlib/encryption/schnorr/schnorr.hpp"
 #include "barretenberg/crypto/schnorr/schnorr.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_format {
 
+using namespace proof_system::plonk::stdlib;
+
 crypto::schnorr::signature convert_signature(Composer& composer, std::vector<uint32_t> signature)
 {
 
@@ -82,9 +83,9 @@ void create_schnorr_verify_constraints(Composer& composer, const SchnorrConstrai
 
     point_ct pub_key{ witness_ct(&composer, pubkey_value_x), witness_ct(&composer, pubkey_value_y) };
 
-    schnorr::signature_bits sig = stdlib::schnorr::convert_signature(&composer, new_sig);
+    schnorr_signature_bits_ct sig = schnorr::convert_signature(&composer, new_sig);
 
-    bool_ct signature_result = stdlib::schnorr::signature_verification_result(message, pub_key, sig);
+    bool_ct signature_result = schnorr::signature_verification_result(message, pub_key, sig);
 
     bool_ct signature_result_normalized = signature_result.normalize();
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.hpp b/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.hpp
index f8e6b9c53f..7b6b984294 100644
--- a/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/schnorr_verify.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -25,7 +25,7 @@ struct SchnorrConstraint {
     friend bool operator==(SchnorrConstraint const& lhs, SchnorrConstraint const& rhs) = default;
 };
 
-void create_schnorr_verify_constraints(plonk::stdlib::types::Composer& composer, const SchnorrConstraint& input);
+void create_schnorr_verify_constraints(Composer& composer, const SchnorrConstraint& input);
 
 template <typename B> inline void read(B& buf, SchnorrConstraint& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.cpp
index e54697d4e7..07c8166bd1 100644
--- a/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.cpp
@@ -1,8 +1,7 @@
 #include "sha256_constraint.hpp"
 #include "round.hpp"
 #include "barretenberg/stdlib/hash/sha256/sha256.hpp"
-
-using namespace proof_system::plonk::stdlib::types;
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.hpp
index dec3bca40a..eccb1521ab 100644
--- a/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include <cstdint>
 #include <vector>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 
 namespace acir_format {
 
@@ -21,7 +21,7 @@ struct Sha256Constraint {
 
 // This function does not work (properly) because the stdlib:sha256 function is not working correctly for 512 bits
 // pair<witness_index, bits>
-void create_sha256_constraints(plonk::stdlib::types::Composer& composer, const Sha256Constraint& constraint);
+void create_sha256_constraints(Composer& composer, const Sha256Constraint& constraint);
 
 template <typename B> inline void read(B& buf, Sha256Input& constraint)
 {
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 4d01512eca..4580792808 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -2,12 +2,10 @@
 #include "acir_proofs.hpp"
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
 #include "barretenberg/dsl/acir_format/acir_format.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/dsl/types.hpp"
 #include "barretenberg/srs/reference_string/pippenger_reference_string.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/sol_gen.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
-
 namespace acir_proofs {
 
 size_t get_solidity_verifier(uint8_t const* g2x, uint8_t const* vk_buf, uint8_t** output_buf)
@@ -79,9 +77,9 @@ size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const*
         reinterpret_cast<scalar_multiplication::Pippenger*>(pippenger), g2x);
     proving_key->reference_string = crs_factory->get_prover_crs(proving_key->circuit_size);
 
-    Composer composer(proving_key, nullptr);
+    acir_format::Composer composer(proving_key, nullptr);
     auto verification_key =
-        plonk::stdlib::types::Composer::compute_verification_key_base(proving_key, crs_factory->get_verifier_crs());
+        acir_format::Composer::compute_verification_key_base(proving_key, crs_factory->get_verifier_crs());
 
     // The composer_type has not yet been set. We need to set the composer_type for when we later read in and
     // construct the verification key so that we have the correct polynomial manifest
@@ -110,25 +108,18 @@ size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
     plonk::proof proof = { std::vector<uint8_t>(proof_data_buf, &proof_data_buf[proof_data_length]) };
 
     transcript::StandardTranscript transcript(
-        proof.proof_data, Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
+        proof.proof_data, acir_format::Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
 
     std::vector<barretenberg::fr> output = transcript.export_transcript_in_recursion_format();
 
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
     const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr);
     auto raw_buf = (uint8_t*)malloc(output_size_bytes);
-    // NOTE: currently we dump the fr values into memory in Mongtomery form
-    // This is so we don't have to re-convert into Montgomery form when we read these back in.
-    // I think this makes it easier to handle the data in barretenberg-sys / aztec-backend.
-    // If this is not the case, the commented out serialize code will convert out of Montgomery form before writing to
-    // the buffer
-    // for (size_t i = 0; i < output.size(); ++i) {
-    //     barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
-    // }
-    // for (size_t i = 0; i < output.size(); ++i) {
-    //     barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
-    // }
-    memcpy(raw_buf, (void*)output.data(), output_size_bytes);
+
+    // The serialization code below will convert out of Montgomery form before writing to the buffer
+    for (size_t i = 0; i < output.size(); ++i) {
+        barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
+    }
     *serialized_proof_data_buf = raw_buf;
 
     return output_size_bytes;
@@ -158,23 +149,17 @@ size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
     // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o
     const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr) - 32;
     auto raw_buf = (uint8_t*)malloc(output_size_bytes);
-    // NOTE: currently we dump the fr values into memory in Mongtomery form
-    // This is so we don't have to re-convert into Montgomery form when we read these back in.
-    // I think this makes it easier to handle the data in barretenberg-sys / aztec-backend.
-    // If this is not the case, the commented out serialize code will convert out of Montgomery form before writing to
-    // the buffer
-    // for (size_t i = 0; i < output.size(); ++i) {
-    //     barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
-    // }
-
-    // copy all but the vkey hash into raw_buf
-    memcpy(raw_buf, (void*)output.data(), output_size_bytes);
+
+    // The serialization code below will convert out of Montgomery form before writing to the buffer
+    for (size_t i = 0; i < output.size(); ++i) {
+        barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
+    }
+
+    // copy the vkey into serialized_vk_buf
     *serialized_vk_buf = raw_buf;
 
-    // copy the vkey hash into vk_hash_raw_buf
-    auto vk_hash_raw_buf = (uint8_t*)malloc(32);
-    memcpy(vk_hash_raw_buf, (void*)&output[output.size() - 1], 32);
-    *serialized_vk_hash_buf = vk_hash_raw_buf;
+    // copy the vkey hash into serialized_vk_hash_buf
+    *serialized_vk_hash_buf = &raw_buf[(output.size() - 1) * 32];
 
     return output_size_bytes;
 }
@@ -184,7 +169,8 @@ size_t new_proof(void* pippenger,
                  uint8_t const* pk_buf,
                  uint8_t const* constraint_system_buf,
                  uint8_t const* witness_buf,
-                 uint8_t** proof_data_buf)
+                 uint8_t** proof_data_buf,
+                 bool is_recursive)
 {
     auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
 
@@ -199,21 +185,33 @@ size_t new_proof(void* pippenger,
         reinterpret_cast<scalar_multiplication::Pippenger*>(pippenger), g2x);
     proving_key->reference_string = crs_factory->get_prover_crs(proving_key->circuit_size);
 
-    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
-
-    auto composer = acir_format::create_circuit_with_witness(constraint_system, witness);
-
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
-    auto heapProver = new stdlib::types::Prover(std::move(prover));
-    auto& proof_data = heapProver->construct_proof().proof_data;
-    *proof_data_buf = proof_data.data();
-
-    return proof_data.size();
+    // TODO: either need a context flag for recursive proofs or a new_recursive_proof method that uses regular
+    // UltraProver
+    acir_format::Composer composer(proving_key, nullptr);
+
+    create_circuit_with_witness(composer, constraint_system, witness);
+
+    if (is_recursive) {
+        auto prover = composer.create_prover();
+        auto heapProver = new acir_format::RecursiveProver(std::move(prover));
+        auto& proof_data = heapProver->construct_proof().proof_data;
+        *proof_data_buf = proof_data.data();
+        return proof_data.size();
+    } else {
+        auto prover = composer.create_ultra_with_keccak_prover();
+        auto heapProver = new acir_format::Prover(std::move(prover));
+        auto& proof_data = heapProver->construct_proof().proof_data;
+        *proof_data_buf = proof_data.data();
+        return proof_data.size();
+    }
 }
 
-bool verify_proof(
-    uint8_t const* g2x, uint8_t const* vk_buf, uint8_t const* constraint_system_buf, uint8_t* proof, uint32_t length)
+bool verify_proof(uint8_t const* g2x,
+                  uint8_t const* vk_buf,
+                  uint8_t const* constraint_system_buf,
+                  uint8_t* proof,
+                  uint32_t length,
+                  bool is_recursive)
 {
     bool verified = false;
 
@@ -226,13 +224,21 @@ bool verify_proof(
         read(vk_buf, vk_data);
         auto verification_key = std::make_shared<proof_system::plonk::verification_key>(std::move(vk_data), crs);
 
-        Composer composer(nullptr, verification_key);
+        acir_format::Composer composer(nullptr, verification_key);
         create_circuit(composer, constraint_system);
         plonk::proof pp = { std::vector<uint8_t>(proof, proof + length) };
 
-        auto verifier = composer.create_verifier();
+        // for inner circuit use new prover and verifier method for outer circuit use the normal prover and verifier
+        // TODO: either need a context flag for recursive verify or a new_recursive_verify_proof method that uses
+        // regular UltraVerifier
+        if (is_recursive) {
+            auto verifier = composer.create_verifier();
+            verified = verifier.verify_proof(pp);
+        } else {
+            auto verifier = composer.create_ultra_with_keccak_verifier();
+            verified = verifier.verify_proof(pp);
+        }
 
-        verified = verifier.verify_proof(pp);
 #ifndef __wasm__
     } catch (const std::exception& e) {
         verified = false;
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
index ced41993c3..95556f11a7 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
@@ -20,8 +20,13 @@ size_t new_proof(void* pippenger,
                  uint8_t const* pk_buf,
                  uint8_t const* constraint_system_buf,
                  uint8_t const* witness_buf,
-                 uint8_t** proof_data_buf);
-bool verify_proof(
-    uint8_t const* g2x, uint8_t const* vk_buf, uint8_t const* constraint_system_buf, uint8_t* proof, uint32_t length);
+                 uint8_t** proof_data_buf,
+                 bool is_recursive);
+bool verify_proof(uint8_t const* g2x,
+                  uint8_t const* vk_buf,
+                  uint8_t const* constraint_system_buf,
+                  uint8_t* proof,
+                  uint32_t length,
+                  bool is_recursive);
 
 } // namespace acir_proofs
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index de011de21e..b344086ca3 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -4,7 +4,7 @@
 #include <gtest/gtest.h>
 #include <vector>
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk;
 
 void create_inner_circuit(acir_format::acir_format& constraint_system, std::vector<fr>& witness)
 {
@@ -131,10 +131,10 @@ TEST(AcirProofs, TestSerialization)
 
     uint8_t* proof_data_buf = nullptr;
     size_t proof_length = acir_proofs::new_proof(
-        pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf);
+        pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, true);
 
     bool verified = acir_proofs::verify_proof(
-        &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
+        &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length), true);
     EXPECT_EQ(verified, true);
 }
 
@@ -178,14 +178,18 @@ TEST(AcirProofs, TestSerializationWithRecursion)
 
         uint8_t* proof_data_buf = nullptr;
         size_t proof_length = acir_proofs::new_proof(
-            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf);
+            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, true);
         proof_fields_size =
             acir_proofs::serialize_proof_into_field_elements(proof_data_buf, &proof_data_fields, proof_length);
         vk_fields_size = acir_proofs::serialize_verification_key_into_field_elements(
             &g2x_buffer[0], vk_buf, &vk_fields, &vk_hash_buf);
 
-        bool verified = acir_proofs::verify_proof(
-            &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
+        bool verified = acir_proofs::verify_proof(&g2x_buffer[0],
+                                                  vk_buf,
+                                                  &constraint_system_buf[0],
+                                                  proof_data_buf,
+                                                  static_cast<uint32_t>(proof_length),
+                                                  true);
         EXPECT_EQ(verified, true);
 
         delete pippenger_ptr_base;
@@ -198,14 +202,17 @@ TEST(AcirProofs, TestSerializationWithRecursion)
         fr vk_hash_value;
         std::vector<fr> proof_witnesses(proof_fields_size / 32);
         std::vector<fr> key_witnesses(vk_fields_size / 32);
-        memcpy(proof_witnesses.data(), (void*)proof_data_fields, proof_fields_size);
-        memcpy(&key_witnesses[0], (void*)vk_fields, vk_fields_size);
-        memcpy(&vk_hash_value, (void*)vk_hash_buf, 32);
+        for (size_t i = 0; i < proof_fields_size / 32; i++) {
+            proof_witnesses[i] = barretenberg::fr::serialize_from_buffer(&proof_data_fields[i * 32]);
+        }
+        for (size_t i = 0; i < vk_fields_size / 32; i++) {
+            key_witnesses[i] = barretenberg::fr::serialize_from_buffer(&vk_fields[i * 32]);
+        }
+        vk_hash_value = barretenberg::fr::serialize_from_buffer(vk_hash_buf);
 
         std::vector<uint32_t> proof_indices;
 
         const size_t proof_size = proof_witnesses.size();
-
         for (size_t i = 0; i < proof_size; ++i) {
             proof_indices.emplace_back(static_cast<uint32_t>(i + 19));
         }
@@ -296,10 +303,14 @@ TEST(AcirProofs, TestSerializationWithRecursion)
 
         uint8_t* proof_data_buf = nullptr;
         size_t proof_length = acir_proofs::new_proof(
-            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf);
-
-        bool verified = acir_proofs::verify_proof(
-            &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length));
+            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, false);
+
+        bool verified = acir_proofs::verify_proof(&g2x_buffer[0],
+                                                  vk_buf,
+                                                  &constraint_system_buf[0],
+                                                  proof_data_buf,
+                                                  static_cast<uint32_t>(proof_length),
+                                                  false);
         EXPECT_EQ(verified, true);
 
         delete pippenger_ptr_base;
@@ -308,6 +319,5 @@ TEST(AcirProofs, TestSerializationWithRecursion)
         free((void*)proof_data_buf);
         free((void*)proof_data_fields);
         free((void*)vk_fields);
-        free((void*)vk_hash_buf);
     }
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index 4051aada3a..ac26be3fd7 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -35,19 +35,41 @@ WASM_EXPORT size_t acir_proofs_init_verification_key(void* pippenger,
     return acir_proofs::init_verification_key(pippenger, g2x, pk_buf, vk_buf);
 }
 
+WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                                       uint8_t const* vk_buf,
+                                                                       uint8_t** serialized_vk_buf,
+                                                                       uint8_t** serialized_vk_hash_buf)
+{
+    return acir_proofs::serialize_verification_key_into_field_elements(
+        g2x, vk_buf, serialized_vk_buf, serialized_vk_hash_buf);
+}
+WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                                            uint8_t** serialized_proof_data_buf,
+                                                            size_t proof_data_length)
+{
+    return acir_proofs::serialize_proof_into_field_elements(
+        proof_data_buf, serialized_proof_data_buf, proof_data_length);
+}
+
 WASM_EXPORT size_t acir_proofs_new_proof(void* pippenger,
                                          uint8_t const* g2x,
                                          uint8_t const* pk_buf,
                                          uint8_t const* constraint_system_buf,
                                          uint8_t const* witness_buf,
-                                         uint8_t** proof_data_buf)
+                                         uint8_t** proof_data_buf,
+                                         bool is_recursive)
 {
-    return acir_proofs::new_proof(pippenger, g2x, pk_buf, constraint_system_buf, witness_buf, proof_data_buf);
+    return acir_proofs::new_proof(
+        pippenger, g2x, pk_buf, constraint_system_buf, witness_buf, proof_data_buf, is_recursive);
 }
 
-WASM_EXPORT bool acir_proofs_verify_proof(
-    uint8_t const* g2x, uint8_t const* vk_buf, uint8_t const* constraint_system_buf, uint8_t* proof, uint32_t length)
+WASM_EXPORT bool acir_proofs_verify_proof(uint8_t const* g2x,
+                                          uint8_t const* vk_buf,
+                                          uint8_t const* constraint_system_buf,
+                                          uint8_t* proof,
+                                          uint32_t length,
+                                          bool is_recursive)
 {
-    return acir_proofs::verify_proof(g2x, vk_buf, constraint_system_buf, proof, length);
+    return acir_proofs::verify_proof(g2x, vk_buf, constraint_system_buf, proof, length, is_recursive);
 }
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index a628c928cb..39591b37d1 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -14,12 +14,24 @@ WASM_EXPORT size_t acir_proofs_init_verification_key(void* pippenger,
                                                      uint8_t const* g2x,
                                                      uint8_t const* pk_buf,
                                                      uint8_t const** vk_buf);
+WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                                       uint8_t const* vk_buf,
+                                                                       uint8_t** serialized_vk_buf,
+                                                                       uint8_t** serialized_vk_hash_buf);
+WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                                            uint8_t** serialized_proof_data_buf,
+                                                            size_t proof_data_length);
 WASM_EXPORT size_t acir_proofs_new_proof(void* pippenger,
                                          uint8_t const* g2x,
                                          uint8_t const* pk_buf,
                                          uint8_t const* constraint_system_buf,
                                          uint8_t const* witness_buf,
-                                         uint8_t** proof_data_buf);
-WASM_EXPORT bool acir_proofs_verify_proof(
-    uint8_t const* g2x, uint8_t const* vk_buf, uint8_t const* constraint_system_buf, uint8_t* proof, uint32_t length);
+                                         uint8_t** proof_data_buf,
+                                         bool is_recursive);
+WASM_EXPORT bool acir_proofs_verify_proof(uint8_t const* g2x,
+                                          uint8_t const* vk_buf,
+                                          uint8_t const* constraint_system_buf,
+                                          uint8_t* proof,
+                                          uint32_t length,
+                                          bool is_recursive);
 }
diff --git a/cpp/src/barretenberg/dsl/types.hpp b/cpp/src/barretenberg/dsl/types.hpp
new file mode 100644
index 0000000000..be741363f9
--- /dev/null
+++ b/cpp/src/barretenberg/dsl/types.hpp
@@ -0,0 +1,74 @@
+#pragma once
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+
+#include "barretenberg/plonk/proof_system/prover/prover.hpp"
+#include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
+#include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
+#include "barretenberg/stdlib/primitives/bit_array/bit_array.hpp"
+#include "barretenberg/stdlib/primitives/bool/bool.hpp"
+#include "barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.hpp"
+#include "barretenberg/stdlib/primitives/byte_array/byte_array.hpp"
+#include "barretenberg/stdlib/primitives/uint/uint.hpp"
+#include "barretenberg/stdlib/primitives/witness/witness.hpp"
+#include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
+#include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp"
+#include "barretenberg/stdlib/merkle_tree/hash_path.hpp"
+#include "barretenberg/stdlib/encryption/schnorr/schnorr.hpp"
+#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
+#include "barretenberg/stdlib/primitives/curves/secp256k1.hpp"
+#include "barretenberg/stdlib/primitives/memory/rom_table.hpp"
+#include "barretenberg/stdlib/recursion/verifier/program_settings.hpp"
+#include "barretenberg/stdlib/recursion/verification_key/verification_key.hpp"
+#include "barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp"
+
+namespace acir_format {
+
+using Composer = plonk::UltraComposer;
+
+using Prover = std::conditional_t<
+    std::same_as<Composer, plonk::UltraComposer>,
+    plonk::UltraWithKeccakProver,
+    std::conditional_t<std::same_as<Composer, plonk::TurboComposer>, plonk::TurboProver, plonk::Prover>>;
+
+using Verifier = std::conditional_t<
+    std::same_as<Composer, plonk::UltraComposer>,
+    plonk::UltraWithKeccakVerifier,
+    std::conditional_t<std::same_as<Composer, plonk::TurboComposer>, plonk::TurboVerifier, plonk::Verifier>>;
+
+using RecursiveProver = plonk::UltraProver;
+
+using witness_ct = proof_system::plonk::stdlib::witness_t<Composer>;
+using public_witness_ct = proof_system::plonk::stdlib::public_witness_t<Composer>;
+using bool_ct = proof_system::plonk::stdlib::bool_t<Composer>;
+using byte_array_ct = proof_system::plonk::stdlib::byte_array<Composer>;
+using packed_byte_array_ct = proof_system::plonk::stdlib::packed_byte_array<Composer>;
+using field_ct = proof_system::plonk::stdlib::field_t<Composer>;
+using suint_ct = proof_system::plonk::stdlib::safe_uint_t<Composer>;
+using uint8_ct = proof_system::plonk::stdlib::uint8<Composer>;
+using uint16_ct = proof_system::plonk::stdlib::uint16<Composer>;
+using uint32_ct = proof_system::plonk::stdlib::uint32<Composer>;
+using uint64_ct = proof_system::plonk::stdlib::uint64<Composer>;
+using bit_array_ct = proof_system::plonk::stdlib::bit_array<Composer>;
+using fq_ct = proof_system::plonk::stdlib::bigfield<Composer, barretenberg::Bn254FqParams>;
+using biggroup_ct = proof_system::plonk::stdlib::element<Composer, fq_ct, field_ct, barretenberg::g1>;
+using point_ct = proof_system::plonk::stdlib::point<Composer>;
+using pedersen_commitment = proof_system::plonk::stdlib::pedersen_commitment<Composer>;
+using group_ct = proof_system::plonk::stdlib::group<Composer>;
+using bn254 = proof_system::plonk::stdlib::bn254<Composer>;
+using secp256k1_ct = proof_system::plonk::stdlib::secp256k1<Composer>;
+
+using hash_path_ct = proof_system::plonk::stdlib::merkle_tree::hash_path<Composer>;
+
+using schnorr_signature_bits_ct = proof_system::plonk::stdlib::schnorr::signature_bits<Composer>;
+
+// Ultra-composer specific typesv
+using rom_table_ct = proof_system::plonk::stdlib::rom_table<plonk::UltraComposer>;
+
+using verification_key_ct = proof_system::plonk::stdlib::recursion::verification_key<bn254>;
+using aggregation_state_ct = proof_system::plonk::stdlib::recursion::aggregation_state<bn254>;
+using noir_recursive_settings = proof_system::plonk::stdlib::recursion::recursive_ultra_verifier_settings<bn254>;
+using Transcript_ct = proof_system::plonk::stdlib::recursion::Transcript<Composer>;
+
+} // namespace acir_format
diff --git a/cpp/src/barretenberg/ecc/fields/field.hpp b/cpp/src/barretenberg/ecc/fields/field.hpp
index 66c59ea0d2..80a87f46af 100644
--- a/cpp/src/barretenberg/ecc/fields/field.hpp
+++ b/cpp/src/barretenberg/ecc/fields/field.hpp
@@ -25,6 +25,10 @@ namespace barretenberg {
 template <class Params> struct alignas(32) field {
   public:
     // We don't initialize data by default since we'd lose a lot of time on pointless initializations.
+    // Other alternatives have been noted, such as casting to get around constructors where they matter,
+    // however it is felt that sanitizer tools (e.g. MSAN) can detect garbage well, whereas doing
+    // hacky casts where needed would require rework to critical algos like MSM, FFT, Sumcheck.
+    // Instead, the recommended solution is use an explicit = 0 where initialization is important.
     field() noexcept {}
 
     constexpr field(const uint256_t& input) noexcept
diff --git a/cpp/src/barretenberg/honk/composer/composer_helper/standard_honk_composer_helper.cpp b/cpp/src/barretenberg/honk/composer/composer_helper/standard_honk_composer_helper.cpp
index 8c61e02a5d..6867d9af37 100644
--- a/cpp/src/barretenberg/honk/composer/composer_helper/standard_honk_composer_helper.cpp
+++ b/cpp/src/barretenberg/honk/composer/composer_helper/standard_honk_composer_helper.cpp
@@ -165,6 +165,7 @@ StandardProver StandardHonkComposerHelper<CircuitConstructor>::create_prover(
     compute_witness(circuit_constructor);
 
     size_t num_sumcheck_rounds(circuit_proving_key->log_circuit_size);
+    // TODO(luke): what is this manifest? Remove?
     auto manifest = Flavor::create_manifest(circuit_constructor.public_inputs.size(), num_sumcheck_rounds);
     StandardProver output_state(std::move(wire_polynomials), circuit_proving_key);
 
diff --git a/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp b/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp
new file mode 100644
index 0000000000..1ef6fdcba0
--- /dev/null
+++ b/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp
@@ -0,0 +1,356 @@
+#include "ultra_honk_composer_helper.hpp"
+#include "barretenberg/honk/proof_system/ultra_prover.hpp"
+#include "barretenberg/plonk/proof_system/types/program_settings.hpp"
+#include "barretenberg/plonk/proof_system/types/prover_settings.hpp"
+// #include "barretenberg/plonk/proof_system/verifier/verifier.hpp"
+#include "barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp"
+#include "barretenberg/proof_system/composer/permutation_helper.hpp"
+#include "barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <utility>
+
+namespace proof_system::honk {
+
+/**
+ * @brief Compute witness polynomials
+ *
+ * TODO(luke): The wire polynomials are returned directly whereas the sorted list polys are added to the proving
+ * key. This should be made consistent once Cody's Flavor work is settled.
+ */
+template <typename CircuitConstructor>
+void UltraHonkComposerHelper<CircuitConstructor>::compute_witness(CircuitConstructor& circuit_constructor)
+{
+    if (computed_witness) {
+        return;
+    }
+
+    size_t tables_size = 0;
+    size_t lookups_size = 0;
+    for (const auto& table : circuit_constructor.lookup_tables) {
+        tables_size += table.size;
+        lookups_size += table.lookup_gates.size();
+    }
+
+    const size_t filled_gates = circuit_constructor.num_gates + circuit_constructor.public_inputs.size();
+    const size_t total_num_gates = std::max(filled_gates, tables_size + lookups_size);
+
+    const size_t subgroup_size = circuit_constructor.get_circuit_subgroup_size(total_num_gates + NUM_RESERVED_GATES);
+
+    // Pad the wires (pointers to `witness_indices` of the `variables` vector).
+    // Note: the remaining NUM_RESERVED_GATES indices are padded with zeros within `compute_witness_base` (called
+    // next).
+    for (size_t i = filled_gates; i < total_num_gates; ++i) {
+        circuit_constructor.w_l.emplace_back(circuit_constructor.zero_idx);
+        circuit_constructor.w_r.emplace_back(circuit_constructor.zero_idx);
+        circuit_constructor.w_o.emplace_back(circuit_constructor.zero_idx);
+        circuit_constructor.w_4.emplace_back(circuit_constructor.zero_idx);
+    }
+
+    // TODO(#340)(luke): within compute_witness_base, the 3rd argument is used in the calculation of the dyadic circuit
+    // size (subgroup_size). Here (and in other split composers) we're passing in NUM_RANDOMIZED_GATES, but elsewhere,
+    // e.g. directly above, we use NUM_RESERVED_GATES in a similar role. Therefore, these two constants must be equal
+    // for everything to be consistent. What we should do is compute the dyadic circuit size once and for all then pass
+    // that around rather than computing in multiple places.
+    wire_polynomials = compute_witness_base(circuit_constructor, total_num_gates, NUM_RANDOMIZED_GATES);
+
+    polynomial s_1(subgroup_size);
+    polynomial s_2(subgroup_size);
+    polynomial s_3(subgroup_size);
+    polynomial s_4(subgroup_size);
+    polynomial z_lookup(subgroup_size + 1); // Only instantiated in this function; nothing assigned.
+
+    // Save space for adding random scalars in the s polynomial later. The subtracted 1 allows us to insert a `1` at the
+    // end, to ensure the evaluations (and hence coefficients) aren't all 0. See ComposerBase::compute_proving_key_base
+    // for further explanation, as a similar trick is done there.
+    size_t count = subgroup_size - tables_size - lookups_size - s_randomness - 1;
+    for (size_t i = 0; i < count; ++i) {
+        s_1[i] = 0;
+        s_2[i] = 0;
+        s_3[i] = 0;
+        s_4[i] = 0;
+    }
+
+    for (auto& table : circuit_constructor.lookup_tables) {
+        const fr table_index(table.table_index);
+        auto& lookup_gates = table.lookup_gates;
+        for (size_t i = 0; i < table.size; ++i) {
+            if (table.use_twin_keys) {
+                lookup_gates.push_back({
+                    {
+                        table.column_1[i].from_montgomery_form().data[0],
+                        table.column_2[i].from_montgomery_form().data[0],
+                    },
+                    {
+                        table.column_3[i],
+                        0,
+                    },
+                });
+            } else {
+                lookup_gates.push_back({
+                    {
+                        table.column_1[i].from_montgomery_form().data[0],
+                        0,
+                    },
+                    {
+                        table.column_2[i],
+                        table.column_3[i],
+                    },
+                });
+            }
+        }
+
+#ifdef NO_TBB
+        std::sort(lookup_gates.begin(), lookup_gates.end());
+#else
+        std::sort(std::execution::par_unseq, lookup_gates.begin(), lookup_gates.end());
+#endif
+
+        for (const auto& entry : lookup_gates) {
+            const auto components = entry.to_sorted_list_components(table.use_twin_keys);
+            s_1[count] = components[0];
+            s_2[count] = components[1];
+            s_3[count] = components[2];
+            s_4[count] = table_index;
+            ++count;
+        }
+    }
+
+    // Initialise the `s_randomness` positions in the s polynomials with 0.
+    // These will be the positions where we will be adding random scalars to add zero knowledge
+    // to plookup (search for `Blinding` in plonk/proof_system/widgets/random_widgets/plookup_widget_impl.hpp
+    // ProverPlookupWidget::compute_sorted_list_polynomial())
+    for (size_t i = 0; i < s_randomness; ++i) {
+        s_1[count] = 0;
+        s_2[count] = 0;
+        s_3[count] = 0;
+        s_4[count] = 0;
+        ++count;
+    }
+
+    // TODO(luke): Adding these to the key for now but this is inconsistent since these are 'witness' polys. Need
+    // to see what becomes of the proving key before making a decision here.
+    circuit_proving_key->polynomial_store.put("s_1_lagrange", std::move(s_1));
+    circuit_proving_key->polynomial_store.put("s_2_lagrange", std::move(s_2));
+    circuit_proving_key->polynomial_store.put("s_3_lagrange", std::move(s_3));
+    circuit_proving_key->polynomial_store.put("s_4_lagrange", std::move(s_4));
+
+    computed_witness = true;
+}
+
+template <typename CircuitConstructor>
+UltraProver UltraHonkComposerHelper<CircuitConstructor>::create_prover(CircuitConstructor& circuit_constructor)
+{
+    finalize_circuit(circuit_constructor);
+
+    compute_proving_key(circuit_constructor);
+    compute_witness(circuit_constructor);
+
+    UltraProver output_state(std::move(wire_polynomials), circuit_proving_key);
+
+    return output_state;
+}
+
+// /**
+//  * Create verifier: compute verification key,
+//  * initialize verifier with it and an initial manifest and initialize commitment_scheme.
+//  *
+//  * @return The verifier.
+//  * */
+// // TODO(Cody): This should go away altogether.
+// template <typename CircuitConstructor>
+// plonk::UltraVerifier UltraHonkComposerHelper<CircuitConstructor>::create_verifier(
+//     const CircuitConstructor& circuit_constructor)
+// {
+//     auto verification_key = compute_verification_key(circuit_constructor);
+
+//     plonk::UltraVerifier output_state(circuit_verification_key,
+//                                       create_manifest(circuit_constructor.public_inputs.size()));
+
+//     std::unique_ptr<plonk::KateCommitmentScheme<plonk::ultra_settings>> kate_commitment_scheme =
+//         std::make_unique<plonk::KateCommitmentScheme<plonk::ultra_settings>>();
+
+//     output_state.commitment_scheme = std::move(kate_commitment_scheme);
+
+//     return output_state;
+// }
+
+template <typename CircuitConstructor>
+std::shared_ptr<plonk::proving_key> UltraHonkComposerHelper<CircuitConstructor>::compute_proving_key(
+    const CircuitConstructor& circuit_constructor)
+{
+    if (circuit_proving_key) {
+        return circuit_proving_key;
+    }
+
+    size_t tables_size = 0;
+    size_t lookups_size = 0;
+    for (const auto& table : circuit_constructor.lookup_tables) {
+        tables_size += table.size;
+        lookups_size += table.lookup_gates.size();
+    }
+
+    const size_t minimum_circuit_size = tables_size + lookups_size;
+    const size_t num_randomized_gates = NUM_RANDOMIZED_GATES;
+    // Initialize circuit_proving_key
+    // TODO(#229)(Kesha): replace composer types.
+    circuit_proving_key = initialize_proving_key(
+        circuit_constructor, crs_factory_.get(), minimum_circuit_size, num_randomized_gates, ComposerType::PLOOKUP);
+
+    construct_lagrange_selector_forms(circuit_constructor, circuit_proving_key.get());
+
+    // TODO(#217)(luke): Naively enforcing non-zero selectors for Honk will result in some relations not being
+    // satisfied.
+    // enforce_nonzero_polynomial_selectors(circuit_constructor, circuit_proving_key.get());
+
+    compute_honk_generalized_sigma_permutations<CircuitConstructor::program_width>(circuit_constructor,
+                                                                                   circuit_proving_key.get());
+
+    compute_first_and_last_lagrange_polynomials(circuit_proving_key.get());
+
+    const size_t subgroup_size = circuit_proving_key->circuit_size;
+
+    polynomial poly_q_table_column_1(subgroup_size);
+    polynomial poly_q_table_column_2(subgroup_size);
+    polynomial poly_q_table_column_3(subgroup_size);
+    polynomial poly_q_table_column_4(subgroup_size);
+
+    size_t offset = subgroup_size - tables_size - s_randomness - 1;
+
+    // Create lookup selector polynomials which interpolate each table column.
+    // Our selector polys always need to interpolate the full subgroup size, so here we offset so as to
+    // put the table column's values at the end. (The first gates are for non-lookup constraints).
+    // [0, ..., 0, ...table, 0, 0, 0, x]
+    //  ^^^^^^^^^  ^^^^^^^^  ^^^^^^^  ^nonzero to ensure uniqueness and to avoid infinity commitments
+    //  |          table     randomness
+    //  ignored, as used for regular constraints and padding to the next power of 2.
+
+    for (size_t i = 0; i < offset; ++i) {
+        poly_q_table_column_1[i] = 0;
+        poly_q_table_column_2[i] = 0;
+        poly_q_table_column_3[i] = 0;
+        poly_q_table_column_4[i] = 0;
+    }
+
+    for (const auto& table : circuit_constructor.lookup_tables) {
+        const fr table_index(table.table_index);
+
+        for (size_t i = 0; i < table.size; ++i) {
+            poly_q_table_column_1[offset] = table.column_1[i];
+            poly_q_table_column_2[offset] = table.column_2[i];
+            poly_q_table_column_3[offset] = table.column_3[i];
+            poly_q_table_column_4[offset] = table_index;
+            ++offset;
+        }
+    }
+
+    // Initialise the last `s_randomness` positions in table polynomials with 0. We don't need to actually randomise
+    // the table polynomials.
+    for (size_t i = 0; i < s_randomness; ++i) {
+        poly_q_table_column_1[offset] = 0;
+        poly_q_table_column_2[offset] = 0;
+        poly_q_table_column_3[offset] = 0;
+        poly_q_table_column_4[offset] = 0;
+        ++offset;
+    }
+
+    // // In the case of using UltraPlonkComposer for a circuit which does _not_ make use of any lookup tables, all
+    // four
+    // // table columns would be all zeros. This would result in these polys' commitments all being the point at
+    // infinity
+    // // (which is bad because our point arithmetic assumes we'll never operate on the point at infinity). To avoid
+    // this,
+    // // we set the last evaluation of each poly to be nonzero. The last `num_roots_cut_out_of_vanishing_poly = 4`
+    // // evaluations are ignored by constraint checks; we arbitrarily choose the very-last evaluation to be nonzero.
+    // See
+    // // ComposerBase::compute_proving_key_base for further explanation, as a similar trick is done there. We could
+    // // have chosen `1` for each such evaluation here, but that would have resulted in identical commitments for
+    // // all four columns. We don't want to have equal commitments, because biggroup operations assume no points are
+    // // equal, so if we tried to verify an ultra proof in a circuit, the biggroup operations would fail. To combat
+    // // this, we just choose distinct values:
+    size_t num_selectors = circuit_constructor.num_selectors;
+    ASSERT(offset == subgroup_size - 1);
+    auto unique_last_value = num_selectors + 1; // Note: in compute_proving_key_base, moments earlier, each selector
+                                                // vector was given a unique last value from 1..num_selectors. So we
+                                                // avoid those values and continue the count, to ensure uniqueness.
+    poly_q_table_column_1[subgroup_size - 1] = unique_last_value;
+    poly_q_table_column_2[subgroup_size - 1] = ++unique_last_value;
+    poly_q_table_column_3[subgroup_size - 1] = ++unique_last_value;
+    poly_q_table_column_4[subgroup_size - 1] = ++unique_last_value;
+
+    circuit_proving_key->polynomial_store.put("table_value_1_lagrange", std::move(poly_q_table_column_1));
+    circuit_proving_key->polynomial_store.put("table_value_2_lagrange", std::move(poly_q_table_column_2));
+    circuit_proving_key->polynomial_store.put("table_value_3_lagrange", std::move(poly_q_table_column_3));
+    circuit_proving_key->polynomial_store.put("table_value_4_lagrange", std::move(poly_q_table_column_4));
+
+    // Copy memory read/write record data into proving key. Prover needs to know which gates contain a read/write
+    // 'record' witness on the 4th wire. This wire value can only be fully computed once the first 3 wire polynomials
+    // have been committed to. The 4th wire on these gates will be a random linear combination of the first 3 wires,
+    // using the plookup challenge `eta`
+    std::copy(circuit_constructor.memory_read_records.begin(),
+              circuit_constructor.memory_read_records.end(),
+              std::back_inserter(circuit_proving_key->memory_read_records));
+    std::copy(circuit_constructor.memory_write_records.begin(),
+              circuit_constructor.memory_write_records.end(),
+              std::back_inserter(circuit_proving_key->memory_write_records));
+
+    circuit_proving_key->recursive_proof_public_input_indices =
+        std::vector<uint32_t>(recursive_proof_public_input_indices.begin(), recursive_proof_public_input_indices.end());
+
+    circuit_proving_key->contains_recursive_proof = contains_recursive_proof;
+
+    return circuit_proving_key;
+}
+
+// /**
+//  * Compute verification key consisting of selector precommitments.
+//  *
+//  * @return Pointer to created circuit verification key.
+//  * */
+// template <typename CircuitConstructor>
+// std::shared_ptr<plonk::verification_key> UltraHonkComposerHelper<CircuitConstructor>::compute_verification_key(
+//     const CircuitConstructor& circuit_constructor)
+// {
+//     if (circuit_verification_key) {
+//         return circuit_verification_key;
+//     }
+
+//     if (!circuit_proving_key) {
+//         compute_proving_key(circuit_constructor);
+//     }
+//     circuit_verification_key = compute_verification_key_common(circuit_proving_key,
+//     crs_factory_->get_verifier_crs());
+
+//     circuit_verification_key->composer_type = type; // Invariably plookup for this class.
+
+//     // See `add_recusrive_proof()` for how this recursive data is assigned.
+//     circuit_verification_key->recursive_proof_public_input_indices =
+//         std::vector<uint32_t>(recursive_proof_public_input_indices.begin(),
+//         recursive_proof_public_input_indices.end());
+
+//     circuit_verification_key->contains_recursive_proof = contains_recursive_proof;
+
+//     return circuit_verification_key;
+// }
+
+// template <typename CircuitConstructor>
+// void UltraHonkComposerHelper<CircuitConstructor>::add_table_column_selector_poly_to_proving_key(
+//     polynomial& selector_poly_lagrange_form, const std::string& tag)
+// {
+//     polynomial selector_poly_lagrange_form_copy(selector_poly_lagrange_form, circuit_proving_key->small_domain.size);
+
+//     selector_poly_lagrange_form.ifft(circuit_proving_key->small_domain);
+//     auto& selector_poly_coeff_form = selector_poly_lagrange_form;
+
+//     polynomial selector_poly_coset_form(selector_poly_coeff_form, circuit_proving_key->circuit_size * 4);
+//     selector_poly_coset_form.coset_fft(circuit_proving_key->large_domain);
+
+//     circuit_proving_key->polynomial_store.put(tag, std::move(selector_poly_coeff_form));
+//     circuit_proving_key->polynomial_store.put(tag + "_lagrange", std::move(selector_poly_lagrange_form_copy));
+//     circuit_proving_key->polynomial_store.put(tag + "_fft", std::move(selector_poly_coset_form));
+// }
+
+template class UltraHonkComposerHelper<UltraCircuitConstructor>;
+} // namespace proof_system::honk
diff --git a/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.hpp b/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.hpp
new file mode 100644
index 0000000000..de309735e6
--- /dev/null
+++ b/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "barretenberg/proof_system/composer/composer_helper_lib.hpp"
+#include "barretenberg/plonk/composer/splitting_tmp/composer_helper/composer_helper_lib.hpp"
+#include "barretenberg/srs/reference_string/file_reference_string.hpp"
+#include "barretenberg/plonk/proof_system/proving_key/proving_key.hpp"
+#include "barretenberg/honk/proof_system/ultra_prover.hpp"
+// #include "barretenberg/plonk/proof_system/verifier/verifier.hpp"
+
+#include <cstddef>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace proof_system::honk {
+// TODO(Kesha): change initializations to specify this parameter
+// Cody: What does this mean?
+template <typename CircuitConstructor> class UltraHonkComposerHelper {
+  public:
+    // TODO(#340)(luke): In the split composers, NUM_RANDOMIZED_GATES has replaced NUM_RESERVED_GATES (in some places)
+    // to determine the next-power-of-2 circuit size. (There are some places in this composer that still use
+    // NUM_RESERVED_GATES). Therefore for consistency within this composer itself, and consistency with the original
+    // Ultra Composer, this value must match that of NUM_RESERVED_GATES. This issue needs to be reconciled
+    // simultaneously here and in the other split composers.
+    static constexpr size_t NUM_RANDOMIZED_GATES = 4; // equal to the number of multilinear evaluations leaked
+    static constexpr size_t program_width = CircuitConstructor::program_width;
+    std::vector<barretenberg::polynomial> wire_polynomials;
+    std::shared_ptr<proof_system::plonk::proving_key> circuit_proving_key;
+    std::shared_ptr<proof_system::plonk::verification_key> circuit_verification_key;
+    // TODO(#218)(kesha): we need to put this into the commitment key, so that the composer doesn't have to handle srs
+    // at all
+    std::shared_ptr<ReferenceStringFactory> crs_factory_;
+
+    std::vector<uint32_t> recursive_proof_public_input_indices;
+    bool contains_recursive_proof = false;
+    bool computed_witness = false;
+
+    // This variable controls the amount with which the lookup table and witness values need to be shifted
+    // above to make room for adding randomness into the permutation and witness polynomials in the plookup widget.
+    // This must be (num_roots_cut_out_of_the_vanishing_polynomial - 1), since the variable num_roots_cut_out_of_
+    // vanishing_polynomial cannot be trivially fetched here, I am directly setting this to 4 - 1 = 3.
+    static constexpr size_t s_randomness = 3;
+
+    explicit UltraHonkComposerHelper(std::shared_ptr<ReferenceStringFactory> crs_factory)
+        : crs_factory_(std::move(crs_factory))
+    {}
+
+    UltraHonkComposerHelper(std::shared_ptr<plonk::proving_key> p_key, std::shared_ptr<plonk::verification_key> v_key)
+        : circuit_proving_key(std::move(p_key))
+        , circuit_verification_key(std::move(v_key))
+    {}
+
+    UltraHonkComposerHelper(UltraHonkComposerHelper&& other) noexcept = default;
+    UltraHonkComposerHelper(UltraHonkComposerHelper const& other) noexcept = default;
+    UltraHonkComposerHelper& operator=(UltraHonkComposerHelper&& other) noexcept = default;
+    UltraHonkComposerHelper& operator=(UltraHonkComposerHelper const& other) noexcept = default;
+    ~UltraHonkComposerHelper() = default;
+
+    void finalize_circuit(CircuitConstructor& circuit_constructor) { circuit_constructor.finalize_circuit(); };
+
+    std::shared_ptr<plonk::proving_key> compute_proving_key(const CircuitConstructor& circuit_constructor);
+    // std::shared_ptr<plonk::verification_key> compute_verification_key(const CircuitConstructor& circuit_constructor);
+
+    void compute_witness(CircuitConstructor& circuit_constructor);
+
+    UltraProver create_prover(CircuitConstructor& circuit_constructor);
+    // UltraVerifier create_verifier(const CircuitConstructor& circuit_constructor);
+
+    void add_table_column_selector_poly_to_proving_key(polynomial& small, const std::string& tag);
+};
+
+} // namespace proof_system::honk
diff --git a/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp b/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp
index 84717e21a4..8ab126ba01 100644
--- a/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp
+++ b/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp
@@ -304,109 +304,6 @@ TEST(StandardHonkComposer, VerificationKeyCreation)
               composer.circuit_constructor.selectors.size() + composer.num_wires * 2 + 2);
 }
 
-/**
- * @brief A test taking sumcheck relations and applying them to the witness and selector polynomials to ensure that the
- * realtions are correct.
- *
- * TODO(Kesha): We'll have to update this function once we add zk, since the relation will be incorrect for he first few
- * indices
- *
- */
-TEST(StandardHonkComposer, SumcheckRelationCorrectness)
-{
-    // Create a composer and a dummy circuit with a few gates
-    StandardHonkComposer composer = StandardHonkComposer();
-    static const size_t num_wires = StandardHonkComposer::num_wires;
-    fr a = fr::one();
-    // Using the public variable to check that public_input_delta is computed and added to the relation correctly
-    uint32_t a_idx = composer.add_public_variable(a);
-    fr b = fr::one();
-    fr c = a + b;
-    fr d = a + c;
-    uint32_t b_idx = composer.add_variable(b);
-    uint32_t c_idx = composer.add_variable(c);
-    uint32_t d_idx = composer.add_variable(d);
-    for (size_t i = 0; i < 16; i++) {
-        composer.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
-        composer.create_add_gate({ d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
-    }
-    // Create a prover (it will compute proving key and witness)
-    auto prover = composer.create_prover();
-
-    // Generate beta and gamma
-    fr beta = fr::random_element();
-    fr gamma = fr::random_element();
-
-    // Compute public input delta
-    const auto public_inputs = composer.circuit_constructor.get_public_inputs();
-    auto public_input_delta =
-        honk::compute_public_input_delta<fr>(public_inputs, beta, gamma, prover.key->circuit_size);
-
-    sumcheck::RelationParameters<fr> params{
-        .beta = beta,
-        .gamma = gamma,
-        .public_input_delta = public_input_delta,
-    };
-
-    constexpr size_t num_polynomials = proof_system::honk::StandardArithmetization::NUM_POLYNOMIALS;
-    // Compute grand product polynomial
-    polynomial z_perm_poly =
-        prover_library::compute_permutation_grand_product<num_wires>(prover.key, prover.wire_polynomials, beta, gamma);
-
-    // Create an array of spans to the underlying polynomials to more easily
-    // get the transposition.
-    // Ex: polynomial_spans[3][i] returns the i-th coefficient of the third polynomial
-    // in the list below
-    std::array<std::span<const fr>, num_polynomials> evaluations_array;
-
-    using POLYNOMIAL = proof_system::honk::StandardArithmetization::POLYNOMIAL;
-    evaluations_array[POLYNOMIAL::W_L] = prover.wire_polynomials[0];
-    evaluations_array[POLYNOMIAL::W_R] = prover.wire_polynomials[1];
-    evaluations_array[POLYNOMIAL::W_O] = prover.wire_polynomials[2];
-    evaluations_array[POLYNOMIAL::Z_PERM] = z_perm_poly;
-    evaluations_array[POLYNOMIAL::Z_PERM_SHIFT] = z_perm_poly.shifted();
-    evaluations_array[POLYNOMIAL::Q_M] = prover.key->polynomial_store.get("q_m_lagrange");
-    evaluations_array[POLYNOMIAL::Q_L] = prover.key->polynomial_store.get("q_1_lagrange");
-    evaluations_array[POLYNOMIAL::Q_R] = prover.key->polynomial_store.get("q_2_lagrange");
-    evaluations_array[POLYNOMIAL::Q_O] = prover.key->polynomial_store.get("q_3_lagrange");
-    evaluations_array[POLYNOMIAL::Q_C] = prover.key->polynomial_store.get("q_c_lagrange");
-    evaluations_array[POLYNOMIAL::SIGMA_1] = prover.key->polynomial_store.get("sigma_1_lagrange");
-    evaluations_array[POLYNOMIAL::SIGMA_2] = prover.key->polynomial_store.get("sigma_2_lagrange");
-    evaluations_array[POLYNOMIAL::SIGMA_3] = prover.key->polynomial_store.get("sigma_3_lagrange");
-    evaluations_array[POLYNOMIAL::ID_1] = prover.key->polynomial_store.get("id_1_lagrange");
-    evaluations_array[POLYNOMIAL::ID_2] = prover.key->polynomial_store.get("id_2_lagrange");
-    evaluations_array[POLYNOMIAL::ID_3] = prover.key->polynomial_store.get("id_3_lagrange");
-    evaluations_array[POLYNOMIAL::LAGRANGE_FIRST] = prover.key->polynomial_store.get("L_first_lagrange");
-    evaluations_array[POLYNOMIAL::LAGRANGE_LAST] = prover.key->polynomial_store.get("L_last_lagrange");
-
-    // Construct the round for applying sumcheck relations and results for storing computed results
-    auto relations = std::tuple(honk::sumcheck::ArithmeticRelation<fr>(),
-                                honk::sumcheck::GrandProductComputationRelation<fr>(),
-                                honk::sumcheck::GrandProductInitializationRelation<fr>());
-
-    fr result = 0;
-    for (size_t i = 0; i < prover.key->circuit_size; i++) {
-        // Compute an array containing all the evaluations at a given row i
-        std::array<fr, num_polynomials> evaluations_at_index_i;
-        for (size_t j = 0; j < num_polynomials; ++j) {
-            evaluations_at_index_i[j] = evaluations_array[j][i];
-        }
-
-        // For each relation, call the `accumulate_relation_evaluation` over all witness/selector values at the
-        // i-th row/vertex of the hypercube.
-        // We use ASSERT_EQ instead of EXPECT_EQ so that the tests stops at the first index at which the result is not
-        // 0, since result = 0 + C(transposed), which we expect will equal 0.
-        std::get<0>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
-        ASSERT_EQ(result, 0);
-
-        std::get<1>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
-        ASSERT_EQ(result, 0);
-
-        std::get<2>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
-        ASSERT_EQ(result, 0);
-    }
-}
-
 TEST(StandardHonkComposer, BaseCase)
 {
     auto composer = StandardHonkComposer();
diff --git a/cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp
new file mode 100644
index 0000000000..5fa40b4626
--- /dev/null
+++ b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp
@@ -0,0 +1,470 @@
+#pragma once
+#include "barretenberg/plonk/composer/plookup_tables/plookup_tables.hpp"
+#include "barretenberg/honk/proof_system/ultra_prover.hpp"
+#include "barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp"
+#include "barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.hpp"
+#include <optional>
+
+namespace proof_system::honk {
+
+class UltraHonkComposer {
+
+  public:
+    // An instantiation of the circuit constructor that only depends on arithmetization, not  on the proof system
+    UltraCircuitConstructor circuit_constructor;
+    // Composer helper contains all proof-related material that is separate from circuit creation such as:
+    // 1) Proving and verification keys
+    // 2) CRS
+    // 3) Converting variables to witness vectors/polynomials
+    UltraHonkComposerHelper<UltraCircuitConstructor> composer_helper;
+    size_t& num_gates;
+
+    UltraHonkComposer()
+        : UltraHonkComposer("../srs_db/ignition", 0){};
+
+    UltraHonkComposer(std::string const& crs_path, const size_t size_hint)
+        : UltraHonkComposer(std::unique_ptr<ReferenceStringFactory>(new FileReferenceStringFactory(crs_path)),
+                            size_hint){};
+
+    UltraHonkComposer(std::shared_ptr<ReferenceStringFactory> const& crs_factory, const size_t size_hint)
+        : circuit_constructor(size_hint)
+        , composer_helper(crs_factory)
+        , num_gates(circuit_constructor.num_gates){};
+
+    UltraHonkComposer(std::shared_ptr<plonk::proving_key> const& p_key,
+                      std::shared_ptr<plonk::verification_key> const& v_key,
+                      size_t size_hint = 0);
+    UltraHonkComposer(UltraHonkComposer&& other) = default;
+    UltraHonkComposer& operator=(UltraHonkComposer&& other) = delete;
+    ~UltraHonkComposer() = default;
+
+    uint32_t get_zero_idx() { return circuit_constructor.zero_idx; }
+
+    uint32_t add_variable(const barretenberg::fr& in) { return circuit_constructor.add_variable(in); }
+
+    barretenberg::fr get_variable(const uint32_t index) const { return circuit_constructor.get_variable(index); }
+
+    void finalize_circuit() { circuit_constructor.finalize_circuit(); };
+
+    UltraProver create_prover() { return composer_helper.create_prover(circuit_constructor); };
+    // UltraVerifier create_verifier() { return composer_helper.create_verifier(circuit_constructor); };
+
+    void create_add_gate(const add_triple& in) { circuit_constructor.create_add_gate(in); }
+
+    void create_big_add_gate(const add_quad& in, const bool use_next_gate_w_4 = false)
+    {
+        circuit_constructor.create_big_add_gate(in, use_next_gate_w_4);
+    };
+
+    // void create_big_add_gate_with_bit_extraction(const add_quad& in);
+    // void create_big_mul_gate(const mul_quad& in);
+    // void create_balanced_add_gate(const add_quad& in);
+
+    // void create_mul_gate(const mul_triple& in) override;
+    // void create_bool_gate(const uint32_t a) override;
+    // void create_poly_gate(const poly_triple& in) override;
+    void create_ecc_add_gate(const ecc_add_gate& in) { circuit_constructor.create_ecc_add_gate(in); };
+
+    // void fix_witness(const uint32_t witness_index, const barretenberg::fr& witness_value);
+
+    // void add_recursive_proof(const std::vector<uint32_t>& proof_output_witness_indices)
+    // {
+    //     if (contains_recursive_proof) {
+    //         failure("added recursive proof when one already exists");
+    //     }
+    //     contains_recursive_proof = true;
+
+    //     for (const auto& idx : proof_output_witness_indices) {
+    //         set_public_input(idx);
+    //         recursive_proof_public_input_indices.push_back((uint32_t)(public_inputs.size() - 1));
+    //     }
+    // }
+
+    void create_new_range_constraint(const uint32_t variable_index,
+                                     const uint64_t target_range,
+                                     std::string const msg = "create_new_range_constraint")
+    {
+        circuit_constructor.create_new_range_constraint(variable_index, target_range, msg);
+    };
+    // void create_range_constraint(const uint32_t variable_index, const size_t num_bits, std::string const& msg)
+    // {
+    //     if (num_bits <= DEFAULT_PLOOKUP_RANGE_BITNUM) {
+    //         /**
+    //          * N.B. if `variable_index` is not used in any arithmetic constraints, this will create an unsatisfiable
+    //          *      circuit!
+    //          *      this range constraint will increase the size of the 'sorted set' of range-constrained integers
+    //          by 1.
+    //          *      The 'non-sorted set' of range-constrained integers is a subset of the wire indices of all
+    //          arithmetic
+    //          *      gates. No arithemtic gate => size imbalance between sorted and non-sorted sets. Checking for this
+    //          *      and throwing an error would require a refactor of the Composer to catelog all 'orphan' variables
+    //          not
+    //          *      assigned to gates.
+    //          **/
+    //         create_new_range_constraint(variable_index, 1ULL << num_bits, msg);
+    //     } else {
+    //         decompose_into_default_range(variable_index, num_bits, DEFAULT_PLOOKUP_RANGE_BITNUM, msg);
+    //     }
+    // }
+
+    // accumulator_triple create_logic_constraint(const uint32_t a,
+    //                                            const uint32_t b,
+    //                                            const size_t num_bits,
+    //                                            bool is_xor_gate);
+    // accumulator_triple create_and_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+    // accumulator_triple create_xor_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+
+    // uint32_t put_constant_variable(const barretenberg::fr& variable);
+
+    // size_t get_num_constant_gates() const override { return 0; }
+
+    // /**
+    //  * @brief Get the final number of gates in a circuit, which consists of the sum of:
+    //  * 1) Current number number of actual gates
+    //  * 2) Number of public inputs, as we'll need to add a gate for each of them
+    //  * 3) Number of Rom array-associated gates
+    //  * 4) NUmber of range-list associated gates
+    //  *
+    //  *
+    //  * @param count return arument, number of existing gates
+    //  * @param rangecount return argument, extra gates due to range checks
+    //  * @param romcount return argument, extra gates due to rom reads
+    //  * @param ramcount return argument, extra gates due to ram read/writes
+    //  */
+    // void get_num_gates_split_into_components(size_t& count,
+    //                                          size_t& rangecount,
+    //                                          size_t& romcount,
+    //                                          size_t& ramcount) const
+    // {
+    //     count = num_gates;
+    //     // each ROM gate adds +1 extra gate due to the rom reads being copied to a sorted list set
+    //     for (size_t i = 0; i < rom_arrays.size(); ++i) {
+    //         for (size_t j = 0; j < rom_arrays[i].state.size(); ++j) {
+    //             if (rom_arrays[i].state[j][0] == UNINITIALIZED_MEMORY_RECORD) {
+    //                 romcount += 2;
+    //             }
+    //         }
+    //         romcount += (rom_arrays[i].records.size());
+    //         romcount += 1; // we add an addition gate after procesing a rom array
+    //     }
+
+    //     constexpr size_t gate_width = ultra_settings::program_width;
+    //     // each RAM gate adds +2 extra gates due to the ram reads being copied to a sorted list set,
+    //     // as well as an extra gate to validate timestamps
+    //     std::vector<size_t> ram_timestamps;
+    //     std::vector<size_t> ram_range_sizes;
+    //     std::vector<size_t> ram_range_exists;
+    //     for (size_t i = 0; i < ram_arrays.size(); ++i) {
+    //         for (size_t j = 0; j < ram_arrays[i].state.size(); ++j) {
+    //             if (ram_arrays[i].state[j] == UNINITIALIZED_MEMORY_RECORD) {
+    //                 ramcount += NUMBER_OF_GATES_PER_RAM_ACCESS;
+    //             }
+    //         }
+    //         ramcount += (ram_arrays[i].records.size() * NUMBER_OF_GATES_PER_RAM_ACCESS);
+    //         ramcount += NUMBER_OF_ARITHMETIC_GATES_PER_RAM_ARRAY; // we add an addition gate after procesing a ram
+    //         array
+
+    //         // there will be 'max_timestamp' number of range checks, need to calculate.
+    //         const auto max_timestamp = ram_arrays[i].access_count - 1;
+
+    //         // if a range check of length `max_timestamp` already exists, we are double counting.
+    //         // We record `ram_timestamps` to detect and correct for this error when we process range lists.
+    //         ram_timestamps.push_back(max_timestamp);
+    //         size_t padding = (gate_width - (max_timestamp % gate_width)) % gate_width;
+    //         if (max_timestamp == gate_width)
+    //             padding += gate_width;
+    //         const size_t ram_range_check_list_size = max_timestamp + padding;
+
+    //         size_t ram_range_check_gate_count = (ram_range_check_list_size / gate_width);
+    //         ram_range_check_gate_count += 1; // we need to add 1 extra addition gates for every distinct range list
+
+    //         ram_range_sizes.push_back(ram_range_check_gate_count);
+    //         ram_range_exists.push_back(false);
+    //         // rangecount += ram_range_check_gate_count;
+    //     }
+    //     for (const auto& list : range_lists) {
+    //         auto list_size = list.second.variable_indices.size();
+    //         size_t padding = (gate_width - (list.second.variable_indices.size() % gate_width)) % gate_width;
+    //         if (list.second.variable_indices.size() == gate_width)
+    //             padding += gate_width;
+    //         list_size += padding;
+
+    //         for (size_t i = 0; i < ram_timestamps.size(); ++i) {
+    //             if (list.second.target_range == ram_timestamps[i]) {
+    //                 ram_range_exists[i] = true;
+    //             }
+    //         }
+    //         rangecount += (list_size / gate_width);
+    //         rangecount += 1; // we need to add 1 extra addition gates for every distinct range list
+    //     }
+    //     // update rangecount to include the ram range checks the composer will eventually be creating
+    //     for (size_t i = 0; i < ram_range_sizes.size(); ++i) {
+    //         if (!ram_range_exists[i]) {
+    //             rangecount += ram_range_sizes[i];
+    //         }
+    //     }
+    // }
+
+    // /**
+    //  * @brief Get the final number of gates in a circuit, which consists of the sum of:
+    //  * 1) Current number number of actual gates
+    //  * 2) Number of public inputs, as we'll need to add a gate for each of them
+    //  * 3) Number of Rom array-associated gates
+    //  * 4) NUmber of range-list associated gates
+    //  *
+    //  * @return size_t
+    //  */
+    // virtual size_t get_num_gates() const override
+    // {
+    //     // if circuit finalised already added extra gates
+    //     if (circuit_finalised) {
+    //         return num_gates;
+    //     }
+    //     size_t count = 0;
+    //     size_t rangecount = 0;
+    //     size_t romcount = 0;
+    //     size_t ramcount = 0;
+    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
+    //     return count + romcount + ramcount + rangecount;
+    // }
+
+    // virtual void print_num_gates() const override
+    // {
+    //     size_t count = 0;
+    //     size_t rangecount = 0;
+    //     size_t romcount = 0;
+    //     size_t ramcount = 0;
+
+    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
+
+    //     size_t total = count + romcount + ramcount + rangecount;
+    //     std::cout << "gates = " << total << " (arith " << count << ", rom " << romcount << ", ram " << ramcount
+    //               << ", range " << rangecount << "), pubinp = " << public_inputs.size() << std::endl;
+    // }
+
+    void assert_equal(const uint32_t a_variable_idx,
+                      const uint32_t b_variable_idx,
+                      std::string const& msg = "assert_equal")
+    {
+        circuit_constructor.assert_equal(a_variable_idx, b_variable_idx, msg);
+    }
+
+    // void assert_equal_constant(const uint32_t a_idx,
+    //                            const barretenberg::fr& b,
+    //                            std::string const& msg = "assert equal constant")
+    // {
+    //     if (variables[a_idx] != b && !failed()) {
+    //         failure(msg);
+    //     }
+    //     auto b_idx = put_constant_variable(b);
+    //     assert_equal(a_idx, b_idx, msg);
+    // }
+
+    // /**
+    //  * Plookup Methods
+    //  **/
+    // void add_table_column_selector_poly_to_proving_key(polynomial& small, const std::string& tag);
+    // void initialize_precomputed_table(
+    //     const plookup::BasicTableId id,
+    //     bool (*generator)(std::vector<barretenberg::fr>&,
+    //                       std::vector<barretenberg::fr>&,
+    //                       std::vector<barretenberg::fr>&),
+    //     std::array<barretenberg::fr, 2> (*get_values_from_key)(const std::array<uint64_t, 2>));
+
+    // plookup::BasicTable& get_table(const plookup::BasicTableId id);
+    // plookup::MultiTable& create_table(const plookup::MultiTableId id);
+
+    plookup::ReadData<uint32_t> create_gates_from_plookup_accumulators(
+        const plookup::MultiTableId& id,
+        const plookup::ReadData<barretenberg::fr>& read_values,
+        const uint32_t key_a_index,
+        std::optional<uint32_t> key_b_index = std::nullopt)
+    {
+        return circuit_constructor.create_gates_from_plookup_accumulators(id, read_values, key_a_index, key_b_index);
+    };
+
+    // /**
+    //  * Generalized Permutation Methods
+    //  **/
+    std::vector<uint32_t> decompose_into_default_range(
+        const uint32_t variable_index,
+        const uint64_t num_bits,
+        const uint64_t target_range_bitnum = DEFAULT_PLOOKUP_RANGE_BITNUM,
+        std::string const& msg = "decompose_into_default_range")
+    {
+        return circuit_constructor.decompose_into_default_range(variable_index, num_bits, target_range_bitnum, msg);
+    };
+    // std::vector<uint32_t> decompose_into_default_range_better_for_oddlimbnum(
+    //     const uint32_t variable_index,
+    //     const size_t num_bits,
+    //     std::string const& msg = "decompose_into_default_range_better_for_oddlimbnum");
+    void create_dummy_constraints(const std::vector<uint32_t>& variable_index)
+    {
+        circuit_constructor.create_dummy_constraints(variable_index);
+    };
+    void create_sort_constraint(const std::vector<uint32_t>& variable_index)
+    {
+        circuit_constructor.create_sort_constraint(variable_index);
+    };
+    void create_sort_constraint_with_edges(const std::vector<uint32_t>& variable_index,
+                                           const barretenberg::fr& start,
+                                           const barretenberg::fr& end)
+    {
+        circuit_constructor.create_sort_constraint_with_edges(variable_index, start, end);
+    };
+
+    void assign_tag(const uint32_t variable_index, const uint32_t tag)
+    {
+        circuit_constructor.assign_tag(variable_index, tag);
+    }
+
+    // void assign_tag(const uint32_t variable_index, const uint32_t tag)
+    // {
+    //     ASSERT(tag <= current_tag);
+    //     ASSERT(real_variable_tags[real_variable_index[variable_index]] == DUMMY_TAG);
+    //     real_variable_tags[real_variable_index[variable_index]] = tag;
+    // }
+
+    uint32_t create_tag(const uint32_t tag_index, const uint32_t tau_index)
+    {
+        return circuit_constructor.create_tag(tag_index, tau_index);
+    }
+
+    // uint32_t get_new_tag()
+    // {
+    //     current_tag++;
+    //     return current_tag;
+    // }
+
+    // RangeList create_range_list(const uint64_t target_range);
+    // void process_range_list(const RangeList& list);
+    // void process_range_lists();
+
+    // /**
+    //  * Custom Gate Selectors
+    //  **/
+    // void apply_aux_selectors(const AUX_SELECTORS type);
+
+    // /**
+    //  * Non Native Field Arithmetic
+    //  **/
+    void range_constrain_two_limbs(const uint32_t lo_idx,
+                                   const uint32_t hi_idx,
+                                   const size_t lo_limb_bits = DEFAULT_NON_NATIVE_FIELD_LIMB_BITS,
+                                   const size_t hi_limb_bits = DEFAULT_NON_NATIVE_FIELD_LIMB_BITS)
+    {
+        circuit_constructor.range_constrain_two_limbs(lo_idx, hi_idx, lo_limb_bits, hi_limb_bits);
+    };
+    // std::array<uint32_t, 2> decompose_non_native_field_double_width_limb(
+    //     const uint32_t limb_idx, const size_t num_limb_bits = (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
+    std::array<uint32_t, 2> evaluate_non_native_field_multiplication(
+        const non_native_field_witnesses& input, const bool range_constrain_quotient_and_remainder = true)
+    {
+        return circuit_constructor.evaluate_non_native_field_multiplication(input,
+                                                                            range_constrain_quotient_and_remainder);
+    };
+    // std::array<uint32_t, 2> evaluate_partial_non_native_field_multiplication(const non_native_field_witnesses&
+    // input); typedef std::pair<uint32_t, barretenberg::fr> scaled_witness; typedef std::tuple<scaled_witness,
+    // scaled_witness, barretenberg::fr> add_simple; std::array<uint32_t, 5> evaluate_non_native_field_subtraction(
+    //     add_simple limb0,
+    //     add_simple limb1,
+    //     add_simple limb2,
+    //     add_simple limb3,
+    //     std::tuple<uint32_t, uint32_t, barretenberg::fr> limbp);
+    // std::array<uint32_t, 5> evaluate_non_native_field_addition(add_simple limb0,
+    //                                                            add_simple limb1,
+    //                                                            add_simple limb2,
+    //                                                            add_simple limb3,
+    //                                                            std::tuple<uint32_t, uint32_t, barretenberg::fr>
+    //                                                            limbp);
+
+    // /**
+    //  * Memory
+    //  **/
+
+    size_t create_RAM_array(const size_t array_size) { return circuit_constructor.create_RAM_array(array_size); };
+    size_t create_ROM_array(const size_t array_size) { return circuit_constructor.create_ROM_array(array_size); };
+
+    void set_ROM_element(const size_t rom_id, const size_t index_value, const uint32_t value_witness)
+    {
+        circuit_constructor.set_ROM_element(rom_id, index_value, value_witness);
+    };
+    // void set_ROM_element_pair(const size_t rom_id,
+    //                           const size_t index_value,
+    //                           const std::array<uint32_t, 2>& value_witnesses);
+    uint32_t read_ROM_array(const size_t rom_id, const uint32_t index_witness)
+    {
+        return circuit_constructor.read_ROM_array(rom_id, index_witness);
+    };
+    // std::array<uint32_t, 2> read_ROM_array_pair(const size_t rom_id, const uint32_t index_witness);
+    // void create_ROM_gate(RomRecord& record);
+    // void create_sorted_ROM_gate(RomRecord& record);
+    // void process_ROM_array(const size_t rom_id, const size_t gate_offset_from_public_inputs);
+    // void process_ROM_arrays(const size_t gate_offset_from_public_inputs);
+
+    // void create_RAM_gate(RamRecord& record);
+    // void create_sorted_RAM_gate(RamRecord& record);
+    // void create_final_sorted_RAM_gate(RamRecord& record, const size_t ram_array_size);
+
+    // size_t create_RAM_array(const size_t array_size);
+    void init_RAM_element(const size_t ram_id, const size_t index_value, const uint32_t value_witness)
+    {
+        circuit_constructor.init_RAM_element(ram_id, index_value, value_witness);
+    };
+    uint32_t read_RAM_array(const size_t ram_id, const uint32_t index_witness)
+    {
+        return circuit_constructor.read_RAM_array(ram_id, index_witness);
+    };
+    void write_RAM_array(const size_t ram_id, const uint32_t index_witness, const uint32_t value_witness)
+    {
+        circuit_constructor.write_RAM_array(ram_id, index_witness, value_witness);
+    };
+    // void process_RAM_array(const size_t ram_id, const size_t gate_offset_from_public_inputs);
+    // void process_RAM_arrays(const size_t gate_offset_from_public_inputs);
+
+    // /**
+    //  * Member Variables
+    //  **/
+
+    // uint32_t zero_idx = 0;
+    bool circuit_finalised = false;
+
+    // // This variable controls the amount with which the lookup table and witness values need to be shifted
+    // // above to make room for adding randomness into the permutation and witness polynomials in the plookup widget.
+    // // This must be (num_roots_cut_out_of_the_vanishing_polynomial - 1), since the variable num_roots_cut_out_of_
+    // // vanishing_polynomial cannot be trivially fetched here, I am directly setting this to 4 - 1 = 3.
+    // static constexpr size_t s_randomness = 3;
+
+    // // these are variables that we have used a gate on, to enforce that they are equal to a defined value
+    // std::map<barretenberg::fr, uint32_t> constant_variable_indices;
+
+    // std::vector<plookup::BasicTable> lookup_tables;
+    // std::vector<plookup::MultiTable> lookup_multi_tables;
+    // std::map<uint64_t, RangeList> range_lists; // DOCTODO: explain this.
+
+    // /**
+    //  * @brief Each entry in ram_arrays represents an independent RAM table.
+    //  * RamTranscript tracks the current table state,
+    //  * as well as the 'records' produced by each read and write operation.
+    //  * Used in `compute_proving_key` to generate consistency check gates required to validate the RAM read/write
+    //  history
+    //  */
+    // std::vector<RamTranscript> ram_arrays;
+
+    // /**
+    //  * @brief Each entry in ram_arrays represents an independent ROM table.
+    //  * RomTranscript tracks the current table state,
+    //  * as well as the 'records' produced by each read operation.
+    //  * Used in `compute_proving_key` to generate consistency check gates required to validate the ROM read history
+    //  */
+    // std::vector<RomTranscript> rom_arrays;
+
+    // // Stores gate index of ROM and RAM reads (required by proving key)
+    // std::vector<uint32_t> memory_read_records;
+    // // Stores gate index of RAM writes (required by proving key)
+    // std::vector<uint32_t> memory_write_records;
+
+    // std::vector<uint32_t> recursive_proof_public_input_indices;
+    // bool contains_recursive_proof = false;
+};
+} // namespace proof_system::honk
diff --git a/cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp
new file mode 100644
index 0000000000..0c8f1baefc
--- /dev/null
+++ b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp
@@ -0,0 +1,1036 @@
+#include "ultra_honk_composer.hpp"
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/honk/proof_system/ultra_prover.hpp"
+#include "barretenberg/honk/sumcheck/relations/relation.hpp"
+#include "barretenberg/numeric/uint256/uint256.hpp"
+#include "barretenberg/honk/flavor/flavor.hpp"
+#include <cstddef>
+#include <cstdint>
+#include "barretenberg/honk/proof_system/prover.hpp"
+#include "barretenberg/honk/sumcheck/sumcheck_round.hpp"
+#include "barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp"
+#include "barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp"
+#include "barretenberg/honk/utils/public_inputs.hpp"
+
+// TODO(luke): TEMPORARY; for testing only (comparison with Ultra Plonk composers)
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+#include "barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.hpp"
+#include "barretenberg/plonk/proof_system/prover/prover.hpp"
+
+#include <gtest/gtest.h>
+#include <string>
+
+using namespace proof_system::honk;
+
+namespace test_ultra_honk_composer {
+
+std::vector<uint32_t> add_variables(auto& composer, std::vector<fr> variables)
+{
+    std::vector<uint32_t> res;
+    for (size_t i = 0; i < variables.size(); i++) {
+        res.emplace_back(composer.add_variable(variables[i]));
+    }
+    return res;
+}
+
+/**
+ * @brief TEMPORARY method for checking consistency of polynomials computed by Ultra Plonk/Honk composers
+ *
+ * @param honk_prover
+ * @param plonk_prover
+ */
+// NOTE: Currently checking exact consistency for witness polynomials (wires, sorted lists) and table polys.
+// The permutation polys are computed differently between plonk and honk so we do not expect consistency.
+// Equality is checked on all selectors but we ignore the final entry since we do not enforce non-zero selectors in
+// Honk.
+void verify_consistency(honk::UltraProver& honk_prover, plonk::UltraProver& plonk_prover)
+{
+    auto& honk_store = honk_prover.key->polynomial_store;
+    auto& plonk_store = plonk_prover.key->polynomial_store;
+
+    // Check that all selectors agree (aside from the final element which will differ due to not enforcing non-zero
+    // selectors in Honk).
+    for (auto& entry : honk_store) {
+        std::string key = entry.first;
+        bool is_selector = (key.find("q_") != std::string::npos) || (key.find("table_type") != std::string::npos);
+        if (plonk_store.contains(key) && is_selector) {
+            // check equality for all but final entry
+            for (size_t i = 0; i < honk_store.get(key).size() - 1; ++i) {
+                ASSERT_EQ(honk_store.get(key)[i], plonk_store.get(key)[i]);
+            }
+        }
+    }
+
+    // Check that sorted witness-table and table polys agree
+    for (auto& entry : honk_store) {
+        std::string key = entry.first;
+        bool is_sorted_table = (key.find("s_") != std::string::npos);
+        bool is_table = (key.find("table_value_") != std::string::npos);
+        if (plonk_store.contains(key) && (is_sorted_table || is_table)) {
+            ASSERT_EQ(honk_store.get(key), plonk_store.get(key));
+        }
+    }
+
+    // Check that all wires agree
+    // Note: for Honk, wires are owned directly by the prover. For Plonk they are stored in the key.
+    for (size_t i = 0; i < 4; ++i) {
+        std::string label = "w_" + std::to_string(i + 1) + "_lagrange";
+        ASSERT_EQ(honk_prover.wire_polynomials[i], plonk_prover.key->polynomial_store.get(label));
+    }
+}
+
+/**
+ * @brief TEMPORARY (verbose) method for checking consistency of polynomials computed by Ultra Plonk/Honk composers
+ *
+ * @param honk_prover
+ * @param plonk_prover
+ */
+void check_consistency(honk::UltraProver& honk_prover, plonk::UltraProver& plonk_prover)
+{
+    auto& honk_store = honk_prover.key->polynomial_store;
+    auto& plonk_store = plonk_prover.key->polynomial_store;
+    for (auto& entry : honk_store) {
+        std::string key = entry.first;
+        if (plonk_store.contains(key)) {
+
+            bool polys_equal = (honk_store.get(key) == plonk_store.get(key));
+            if (polys_equal) {
+                info("Equal: ", key);
+            }
+            if (!polys_equal) {
+                info("UNEQUAL: ", key);
+            }
+        }
+    }
+
+    for (size_t i = 0; i < 4; ++i) {
+        std::string label = "w_" + std::to_string(i + 1) + "_lagrange";
+        bool wire_equal = (honk_prover.wire_polynomials[i] == plonk_prover.key->polynomial_store.get(label));
+        if (wire_equal) {
+            info("Wire Equal: ", i);
+        }
+        if (!wire_equal) {
+            info("Wire UNEQUAL: ", i);
+        }
+    }
+
+    // std::string label = "w_1_lagrange";
+    // for (size_t i = 0; i < plonk_store.get(label).size(); ++i) {
+    //     auto val_honk = honk_prover.wire_polynomials[0][i];
+    //     // auto val_honk = honk_store.get(label)[i];
+    //     auto val_plonk = plonk_store.get(label)[i];
+    //     if (val_honk != val_plonk) {
+    //         info("UNEQUAL index = ", i);
+    //         info("honk: ",val_honk);
+    //         info("plonk: ", val_plonk);
+    //     }
+    // }
+}
+
+TEST(UltraHonkComposer, create_gates_from_plookup_accumulators)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    barretenberg::fr input_value = fr::random_element();
+    {
+
+        const fr input_hi = uint256_t(input_value).slice(126, 256);
+        const fr input_lo = uint256_t(input_value).slice(0, 126);
+        const auto input_hi_index = honk_composer.add_variable(input_hi);
+        const auto input_lo_index = honk_composer.add_variable(input_lo);
+
+        const auto sequence_data_hi =
+            plookup::get_lookup_accumulators(plookup::MultiTableId::PEDERSEN_LEFT_HI, input_hi);
+        const auto sequence_data_lo =
+            plookup::get_lookup_accumulators(plookup::MultiTableId::PEDERSEN_LEFT_LO, input_lo);
+
+        const auto lookup_witnesses_hi = honk_composer.create_gates_from_plookup_accumulators(
+            plookup::MultiTableId::PEDERSEN_LEFT_HI, sequence_data_hi, input_hi_index);
+        const auto lookup_witnesses_lo = honk_composer.create_gates_from_plookup_accumulators(
+            plookup::MultiTableId::PEDERSEN_LEFT_LO, sequence_data_lo, input_lo_index);
+    }
+    {
+        const fr input_hi = uint256_t(input_value).slice(126, 256);
+        const fr input_lo = uint256_t(input_value).slice(0, 126);
+        const auto input_hi_index = plonk_composer.add_variable(input_hi);
+        const auto input_lo_index = plonk_composer.add_variable(input_lo);
+
+        const auto sequence_data_hi =
+            plookup::get_lookup_accumulators(plookup::MultiTableId::PEDERSEN_LEFT_HI, input_hi);
+        const auto sequence_data_lo =
+            plookup::get_lookup_accumulators(plookup::MultiTableId::PEDERSEN_LEFT_LO, input_lo);
+
+        const auto lookup_witnesses_hi = plonk_composer.create_gates_from_plookup_accumulators(
+            plookup::MultiTableId::PEDERSEN_LEFT_HI, sequence_data_hi, input_hi_index);
+        const auto lookup_witnesses_lo = plonk_composer.create_gates_from_plookup_accumulators(
+            plookup::MultiTableId::PEDERSEN_LEFT_LO, sequence_data_lo, input_lo_index);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+/**
+ * @brief Build UltraHonkComposer
+ *
+ */
+TEST(UltraHonkComposer, test_no_lookup_proof)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    size_t MM = 4;
+    for (size_t i = 0; i < MM; ++i) {
+        for (size_t j = 0; j < MM; ++j) {
+            uint64_t left = static_cast<uint64_t>(j);
+            uint64_t right = static_cast<uint64_t>(i);
+            uint32_t left_idx = honk_composer.add_variable(fr(left));
+            uint32_t right_idx = honk_composer.add_variable(fr(right));
+            uint32_t result_idx = honk_composer.add_variable(fr(left ^ right));
+
+            uint32_t add_idx =
+                honk_composer.add_variable(fr(left) + fr(right) + honk_composer.get_variable(result_idx));
+            honk_composer.create_big_add_gate(
+                { left_idx, right_idx, result_idx, add_idx, fr(1), fr(1), fr(1), fr(-1), fr(0) });
+        }
+    }
+
+    for (size_t i = 0; i < MM; ++i) {
+        for (size_t j = 0; j < MM; ++j) {
+            uint64_t left = static_cast<uint64_t>(j);
+            uint64_t right = static_cast<uint64_t>(i);
+            uint32_t left_idx = plonk_composer.add_variable(fr(left));
+            uint32_t right_idx = plonk_composer.add_variable(fr(right));
+            uint32_t result_idx = plonk_composer.add_variable(fr(left ^ right));
+
+            uint32_t add_idx =
+                plonk_composer.add_variable(fr(left) + fr(right) + plonk_composer.get_variable(result_idx));
+            plonk_composer.create_big_add_gate(
+                { left_idx, right_idx, result_idx, add_idx, fr(1), fr(1), fr(1), fr(-1), fr(0) });
+        }
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, test_elliptic_gate)
+{
+    typedef grumpkin::g1::affine_element affine_element;
+    typedef grumpkin::g1::element element;
+
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    {
+        affine_element p1 = crypto::generators::get_generator_data({ 0, 0 }).generator;
+        affine_element p2 = crypto::generators::get_generator_data({ 0, 1 }).generator;
+        affine_element p3(element(p1) + element(p2));
+
+        uint32_t x1 = honk_composer.add_variable(p1.x);
+        uint32_t y1 = honk_composer.add_variable(p1.y);
+        uint32_t x2 = honk_composer.add_variable(p2.x);
+        uint32_t y2 = honk_composer.add_variable(p2.y);
+        uint32_t x3 = honk_composer.add_variable(p3.x);
+        uint32_t y3 = honk_composer.add_variable(p3.y);
+
+        ecc_add_gate gate{ x1, y1, x2, y2, x3, y3, 1, 1 };
+        honk_composer.create_ecc_add_gate(gate);
+
+        grumpkin::fq beta = grumpkin::fq::cube_root_of_unity();
+        affine_element p2_endo = p2;
+        p2_endo.x *= beta;
+        p3 = affine_element(element(p1) + element(p2_endo));
+        x3 = honk_composer.add_variable(p3.x);
+        y3 = honk_composer.add_variable(p3.y);
+        gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta, 1 };
+        honk_composer.create_ecc_add_gate(gate);
+
+        p2_endo.x *= beta;
+        p3 = affine_element(element(p1) - element(p2_endo));
+        x3 = honk_composer.add_variable(p3.x);
+        y3 = honk_composer.add_variable(p3.y);
+        gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 };
+        honk_composer.create_ecc_add_gate(gate);
+    }
+    {
+        affine_element p1 = crypto::generators::get_generator_data({ 0, 0 }).generator;
+        affine_element p2 = crypto::generators::get_generator_data({ 0, 1 }).generator;
+        affine_element p3(element(p1) + element(p2));
+
+        uint32_t x1 = plonk_composer.add_variable(p1.x);
+        uint32_t y1 = plonk_composer.add_variable(p1.y);
+        uint32_t x2 = plonk_composer.add_variable(p2.x);
+        uint32_t y2 = plonk_composer.add_variable(p2.y);
+        uint32_t x3 = plonk_composer.add_variable(p3.x);
+        uint32_t y3 = plonk_composer.add_variable(p3.y);
+
+        ecc_add_gate gate{ x1, y1, x2, y2, x3, y3, 1, 1 };
+        plonk_composer.create_ecc_add_gate(gate);
+
+        grumpkin::fq beta = grumpkin::fq::cube_root_of_unity();
+        affine_element p2_endo = p2;
+        p2_endo.x *= beta;
+        p3 = affine_element(element(p1) + element(p2_endo));
+        x3 = plonk_composer.add_variable(p3.x);
+        y3 = plonk_composer.add_variable(p3.y);
+        gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta, 1 };
+        plonk_composer.create_ecc_add_gate(gate);
+
+        p2_endo.x *= beta;
+        p3 = affine_element(element(p1) - element(p2_endo));
+        x3 = plonk_composer.add_variable(p3.x);
+        y3 = plonk_composer.add_variable(p3.y);
+        gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 };
+        plonk_composer.create_ecc_add_gate(gate);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, non_trivial_tag_permutation)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    fr a = fr::random_element();
+    {
+        fr b = -a;
+
+        auto a_idx = honk_composer.add_variable(a);
+        auto b_idx = honk_composer.add_variable(b);
+        auto c_idx = honk_composer.add_variable(b);
+        auto d_idx = honk_composer.add_variable(a);
+
+        honk_composer.create_add_gate(
+            { a_idx, b_idx, honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), fr::zero() });
+        honk_composer.create_add_gate(
+            { c_idx, d_idx, honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), fr::zero() });
+
+        honk_composer.create_tag(1, 2);
+        honk_composer.create_tag(2, 1);
+
+        honk_composer.assign_tag(a_idx, 1);
+        honk_composer.assign_tag(b_idx, 1);
+        honk_composer.assign_tag(c_idx, 2);
+        honk_composer.assign_tag(d_idx, 2);
+    }
+    {
+        fr b = -a;
+
+        auto a_idx = plonk_composer.add_variable(a);
+        auto b_idx = plonk_composer.add_variable(b);
+        auto c_idx = plonk_composer.add_variable(b);
+        auto d_idx = plonk_composer.add_variable(a);
+
+        plonk_composer.create_add_gate(
+            { a_idx, b_idx, plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), fr::zero() });
+        plonk_composer.create_add_gate(
+            { c_idx, d_idx, plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), fr::zero() });
+
+        plonk_composer.create_tag(1, 2);
+        plonk_composer.create_tag(2, 1);
+
+        plonk_composer.assign_tag(a_idx, 1);
+        plonk_composer.assign_tag(b_idx, 1);
+        plonk_composer.assign_tag(c_idx, 2);
+        plonk_composer.assign_tag(d_idx, 2);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, non_trivial_tag_permutation_and_cycles)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    fr a = fr::random_element();
+    {
+        fr c = -a;
+
+        auto a_idx = honk_composer.add_variable(a);
+        auto b_idx = honk_composer.add_variable(a);
+        honk_composer.assert_equal(a_idx, b_idx);
+        auto c_idx = honk_composer.add_variable(c);
+        auto d_idx = honk_composer.add_variable(c);
+        honk_composer.assert_equal(c_idx, d_idx);
+        auto e_idx = honk_composer.add_variable(a);
+        auto f_idx = honk_composer.add_variable(a);
+        honk_composer.assert_equal(e_idx, f_idx);
+        auto g_idx = honk_composer.add_variable(c);
+        auto h_idx = honk_composer.add_variable(c);
+        honk_composer.assert_equal(g_idx, h_idx);
+
+        honk_composer.create_tag(1, 2);
+        honk_composer.create_tag(2, 1);
+
+        honk_composer.assign_tag(a_idx, 1);
+        honk_composer.assign_tag(c_idx, 1);
+        honk_composer.assign_tag(e_idx, 2);
+        honk_composer.assign_tag(g_idx, 2);
+
+        honk_composer.create_add_gate(
+            { b_idx, a_idx, honk_composer.get_zero_idx(), fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
+        honk_composer.create_add_gate(
+            { c_idx, g_idx, honk_composer.get_zero_idx(), fr::one(), -fr::one(), fr::zero(), fr::zero() });
+        honk_composer.create_add_gate(
+            { e_idx, f_idx, honk_composer.get_zero_idx(), fr::one(), -fr::one(), fr::zero(), fr::zero() });
+    }
+    {
+        fr c = -a;
+
+        auto a_idx = plonk_composer.add_variable(a);
+        auto b_idx = plonk_composer.add_variable(a);
+        plonk_composer.assert_equal(a_idx, b_idx);
+        auto c_idx = plonk_composer.add_variable(c);
+        auto d_idx = plonk_composer.add_variable(c);
+        plonk_composer.assert_equal(c_idx, d_idx);
+        auto e_idx = plonk_composer.add_variable(a);
+        auto f_idx = plonk_composer.add_variable(a);
+        plonk_composer.assert_equal(e_idx, f_idx);
+        auto g_idx = plonk_composer.add_variable(c);
+        auto h_idx = plonk_composer.add_variable(c);
+        plonk_composer.assert_equal(g_idx, h_idx);
+
+        plonk_composer.create_tag(1, 2);
+        plonk_composer.create_tag(2, 1);
+
+        plonk_composer.assign_tag(a_idx, 1);
+        plonk_composer.assign_tag(c_idx, 1);
+        plonk_composer.assign_tag(e_idx, 2);
+        plonk_composer.assign_tag(g_idx, 2);
+
+        plonk_composer.create_add_gate(
+            { b_idx, a_idx, plonk_composer.zero_idx, fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
+        plonk_composer.create_add_gate(
+            { c_idx, g_idx, plonk_composer.zero_idx, fr::one(), -fr::one(), fr::zero(), fr::zero() });
+        plonk_composer.create_add_gate(
+            { e_idx, f_idx, plonk_composer.zero_idx, fr::one(), -fr::one(), fr::zero(), fr::zero() });
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, bad_tag_permutation)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    fr a = fr::random_element();
+    {
+        fr b = -a;
+
+        auto a_idx = honk_composer.add_variable(a);
+        auto b_idx = honk_composer.add_variable(b);
+        auto c_idx = honk_composer.add_variable(b);
+        auto d_idx = honk_composer.add_variable(a + 1);
+
+        honk_composer.create_add_gate({ a_idx, b_idx, honk_composer.get_zero_idx(), 1, 1, 0, 0 });
+        honk_composer.create_add_gate({ c_idx, d_idx, honk_composer.get_zero_idx(), 1, 1, 0, -1 });
+
+        honk_composer.create_tag(1, 2);
+        honk_composer.create_tag(2, 1);
+
+        honk_composer.assign_tag(a_idx, 1);
+        honk_composer.assign_tag(b_idx, 1);
+        honk_composer.assign_tag(c_idx, 2);
+        honk_composer.assign_tag(d_idx, 2);
+    }
+    {
+        fr b = -a;
+
+        auto a_idx = plonk_composer.add_variable(a);
+        auto b_idx = plonk_composer.add_variable(b);
+        auto c_idx = plonk_composer.add_variable(b);
+        auto d_idx = plonk_composer.add_variable(a + 1);
+
+        plonk_composer.create_add_gate({ a_idx, b_idx, plonk_composer.zero_idx, 1, 1, 0, 0 });
+        plonk_composer.create_add_gate({ c_idx, d_idx, plonk_composer.zero_idx, 1, 1, 0, -1 });
+
+        plonk_composer.create_tag(1, 2);
+        plonk_composer.create_tag(2, 1);
+
+        plonk_composer.assign_tag(a_idx, 1);
+        plonk_composer.assign_tag(b_idx, 1);
+        plonk_composer.assign_tag(c_idx, 2);
+        plonk_composer.assign_tag(d_idx, 2);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, sort_widget)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    {
+        fr a = fr::one();
+        fr b = fr(2);
+        fr c = fr(3);
+        fr d = fr(4);
+
+        auto a_idx = honk_composer.add_variable(a);
+        auto b_idx = honk_composer.add_variable(b);
+        auto c_idx = honk_composer.add_variable(c);
+        auto d_idx = honk_composer.add_variable(d);
+        honk_composer.create_sort_constraint({ a_idx, b_idx, c_idx, d_idx });
+    }
+    {
+        fr a = fr::one();
+        fr b = fr(2);
+        fr c = fr(3);
+        fr d = fr(4);
+
+        auto a_idx = plonk_composer.add_variable(a);
+        auto b_idx = plonk_composer.add_variable(b);
+        auto c_idx = plonk_composer.add_variable(c);
+        auto d_idx = plonk_composer.add_variable(d);
+        plonk_composer.create_sort_constraint({ a_idx, b_idx, c_idx, d_idx });
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, sort_with_edges_gate)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    {
+        auto idx = add_variables(honk_composer, { 1,  2,  5,  6,  7,  10, 11, 13, 16, 17, 20, 22, 22, 25,
+                                                  26, 29, 29, 32, 32, 33, 35, 38, 39, 39, 42, 42, 43, 45 });
+
+        honk_composer.create_sort_constraint_with_edges(idx, 1, 29);
+    }
+    {
+        auto idx = add_variables(plonk_composer, { 1,  2,  5,  6,  7,  10, 11, 13, 16, 17, 20, 22, 22, 25,
+                                                   26, 29, 29, 32, 32, 33, 35, 38, 39, 39, 42, 42, 43, 45 });
+
+        plonk_composer.create_sort_constraint_with_edges(idx, 1, 29);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, range_constraint)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    {
+        auto indices =
+            add_variables(honk_composer, { 1, 0, 3, 80, 5, 6, 29, 8, 15, 11, 32, 21, 42, 79, 16, 10, 3, 26, 13, 14 });
+        for (size_t i = 0; i < indices.size(); i++) {
+            honk_composer.create_new_range_constraint(indices[i], 79);
+        }
+        honk_composer.create_dummy_constraints(indices);
+    }
+    {
+        auto indices =
+            add_variables(plonk_composer, { 1, 0, 3, 80, 5, 6, 29, 8, 15, 11, 32, 21, 42, 79, 16, 10, 3, 26, 13, 14 });
+        for (size_t i = 0; i < indices.size(); i++) {
+            plonk_composer.create_new_range_constraint(indices[i], 79);
+        }
+        plonk_composer.create_dummy_constraints(indices);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, range_with_gates)
+{
+
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    {
+        auto idx = add_variables(honk_composer, { 1, 2, 3, 4, 5, 6, 7, 8 });
+        for (size_t i = 0; i < idx.size(); i++) {
+            honk_composer.create_new_range_constraint(idx[i], 8);
+        }
+
+        honk_composer.create_add_gate(
+            { idx[0], idx[1], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -3 });
+        honk_composer.create_add_gate(
+            { idx[2], idx[3], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -7 });
+        honk_composer.create_add_gate(
+            { idx[4], idx[5], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -11 });
+        honk_composer.create_add_gate(
+            { idx[6], idx[7], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -15 });
+    }
+    {
+        auto idx = add_variables(plonk_composer, { 1, 2, 3, 4, 5, 6, 7, 8 });
+        for (size_t i = 0; i < idx.size(); i++) {
+            plonk_composer.create_new_range_constraint(idx[i], 8);
+        }
+
+        plonk_composer.create_add_gate(
+            { idx[0], idx[1], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -3 });
+        plonk_composer.create_add_gate(
+            { idx[2], idx[3], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -7 });
+        plonk_composer.create_add_gate(
+            { idx[4], idx[5], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -11 });
+        plonk_composer.create_add_gate(
+            { idx[6], idx[7], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -15 });
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, range_with_gates_where_range_is_not_a_power_of_two)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    {
+        auto idx = add_variables(honk_composer, { 1, 2, 3, 4, 5, 6, 7, 8 });
+        for (size_t i = 0; i < idx.size(); i++) {
+            honk_composer.create_new_range_constraint(idx[i], 12);
+        }
+
+        honk_composer.create_add_gate(
+            { idx[0], idx[1], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -3 });
+        honk_composer.create_add_gate(
+            { idx[2], idx[3], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -7 });
+        honk_composer.create_add_gate(
+            { idx[4], idx[5], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -11 });
+        honk_composer.create_add_gate(
+            { idx[6], idx[7], honk_composer.get_zero_idx(), fr::one(), fr::one(), fr::zero(), -15 });
+    }
+    {
+        auto idx = add_variables(plonk_composer, { 1, 2, 3, 4, 5, 6, 7, 8 });
+        for (size_t i = 0; i < idx.size(); i++) {
+            plonk_composer.create_new_range_constraint(idx[i], 12);
+        }
+
+        plonk_composer.create_add_gate(
+            { idx[0], idx[1], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -3 });
+        plonk_composer.create_add_gate(
+            { idx[2], idx[3], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -7 });
+        plonk_composer.create_add_gate(
+            { idx[4], idx[5], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -11 });
+        plonk_composer.create_add_gate(
+            { idx[6], idx[7], plonk_composer.zero_idx, fr::one(), fr::one(), fr::zero(), -15 });
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, sort_widget_complex)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    {
+        std::vector<fr> a = { 1, 3, 4, 7, 7, 8, 16, 14, 15, 15, 18, 19, 21, 21, 24, 25, 26, 27, 30, 32 };
+        std::vector<uint32_t> ind;
+        for (size_t i = 0; i < a.size(); i++)
+            ind.emplace_back(honk_composer.add_variable(a[i]));
+        honk_composer.create_sort_constraint(ind);
+    }
+    {
+        std::vector<fr> a = { 1, 3, 4, 7, 7, 8, 16, 14, 15, 15, 18, 19, 21, 21, 24, 25, 26, 27, 30, 32 };
+        std::vector<uint32_t> ind;
+        for (size_t i = 0; i < a.size(); i++)
+            ind.emplace_back(plonk_composer.add_variable(a[i]));
+        plonk_composer.create_sort_constraint(ind);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, composed_range_constraint)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    auto c = fr::random_element();
+    {
+        auto d = uint256_t(c).slice(0, 133);
+        auto e = fr(d);
+        auto a_idx = honk_composer.add_variable(fr(e));
+        honk_composer.create_add_gate(
+            { a_idx, honk_composer.get_zero_idx(), honk_composer.get_zero_idx(), 1, 0, 0, -fr(e) });
+        honk_composer.decompose_into_default_range(a_idx, 134);
+    }
+    {
+        auto d = uint256_t(c).slice(0, 133);
+        auto e = fr(d);
+        auto a_idx = plonk_composer.add_variable(fr(e));
+        plonk_composer.create_add_gate({ a_idx, plonk_composer.zero_idx, plonk_composer.zero_idx, 1, 0, 0, -fr(e) });
+        plonk_composer.decompose_into_default_range(a_idx, 134);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, non_native_field_multiplication)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    fq a = fq::random_element();
+    fq b = fq::random_element();
+    {
+        uint256_t modulus = fq::modulus;
+
+        uint1024_t a_big = uint512_t(uint256_t(a));
+        uint1024_t b_big = uint512_t(uint256_t(b));
+        uint1024_t p_big = uint512_t(uint256_t(modulus));
+
+        uint1024_t q_big = (a_big * b_big) / p_big;
+        uint1024_t r_big = (a_big * b_big) % p_big;
+
+        uint256_t q(q_big.lo.lo);
+        uint256_t r(r_big.lo.lo);
+
+        const auto split_into_limbs = [&](const uint512_t& input) {
+            constexpr size_t NUM_BITS = 68;
+            std::array<fr, 5> limbs;
+            limbs[0] = input.slice(0, NUM_BITS).lo;
+            limbs[1] = input.slice(NUM_BITS * 1, NUM_BITS * 2).lo;
+            limbs[2] = input.slice(NUM_BITS * 2, NUM_BITS * 3).lo;
+            limbs[3] = input.slice(NUM_BITS * 3, NUM_BITS * 4).lo;
+            limbs[4] = fr(input.lo);
+            return limbs;
+        };
+
+        const auto get_limb_witness_indices = [&](const std::array<fr, 5>& limbs) {
+            std::array<uint32_t, 5> limb_indices;
+            limb_indices[0] = honk_composer.add_variable(limbs[0]);
+            limb_indices[1] = honk_composer.add_variable(limbs[1]);
+            limb_indices[2] = honk_composer.add_variable(limbs[2]);
+            limb_indices[3] = honk_composer.add_variable(limbs[3]);
+            limb_indices[4] = honk_composer.add_variable(limbs[4]);
+            return limb_indices;
+        };
+        const uint512_t BINARY_BASIS_MODULUS = uint512_t(1) << (68 * 4);
+        auto modulus_limbs = split_into_limbs(BINARY_BASIS_MODULUS - uint512_t(modulus));
+
+        const auto a_indices = get_limb_witness_indices(split_into_limbs(uint256_t(a)));
+        const auto b_indices = get_limb_witness_indices(split_into_limbs(uint256_t(b)));
+        const auto q_indices = get_limb_witness_indices(split_into_limbs(uint256_t(q)));
+        const auto r_indices = get_limb_witness_indices(split_into_limbs(uint256_t(r)));
+
+        proof_system::non_native_field_witnesses inputs{
+            a_indices, b_indices, q_indices, r_indices, modulus_limbs, fr(uint256_t(modulus)),
+        };
+        const auto [lo_1_idx, hi_1_idx] = honk_composer.evaluate_non_native_field_multiplication(inputs);
+        honk_composer.range_constrain_two_limbs(lo_1_idx, hi_1_idx, 70, 70);
+    }
+    {
+        uint256_t modulus = fq::modulus;
+
+        uint1024_t a_big = uint512_t(uint256_t(a));
+        uint1024_t b_big = uint512_t(uint256_t(b));
+        uint1024_t p_big = uint512_t(uint256_t(modulus));
+
+        uint1024_t q_big = (a_big * b_big) / p_big;
+        uint1024_t r_big = (a_big * b_big) % p_big;
+
+        uint256_t q(q_big.lo.lo);
+        uint256_t r(r_big.lo.lo);
+
+        const auto split_into_limbs = [&](const uint512_t& input) {
+            constexpr size_t NUM_BITS = 68;
+            std::array<fr, 5> limbs;
+            limbs[0] = input.slice(0, NUM_BITS).lo;
+            limbs[1] = input.slice(NUM_BITS * 1, NUM_BITS * 2).lo;
+            limbs[2] = input.slice(NUM_BITS * 2, NUM_BITS * 3).lo;
+            limbs[3] = input.slice(NUM_BITS * 3, NUM_BITS * 4).lo;
+            limbs[4] = fr(input.lo);
+            return limbs;
+        };
+
+        const auto get_limb_witness_indices = [&](const std::array<fr, 5>& limbs) {
+            std::array<uint32_t, 5> limb_indices;
+            limb_indices[0] = plonk_composer.add_variable(limbs[0]);
+            limb_indices[1] = plonk_composer.add_variable(limbs[1]);
+            limb_indices[2] = plonk_composer.add_variable(limbs[2]);
+            limb_indices[3] = plonk_composer.add_variable(limbs[3]);
+            limb_indices[4] = plonk_composer.add_variable(limbs[4]);
+            return limb_indices;
+        };
+        const uint512_t BINARY_BASIS_MODULUS = uint512_t(1) << (68 * 4);
+        auto modulus_limbs = split_into_limbs(BINARY_BASIS_MODULUS - uint512_t(modulus));
+
+        const auto a_indices = get_limb_witness_indices(split_into_limbs(uint256_t(a)));
+        const auto b_indices = get_limb_witness_indices(split_into_limbs(uint256_t(b)));
+        const auto q_indices = get_limb_witness_indices(split_into_limbs(uint256_t(q)));
+        const auto r_indices = get_limb_witness_indices(split_into_limbs(uint256_t(r)));
+
+        proof_system::plonk::UltraComposer::non_native_field_witnesses inputs{
+            a_indices, b_indices, q_indices, r_indices, modulus_limbs, fr(uint256_t(modulus)),
+        };
+        const auto [lo_1_idx, hi_1_idx] = plonk_composer.evaluate_non_native_field_multiplication(inputs);
+        plonk_composer.range_constrain_two_limbs(lo_1_idx, hi_1_idx, 70, 70);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, rom)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    auto a = fr::random_element();
+    auto b = fr::random_element();
+    auto c = fr::random_element();
+    auto d = fr::random_element();
+    auto e = fr::random_element();
+    auto f = fr::random_element();
+    auto g = fr::random_element();
+    auto h = fr::random_element();
+    {
+        uint32_t rom_values[8]{
+            honk_composer.add_variable(a), honk_composer.add_variable(b), honk_composer.add_variable(c),
+            honk_composer.add_variable(d), honk_composer.add_variable(e), honk_composer.add_variable(f),
+            honk_composer.add_variable(g), honk_composer.add_variable(h),
+        };
+
+        size_t rom_id = honk_composer.create_ROM_array(8);
+
+        for (size_t i = 0; i < 8; ++i) {
+            honk_composer.set_ROM_element(rom_id, i, rom_values[i]);
+        }
+
+        uint32_t a_idx = honk_composer.read_ROM_array(rom_id, honk_composer.add_variable(5));
+        EXPECT_EQ(a_idx != rom_values[5], true);
+        uint32_t b_idx = honk_composer.read_ROM_array(rom_id, honk_composer.add_variable(4));
+        uint32_t c_idx = honk_composer.read_ROM_array(rom_id, honk_composer.add_variable(1));
+
+        const auto d_value =
+            honk_composer.get_variable(a_idx) + honk_composer.get_variable(b_idx) + honk_composer.get_variable(c_idx);
+        uint32_t d_idx = honk_composer.add_variable(d_value);
+
+        honk_composer.create_big_add_gate({
+            a_idx,
+            b_idx,
+            c_idx,
+            d_idx,
+            1,
+            1,
+            1,
+            -1,
+            0,
+        });
+    }
+    {
+        uint32_t rom_values[8]{
+            plonk_composer.add_variable(a), plonk_composer.add_variable(b), plonk_composer.add_variable(c),
+            plonk_composer.add_variable(d), plonk_composer.add_variable(e), plonk_composer.add_variable(f),
+            plonk_composer.add_variable(g), plonk_composer.add_variable(h),
+        };
+
+        size_t rom_id = plonk_composer.create_ROM_array(8);
+
+        for (size_t i = 0; i < 8; ++i) {
+            plonk_composer.set_ROM_element(rom_id, i, rom_values[i]);
+        }
+
+        uint32_t a_idx = plonk_composer.read_ROM_array(rom_id, plonk_composer.add_variable(5));
+        EXPECT_EQ(a_idx != rom_values[5], true);
+        uint32_t b_idx = plonk_composer.read_ROM_array(rom_id, plonk_composer.add_variable(4));
+        uint32_t c_idx = plonk_composer.read_ROM_array(rom_id, plonk_composer.add_variable(1));
+
+        const auto d_value = plonk_composer.get_variable(a_idx) + plonk_composer.get_variable(b_idx) +
+                             plonk_composer.get_variable(c_idx);
+        uint32_t d_idx = plonk_composer.add_variable(d_value);
+
+        plonk_composer.create_big_add_gate({
+            a_idx,
+            b_idx,
+            c_idx,
+            d_idx,
+            1,
+            1,
+            1,
+            -1,
+            0,
+        });
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    check_consistency(honk_prover, plonk_prover);
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+TEST(UltraHonkComposer, ram)
+{
+    auto honk_composer = UltraHonkComposer();
+    auto plonk_composer = proof_system::plonk::UltraComposer();
+
+    auto a = fr::random_element();
+    auto b = fr::random_element();
+    auto c = fr::random_element();
+    auto d = fr::random_element();
+    auto e = fr::random_element();
+    auto f = fr::random_element();
+    auto g = fr::random_element();
+    auto h = fr::random_element();
+    {
+        uint32_t ram_values[8]{
+            honk_composer.add_variable(a), honk_composer.add_variable(b), honk_composer.add_variable(c),
+            honk_composer.add_variable(d), honk_composer.add_variable(e), honk_composer.add_variable(f),
+            honk_composer.add_variable(g), honk_composer.add_variable(h),
+        };
+
+        size_t ram_id = honk_composer.create_RAM_array(8);
+
+        for (size_t i = 0; i < 8; ++i) {
+            honk_composer.init_RAM_element(ram_id, i, ram_values[i]);
+        }
+
+        uint32_t a_idx = honk_composer.read_RAM_array(ram_id, honk_composer.add_variable(5));
+        EXPECT_EQ(a_idx != ram_values[5], true);
+
+        uint32_t b_idx = honk_composer.read_RAM_array(ram_id, honk_composer.add_variable(4));
+        uint32_t c_idx = honk_composer.read_RAM_array(ram_id, honk_composer.add_variable(1));
+
+        honk_composer.write_RAM_array(ram_id, honk_composer.add_variable(4), honk_composer.add_variable(500));
+        uint32_t d_idx = honk_composer.read_RAM_array(ram_id, honk_composer.add_variable(4));
+
+        EXPECT_EQ(honk_composer.get_variable(d_idx), 500);
+
+        // ensure these vars get used in another arithmetic gate
+        const auto e_value = honk_composer.get_variable(a_idx) + honk_composer.get_variable(b_idx) +
+                             honk_composer.get_variable(c_idx) + honk_composer.get_variable(d_idx);
+        uint32_t e_idx = honk_composer.add_variable(e_value);
+
+        honk_composer.create_big_add_gate(
+            {
+                a_idx,
+                b_idx,
+                c_idx,
+                d_idx,
+                -1,
+                -1,
+                -1,
+                -1,
+                0,
+            },
+            true);
+        honk_composer.create_big_add_gate(
+            {
+                honk_composer.get_zero_idx(),
+                honk_composer.get_zero_idx(),
+                honk_composer.get_zero_idx(),
+                e_idx,
+                0,
+                0,
+                0,
+                0,
+                0,
+            },
+            false);
+    }
+    {
+        uint32_t ram_values[8]{
+            plonk_composer.add_variable(a), plonk_composer.add_variable(b), plonk_composer.add_variable(c),
+            plonk_composer.add_variable(d), plonk_composer.add_variable(e), plonk_composer.add_variable(f),
+            plonk_composer.add_variable(g), plonk_composer.add_variable(h),
+        };
+
+        size_t ram_id = plonk_composer.create_RAM_array(8);
+
+        for (size_t i = 0; i < 8; ++i) {
+            plonk_composer.init_RAM_element(ram_id, i, ram_values[i]);
+        }
+
+        uint32_t a_idx = plonk_composer.read_RAM_array(ram_id, plonk_composer.add_variable(5));
+        EXPECT_EQ(a_idx != ram_values[5], true);
+
+        uint32_t b_idx = plonk_composer.read_RAM_array(ram_id, plonk_composer.add_variable(4));
+        uint32_t c_idx = plonk_composer.read_RAM_array(ram_id, plonk_composer.add_variable(1));
+
+        plonk_composer.write_RAM_array(ram_id, plonk_composer.add_variable(4), plonk_composer.add_variable(500));
+        uint32_t d_idx = plonk_composer.read_RAM_array(ram_id, plonk_composer.add_variable(4));
+
+        EXPECT_EQ(plonk_composer.get_variable(d_idx), 500);
+
+        // ensure these vars get used in another arithmetic gate
+        const auto e_value = plonk_composer.get_variable(a_idx) + plonk_composer.get_variable(b_idx) +
+                             plonk_composer.get_variable(c_idx) + plonk_composer.get_variable(d_idx);
+        uint32_t e_idx = plonk_composer.add_variable(e_value);
+
+        plonk_composer.create_big_add_gate(
+            {
+                a_idx,
+                b_idx,
+                c_idx,
+                d_idx,
+                -1,
+                -1,
+                -1,
+                -1,
+                0,
+            },
+            true);
+        plonk_composer.create_big_add_gate(
+            {
+                plonk_composer.zero_idx,
+                plonk_composer.zero_idx,
+                plonk_composer.zero_idx,
+                e_idx,
+                0,
+                0,
+                0,
+                0,
+                0,
+            },
+            false);
+    }
+
+    auto honk_prover = honk_composer.create_prover();
+    auto plonk_prover = plonk_composer.create_prover();
+
+    verify_consistency(honk_prover, plonk_prover);
+}
+
+} // namespace test_ultra_honk_composer
diff --git a/cpp/src/barretenberg/honk/flavor/flavor.hpp b/cpp/src/barretenberg/honk/flavor/flavor.hpp
index ad47783e1d..c420ed64aa 100644
--- a/cpp/src/barretenberg/honk/flavor/flavor.hpp
+++ b/cpp/src/barretenberg/honk/flavor/flavor.hpp
@@ -14,7 +14,7 @@ struct StandardArithmetization {
      * This separation must be maintained to allow for programmatic access, but the ordering of the
      * polynomials can be permuted within each category if necessary. Polynomials can also be added
      * or removed (assuming consistency with the prover algorithm) but the constants describing the
-     * number of poynomials in each category must be manually updated.
+     * number of polynomials in each category must be manually updated.
      *
      */
     enum POLYNOMIAL {
@@ -187,4 +187,58 @@ struct StandardHonk {
         return output;
     }
 };
+
+struct UltraArithmetization {
+    /**
+     * @brief All of the multivariate polynomials used by the Ultra Honk Prover.
+     * @details The polynomials are broken into three categories: precomputed, witness, and shifted.
+     * This separation must be maintained to allow for programmatic access, but the ordering of the
+     * polynomials can be permuted within each category if necessary. Polynomials can also be added
+     * or removed (assuming consistency with the prover algorithm) but the constants describing the
+     * number of polynomials in each category must be manually updated.
+     *
+     */
+    enum POLYNOMIAL {
+        /* --- PRECOMPUTED POLYNOMIALS --- */
+        Q_C,
+        Q_L,
+        Q_R,
+        Q_O,
+        Q_4,
+        Q_M,
+        QARITH,
+        QSORT,
+        QELLIPTIC,
+        QAUX,
+        QLOOKUPTYPE,
+        SIGMA_1,
+        SIGMA_2,
+        SIGMA_3,
+        SIGMA_4,
+        ID_1,
+        ID_2,
+        ID_3,
+        ID_4,
+        LAGRANGE_FIRST,
+        LAGRANGE_LAST, // = LAGRANGE_N-1 whithout ZK, but can be less
+        /* --- WITNESS POLYNOMIALS --- */
+        W_L,
+        W_R,
+        W_O,
+        W_4,
+        S_1,
+        S_2,
+        S_3,
+        S_4,
+        Z_PERM,
+        Z_LOOKUP,
+        /* --- SHIFTED POLYNOMIALS --- */
+        W_1_SHIFT,
+        W_4_SHIFT,
+        Z_PERM_SHIFT,
+        Z_LOOKUP_SHIFT,
+        /* --- --- */
+        COUNT // for programmatic determination of NUM_POLYNOMIALS
+    };
+};
 } // namespace proof_system::honk
diff --git a/cpp/src/barretenberg/honk/proof_system/prover_library.cpp b/cpp/src/barretenberg/honk/proof_system/prover_library.cpp
index d99a2947a4..753bee2b92 100644
--- a/cpp/src/barretenberg/honk/proof_system/prover_library.cpp
+++ b/cpp/src/barretenberg/honk/proof_system/prover_library.cpp
@@ -1,6 +1,7 @@
 #include "prover_library.hpp"
 #include "barretenberg/plonk/proof_system/types/prover_settings.hpp"
 #include <span>
+#include <string>
 
 namespace proof_system::honk::prover_library {
 
@@ -55,19 +56,18 @@ Polynomial compute_permutation_grand_product(std::shared_ptr<plonk::proving_key>
     // Populate wire and permutation polynomials
     std::array<std::span<const Fr>, program_width> wires;
     std::array<std::span<const Fr>, program_width> sigmas;
+    std::array<std::span<const Fr>, program_width> ids;
     for (size_t i = 0; i < program_width; ++i) {
-        std::string sigma_id = "sigma_" + std::to_string(i + 1) + "_lagrange";
         wires[i] = wire_polynomials[i];
-        sigmas[i] = key->polynomial_store.get(sigma_id);
+        sigmas[i] = key->polynomial_store.get("sigma_" + std::to_string(i + 1) + "_lagrange");
+        ids[i] = key->polynomial_store.get("id_" + std::to_string(i + 1) + "_lagrange");
     }
 
     // Step (1)
     // TODO(#222)(kesha): Change the order to engage automatic prefetching and get rid of redundant computation
     for (size_t i = 0; i < key->circuit_size; ++i) {
         for (size_t k = 0; k < program_width; ++k) {
-            // Note(luke): this idx could be replaced by proper ID polys if desired
-            Fr idx = k * key->circuit_size + i;
-            numerator_accumulator[k][i] = wires[k][i] + (idx * beta) + gamma;            // w_k(i) + β.(k*n+i) + γ
+            numerator_accumulator[k][i] = wires[k][i] + (ids[k][i] * beta) + gamma;      // w_k(i) + β.id_k(i) + γ
             denominator_accumulator[k][i] = wires[k][i] + (sigmas[k][i] * beta) + gamma; // w_k(i) + β.σ_k(i) + γ
         }
     }
diff --git a/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp b/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp
index 0902129370..f62380ebc9 100644
--- a/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp
+++ b/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp
@@ -13,7 +13,6 @@
 using namespace proof_system::honk;
 namespace prover_library_tests {
 
-// field is named Fscalar here because of clash with the Fr
 template <class FF> class ProverLibraryTests : public testing::Test {
 
     using Polynomial = barretenberg::Polynomial<FF>;
@@ -60,13 +59,17 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         // can simply be random. We're not interested in the particular properties of the result.
         std::vector<Polynomial> wires;
         std::vector<Polynomial> sigmas;
+        std::vector<Polynomial> ids;
         for (size_t i = 0; i < program_width; ++i) {
             wires.emplace_back(get_random_polynomial(num_gates));
             sigmas.emplace_back(get_random_polynomial(num_gates));
+            ids.emplace_back(get_random_polynomial(num_gates));
 
-            // Add sigma polys to proving_key; to be used by the prover in constructing it's own z_perm
-            std::string sigma_id = "sigma_" + std::to_string(i + 1) + "_lagrange";
-            proving_key->polynomial_store.put(sigma_id, Polynomial{ sigmas[i] });
+            // Add sigma/ID polys to proving_key; to be used by the prover in constructing it's own z_perm
+            std::string sigma_label = "sigma_" + std::to_string(i + 1) + "_lagrange";
+            proving_key->polynomial_store.put(sigma_label, Polynomial{ sigmas[i] });
+            std::string id_label = "id_" + std::to_string(i + 1) + "_lagrange";
+            proving_key->polynomial_store.put(id_label, Polynomial{ ids[i] });
         }
 
         // Get random challenges
@@ -109,8 +112,7 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         // Step (1)
         for (size_t i = 0; i < proving_key->circuit_size; ++i) {
             for (size_t k = 0; k < program_width; ++k) {
-                FF idx = k * proving_key->circuit_size + i;                            // id_k[i]
-                numererator_accum[k][i] = wires[k][i] + (idx * beta) + gamma;          // w_k(i) + β.(k*n+i) + γ
+                numererator_accum[k][i] = wires[k][i] + (ids[k][i] * beta) + gamma;    // w_k(i) + β.id_k(i) + γ
                 denominator_accum[k][i] = wires[k][i] + (sigmas[k][i] * beta) + gamma; // w_k(i) + β.σ_k(i) + γ
             }
         }
@@ -206,8 +208,8 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         //                                   ∏(s_k + βs_{k+1} + γ(1 + β))
         //
         // in a way that is simple to read (but inefficient). See prover library method for more details.
-        const Fr eta_sqr = eta.sqr();
-        const Fr eta_cube = eta_sqr * eta;
+        const FF eta_sqr = eta.sqr();
+        const FF eta_cube = eta_sqr * eta;
 
         std::array<Polynomial, 4> accumulators;
         for (size_t i = 0; i < 4; ++i) {
@@ -219,12 +221,12 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         // Note: block_mask is used for efficient modulus, i.e. i % N := i & (N-1), for N = 2^k
         const size_t block_mask = circuit_size - 1;
         // Initialize 't(X)' to be used in an expression of the form t(X) + β*t(Xω)
-        Fr table_i = tables[0][0] + tables[1][0] * eta + tables[2][0] * eta_sqr + tables[3][0] * eta_cube;
+        FF table_i = tables[0][0] + tables[1][0] * eta + tables[2][0] * eta_sqr + tables[3][0] * eta_cube;
         for (size_t i = 0; i < circuit_size; ++i) {
             size_t shift_idx = (i + 1) & block_mask;
 
             // f = (w_1 + q_2*w_1(Xω)) + η(w_2 + q_m*w_2(Xω)) + η²(w_3 + q_c*w_3(Xω)) + η³q_index.
-            Fr f_i = (wires[0][i] + wires[0][shift_idx] * column_1_step_size[i]) +
+            FF f_i = (wires[0][i] + wires[0][shift_idx] * column_1_step_size[i]) +
                      (wires[1][i] + wires[1][shift_idx] * column_2_step_size[i]) * eta +
                      (wires[2][i] + wires[2][shift_idx] * column_3_step_size[i]) * eta_sqr +
                      eta_cube * lookup_index_selector[i];
@@ -233,17 +235,17 @@ template <class FF> class ProverLibraryTests : public testing::Test {
             accumulators[0][i] = lookup_selector[i] * f_i + gamma;
 
             // t = t_1 + ηt_2 + η²t_3 + η³t_4
-            Fr table_i_plus_1 = tables[0][shift_idx] + eta * tables[1][shift_idx] + eta_sqr * tables[2][shift_idx] +
+            FF table_i_plus_1 = tables[0][shift_idx] + eta * tables[1][shift_idx] + eta_sqr * tables[2][shift_idx] +
                                 eta_cube * tables[3][shift_idx];
 
             // t + βt(Xω) + γ(1 + β)
-            accumulators[1][i] = table_i + table_i_plus_1 * beta + gamma * (Fr::one() + beta);
+            accumulators[1][i] = table_i + table_i_plus_1 * beta + gamma * (FF::one() + beta);
 
             // (1 + β)
-            accumulators[2][i] = Fr::one() + beta;
+            accumulators[2][i] = FF::one() + beta;
 
             // s + βs(Xω) + γ(1 + β)
-            accumulators[3][i] = s_lagrange[i] + beta * s_lagrange[shift_idx] + gamma * (Fr::one() + beta);
+            accumulators[3][i] = s_lagrange[i] + beta * s_lagrange[shift_idx] + gamma * (FF::one() + beta);
 
             // Set t(X_i) for next iteration
             table_i = table_i_plus_1;
@@ -303,8 +305,8 @@ template <class FF> class ProverLibraryTests : public testing::Test {
             prover_library::compute_sorted_list_accumulator(proving_key, sorted_list_polynomials, eta);
 
         // Method 2: Compute local sorted list accumulator simply and inefficiently
-        const Fr eta_sqr = eta.sqr();
-        const Fr eta_cube = eta_sqr * eta;
+        const FF eta_sqr = eta.sqr();
+        const FF eta_cube = eta_sqr * eta;
 
         // Compute s = s_1 + η*s_2 + η²*s_3 + η³*s_4
         Polynomial sorted_list_accumulator_expected{ sorted_list_polynomials[0] };
diff --git a/cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp b/cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp
new file mode 100644
index 0000000000..769e744a6d
--- /dev/null
+++ b/cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp
@@ -0,0 +1,56 @@
+#include "ultra_prover.hpp"
+#include <algorithm>
+#include <cstddef>
+#include "barretenberg/honk/proof_system/prover_library.hpp"
+#include "barretenberg/honk/sumcheck/sumcheck.hpp"
+#include <array>
+#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp" // will go away
+#include "barretenberg/honk/utils/power_polynomial.hpp"
+#include "barretenberg/honk/pcs/commitment_key.hpp"
+#include <memory>
+#include <span>
+#include <utility>
+#include <vector>
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/ecc/curves/bn254/g1.hpp"
+#include "barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp"
+#include "barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp"
+#include "barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp"
+#include "barretenberg/polynomials/polynomial.hpp"
+#include "barretenberg/honk/flavor/flavor.hpp"
+#include "barretenberg/transcript/transcript_wrappers.hpp"
+#include <string>
+#include "barretenberg/honk/pcs/claim.hpp"
+
+namespace proof_system::honk {
+
+/**
+ * Create UltraHonkProver from proving key, witness and manifest.
+ *
+ * @param input_key Proving key.
+ * @param input_manifest Input manifest
+ *
+ * @tparam settings Settings class.
+ * */
+template <typename settings>
+UltraHonkProver<settings>::UltraHonkProver(std::vector<barretenberg::polynomial>&& wire_polys,
+                                           std::shared_ptr<plonk::proving_key> input_key)
+    : wire_polynomials(wire_polys)
+    , key(input_key)
+    , queue(key, transcript)
+{}
+
+template <typename settings> plonk::proof& UltraHonkProver<settings>::export_proof()
+{
+    proof.proof_data = transcript.proof_data;
+    return proof;
+}
+
+template <typename settings> plonk::proof& UltraHonkProver<settings>::construct_proof()
+{
+    return export_proof();
+}
+
+template class UltraHonkProver<plonk::ultra_settings>;
+
+} // namespace proof_system::honk
diff --git a/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp b/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
new file mode 100644
index 0000000000..b645e5863f
--- /dev/null
+++ b/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
@@ -0,0 +1,63 @@
+#pragma once
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/honk/pcs/shplonk/shplonk.hpp"
+#include "barretenberg/polynomials/polynomial.hpp"
+#include "barretenberg/honk/flavor/flavor.hpp"
+#include <array>
+#include "barretenberg/plonk/proof_system/proving_key/proving_key.hpp"
+#include "barretenberg/honk/pcs/commitment_key.hpp"
+#include "barretenberg/plonk/proof_system/types/proof.hpp"
+#include "barretenberg/plonk/proof_system/types/program_settings.hpp"
+#include "barretenberg/honk/pcs/gemini/gemini.hpp"
+#include "barretenberg/honk/pcs/shplonk/shplonk_single.hpp"
+#include "barretenberg/honk/pcs/kzg/kzg.hpp"
+#include "barretenberg/honk/transcript/transcript.hpp"
+#include "barretenberg/honk/sumcheck/sumcheck.hpp"
+#include "barretenberg/honk/sumcheck/sumcheck_output.hpp"
+#include <span>
+#include <unordered_map>
+#include <vector>
+#include <algorithm>
+#include <cstddef>
+#include <memory>
+#include <utility>
+#include <string>
+#include "barretenberg/honk/pcs/claim.hpp"
+#include "barretenberg/honk/proof_system/prover_library.hpp"
+
+namespace proof_system::honk {
+
+// TODO(luke): The naming here is awkward. The Standard Honk prover is called "Prover" and aliased as StandardProver. To
+// be consistent with that convention outside of the prover class itself, I've called this class UltraHonkProver and use
+// the alias UltraProver externally. Resolve.
+template <typename settings> class UltraHonkProver {
+
+    using Fr = barretenberg::fr;
+    using Polynomial = barretenberg::Polynomial<Fr>;
+    using Commitment = barretenberg::g1::affine_element;
+    using POLYNOMIAL = proof_system::honk::StandardArithmetization::POLYNOMIAL;
+
+  public:
+    UltraHonkProver(std::vector<barretenberg::polynomial>&& wire_polys,
+                    std::shared_ptr<plonk::proving_key> input_key = nullptr);
+
+    plonk::proof& export_proof();
+    plonk::proof& construct_proof();
+
+    ProverTranscript<Fr> transcript;
+
+    std::vector<barretenberg::polynomial> wire_polynomials;
+
+    std::shared_ptr<plonk::proving_key> key;
+
+    work_queue<pcs::kzg::Params> queue;
+
+  private:
+    plonk::proof proof;
+};
+
+extern template class UltraHonkProver<plonk::ultra_settings>;
+
+using UltraProver = UltraHonkProver<plonk::ultra_settings>;
+
+} // namespace proof_system::honk
diff --git a/cpp/src/barretenberg/honk/proof_system/verifier.cpp b/cpp/src/barretenberg/honk/proof_system/verifier.cpp
index 26e4b7e033..b26f10fa47 100644
--- a/cpp/src/barretenberg/honk/proof_system/verifier.cpp
+++ b/cpp/src/barretenberg/honk/proof_system/verifier.cpp
@@ -3,7 +3,6 @@
 #include <cstddef>
 #include <memory>
 #include "barretenberg/honk/transcript/transcript.hpp"
-#include "barretenberg/plonk/proof_system/constants.hpp"
 #include "./verifier.hpp"
 #include "barretenberg/plonk/proof_system/public_inputs/public_inputs.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
diff --git a/cpp/src/barretenberg/honk/proof_system/verifier.test.cpp b/cpp/src/barretenberg/honk/proof_system/verifier.test.cpp
index b98d39e893..903ea36adb 100644
--- a/cpp/src/barretenberg/honk/proof_system/verifier.test.cpp
+++ b/cpp/src/barretenberg/honk/proof_system/verifier.test.cpp
@@ -1,5 +1,4 @@
 #include "barretenberg/numeric/bitop/get_msb.hpp"
-#include "barretenberg/plonk/proof_system/constants.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/honk/flavor/flavor.hpp"
 #include "prover.hpp"
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp
index 5ecdedf61d..61f799e030 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp
@@ -90,4 +90,91 @@ template <typename FF> class GrandProductComputationRelation {
                  (w_2 + beta * sigma_2 + gamma) * (w_3 + beta * sigma_3 + gamma));
     };
 };
+
+// TODO(luke): With Cody's Flavor work it should be easier to create a simple templated relation
+// for handling arbitrary width. For now I'm duplicating the width 3 logic for width 4.
+template <typename FF> class UltraGrandProductComputationRelation {
+  public:
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 6;
+    using MULTIVARIATE = proof_system::honk::UltraArithmetization::POLYNOMIAL;
+
+    /**
+     * @brief Compute contribution of the permutation relation for a given edge (internal function)
+     *
+     * @details This the relation confirms faithful calculation of the grand
+     * product polynomial Z_perm.
+     *
+     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
+     * @param extended_edges an std::array containing the fully extended Univariate edges.
+     * @param parameters contains beta, gamma, and public_input_delta, ....
+     * @param scaling_factor optional term to scale the evaluation before adding to evals.
+     */
+    inline void add_edge_contribution(Univariate<FF, RELATION_LENGTH>& evals,
+                                      const auto& extended_edges,
+                                      const RelationParameters<FF>& relation_parameters,
+                                      const FF& scaling_factor) const
+    {
+        const auto& beta = relation_parameters.beta;
+        const auto& gamma = relation_parameters.gamma;
+        const auto& public_input_delta = relation_parameters.public_input_delta;
+
+        auto w_1 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_L]);
+        auto w_2 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_R]);
+        auto w_3 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_O]);
+        auto w_4 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_4]);
+        auto sigma_1 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::SIGMA_1]);
+        auto sigma_2 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::SIGMA_2]);
+        auto sigma_3 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::SIGMA_3]);
+        auto sigma_4 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::SIGMA_4]);
+        auto id_1 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::ID_1]);
+        auto id_2 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::ID_2]);
+        auto id_3 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::ID_3]);
+        auto id_4 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::ID_4]);
+        auto z_perm = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Z_PERM]);
+        auto z_perm_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Z_PERM_SHIFT]);
+        auto lagrange_first = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::LAGRANGE_FIRST]);
+        auto lagrange_last = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::LAGRANGE_LAST]);
+
+        // Contribution (1)
+        evals += (((z_perm + lagrange_first) * (w_1 + id_1 * beta + gamma) * (w_2 + id_2 * beta + gamma) *
+                   (w_3 + id_3 * beta + gamma) * (w_4 + id_4 * beta + gamma)) -
+                  ((z_perm_shift + lagrange_last * public_input_delta) * (w_1 + sigma_1 * beta + gamma) *
+                   (w_2 + sigma_2 * beta + gamma) * (w_3 + sigma_3 * beta + gamma) * (w_4 + sigma_4 * beta + gamma))) *
+                 scaling_factor;
+    };
+
+    void add_full_relation_value_contribution(FF& full_honk_relation_value,
+                                              auto& purported_evaluations,
+                                              const RelationParameters<FF>& relation_parameters) const
+    {
+        const auto& beta = relation_parameters.beta;
+        const auto& gamma = relation_parameters.gamma;
+        const auto& public_input_delta = relation_parameters.public_input_delta;
+
+        auto w_1 = purported_evaluations[MULTIVARIATE::W_L];
+        auto w_2 = purported_evaluations[MULTIVARIATE::W_R];
+        auto w_3 = purported_evaluations[MULTIVARIATE::W_O];
+        auto w_4 = purported_evaluations[MULTIVARIATE::W_4];
+        auto sigma_1 = purported_evaluations[MULTIVARIATE::SIGMA_1];
+        auto sigma_2 = purported_evaluations[MULTIVARIATE::SIGMA_2];
+        auto sigma_3 = purported_evaluations[MULTIVARIATE::SIGMA_3];
+        auto sigma_4 = purported_evaluations[MULTIVARIATE::SIGMA_4];
+        auto id_1 = purported_evaluations[MULTIVARIATE::ID_1];
+        auto id_2 = purported_evaluations[MULTIVARIATE::ID_2];
+        auto id_3 = purported_evaluations[MULTIVARIATE::ID_3];
+        auto id_4 = purported_evaluations[MULTIVARIATE::ID_4];
+        auto z_perm = purported_evaluations[MULTIVARIATE::Z_PERM];
+        auto z_perm_shift = purported_evaluations[MULTIVARIATE::Z_PERM_SHIFT];
+        auto lagrange_first = purported_evaluations[MULTIVARIATE::LAGRANGE_FIRST];
+        auto lagrange_last = purported_evaluations[MULTIVARIATE::LAGRANGE_LAST];
+
+        // Contribution (1)
+        full_honk_relation_value +=
+            ((z_perm + lagrange_first) * (w_1 + beta * id_1 + gamma) * (w_2 + beta * id_2 + gamma) *
+                 (w_3 + beta * id_3 + gamma) * (w_4 + beta * id_4 + gamma) -
+             (z_perm_shift + lagrange_last * public_input_delta) * (w_1 + beta * sigma_1 + gamma) *
+                 (w_2 + beta * sigma_2 + gamma) * (w_3 + beta * sigma_3 + gamma) * (w_4 + beta * sigma_4 + gamma));
+    };
+};
 } // namespace proof_system::honk::sumcheck
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp
index 788cec7f52..6aa7d9f3b2 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp
@@ -45,4 +45,48 @@ template <typename FF> class GrandProductInitializationRelation {
         full_honk_relation_value += lagrange_last * z_perm_shift;
     };
 };
+
+// TODO(luke): The only difference between the Ultra relation and the Standard version is the enum
+// used to refer into the edge polynomials. Seems desireable to not duplicate the code here but
+// leaving this as is until Codys Flavor work is settled.
+template <typename FF> class UltraGrandProductInitializationRelation {
+  public:
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 3;
+    using MULTIVARIATE = UltraArithmetization::POLYNOMIAL; // could just get from StandardArithmetization
+
+    /**
+     * @brief Add contribution of the permutation relation for a given edge
+     *
+     * @details There are 2 relations associated with enforcing the wire copy relations
+     * This file handles the relation Z_perm_shift(n_last) = 0 via the relation:
+     *
+     *                      C(X) = L_LAST(X) * Z_perm_shift(X)
+     *
+     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
+     * @param extended_edges an std::array containing the fully extended Univariate edges.
+     * @param parameters contains beta, gamma, and public_input_delta, ....
+     * @param scaling_factor optional term to scale the evaluation before adding to evals.
+     */
+    void add_edge_contribution(Univariate<FF, RELATION_LENGTH>& evals,
+                               const auto& extended_edges,
+                               const RelationParameters<FF>&,
+                               const FF& scaling_factor) const
+    {
+        auto z_perm_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Z_PERM_SHIFT]);
+        auto lagrange_last = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::LAGRANGE_LAST]);
+
+        evals += (lagrange_last * z_perm_shift) * scaling_factor;
+    };
+
+    void add_full_relation_value_contribution(FF& full_honk_relation_value,
+                                              auto& purported_evaluations,
+                                              const RelationParameters<FF>&) const
+    {
+        auto z_perm_shift = purported_evaluations[MULTIVARIATE::Z_PERM_SHIFT];
+        auto lagrange_last = purported_evaluations[MULTIVARIATE::LAGRANGE_LAST];
+
+        full_honk_relation_value += lagrange_last * z_perm_shift;
+    };
+};
 } // namespace proof_system::honk::sumcheck
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp
index a7860faeeb..e03f09f990 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp
@@ -2,7 +2,6 @@
 
 namespace proof_system::honk::sumcheck {
 
-// TODO(#226)(Adrian): Remove zeta, alpha as they are not used by the relations.
 template <typename FF> struct RelationParameters {
     FF beta;
     FF gamma;
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/relation.test.cpp b/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
similarity index 57%
rename from cpp/src/barretenberg/honk/sumcheck/relations/relation.test.cpp
rename to cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
index 6b7e1ac521..5557d7d47c 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/relation.test.cpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
@@ -1,3 +1,5 @@
+#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
+#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp"
 #include "relation.hpp"
 #include "barretenberg/honk/flavor/flavor.hpp"
 #include "arithmetic_relation.hpp"
@@ -9,6 +11,7 @@
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
 
+#include <cstddef>
 #include <gtest/gtest.h>
 using namespace proof_system::honk::sumcheck;
 /**
@@ -21,13 +24,11 @@ using namespace proof_system::honk::sumcheck;
  points),
  * extends them (using barycentric formula) to six evaluation points, and stores them to an array of polynomials.
  */
-static const size_t input_univariate_length = 2;
-static constexpr size_t FULL_RELATION_LENGTH = 5;
-static const size_t NUM_POLYNOMIALS = proof_system::honk::StandardArithmetization::NUM_POLYNOMIALS;
+static const size_t INPUT_UNIVARIATE_LENGTH = 2;
 
 namespace proof_system::honk_relation_tests {
 
-template <class FF> class SumcheckRelation : public testing::Test {
+template <class FF> class RelationConsistency : public testing::Test {
   public:
     template <size_t t> using Univariate = Univariate<FF, t>;
     template <size_t t> using UnivariateView = UnivariateView<FF, t>;
@@ -35,11 +36,12 @@ template <class FF> class SumcheckRelation : public testing::Test {
     // TODO(#225)(Adrian): Accept FULL_RELATION_LENGTH as a template parameter for this function only, so that the test
     // can decide to which degree the polynomials must be extended. Possible accept an existing list of "edges" and
     // extend them to the degree.
+    template <size_t FULL_RELATION_LENGTH, size_t NUM_POLYNOMIALS>
     static std::array<Univariate<FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> compute_mock_extended_edges(
-        std::array<Univariate<input_univariate_length>, NUM_POLYNOMIALS>& input_univariates)
+        std::array<Univariate<INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS>& input_univariates)
     {
-        BarycentricData<FF, input_univariate_length, FULL_RELATION_LENGTH> barycentric_2_to_max =
-            BarycentricData<FF, input_univariate_length, FULL_RELATION_LENGTH>();
+        BarycentricData<FF, INPUT_UNIVARIATE_LENGTH, FULL_RELATION_LENGTH> barycentric_2_to_max =
+            BarycentricData<FF, INPUT_UNIVARIATE_LENGTH, FULL_RELATION_LENGTH>();
         std::array<Univariate<FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_univariates;
         for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
             extended_univariates[i] = barycentric_2_to_max.extend(input_univariates[i]);
@@ -136,6 +138,7 @@ template <class FF> class SumcheckRelation : public testing::Test {
      * @param extended_edges
      * @param relation_parameters
      */
+    template <size_t FULL_RELATION_LENGTH, size_t NUM_POLYNOMIALS>
     static void validate_evaluations(
         const Univariate<FULL_RELATION_LENGTH>& expected_evals,
         const auto relation,
@@ -166,31 +169,35 @@ template <class FF> class SumcheckRelation : public testing::Test {
     };
 };
 using FieldTypes = testing::Types<barretenberg::fr>;
-TYPED_TEST_SUITE(SumcheckRelation, FieldTypes);
+TYPED_TEST_SUITE(RelationConsistency, FieldTypes);
 
 #define SUMCHECK_RELATION_TYPE_ALIASES using FF = TypeParam;
 
-TYPED_TEST(SumcheckRelation, ArithmeticRelation)
+TYPED_TEST(RelationConsistency, ArithmeticRelation)
 {
     SUMCHECK_RELATION_TYPE_ALIASES
     using MULTIVARIATE = honk::StandardArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 5;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::StandardArithmetization::NUM_POLYNOMIALS;
+
     const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
     auto run_test = [&relation_parameters](bool is_random_input) {
         std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
-        std::array<Univariate<FF, input_univariate_length>, NUM_POLYNOMIALS> input_polynomials;
+        std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
         if (!is_random_input) {
             // evaluation form, i.e. input_univariate(0) = 1, input_univariate(1) = 2,.. The polynomial is x+1.
             for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-                input_polynomials[i] = Univariate<FF, input_univariate_length>({ 1, 2 });
+                input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ 1, 2 });
             }
-            extended_edges = TestFixture::compute_mock_extended_edges(input_polynomials);
+            extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
         } else {
             // input_univariates are random polynomials of degree one
             for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
                 input_polynomials[i] =
-                    Univariate<FF, input_univariate_length>({ FF::random_element(), FF::random_element() });
+                    Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
             }
-            extended_edges = TestFixture::compute_mock_extended_edges(input_polynomials);
+            extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
         };
         auto relation = ArithmeticRelation<FF>();
         // Manually compute the expected edge contribution
@@ -207,33 +214,37 @@ TYPED_TEST(SumcheckRelation, ArithmeticRelation)
         // Ensure that expression changes are detected.
         // expected_evals, length 4, extends to { { 5, 22, 57, 116, 205} } for input polynomial {1, 2}
         auto expected_evals = (q_m * w_r * w_l) + (q_r * w_r) + (q_l * w_l) + (q_o * w_o) + (q_c);
-        TestFixture::validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+        TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
     };
     run_test(/* is_random_input=*/true);
     run_test(/* is_random_input=*/false);
 };
 
-TYPED_TEST(SumcheckRelation, GrandProductComputationRelation)
+TYPED_TEST(RelationConsistency, GrandProductComputationRelation)
 {
     SUMCHECK_RELATION_TYPE_ALIASES
     using MULTIVARIATE = honk::StandardArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 5;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::StandardArithmetization::NUM_POLYNOMIALS;
+
     const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
     auto run_test = [&relation_parameters](bool is_random_input) {
         std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
-        std::array<Univariate<FF, input_univariate_length>, NUM_POLYNOMIALS> input_polynomials;
+        std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
         if (!is_random_input) {
             // evaluation form, i.e. input_univariate(0) = 1, input_univariate(1) = 2,.. The polynomial is x+1.
             for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-                input_polynomials[i] = Univariate<FF, input_univariate_length>({ 1, 2 });
+                input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ 1, 2 });
             }
-            extended_edges = TestFixture::compute_mock_extended_edges(input_polynomials);
+            extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
         } else {
             // input_univariates are random polynomials of degree one
             for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
                 input_polynomials[i] =
-                    Univariate<FF, input_univariate_length>({ FF::random_element(), FF::random_element() });
+                    Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
             }
-            extended_edges = TestFixture::compute_mock_extended_edges(input_polynomials);
+            extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
         };
         auto relation = GrandProductComputationRelation<FF>();
 
@@ -269,33 +280,37 @@ TYPED_TEST(SumcheckRelation, GrandProductComputationRelation)
                               (z_perm_shift + lagrange_last * public_input_delta) * (w_1 + sigma_1 * beta + gamma) *
                                   (w_2 + sigma_2 * beta + gamma) * (w_3 + sigma_3 * beta + gamma);
 
-        TestFixture::validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+        TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
     };
     run_test(/* is_random_input=*/true);
     run_test(/* is_random_input=*/false);
 };
 
-TYPED_TEST(SumcheckRelation, GrandProductInitializationRelation)
+TYPED_TEST(RelationConsistency, GrandProductInitializationRelation)
 {
     SUMCHECK_RELATION_TYPE_ALIASES
     using MULTIVARIATE = honk::StandardArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 5;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::StandardArithmetization::NUM_POLYNOMIALS;
+
     const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
     auto run_test = [&relation_parameters](bool is_random_input) {
         std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
-        std::array<Univariate<FF, input_univariate_length>, NUM_POLYNOMIALS> input_polynomials;
+        std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
         if (!is_random_input) {
             // evaluation form, i.e. input_univariate(0) = 1, input_univariate(1) = 2,.. The polynomial is x+1.
             for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-                input_polynomials[i] = Univariate<FF, input_univariate_length>({ 1, 2 });
+                input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ 1, 2 });
             }
-            extended_edges = TestFixture::compute_mock_extended_edges(input_polynomials);
+            extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
         } else {
             // input_univariates are random polynomials of degree one
             for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
                 input_polynomials[i] =
-                    Univariate<FF, input_univariate_length>({ FF::random_element(), FF::random_element() });
+                    Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
             }
-            extended_edges = TestFixture::compute_mock_extended_edges(input_polynomials);
+            extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
         };
         auto relation = GrandProductInitializationRelation<FF>();
         const auto& z_perm_shift = extended_edges[MULTIVARIATE::Z_PERM_SHIFT];
@@ -305,10 +320,169 @@ TYPED_TEST(SumcheckRelation, GrandProductInitializationRelation)
         // expected_evals, lenght 3 (coeff form = x^2 + x), extends to { { 0, 2, 6, 12, 20 } }
         auto expected_evals = z_perm_shift * lagrange_last;
 
-        TestFixture::validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+        TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
     };
     run_test(/* is_random_input=*/true);
     run_test(/* is_random_input=*/false);
 };
 
+TYPED_TEST(RelationConsistency, UltraArithmeticRelation)
+{
+    SUMCHECK_RELATION_TYPE_ALIASES
+    using MULTIVARIATE = honk::UltraArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 6;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::UltraArithmetization::COUNT;
+
+    const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
+    std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
+    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
+
+    // input_univariates are random polynomials of degree one
+    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
+        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
+    }
+    extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
+
+    auto relation = UltraArithmeticRelation<FF>();
+
+    // Extract the extended edges for manual computation of relation contribution
+    const auto& w_1 = extended_edges[MULTIVARIATE::W_L];
+    const auto& w_2 = extended_edges[MULTIVARIATE::W_R];
+    const auto& w_3 = extended_edges[MULTIVARIATE::W_O];
+    const auto& w_4 = extended_edges[MULTIVARIATE::W_4];
+    const auto& w_4_shift = extended_edges[MULTIVARIATE::W_4_SHIFT];
+    const auto& q_m = extended_edges[MULTIVARIATE::Q_M];
+    const auto& q_l = extended_edges[MULTIVARIATE::Q_L];
+    const auto& q_r = extended_edges[MULTIVARIATE::Q_R];
+    const auto& q_o = extended_edges[MULTIVARIATE::Q_O];
+    const auto& q_4 = extended_edges[MULTIVARIATE::Q_4];
+    const auto& q_c = extended_edges[MULTIVARIATE::Q_C];
+    const auto& q_arith = extended_edges[MULTIVARIATE::QARITH];
+
+    static const FF neg_half = FF(-2).invert();
+
+    auto expected_evals = (q_arith - 3) * (q_m * w_2 * w_1) * neg_half;
+    expected_evals += (q_l * w_1) + (q_r * w_2) + (q_o * w_3) + (q_4 * w_4) + q_c;
+    expected_evals += (q_arith - 1) * w_4_shift;
+    expected_evals *= q_arith;
+
+    TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+};
+
+TYPED_TEST(RelationConsistency, UltraArithmeticRelationSecondary)
+{
+    SUMCHECK_RELATION_TYPE_ALIASES
+    using MULTIVARIATE = honk::UltraArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 6;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::UltraArithmetization::COUNT;
+
+    const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
+    std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
+    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
+
+    // input_univariates are random polynomials of degree one
+    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
+        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
+    }
+    extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
+
+    auto relation = UltraArithmeticRelationSecondary<FF>();
+
+    // Extract the extended edges for manual computation of relation contribution
+    const auto& w_1 = extended_edges[MULTIVARIATE::W_L];
+    const auto& w_4 = extended_edges[MULTIVARIATE::W_4];
+    const auto& w_1_shift = extended_edges[MULTIVARIATE::W_1_SHIFT];
+    const auto& q_m = extended_edges[MULTIVARIATE::Q_M];
+    const auto& q_arith = extended_edges[MULTIVARIATE::QARITH];
+
+    auto expected_evals = (w_1 + w_4 - w_1_shift + q_m);
+    expected_evals *= (q_arith - 2) * (q_arith - 1) * q_arith;
+
+    TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+};
+
+TYPED_TEST(RelationConsistency, UltraGrandProductInitializationRelation)
+{
+    SUMCHECK_RELATION_TYPE_ALIASES
+    using MULTIVARIATE = honk::UltraArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 6;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::UltraArithmetization::COUNT;
+
+    const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
+    std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
+    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
+
+    // input_univariates are random polynomials of degree one
+    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
+        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
+    }
+    extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
+
+    auto relation = UltraGrandProductInitializationRelation<FF>();
+
+    // Extract the extended edges for manual computation of relation contribution
+    const auto& z_perm_shift = extended_edges[MULTIVARIATE::Z_PERM_SHIFT];
+    const auto& lagrange_last = extended_edges[MULTIVARIATE::LAGRANGE_LAST];
+
+    // Compute the expected result using a simple to read version of the relation expression
+    auto expected_evals = z_perm_shift * lagrange_last;
+
+    TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+};
+
+TYPED_TEST(RelationConsistency, UltraGrandProductComputationRelation)
+{
+    SUMCHECK_RELATION_TYPE_ALIASES
+    using MULTIVARIATE = honk::UltraArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 6;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::UltraArithmetization::COUNT;
+
+    const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
+    std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
+    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
+
+    // input_univariates are random polynomials of degree one
+    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
+        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
+    }
+    extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
+
+    auto relation = UltraGrandProductComputationRelation<FF>();
+
+    const auto& beta = relation_parameters.beta;
+    const auto& gamma = relation_parameters.gamma;
+    const auto& public_input_delta = relation_parameters.public_input_delta;
+
+    // Extract the extended edges for manual computation of relation contribution
+    const auto& w_1 = extended_edges[MULTIVARIATE::W_L];
+    const auto& w_2 = extended_edges[MULTIVARIATE::W_R];
+    const auto& w_3 = extended_edges[MULTIVARIATE::W_O];
+    const auto& w_4 = extended_edges[MULTIVARIATE::W_4];
+    const auto& sigma_1 = extended_edges[MULTIVARIATE::SIGMA_1];
+    const auto& sigma_2 = extended_edges[MULTIVARIATE::SIGMA_2];
+    const auto& sigma_3 = extended_edges[MULTIVARIATE::SIGMA_3];
+    const auto& sigma_4 = extended_edges[MULTIVARIATE::SIGMA_4];
+    const auto& id_1 = extended_edges[MULTIVARIATE::ID_1];
+    const auto& id_2 = extended_edges[MULTIVARIATE::ID_2];
+    const auto& id_3 = extended_edges[MULTIVARIATE::ID_3];
+    const auto& id_4 = extended_edges[MULTIVARIATE::ID_4];
+    const auto& z_perm = extended_edges[MULTIVARIATE::Z_PERM];
+    const auto& z_perm_shift = extended_edges[MULTIVARIATE::Z_PERM_SHIFT];
+    const auto& lagrange_first = extended_edges[MULTIVARIATE::LAGRANGE_FIRST];
+    const auto& lagrange_last = extended_edges[MULTIVARIATE::LAGRANGE_LAST];
+
+    // Compute the expected result using a simple to read version of the relation expression
+    auto expected_evals = (z_perm + lagrange_first) * (w_1 + id_1 * beta + gamma) * (w_2 + id_2 * beta + gamma) *
+                              (w_3 + id_3 * beta + gamma) * (w_4 + id_4 * beta + gamma) -
+                          (z_perm_shift + lagrange_last * public_input_delta) * (w_1 + sigma_1 * beta + gamma) *
+                              (w_2 + sigma_2 * beta + gamma) * (w_3 + sigma_3 * beta + gamma) *
+                              (w_4 + sigma_4 * beta + gamma);
+
+    TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+};
+
 } // namespace proof_system::honk_relation_tests
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp b/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
new file mode 100644
index 0000000000..f5556a31da
--- /dev/null
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
@@ -0,0 +1,258 @@
+#include "barretenberg/honk/composer/ultra_honk_composer.hpp"
+#include "barretenberg/honk/composer/standard_honk_composer.hpp"
+#include "barretenberg/honk/sumcheck/relations/relation.hpp"
+#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
+#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp"
+#include "barretenberg/numeric/uint256/uint256.hpp"
+#include "barretenberg/honk/flavor/flavor.hpp"
+#include <cstdint>
+#include "barretenberg/honk/proof_system/prover.hpp"
+#include "barretenberg/honk/sumcheck/sumcheck_round.hpp"
+#include "barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp"
+#include "barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp"
+#include "barretenberg/honk/utils/public_inputs.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace proof_system::honk;
+
+namespace test_honk_relations {
+
+/**
+ * @brief Test the correctness of the Standard Honk relations
+ *
+ * @details Check that the constraints encoded by the relations are satisfied by the polynomials produced by the
+ * Standard Honk Composer for a real circuit.
+ *
+ * TODO(Kesha): We'll have to update this function once we add zk, since the relation will be incorrect for he first few
+ * indices
+ *
+ */
+TEST(RelationCorrectness, StandardRelationCorrectness)
+{
+    // Create a composer and a dummy circuit with a few gates
+    auto composer = StandardHonkComposer();
+    static const size_t num_wires = StandardHonkComposer::num_wires;
+    fr a = fr::one();
+    // Using the public variable to check that public_input_delta is computed and added to the relation correctly
+    uint32_t a_idx = composer.add_public_variable(a);
+    fr b = fr::one();
+    fr c = a + b;
+    fr d = a + c;
+    uint32_t b_idx = composer.add_variable(b);
+    uint32_t c_idx = composer.add_variable(c);
+    uint32_t d_idx = composer.add_variable(d);
+    for (size_t i = 0; i < 16; i++) {
+        composer.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+        composer.create_add_gate({ d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
+    }
+    // Create a prover (it will compute proving key and witness)
+    auto prover = composer.create_prover();
+
+    // Generate beta and gamma
+    fr beta = fr::random_element();
+    fr gamma = fr::random_element();
+
+    // Compute public input delta
+    const auto public_inputs = composer.circuit_constructor.get_public_inputs();
+    auto public_input_delta =
+        honk::compute_public_input_delta<fr>(public_inputs, beta, gamma, prover.key->circuit_size);
+
+    sumcheck::RelationParameters<fr> params{
+        .beta = beta,
+        .gamma = gamma,
+        .public_input_delta = public_input_delta,
+    };
+
+    constexpr size_t num_polynomials = proof_system::honk::StandardArithmetization::NUM_POLYNOMIALS;
+    // Compute grand product polynomial
+    polynomial z_perm_poly =
+        prover_library::compute_permutation_grand_product<num_wires>(prover.key, prover.wire_polynomials, beta, gamma);
+
+    // Create an array of spans to the underlying polynomials to more easily
+    // get the transposition.
+    // Ex: polynomial_spans[3][i] returns the i-th coefficient of the third polynomial
+    // in the list below
+    std::array<std::span<const fr>, num_polynomials> evaluations_array;
+
+    using POLYNOMIAL = proof_system::honk::StandardArithmetization::POLYNOMIAL;
+    evaluations_array[POLYNOMIAL::W_L] = prover.wire_polynomials[0];
+    evaluations_array[POLYNOMIAL::W_R] = prover.wire_polynomials[1];
+    evaluations_array[POLYNOMIAL::W_O] = prover.wire_polynomials[2];
+    evaluations_array[POLYNOMIAL::Z_PERM] = z_perm_poly;
+    evaluations_array[POLYNOMIAL::Z_PERM_SHIFT] = z_perm_poly.shifted();
+    evaluations_array[POLYNOMIAL::Q_M] = prover.key->polynomial_store.get("q_m_lagrange");
+    evaluations_array[POLYNOMIAL::Q_L] = prover.key->polynomial_store.get("q_1_lagrange");
+    evaluations_array[POLYNOMIAL::Q_R] = prover.key->polynomial_store.get("q_2_lagrange");
+    evaluations_array[POLYNOMIAL::Q_O] = prover.key->polynomial_store.get("q_3_lagrange");
+    evaluations_array[POLYNOMIAL::Q_C] = prover.key->polynomial_store.get("q_c_lagrange");
+    evaluations_array[POLYNOMIAL::SIGMA_1] = prover.key->polynomial_store.get("sigma_1_lagrange");
+    evaluations_array[POLYNOMIAL::SIGMA_2] = prover.key->polynomial_store.get("sigma_2_lagrange");
+    evaluations_array[POLYNOMIAL::SIGMA_3] = prover.key->polynomial_store.get("sigma_3_lagrange");
+    evaluations_array[POLYNOMIAL::ID_1] = prover.key->polynomial_store.get("id_1_lagrange");
+    evaluations_array[POLYNOMIAL::ID_2] = prover.key->polynomial_store.get("id_2_lagrange");
+    evaluations_array[POLYNOMIAL::ID_3] = prover.key->polynomial_store.get("id_3_lagrange");
+    evaluations_array[POLYNOMIAL::LAGRANGE_FIRST] = prover.key->polynomial_store.get("L_first_lagrange");
+    evaluations_array[POLYNOMIAL::LAGRANGE_LAST] = prover.key->polynomial_store.get("L_last_lagrange");
+
+    // Construct the round for applying sumcheck relations and results for storing computed results
+    auto relations = std::tuple(honk::sumcheck::ArithmeticRelation<fr>(),
+                                honk::sumcheck::GrandProductComputationRelation<fr>(),
+                                honk::sumcheck::GrandProductInitializationRelation<fr>());
+
+    fr result = 0;
+    for (size_t i = 0; i < prover.key->circuit_size; i++) {
+        // Compute an array containing all the evaluations at a given row i
+        std::array<fr, num_polynomials> evaluations_at_index_i;
+        for (size_t j = 0; j < num_polynomials; ++j) {
+            evaluations_at_index_i[j] = evaluations_array[j][i];
+        }
+
+        // For each relation, call the `accumulate_relation_evaluation` over all witness/selector values at the
+        // i-th row/vertex of the hypercube.
+        // We use ASSERT_EQ instead of EXPECT_EQ so that the tests stops at the first index at which the result is not
+        // 0, since result = 0 + C(transposed), which we expect will equal 0.
+        std::get<0>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+
+        std::get<1>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+
+        std::get<2>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+    }
+}
+
+/**
+ * @brief Test the correctness of the Ultra Honk relations
+ *
+ * @details Check that the constraints encoded by the relations are satisfied by the polynomials produced by the
+ * Ultra Honk Composer for a real circuit.
+ *
+ * TODO(Kesha): We'll have to update this function once we add zk, since the relation will be incorrect for he first few
+ * indices
+ *
+ */
+// TODO(luke): Increase variety of gates in the test circuit to fully stress the relations, e.g. create_big_add_gate.
+// NOTE(luke): More relations will be added as they are implemented for Ultra Honk
+TEST(RelationCorrectness, UltraRelationCorrectness)
+{
+    // Create a composer and a dummy circuit with a few gates
+    auto composer = UltraHonkComposer();
+    static const size_t num_wires = 4;
+    fr a = fr::one();
+    // Using the public variable to check that public_input_delta is computed and added to the relation correctly
+    // TODO(luke): add method "add_public_variable" to UH composer
+    // uint32_t a_idx = composer.add_public_variable(a);
+    uint32_t a_idx = composer.add_variable(a);
+    fr b = fr::one();
+    fr c = a + b;
+    fr d = a + c;
+    uint32_t b_idx = composer.add_variable(b);
+    uint32_t c_idx = composer.add_variable(c);
+    uint32_t d_idx = composer.add_variable(d);
+    for (size_t i = 0; i < 1; i++) {
+        composer.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+        composer.create_add_gate({ d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
+    }
+    // Create a prover (it will compute proving key and witness)
+    auto prover = composer.create_prover();
+
+    // Generate beta and gamma
+    fr beta = fr::random_element();
+    fr gamma = fr::random_element();
+
+    // Compute public input delta
+    const auto public_inputs = composer.circuit_constructor.get_public_inputs();
+    auto public_input_delta =
+        honk::compute_public_input_delta<fr>(public_inputs, beta, gamma, prover.key->circuit_size);
+
+    info("public_input_delta = ", public_input_delta);
+
+    sumcheck::RelationParameters<fr> params{
+        .beta = beta,
+        .gamma = gamma,
+        .public_input_delta = public_input_delta,
+    };
+
+    constexpr size_t num_polynomials = proof_system::honk::UltraArithmetization::COUNT;
+    // Compute grand product polynomial
+    auto z_perm_poly =
+        prover_library::compute_permutation_grand_product<num_wires>(prover.key, prover.wire_polynomials, beta, gamma);
+
+    // Create an array of spans to the underlying polynomials to more easily
+    // get the transposition.
+    // Ex: polynomial_spans[3][i] returns the i-th coefficient of the third polynomial
+    // in the list below
+    std::array<std::span<const fr>, num_polynomials> evaluations_array;
+
+    using POLYNOMIAL = proof_system::honk::UltraArithmetization::POLYNOMIAL;
+    evaluations_array[POLYNOMIAL::W_L] = prover.wire_polynomials[0];
+    evaluations_array[POLYNOMIAL::W_R] = prover.wire_polynomials[1];
+    evaluations_array[POLYNOMIAL::W_O] = prover.wire_polynomials[2];
+    evaluations_array[POLYNOMIAL::W_4] = prover.wire_polynomials[3];
+    evaluations_array[POLYNOMIAL::W_1_SHIFT] = prover.wire_polynomials[0].shifted();
+    evaluations_array[POLYNOMIAL::W_4_SHIFT] = prover.wire_polynomials[3].shifted();
+    evaluations_array[POLYNOMIAL::S_1] = prover.key->polynomial_store.get("s_1_lagrange");
+    evaluations_array[POLYNOMIAL::S_2] = prover.key->polynomial_store.get("s_2_lagrange");
+    evaluations_array[POLYNOMIAL::S_3] = prover.key->polynomial_store.get("s_3_lagrange");
+    evaluations_array[POLYNOMIAL::S_4] = prover.key->polynomial_store.get("s_4_lagrange");
+    evaluations_array[POLYNOMIAL::Z_PERM] = z_perm_poly;
+    evaluations_array[POLYNOMIAL::Z_PERM_SHIFT] = z_perm_poly.shifted();
+    evaluations_array[POLYNOMIAL::Z_LOOKUP] = z_perm_poly;
+    evaluations_array[POLYNOMIAL::Z_LOOKUP_SHIFT] = z_perm_poly.shifted();
+    evaluations_array[POLYNOMIAL::Q_M] = prover.key->polynomial_store.get("q_m_lagrange");
+    evaluations_array[POLYNOMIAL::Q_L] = prover.key->polynomial_store.get("q_1_lagrange");
+    evaluations_array[POLYNOMIAL::Q_R] = prover.key->polynomial_store.get("q_2_lagrange");
+    evaluations_array[POLYNOMIAL::Q_O] = prover.key->polynomial_store.get("q_3_lagrange");
+    evaluations_array[POLYNOMIAL::Q_C] = prover.key->polynomial_store.get("q_c_lagrange");
+    evaluations_array[POLYNOMIAL::Q_4] = prover.key->polynomial_store.get("q_4_lagrange");
+    evaluations_array[POLYNOMIAL::QARITH] = prover.key->polynomial_store.get("q_arith_lagrange");
+    evaluations_array[POLYNOMIAL::QSORT] = prover.key->polynomial_store.get("q_sort_lagrange");
+    evaluations_array[POLYNOMIAL::QELLIPTIC] = prover.key->polynomial_store.get("q_elliptic_lagrange");
+    evaluations_array[POLYNOMIAL::QAUX] = prover.key->polynomial_store.get("q_aux_lagrange");
+    evaluations_array[POLYNOMIAL::QLOOKUPTYPE] = prover.key->polynomial_store.get("table_type_lagrange");
+    evaluations_array[POLYNOMIAL::SIGMA_1] = prover.key->polynomial_store.get("sigma_1_lagrange");
+    evaluations_array[POLYNOMIAL::SIGMA_2] = prover.key->polynomial_store.get("sigma_2_lagrange");
+    evaluations_array[POLYNOMIAL::SIGMA_3] = prover.key->polynomial_store.get("sigma_3_lagrange");
+    evaluations_array[POLYNOMIAL::SIGMA_4] = prover.key->polynomial_store.get("sigma_4_lagrange");
+    evaluations_array[POLYNOMIAL::ID_1] = prover.key->polynomial_store.get("id_1_lagrange");
+    evaluations_array[POLYNOMIAL::ID_2] = prover.key->polynomial_store.get("id_2_lagrange");
+    evaluations_array[POLYNOMIAL::ID_3] = prover.key->polynomial_store.get("id_3_lagrange");
+    evaluations_array[POLYNOMIAL::ID_4] = prover.key->polynomial_store.get("id_4_lagrange");
+    evaluations_array[POLYNOMIAL::LAGRANGE_FIRST] = prover.key->polynomial_store.get("L_first_lagrange");
+    evaluations_array[POLYNOMIAL::LAGRANGE_LAST] = prover.key->polynomial_store.get("L_last_lagrange");
+
+    // Construct the round for applying sumcheck relations and results for storing computed results
+    auto relations = std::tuple(honk::sumcheck::UltraArithmeticRelation<fr>(),
+                                honk::sumcheck::UltraArithmeticRelationSecondary<fr>(),
+                                honk::sumcheck::UltraGrandProductInitializationRelation<fr>(),
+                                honk::sumcheck::UltraGrandProductComputationRelation<fr>());
+
+    fr result = 0;
+    for (size_t i = 0; i < prover.key->circuit_size; i++) {
+        // Compute an array containing all the evaluations at a given row i
+        std::array<fr, num_polynomials> evaluations_at_index_i;
+        for (size_t j = 0; j < num_polynomials; ++j) {
+            evaluations_at_index_i[j] = evaluations_array[j][i];
+        }
+
+        // For each relation, call the `accumulate_relation_evaluation` over all witness/selector values at the
+        // i-th row/vertex of the hypercube. We use ASSERT_EQ instead of EXPECT_EQ so that the tests stops at
+        // the first index at which the result is not 0, since result = 0 + C(transposed), which we expect will
+        // equal 0.
+        std::get<0>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+
+        std::get<1>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+
+        std::get<2>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+
+        std::get<3>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+    }
+}
+
+} // namespace test_honk_relations
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp
new file mode 100644
index 0000000000..2df6efc2c7
--- /dev/null
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp
@@ -0,0 +1,87 @@
+#pragma once
+#include <array>
+#include <tuple>
+
+#include "barretenberg/honk/flavor/flavor.hpp"
+#include "../polynomials/univariate.hpp"
+#include "relation.hpp"
+
+namespace proof_system::honk::sumcheck {
+
+template <typename FF> class UltraArithmeticRelation {
+  public:
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 6; // degree(q_arith^2 * q_m * w_r * w_l) = 5
+    using MULTIVARIATE = UltraArithmetization::POLYNOMIAL;
+
+    /**
+     * @brief Expression for the Ultra Arithmetic gate.
+     * @details The relation is defined as C(extended_edges(X)...) =
+     *    q_arith *
+     *      [ -1/2(q_arith - 3)(q_m * w_r * w_l) +
+     *        (q_l * w_l) + (q_r * w_r) + (q_o * w_o) + (q_4 * w_4) + q_c +
+     *        (q_arith - 1)w_4_shift ]
+     *
+     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
+     * @param extended_edges an std::array containing the fully extended Univariate edges.
+     * @param parameters contains beta, gamma, and public_input_delta, ....
+     * @param scaling_factor optional term to scale the evaluation before adding to evals.
+     */
+    void add_edge_contribution(Univariate<FF, RELATION_LENGTH>& evals,
+                               const auto& extended_edges,
+                               const RelationParameters<FF>&,
+                               const FF& scaling_factor) const
+    {
+        // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
+        //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
+
+        auto w_l = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_L]);
+        auto w_r = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_R]);
+        auto w_o = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_O]);
+        auto w_4 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_4]);
+        auto w_4_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_4_SHIFT]);
+        auto q_m = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_M]);
+        auto q_l = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_L]);
+        auto q_r = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_R]);
+        auto q_o = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_O]);
+        auto q_4 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_4]);
+        auto q_c = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_C]);
+        auto q_arith = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::QARITH]);
+
+        static const FF neg_half = FF(-2).invert();
+
+        auto tmp = (q_arith - 3) * (q_m * w_r * w_l) * neg_half;
+        tmp += (q_l * w_l) + (q_r * w_r) + (q_o * w_o) + (q_4 * w_4) + q_c;
+        tmp += (q_arith - 1) * w_4_shift;
+        tmp *= q_arith;
+        tmp *= scaling_factor;
+        evals += tmp;
+    };
+
+    void add_full_relation_value_contribution(FF& full_honk_relation_value,
+                                              const auto& purported_evaluations,
+                                              const RelationParameters<FF>&) const
+    {
+        auto w_l = purported_evaluations[MULTIVARIATE::W_L];
+        auto w_r = purported_evaluations[MULTIVARIATE::W_R];
+        auto w_o = purported_evaluations[MULTIVARIATE::W_O];
+        auto w_4 = purported_evaluations[MULTIVARIATE::W_4];
+        auto w_4_shift = purported_evaluations[MULTIVARIATE::W_4_SHIFT];
+        auto q_m = purported_evaluations[MULTIVARIATE::Q_M];
+        auto q_l = purported_evaluations[MULTIVARIATE::Q_L];
+        auto q_r = purported_evaluations[MULTIVARIATE::Q_R];
+        auto q_o = purported_evaluations[MULTIVARIATE::Q_O];
+        auto q_4 = purported_evaluations[MULTIVARIATE::Q_4];
+        auto q_c = purported_evaluations[MULTIVARIATE::Q_C];
+        auto q_arith = purported_evaluations[MULTIVARIATE::QARITH];
+
+        static const FF neg_half = FF(-2).invert();
+
+        auto tmp = (q_arith - 3) * (q_m * w_r * w_l) * neg_half;
+        tmp += (q_l * w_l) + (q_r * w_r) + (q_o * w_o) + (q_4 * w_4) + q_c;
+        tmp += (q_arith - 1) * w_4_shift;
+        tmp *= q_arith;
+        full_honk_relation_value += tmp;
+    };
+};
+} // namespace proof_system::honk::sumcheck
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp
new file mode 100644
index 0000000000..78c01db356
--- /dev/null
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp
@@ -0,0 +1,67 @@
+#pragma once
+#include <array>
+#include <tuple>
+
+#include "barretenberg/honk/flavor/flavor.hpp"
+#include "../polynomials/univariate.hpp"
+#include "relation.hpp"
+
+namespace proof_system::honk::sumcheck {
+
+template <typename FF> class UltraArithmeticRelationSecondary {
+  public:
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 5; // degree(q_arith^3 * w_l) = 4
+    using MULTIVARIATE = UltraArithmetization::POLYNOMIAL;
+
+    /**
+     * @brief Expression for the Ultra Arithmetic gate.
+     * @details The relation is defined as C(extended_edges(X)...) =
+     *    q_arith *
+     *      (q_arith - 2) * (q_arith - 1) * (w_l + w_4 - w_l_shift + q_m)
+     *
+     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
+     * @param extended_edges an std::array containing the fully extended Univariate edges.
+     * @param parameters contains beta, gamma, and public_input_delta, ....
+     * @param scaling_factor optional term to scale the evaluation before adding to evals.
+     */
+    void add_edge_contribution(Univariate<FF, RELATION_LENGTH>& evals,
+                               const auto& extended_edges,
+                               const RelationParameters<FF>&,
+                               const FF& scaling_factor) const
+    {
+        // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
+        //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
+
+        auto w_l = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_L]);
+        auto w_4 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_4]);
+        auto w_l_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_1_SHIFT]);
+        auto q_m = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_M]);
+        auto q_arith = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::QARITH]);
+
+        auto tmp = w_l + w_4 - w_l_shift + q_m;
+        tmp *= (q_arith - 2);
+        tmp *= (q_arith - 1);
+        tmp *= q_arith;
+        tmp *= scaling_factor;
+        evals += tmp;
+    };
+
+    void add_full_relation_value_contribution(FF& full_honk_relation_value,
+                                              const auto& purported_evaluations,
+                                              const RelationParameters<FF>&) const
+    {
+        auto w_l = purported_evaluations[MULTIVARIATE::W_L];
+        auto w_4 = purported_evaluations[MULTIVARIATE::W_4];
+        auto w_l_shift = purported_evaluations[MULTIVARIATE::W_1_SHIFT];
+        auto q_m = purported_evaluations[MULTIVARIATE::Q_M];
+        auto q_arith = purported_evaluations[MULTIVARIATE::QARITH];
+
+        auto tmp = w_l + w_4 - w_l_shift + q_m;
+        tmp *= (q_arith - 2);
+        tmp *= (q_arith - 1);
+        tmp *= q_arith;
+        full_honk_relation_value += tmp;
+    };
+};
+} // namespace proof_system::honk::sumcheck
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/c_bind.cpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/c_bind.cpp
index cb35a19d27..5ee4b90fad 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/c_bind.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/c_bind.cpp
@@ -1,3 +1,6 @@
+#include <cstdint>
+#include <sstream>
+
 #include "c_bind.h"
 #include "join_split.hpp"
 #include "compute_signing_data.hpp"
@@ -5,14 +8,12 @@
 #include "barretenberg/common/streams.hpp"
 #include "barretenberg/common/mem.hpp"
 #include "barretenberg/common/container.hpp"
-#include <cstdint>
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/srs/reference_string/pippenger_reference_string.hpp"
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
-#include <sstream>
+#include "barretenberg/join_split_example/types.hpp"
 
 using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
 using namespace join_split_example::proofs::join_split;
 
 #define WASM_EXPORT __attribute__((visibility("default")))
@@ -42,22 +43,10 @@ WASM_EXPORT void join_split__release_key()
 
 WASM_EXPORT uint32_t join_split__get_new_proving_key_data(uint8_t** output)
 {
-// Computing the size of the serialized key is non trivial. We know it's ~331mb.
-// Allocate a buffer large enough to hold it, and abort if we overflow.
-// This is to keep memory usage down.
-#ifdef USE_TURBO
-    size_t total_buf_len = 350 * 1024 * 1024;
-    auto raw_buf = (uint8_t*)malloc(total_buf_len);
-    auto raw_buf_end = raw_buf;
-    write(raw_buf_end, *get_proving_key());
-    *output = raw_buf;
-    auto len = static_cast<uint32_t>(raw_buf_end - raw_buf);
-    if (len > total_buf_len) {
-        info("Buffer overflow serializing proving key.");
-        std::abort();
-    }
-    return len;
-#else
+    // Computing the size of the serialized key is non trivial. We know it's ~331mb.
+    // Allocate a buffer large enough to hold it, and abort if we overflow.
+    // This is to keep memory usage down.
+
     auto proving_key = get_proving_key();
     auto buffer = to_buffer(*proving_key);
     auto raw_buf = (uint8_t*)malloc(buffer.size());
@@ -65,7 +54,6 @@ WASM_EXPORT uint32_t join_split__get_new_proving_key_data(uint8_t** output)
     *output = raw_buf;
 
     return static_cast<uint32_t>(buffer.size());
-#endif
 }
 
 WASM_EXPORT void join_split__init_verification_key(void* pippenger, uint8_t const* g2x)
@@ -103,13 +91,13 @@ WASM_EXPORT void* join_split__new_prover(uint8_t const* join_split_buf, bool moc
 {
     auto tx = from_buffer<join_split_tx>(join_split_buf);
     auto prover = new_join_split_prover(tx, mock);
-    auto heapProver = new stdlib::types::Prover(std::move(prover));
+    auto heapProver = new join_split_example::Prover(std::move(prover));
     return heapProver;
 }
 
 WASM_EXPORT void join_split__delete_prover(void* prover)
 {
-    delete reinterpret_cast<plonk::stdlib::types::Prover*>(prover);
+    delete reinterpret_cast<join_split_example::Prover*>(prover);
 }
 
 WASM_EXPORT bool join_split__verify_proof(uint8_t* proof, uint32_t length)
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp
index 47fc4deec2..037799660b 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp
@@ -3,13 +3,14 @@
 #include "sign_join_split_tx.hpp"
 #include "../notes/native/index.hpp"
 #include "barretenberg/stdlib/merkle_tree/hash_path.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
 namespace join_split {
 
 using namespace join_split_example::proofs::join_split;
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 using namespace join_split_example::proofs::notes::native;
 using namespace proof_system::plonk::stdlib::merkle_tree;
 
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp
index 44567b5b26..95aee064e2 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp
@@ -2,6 +2,7 @@
 #include "join_split_circuit.hpp"
 #include "compute_circuit_data.hpp"
 #include "barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -23,7 +24,7 @@ void init_proving_key(std::shared_ptr<proof_system::ReferenceStringFactory> cons
     join_split_tx tx = noop_tx();
 
     if (!mock) {
-        stdlib::types::Composer composer(crs_factory);
+        Composer composer(crs_factory);
         join_split_circuit(composer, tx);
         proving_key = composer.compute_proving_key();
     } else {
@@ -55,8 +56,7 @@ void init_verification_key(std::unique_ptr<proof_system::ReferenceStringFactory>
     // Patch the 'nothing' reference string fed to init_proving_key.
     proving_key->reference_string = crs_factory->get_prover_crs(proving_key->circuit_size + 1);
 
-    verification_key =
-        plonk::stdlib::types::Composer::compute_verification_key_base(proving_key, crs_factory->get_verifier_crs());
+    verification_key = Composer::compute_verification_key_base(proving_key, crs_factory->get_verifier_crs());
 }
 
 void init_verification_key(std::shared_ptr<proof_system::VerifierMemReferenceString> const& crs,
@@ -65,7 +65,7 @@ void init_verification_key(std::shared_ptr<proof_system::VerifierMemReferenceStr
     verification_key = std::make_shared<plonk::verification_key>(std::move(vk_data), crs);
 }
 
-stdlib::types::Prover new_join_split_prover(join_split_tx const& tx, bool mock)
+Prover new_join_split_prover(join_split_tx const& tx, bool mock)
 {
     Composer composer(proving_key, nullptr);
     join_split_circuit(composer, tx);
@@ -90,16 +90,10 @@ stdlib::types::Prover new_join_split_prover(join_split_tx const& tx, bool mock)
 
 bool verify_proof(plonk::proof const& proof)
 {
-    plonk::stdlib::types::Verifier verifier(verification_key,
-                                            Composer::create_manifest(verification_key->num_public_inputs));
+    Verifier verifier(verification_key, Composer::create_manifest(verification_key->num_public_inputs));
 
-#ifdef USE_TURBO
-    std::unique_ptr<plonk::KateCommitmentScheme<plonk::turbo_settings>> kate_commitment_scheme =
-        std::make_unique<plonk::KateCommitmentScheme<plonk::turbo_settings>>();
-#else
     std::unique_ptr<plonk::KateCommitmentScheme<plonk::ultra_settings>> kate_commitment_scheme =
         std::make_unique<plonk::KateCommitmentScheme<plonk::ultra_settings>>();
-#endif
     verifier.commitment_scheme = std::move(kate_commitment_scheme);
 
     return verifier.verify_proof(proof);
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp
index 6c9b4ac5ab..a6c103a4a0 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp
@@ -1,14 +1,13 @@
 #pragma once
 #include "join_split_tx.hpp"
 #include "barretenberg/srs/reference_string/mem_reference_string.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
 namespace join_split {
 
 using namespace proof_system::plonk::stdlib::merkle_tree;
-using namespace proof_system::plonk::stdlib::types;
 
 void init_proving_key(std::shared_ptr<proof_system::ReferenceStringFactory> const& crs_factory, bool mock);
 
@@ -22,7 +21,7 @@ void init_verification_key(std::unique_ptr<proof_system::ReferenceStringFactory>
 void init_verification_key(std::shared_ptr<proof_system::VerifierMemReferenceString> const& crs,
                            plonk::verification_key_data&& vk_data);
 
-stdlib::types::Prover new_join_split_prover(join_split_tx const& tx, bool mock);
+Prover new_join_split_prover(join_split_tx const& tx, bool mock);
 
 bool verify_proof(plonk::proof const& proof);
 
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp
index c729f91434..25b802cd62 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp
@@ -1,3 +1,5 @@
+#include <gtest/gtest.h>
+
 #include "../../constants.hpp"
 #include "../inner_proof_data/inner_proof_data.hpp"
 #include "index.hpp"
@@ -5,9 +7,9 @@
 #include "join_split_circuit.hpp"
 #include "barretenberg/common/streams.hpp"
 #include "barretenberg/common/test.hpp"
-#include <gtest/gtest.h>
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
 #include "barretenberg/stdlib/merkle_tree/index.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example::proofs::join_split {
 
@@ -122,7 +124,7 @@ constexpr bool CIRCUIT_CHANGE_EXPECTED = false;
 #endif
 
 using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 using namespace proof_system::plonk::stdlib::merkle_tree;
 using namespace join_split_example::proofs::notes::native;
 using key_pair = join_split_example::fixtures::grumpkin_key_pair;
@@ -800,17 +802,12 @@ TEST_F(join_split_tests, test_0_input_notes_and_detect_circuit_change)
 
     EXPECT_TRUE(result.valid);
 
-// The below part detects any changes in the join-split circuit
-#ifdef USE_TURBO
-    constexpr uint32_t CIRCUIT_GATE_COUNT = 59175;
-    constexpr uint32_t GATES_NEXT_POWER_OF_TWO = 65536;
-    const uint256_t VK_HASH("095cbe8f1b09690713d5161708b5ea77119575884e3cfab14f7364b9f1ba7faa");
-#else
+    // The below part detects any changes in the join-split circuit
+
     constexpr uint32_t CIRCUIT_GATE_COUNT = 185573;
     constexpr uint32_t GATES_NEXT_POWER_OF_TWO = 524288;
-    const uint256_t VK_HASH("21389d5392ee23ffc96984689150b63d62113678b1ba127346a0ec72df842354");
+    const uint256_t VK_HASH("13eb88883e80efb9bf306af2962cd1a49e9fa1b0bfb2d4b563b95217a17bcc74");
 
-#endif
     auto number_of_gates_js = result.number_of_gates;
     auto vk_hash_js = get_verification_key()->sha256_hash();
 
@@ -2623,11 +2620,8 @@ TEST_F(join_split_tests, serialized_proving_key_size)
 {
     uint8_t* ptr;
     auto len = join_split__get_new_proving_key_data(&ptr);
-#ifdef USE_TURBO
-    EXPECT_LE(len, 2 * 170 * 1024 * 1024);
-#else
+
     EXPECT_LE(len, 2315258552);
-#endif
 }
 
 } // namespace join_split_example::proofs::join_split
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.cpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.cpp
index a0061cde88..c1ea2af1da 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.cpp
@@ -6,6 +6,7 @@
 #include "../notes/circuit/claim/claim_note.hpp"
 #include "verify_signature.hpp"
 #include "barretenberg/stdlib/merkle_tree/membership.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -22,7 +23,7 @@ using namespace proof_system::plonk::stdlib::merkle_tree;
  */
 field_ct process_input_note(field_ct const& account_private_key,
                             field_ct const& merkle_root,
-                            merkle_tree::hash_path const& hash_path,
+                            hash_path_ct const& hash_path,
                             suint_ct const& index,
                             value::value_note const& note,
                             bool_ct is_propagated,
@@ -31,7 +32,7 @@ field_ct process_input_note(field_ct const& account_private_key,
     const bool_ct valid_value = note.value == 0 || is_note_in_use;
     valid_value.assert_equal(true, "padding note non zero");
 
-    const bool_ct exists = merkle_tree::check_membership(
+    const bool_ct exists = proof_system::plonk::stdlib::merkle_tree::check_membership(
         merkle_root, hash_path, note.commitment, index.value.decompose_into_bits(DATA_TREE_DEPTH));
     const bool_ct valid = exists || is_propagated || !is_note_in_use;
     valid.assert_equal(true, "input note not a member");
@@ -216,10 +217,10 @@ join_split_outputs join_split_circuit_component(join_split_inputs const& inputs)
         const auto account_alias_hash = inputs.alias_hash;
         const auto account_note_data = account::account_note(account_alias_hash.value, account_public_key, signer);
         const bool_ct signing_key_exists =
-            merkle_tree::check_membership(inputs.merkle_root,
-                                          inputs.account_note_path,
-                                          account_note_data.commitment,
-                                          inputs.account_note_index.value.decompose_into_bits(DATA_TREE_DEPTH));
+            stdlib::merkle_tree::check_membership(inputs.merkle_root,
+                                                  inputs.account_note_path,
+                                                  account_note_data.commitment,
+                                                  inputs.account_note_index.value.decompose_into_bits(DATA_TREE_DEPTH));
         (signing_key_exists || !inputs.account_required).assert_equal(true, "account check_membership failed");
     }
 
@@ -287,8 +288,8 @@ void join_split_circuit(Composer& composer, join_split_tx const& tx)
         .signing_pub_key = stdlib::create_point_witness(composer, tx.signing_pub_key),
         .signature = stdlib::schnorr::convert_signature(&composer, tx.signature),
         .merkle_root = witness_ct(&composer, tx.old_data_root),
-        .input_path1 = merkle_tree::create_witness_hash_path(composer, tx.input_path[0]),
-        .input_path2 = merkle_tree::create_witness_hash_path(composer, tx.input_path[1]),
+        .input_path1 = stdlib::merkle_tree::create_witness_hash_path(composer, tx.input_path[0]),
+        .input_path2 = stdlib::merkle_tree::create_witness_hash_path(composer, tx.input_path[1]),
         .account_note_index =
             suint_ct(witness_ct(&composer, tx.account_note_index), DATA_TREE_DEPTH, "account_note_index"),
         .account_note_path = merkle_tree::create_witness_hash_path(composer, tx.account_note_path),
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.hpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.hpp
index b8821989b4..bde45a710c 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_circuit.hpp
@@ -3,15 +3,14 @@
 #include "../notes/circuit/value/witness_data.hpp"
 #include "../notes/circuit/claim/witness_data.hpp"
 #include "barretenberg/crypto/schnorr/schnorr.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
 namespace join_split {
 
-using namespace proof_system::plonk::stdlib::types;
-
 struct join_split_inputs {
+
     field_ct proof_id;
     suint_ct public_value;
     field_ct public_owner;
@@ -25,12 +24,12 @@ struct join_split_inputs {
     notes::circuit::value::witness_data output_note2;
     notes::circuit::claim::partial_claim_note_witness_data partial_claim_note;
     point_ct signing_pub_key;
-    stdlib::schnorr::signature_bits<Composer> signature;
+    schnorr::signature_bits signature;
     field_ct merkle_root;
-    merkle_tree::hash_path input_path1;
-    merkle_tree::hash_path input_path2;
+    hash_path_ct input_path1;
+    hash_path_ct input_path2;
     suint_ct account_note_index;
-    merkle_tree::hash_path account_note_path;
+    hash_path_ct account_note_path;
     field_ct account_private_key;
     suint_ct alias_hash;
     bool_ct account_required;
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.hpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.hpp
index 4dae8f30e3..fe309b8dac 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.hpp
@@ -3,14 +3,12 @@
 #include "../notes/native/value/value_note.hpp"
 #include "barretenberg/crypto/schnorr/schnorr.hpp"
 #include "barretenberg/stdlib/merkle_tree/hash_path.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
 namespace join_split {
 
-using namespace proof_system::plonk::stdlib::types;
-
 struct join_split_tx {
     uint32_t proof_id;
     uint256_t public_value;
@@ -19,7 +17,7 @@ struct join_split_tx {
     uint32_t num_input_notes;
     std::array<uint32_t, 2> input_index;
     barretenberg::fr old_data_root;
-    std::array<merkle_tree::fr_hash_path, 2> input_path;
+    std::array<proof_system::plonk::stdlib::merkle_tree::fr_hash_path, 2> input_path;
     std::array<notes::native::value::value_note, 2> input_note;
     std::array<notes::native::value::value_note, 2> output_note;
 
@@ -29,7 +27,7 @@ struct join_split_tx {
     barretenberg::fr alias_hash;
     bool account_required;
     uint32_t account_note_index;
-    merkle_tree::fr_hash_path account_note_path;
+    proof_system::plonk::stdlib::merkle_tree::fr_hash_path account_note_path;
     grumpkin::g1::affine_element signing_pub_key;
 
     barretenberg::fr backward_link; // 0: no link, otherwise: any commitment.
diff --git a/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.test.cpp b/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.test.cpp
index 16004e9787..6960962095 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.test.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.test.cpp
@@ -1,9 +1,9 @@
 #include "mock_circuit.hpp"
 #include "../join_split/join_split_tx.hpp"
 #include "barretenberg/common/test.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 namespace rollup {
 namespace proofs {
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/account_note.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/account_note.hpp
index 334b2edfc3..30390eb103 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/account_note.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/account_note.hpp
@@ -1,6 +1,7 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include "commit.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -8,8 +9,6 @@ namespace notes {
 namespace circuit {
 namespace account {
 
-using namespace proof_system::plonk::stdlib::types;
-
 struct account_note {
     field_ct account_alias_hash;
     point_ct account_public_key;
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/commit.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/commit.hpp
index 497644a951..dbe568197a 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/commit.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/account/commit.hpp
@@ -1,6 +1,8 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/primitives/point/point.hpp"
 #include "../../constants.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -8,7 +10,7 @@ namespace notes {
 namespace circuit {
 namespace account {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 inline auto commit(field_ct const& account_alias_hash,
                    point_ct const& account_public_key,
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.cpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.cpp
index 5163231bc5..6a7a559b70 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.cpp
@@ -1,9 +1,9 @@
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include "../constants.hpp"
 
 namespace join_split_example::proofs::notes::circuit {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 std::pair<bool_ct, suint_ct> deflag_asset_id(suint_ct const& asset_id)
 {
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.hpp
index 3c67f16695..89e244f39b 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/asset_id.hpp
@@ -1,9 +1,9 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example::proofs::notes::circuit {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 std::pair<bool_ct, suint_ct> deflag_asset_id(suint_ct const& asset_id);
 
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/bridge_call_data.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/bridge_call_data.hpp
index f5b1bbd319..f8ea941167 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/bridge_call_data.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/bridge_call_data.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include "../native/bridge_call_data.hpp"
 #include "./asset_id.hpp"
 #include "../constants.hpp"
@@ -9,7 +9,7 @@ namespace proofs {
 namespace notes {
 namespace circuit {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 constexpr uint32_t input_asset_id_a_shift = DEFI_BRIDGE_ADDRESS_ID_LEN;
 constexpr uint32_t input_asset_id_b_shift = input_asset_id_a_shift + DEFI_BRIDGE_INPUT_A_ASSET_ID_LEN;
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/claim_note.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/claim_note.hpp
index 8021265a43..8a23ff9f93 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/claim_note.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/claim_note.hpp
@@ -1,5 +1,6 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
+
 #include "../bridge_call_data.hpp"
 #include "witness_data.hpp"
 #include "../value/create_partial_commitment.hpp"
@@ -12,7 +13,7 @@ namespace notes {
 namespace circuit {
 namespace claim {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 struct partial_claim_note {
     suint_ct deposit_value;
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/complete_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/complete_partial_commitment.hpp
index 9b1010ab58..fb20d7fef9 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/complete_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/complete_partial_commitment.hpp
@@ -1,6 +1,7 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include "../../constants.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -8,7 +9,7 @@ namespace notes {
 namespace circuit {
 namespace claim {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 inline auto complete_partial_commitment(field_ct const& partial_commitment,
                                         field_ct const& interaction_nonce,
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/compute_nullifier.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/compute_nullifier.hpp
index 304f9f6205..2ffb181bb2 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/compute_nullifier.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/compute_nullifier.hpp
@@ -1,5 +1,6 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+
+#include "barretenberg/join_split_example/types.hpp"
 #include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
 #include "../../constants.hpp"
 
@@ -9,8 +10,6 @@ namespace notes {
 namespace circuit {
 namespace claim {
 
-using namespace proof_system::plonk::stdlib::types;
-
 inline field_ct compute_nullifier(field_ct const& note_commitment)
 {
     return pedersen_commitment::compress(std::vector<field_ct>{ note_commitment },
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/create_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/create_partial_commitment.hpp
index 30eb7adb7a..36c37a8e78 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/create_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/create_partial_commitment.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
 #include "../../constants.hpp"
 
@@ -9,7 +9,7 @@ namespace notes {
 namespace circuit {
 namespace claim {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 inline auto create_partial_commitment(field_ct const& deposit_value,
                                       field_ct const& bridge_call_data,
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/witness_data.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/witness_data.hpp
index b49bddd3bb..e5fc35fb39 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/witness_data.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/claim/witness_data.hpp
@@ -1,5 +1,6 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+
+#include "barretenberg/join_split_example/types.hpp"
 #include "../../native/claim/claim_note.hpp"
 #include "../../native/claim/claim_note_tx_data.hpp"
 #include "../../constants.hpp"
@@ -11,7 +12,7 @@ namespace notes {
 namespace circuit {
 namespace claim {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 /**
  * Convert native claim note data into circuit witness data.
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/complete_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/complete_partial_commitment.hpp
index e5bc84b994..1ec344d17a 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/complete_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/complete_partial_commitment.hpp
@@ -1,15 +1,15 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+
+#include "barretenberg/join_split_example/types.hpp"
 #include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
 #include "../../constants.hpp"
-
 namespace join_split_example {
 namespace proofs {
 namespace notes {
 namespace circuit {
 namespace value {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 inline auto complete_partial_commitment(field_ct const& value_note_partial_commitment,
                                         suint_ct const& value,
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.cpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.cpp
index 30dafca6b6..6f73dd418f 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.cpp
@@ -1,6 +1,6 @@
 #include "compute_nullifier.hpp"
 #include "../../constants.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -8,7 +8,7 @@ namespace notes {
 namespace circuit {
 
 using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 field_ct compute_nullifier(field_ct const& note_commitment,
                            field_ct const& account_private_key,
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.hpp
index 3271035abb..85a14dd416 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.hpp
@@ -1,14 +1,11 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
 namespace notes {
 namespace circuit {
 
-using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
-
 field_ct compute_nullifier(field_ct const& note_commitment,
                            field_ct const& account_private_key,
                            bool_ct const& is_note_in_use);
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.test.cpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.test.cpp
index 063ef93edd..88198aa7c5 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.test.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/compute_nullifier.test.cpp
@@ -4,10 +4,10 @@
 #include "./value_note.hpp"
 #include "../../native/value/compute_nullifier.hpp"
 #include "../../native/value/value_note.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
+namespace join_split_example {
 using namespace join_split_example::proofs::notes;
-using namespace proof_system::plonk::stdlib::types;
 
 TEST(compute_nullifier_circuit, native_consistency)
 {
@@ -18,7 +18,6 @@ TEST(compute_nullifier_circuit, native_consistency)
         native::value::value_note{ 100, 0, 0, user.owner.public_key, user.note_secret, 0, fr::random_element() };
     auto native_commitment = native_input_note.commit();
     auto native_nullifier = native::compute_nullifier(native_commitment, priv_key, true);
-
     Composer composer;
     auto circuit_witness_data = circuit::value::witness_data(composer, native_input_note);
     auto circuit_input_note = circuit::value::value_note(circuit_witness_data);
@@ -27,3 +26,4 @@ TEST(compute_nullifier_circuit, native_consistency)
 
     EXPECT_EQ(circuit_nullifier.get_value(), native_nullifier);
 }
+} // namespace join_split_example
\ No newline at end of file
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/create_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/create_partial_commitment.hpp
index f01324ee34..ac6104c65a 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/create_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/create_partial_commitment.hpp
@@ -1,6 +1,6 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
-#include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include "../../constants.hpp"
 
 namespace join_split_example {
@@ -9,8 +9,6 @@ namespace notes {
 namespace circuit {
 namespace value {
 
-using namespace proof_system::plonk::stdlib::types;
-
 inline auto create_partial_commitment(field_ct const& secret,
                                       point_ct const& owner,
                                       bool_ct const& account_required,
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.hpp
index a4f8cc04c8..9f2d47a6c6 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include "witness_data.hpp"
 #include "commit.hpp"
 
@@ -9,7 +9,7 @@ namespace notes {
 namespace circuit {
 namespace value {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 struct value_note {
     point_ct owner;
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.test.cpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.test.cpp
index e243b35fb8..55b65c9949 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.test.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/value_note.test.cpp
@@ -2,13 +2,14 @@
 #include "../../../../fixtures/user_context.hpp"
 #include "../../native/value/value_note.hpp"
 #include "../../constants.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 #include <gtest/gtest.h>
 
+namespace join_split_example {
 using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 using namespace join_split_example::proofs::notes;
 using namespace join_split_example::proofs::notes::circuit::value;
-
 TEST(value_note, commits)
 {
     auto user = join_split_example::fixtures::create_user_context();
@@ -106,4 +107,5 @@ TEST(value_note, commit_with_oversized_asset_id_fails)
 
     bool proof_result = verifier.verify_proof(proof);
     EXPECT_EQ(proof_result, false);
-}
\ No newline at end of file
+}
+} // namespace join_split_example
\ No newline at end of file
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/witness_data.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/witness_data.hpp
index ff0cbc0cc2..367f0e704e 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/witness_data.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/circuit/value/witness_data.hpp
@@ -1,7 +1,6 @@
 #pragma once
-#include "barretenberg/stdlib/types/types.hpp"
 #include "../../native/value/value_note.hpp"
-#include "../../constants.hpp"
+#include "barretenberg/join_split_example/types.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -9,7 +8,7 @@ namespace notes {
 namespace circuit {
 namespace value {
 
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 
 struct witness_data {
     point_ct owner;
diff --git a/cpp/src/barretenberg/join_split_example/types.hpp b/cpp/src/barretenberg/join_split_example/types.hpp
new file mode 100644
index 0000000000..65b6cca423
--- /dev/null
+++ b/cpp/src/barretenberg/join_split_example/types.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+
+#include "barretenberg/plonk/proof_system/prover/prover.hpp"
+#include "barretenberg/stdlib/primitives/bool/bool.hpp"
+#include "barretenberg/stdlib/primitives/byte_array/byte_array.hpp"
+#include "barretenberg/stdlib/primitives/uint/uint.hpp"
+#include "barretenberg/stdlib/primitives/witness/witness.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp"
+#include "barretenberg/stdlib/merkle_tree/hash_path.hpp"
+#include "barretenberg/stdlib/encryption/schnorr/schnorr.hpp"
+#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
+
+namespace join_split_example {
+
+using Composer = plonk::UltraComposer;
+
+using Prover = std::conditional_t<
+    std::same_as<Composer, plonk::UltraComposer>,
+    plonk::UltraProver,
+    std::conditional_t<std::same_as<Composer, plonk::TurboComposer>, plonk::TurboProver, plonk::Prover>>;
+
+using Verifier = std::conditional_t<
+    std::same_as<Composer, plonk::UltraComposer>,
+    plonk::UltraVerifier,
+    std::conditional_t<std::same_as<Composer, plonk::TurboComposer>, plonk::TurboVerifier, plonk::Verifier>>;
+
+using witness_ct = proof_system::plonk::stdlib::witness_t<Composer>;
+using public_witness_ct = proof_system::plonk::stdlib::public_witness_t<Composer>;
+using bool_ct = proof_system::plonk::stdlib::bool_t<Composer>;
+using byte_array_ct = proof_system::plonk::stdlib::byte_array<Composer>;
+using field_ct = proof_system::plonk::stdlib::field_t<Composer>;
+using suint_ct = proof_system::plonk::stdlib::safe_uint_t<Composer>;
+using uint32_ct = proof_system::plonk::stdlib::uint32<Composer>;
+using point_ct = proof_system::plonk::stdlib::point<Composer>;
+using pedersen_commitment = proof_system::plonk::stdlib::pedersen_commitment<Composer>;
+using group_ct = proof_system::plonk::stdlib::group<Composer>;
+using bn254 = proof_system::plonk::stdlib::bn254<Composer>;
+
+using hash_path_ct = proof_system::plonk::stdlib::merkle_tree::hash_path<Composer>;
+
+namespace schnorr {
+using signature_bits = proof_system::plonk::stdlib::schnorr::signature_bits<Composer>;
+} // namespace schnorr
+
+} // namespace join_split_example
\ No newline at end of file
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
index 597b2ddea0..8782f6ab61 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
@@ -890,6 +890,50 @@ UltraToStandardProver UltraComposer::create_ultra_to_standard_prover()
     return output_state;
 }
 
+/**
+ * @brief Uses slightly different settings from the UltraProver.
+ */
+UltraWithKeccakProver UltraComposer::create_ultra_with_keccak_prover()
+{
+    compute_proving_key();
+    compute_witness();
+
+    UltraWithKeccakProver output_state(circuit_proving_key, create_manifest(public_inputs.size()));
+
+    std::unique_ptr<ProverPermutationWidget<4, true>> permutation_widget =
+        std::make_unique<ProverPermutationWidget<4, true>>(circuit_proving_key.get());
+
+    std::unique_ptr<ProverPlookupWidget<>> plookup_widget =
+        std::make_unique<ProverPlookupWidget<>>(circuit_proving_key.get());
+
+    std::unique_ptr<ProverPlookupArithmeticWidget<ultra_with_keccak_settings>> arithmetic_widget =
+        std::make_unique<ProverPlookupArithmeticWidget<ultra_with_keccak_settings>>(circuit_proving_key.get());
+
+    std::unique_ptr<ProverGenPermSortWidget<ultra_with_keccak_settings>> sort_widget =
+        std::make_unique<ProverGenPermSortWidget<ultra_with_keccak_settings>>(circuit_proving_key.get());
+
+    std::unique_ptr<ProverEllipticWidget<ultra_with_keccak_settings>> elliptic_widget =
+        std::make_unique<ProverEllipticWidget<ultra_with_keccak_settings>>(circuit_proving_key.get());
+
+    std::unique_ptr<ProverPlookupAuxiliaryWidget<ultra_with_keccak_settings>> auxiliary_widget =
+        std::make_unique<ProverPlookupAuxiliaryWidget<ultra_with_keccak_settings>>(circuit_proving_key.get());
+
+    output_state.random_widgets.emplace_back(std::move(permutation_widget));
+    output_state.random_widgets.emplace_back(std::move(plookup_widget));
+
+    output_state.transition_widgets.emplace_back(std::move(arithmetic_widget));
+    output_state.transition_widgets.emplace_back(std::move(sort_widget));
+    output_state.transition_widgets.emplace_back(std::move(elliptic_widget));
+    output_state.transition_widgets.emplace_back(std::move(auxiliary_widget));
+
+    std::unique_ptr<KateCommitmentScheme<ultra_with_keccak_settings>> kate_commitment_scheme =
+        std::make_unique<KateCommitmentScheme<ultra_with_keccak_settings>>();
+
+    output_state.commitment_scheme = std::move(kate_commitment_scheme);
+
+    return output_state;
+}
+
 UltraVerifier UltraComposer::create_verifier()
 {
     compute_verification_key();
@@ -918,6 +962,20 @@ UltraToStandardVerifier UltraComposer::create_ultra_to_standard_verifier()
     return output_state;
 }
 
+UltraWithKeccakVerifier UltraComposer::create_ultra_with_keccak_verifier()
+{
+    compute_verification_key();
+
+    UltraWithKeccakVerifier output_state(circuit_verification_key, create_manifest(public_inputs.size()));
+
+    std::unique_ptr<KateCommitmentScheme<ultra_with_keccak_settings>> kate_commitment_scheme =
+        std::make_unique<KateCommitmentScheme<ultra_with_keccak_settings>>();
+
+    output_state.commitment_scheme = std::move(kate_commitment_scheme);
+
+    return output_state;
+}
+
 void UltraComposer::initialize_precomputed_table(
     const plookup::BasicTableId id,
     bool (*generator)(std::vector<fr>&, std ::vector<fr>&, std::vector<fr>&),
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
index 6cdc969423..b3157639fd 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
@@ -160,6 +160,9 @@ class UltraComposer : public ComposerBase {
     UltraToStandardProver create_ultra_to_standard_prover();
     UltraToStandardVerifier create_ultra_to_standard_verifier();
 
+    UltraWithKeccakProver create_ultra_with_keccak_prover();
+    UltraWithKeccakVerifier create_ultra_with_keccak_verifier();
+
     void create_add_gate(const add_triple& in) override;
 
     void create_big_add_gate(const add_quad& in, const bool use_next_gate_w_4 = false);
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
index 8219f9183c..eef80fa56c 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
@@ -10,7 +10,7 @@
 using namespace barretenberg;
 using namespace proof_system;
 
-namespace proof_system::plonk {
+namespace proof_system::plonk::test_ultra_composer {
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
@@ -27,7 +27,39 @@ std::vector<uint32_t> add_variables(UltraComposer& composer, std::vector<fr> var
     }
     return res;
 }
-TEST(ultra_composer, create_gates_from_plookup_accumulators)
+
+template <typename T> class ultra_composer : public ::testing::Test {
+  public:
+    void prove_and_verify(UltraComposer& composer, bool expected_result)
+    {
+        if constexpr (T::use_keccak) {
+            auto prover = composer.create_ultra_with_keccak_prover();
+            auto verifier = composer.create_ultra_with_keccak_verifier();
+            auto proof = prover.construct_proof();
+            bool verified = verifier.verify_proof(proof);
+            EXPECT_EQ(verified, expected_result);
+        } else {
+            auto prover = composer.create_prover();
+            auto verifier = composer.create_verifier();
+            auto proof = prover.construct_proof();
+            bool verified = verifier.verify_proof(proof);
+            EXPECT_EQ(verified, expected_result);
+        }
+    };
+};
+
+struct UseKeccak32Bytes {
+    static constexpr bool use_keccak = true;
+};
+
+struct UsePlookupPedersen16Bytes {
+    static constexpr bool use_keccak = false;
+};
+
+using BooleanTypes = ::testing::Types<UseKeccak32Bytes, UsePlookupPedersen16Bytes>;
+TYPED_TEST_SUITE(ultra_composer, BooleanTypes);
+
+TYPED_TEST(ultra_composer, create_gates_from_plookup_accumulators)
 {
     UltraComposer composer = UltraComposer();
 
@@ -106,16 +138,10 @@ TEST(ultra_composer, create_gates_from_plookup_accumulators)
         EXPECT_EQ(composer.get_variable(lookup_witnesses_hi[ColumnIdx::C3][i]), expected_y[i + num_lookups_lo]);
     }
 
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
-    auto proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof);
-
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, test_no_lookup_proof)
+TYPED_TEST(ultra_composer, test_no_lookup_proof)
 {
     UltraComposer composer = UltraComposer();
 
@@ -133,17 +159,10 @@ TEST(ultra_composer, test_no_lookup_proof)
         }
     }
 
-    auto prover = composer.create_prover();
-
-    auto verifier = composer.create_verifier();
-
-    auto proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, test_elliptic_gate)
+TYPED_TEST(ultra_composer, test_elliptic_gate)
 {
     typedef grumpkin::g1::affine_element affine_element;
     typedef grumpkin::g1::element element;
@@ -180,17 +199,10 @@ TEST(ultra_composer, test_elliptic_gate)
     gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 };
     composer.create_ecc_add_gate(gate);
 
-    auto prover = composer.create_prover();
-
-    auto verifier = composer.create_verifier();
-
-    auto proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, non_trivial_tag_permutation)
+TYPED_TEST(ultra_composer, non_trivial_tag_permutation)
 {
     UltraComposer composer = UltraComposer();
     fr a = fr::random_element();
@@ -215,15 +227,11 @@ TEST(ultra_composer, non_trivial_tag_permutation)
     // composer.create_add_gate({ a_idx, b_idx, composer.zero_idx, fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
     // composer.create_add_gate({ a_idx, b_idx, composer.zero_idx, fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
     // composer.create_add_gate({ a_idx, b_idx, composer.zero_idx, fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
-
-    proof proof = prover.construct_proof();
 
-    bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
-TEST(ultra_composer, non_trivial_tag_permutation_and_cycles)
+
+TYPED_TEST(ultra_composer, non_trivial_tag_permutation_and_cycles)
 {
     UltraComposer composer = UltraComposer();
     fr a = fr::random_element();
@@ -257,17 +265,11 @@ TEST(ultra_composer, non_trivial_tag_permutation_and_cycles)
     // composer.create_add_gate({ a_idx, b_idx, composer.zero_idx, fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
     // composer.create_add_gate({ a_idx, b_idx, composer.zero_idx, fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
     // composer.create_add_gate({ a_idx, b_idx, composer.zero_idx, fr::one(), fr::neg_one(), fr::zero(), fr::zero() });
-    auto prover = composer.create_prover();
-
-    auto verifier = composer.create_verifier();
-
-    proof proof = prover.construct_proof();
 
-    bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, bad_tag_permutation)
+TYPED_TEST(ultra_composer, bad_tag_permutation)
 {
     UltraComposer composer = UltraComposer();
     fr a = fr::random_element();
@@ -288,16 +290,12 @@ TEST(ultra_composer, bad_tag_permutation)
     composer.assign_tag(b_idx, 1);
     composer.assign_tag(c_idx, 2);
     composer.assign_tag(d_idx, 2);
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
-    proof proof = prover.construct_proof();
 
-    bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-    EXPECT_EQ(result, false);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/false);
 }
 
 // same as above but with turbocomposer to check reason of failue is really tag mismatch
-TEST(ultra_composer, bad_tag_turbo_permutation)
+TYPED_TEST(ultra_composer, bad_tag_turbo_permutation)
 {
     UltraComposer composer = UltraComposer();
     fr a = fr::random_element();
@@ -317,13 +315,10 @@ TEST(ultra_composer, bad_tag_turbo_permutation)
     auto prover = composer.create_prover();
     auto verifier = composer.create_verifier();
 
-    proof proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, sort_widget)
+TYPED_TEST(ultra_composer, sort_widget)
 {
     UltraComposer composer = UltraComposer();
     fr a = fr::one();
@@ -336,16 +331,11 @@ TEST(ultra_composer, sort_widget)
     auto c_idx = composer.add_variable(c);
     auto d_idx = composer.add_variable(d);
     composer.create_sort_constraint({ a_idx, b_idx, c_idx, d_idx });
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
-
-    proof proof = prover.construct_proof();
 
-    bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, sort_with_edges_gate)
+TYPED_TEST(ultra_composer, sort_with_edges_gate)
 {
 
     fr a = fr::one();
@@ -368,13 +358,8 @@ TEST(ultra_composer, sort_with_edges_gate)
         auto g_idx = composer.add_variable(g);
         auto h_idx = composer.add_variable(h);
         composer.create_sort_constraint_with_edges({ a_idx, b_idx, c_idx, d_idx, e_idx, f_idx, g_idx, h_idx }, a, h);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
 
-        proof proof = prover.construct_proof();
-
-        bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-        EXPECT_EQ(result, true);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/true);
     }
 
     {
@@ -407,13 +392,8 @@ TEST(ultra_composer, sort_with_edges_gate)
         auto g_idx = composer.add_variable(g);
         auto h_idx = composer.add_variable(h);
         composer.create_sort_constraint_with_edges({ a_idx, b_idx, c_idx, d_idx, e_idx, f_idx, g_idx, h_idx }, b, h);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
-
-        proof proof = prover.construct_proof();
 
-        bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-        EXPECT_EQ(result, false);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/false);
     }
     {
         UltraComposer composer = UltraComposer();
@@ -426,26 +406,16 @@ TEST(ultra_composer, sort_with_edges_gate)
         auto h_idx = composer.add_variable(h);
         auto b2_idx = composer.add_variable(fr(15));
         composer.create_sort_constraint_with_edges({ a_idx, b2_idx, c_idx, d_idx, e_idx, f_idx, g_idx, h_idx }, b, h);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
-
-        proof proof = prover.construct_proof();
 
-        bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-        EXPECT_EQ(result, false);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/false);
     }
     {
         UltraComposer composer = UltraComposer();
         auto idx = add_variables(composer, { 1,  2,  5,  6,  7,  10, 11, 13, 16, 17, 20, 22, 22, 25,
                                              26, 29, 29, 32, 32, 33, 35, 38, 39, 39, 42, 42, 43, 45 });
         composer.create_sort_constraint_with_edges(idx, 1, 45);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
 
-        proof proof = prover.construct_proof();
-
-        bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-        EXPECT_EQ(result, true);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/true);
     }
     {
         UltraComposer composer = UltraComposer();
@@ -453,16 +423,12 @@ TEST(ultra_composer, sort_with_edges_gate)
                                              26, 29, 29, 32, 32, 33, 35, 38, 39, 39, 42, 42, 43, 45 });
 
         composer.create_sort_constraint_with_edges(idx, 1, 29);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
-        proof proof = prover.construct_proof();
 
-        bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-        EXPECT_EQ(result, false);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/false);
     }
 }
 
-TEST(ultra_composer, range_constraint)
+TYPED_TEST(ultra_composer, range_constraint)
 {
     {
         UltraComposer composer = UltraComposer();
@@ -488,13 +454,8 @@ TEST(ultra_composer, range_constraint)
         }
         // auto ind = {a_idx,b_idx,c_idx,d_idx,e_idx,f_idx,g_idx,h_idx};
         composer.create_dummy_constraints(indices);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
 
-        proof proof = prover.construct_proof();
-
-        bool result = verifier.verify_proof(proof);
-        EXPECT_EQ(result, true);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/true);
     }
     {
         UltraComposer composer = UltraComposer();
@@ -503,13 +464,8 @@ TEST(ultra_composer, range_constraint)
             composer.create_new_range_constraint(indices[i], 8);
         }
         composer.create_sort_constraint(indices);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
-
-        proof proof = prover.construct_proof();
 
-        bool result = verifier.verify_proof(proof);
-        EXPECT_EQ(result, false);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/false);
     }
     {
         UltraComposer composer = UltraComposer();
@@ -519,13 +475,8 @@ TEST(ultra_composer, range_constraint)
             composer.create_new_range_constraint(indices[i], 128);
         }
         composer.create_dummy_constraints(indices);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
 
-        proof proof = prover.construct_proof();
-
-        bool result = verifier.verify_proof(proof);
-        EXPECT_EQ(result, true);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/true);
     }
     {
         UltraComposer composer = UltraComposer();
@@ -551,17 +502,12 @@ TEST(ultra_composer, range_constraint)
             composer.create_new_range_constraint(indices[i], 79);
         }
         composer.create_dummy_constraints(indices);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
-
-        proof proof = prover.construct_proof();
 
-        bool result = verifier.verify_proof(proof);
-        EXPECT_EQ(result, false);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/false);
     }
 }
 
-TEST(ultra_composer, range_with_gates)
+TYPED_TEST(ultra_composer, range_with_gates)
 {
 
     UltraComposer composer = UltraComposer();
@@ -574,15 +520,11 @@ TEST(ultra_composer, range_with_gates)
     composer.create_add_gate({ idx[2], idx[3], composer.zero_idx, fr::one(), fr::one(), fr::zero(), -7 });
     composer.create_add_gate({ idx[4], idx[5], composer.zero_idx, fr::one(), fr::one(), fr::zero(), -11 });
     composer.create_add_gate({ idx[6], idx[7], composer.zero_idx, fr::one(), fr::one(), fr::zero(), -15 });
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
 
-    proof proof = prover.construct_proof();
-    bool result = verifier.verify_proof(proof);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, range_with_gates_where_range_is_not_a_power_of_two)
+TYPED_TEST(ultra_composer, range_with_gates_where_range_is_not_a_power_of_two)
 {
     UltraComposer composer = UltraComposer();
     auto idx = add_variables(composer, { 1, 2, 3, 4, 5, 6, 7, 8 });
@@ -594,15 +536,11 @@ TEST(ultra_composer, range_with_gates_where_range_is_not_a_power_of_two)
     composer.create_add_gate({ idx[2], idx[3], composer.zero_idx, fr::one(), fr::one(), fr::zero(), -7 });
     composer.create_add_gate({ idx[4], idx[5], composer.zero_idx, fr::one(), fr::one(), fr::zero(), -11 });
     composer.create_add_gate({ idx[6], idx[7], composer.zero_idx, fr::one(), fr::one(), fr::zero(), -15 });
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
 
-    proof proof = prover.construct_proof();
-    bool result = verifier.verify_proof(proof);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, sort_widget_complex)
+TYPED_TEST(ultra_composer, sort_widget_complex)
 {
     {
 
@@ -628,16 +566,11 @@ TEST(ultra_composer, sort_widget_complex)
         for (size_t i = 0; i < a.size(); i++)
             ind.emplace_back(composer.add_variable(a[i]));
         composer.create_sort_constraint(ind);
-        auto prover = composer.create_prover();
-        auto verifier = composer.create_verifier();
-
-        proof proof = prover.construct_proof();
 
-        bool result = verifier.verify_proof(proof); // instance, prover.reference_string.SRS_T2);
-        EXPECT_EQ(result, false);
+        TestFixture::prove_and_verify(composer, /*expected_result=*/false);
     }
 }
-TEST(ultra_composer, sort_widget_neg)
+TYPED_TEST(ultra_composer, sort_widget_neg)
 {
     UltraComposer composer = UltraComposer();
     fr a = fr::one();
@@ -650,15 +583,11 @@ TEST(ultra_composer, sort_widget_neg)
     auto c_idx = composer.add_variable(c);
     auto d_idx = composer.add_variable(d);
     composer.create_sort_constraint({ a_idx, b_idx, c_idx, d_idx });
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
-
-    proof proof = prover.construct_proof();
 
-    bool result = verifier.verify_proof(proof);
-    EXPECT_EQ(result, false);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/false);
 }
-TEST(ultra_composer, composed_range_constraint)
+
+TYPED_TEST(ultra_composer, composed_range_constraint)
 {
     UltraComposer composer = UltraComposer();
     auto c = fr::random_element();
@@ -667,16 +596,11 @@ TEST(ultra_composer, composed_range_constraint)
     auto a_idx = composer.add_variable(fr(e));
     composer.create_add_gate({ a_idx, composer.zero_idx, composer.zero_idx, 1, 0, 0, -fr(e) });
     composer.decompose_into_default_range(a_idx, 134);
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
 
-    proof proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, non_native_field_multiplication)
+TYPED_TEST(ultra_composer, non_native_field_multiplication)
 {
     UltraComposer composer = UltraComposer();
 
@@ -728,16 +652,10 @@ TEST(ultra_composer, non_native_field_multiplication)
     const auto [lo_1_idx, hi_1_idx] = composer.evaluate_non_native_field_multiplication(inputs);
     composer.range_constrain_two_limbs(lo_1_idx, hi_1_idx, 70, 70);
 
-    auto prover = composer.create_prover();
-    auto verifier = composer.create_verifier();
-
-    proof proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, rom)
+TYPED_TEST(ultra_composer, rom)
 {
     UltraComposer composer = UltraComposer();
 
@@ -774,18 +692,10 @@ TEST(ultra_composer, rom)
         0,
     });
 
-    auto prover = composer.create_prover();
-    info("composer.num_gates after constructing prover: ", composer.num_gates);
-
-    auto verifier = composer.create_verifier();
-
-    proof proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-TEST(ultra_composer, ram)
+TYPED_TEST(ultra_composer, ram)
 {
     UltraComposer composer = UltraComposer();
 
@@ -845,15 +755,7 @@ TEST(ultra_composer, ram)
         },
         false);
 
-    auto prover = composer.create_prover();
-    std::cout << "prover num_gates = " << composer.num_gates << std::endl;
-
-    auto verifier = composer.create_verifier();
-
-    proof proof = prover.construct_proof();
-
-    bool result = verifier.verify_proof(proof);
-    EXPECT_EQ(result, true);
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
-} // namespace proof_system::plonk
+} // namespace proof_system::plonk::test_ultra_composer
diff --git a/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.cpp b/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.cpp
index 9e1d5a9d02..f084d8ad34 100644
--- a/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.cpp
@@ -392,4 +392,5 @@ template class KateCommitmentScheme<standard_settings>;
 template class KateCommitmentScheme<turbo_settings>;
 template class KateCommitmentScheme<ultra_settings>;
 template class KateCommitmentScheme<ultra_to_standard_settings>;
+template class KateCommitmentScheme<ultra_with_keccak_settings>;
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.hpp b/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.hpp
index 653340dbdf..741193d0d8 100644
--- a/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/kate_commitment_scheme.hpp
@@ -43,5 +43,6 @@ extern template class KateCommitmentScheme<standard_settings>;
 extern template class KateCommitmentScheme<turbo_settings>;
 extern template class KateCommitmentScheme<ultra_settings>;
 extern template class KateCommitmentScheme<ultra_to_standard_settings>;
+extern template class KateCommitmentScheme<ultra_with_keccak_settings>;
 
 } // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/plonk/proof_system/constants.hpp b/cpp/src/barretenberg/plonk/proof_system/constants.hpp
index b5de8c110a..ac2ee70fec 100644
--- a/cpp/src/barretenberg/plonk/proof_system/constants.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/constants.hpp
@@ -1,20 +1,10 @@
 #pragma once
 #include <cstdint>
-#include "barretenberg/proof_system/types/composer_type.hpp"
-namespace proof_system::plonk {
 
-// This variable sets the composer (TURBO or ULTRA) of the entire stdlib and rollup modules.
-// To switch to using a new composer, only changing this variable should activate the new composer
-// throughout the stdlib and circuits.
-#ifdef USE_TURBO
-static constexpr uint32_t SYSTEM_COMPOSER = ComposerType::TURBO;
-#else
-static constexpr uint32_t SYSTEM_COMPOSER = ComposerType::PLOOKUP;
-#endif
+namespace proof_system::plonk {
 
 // limb size when simulating a non-native field using bigfield class
 // (needs to be a universal constant to be used by native verifier)
 static constexpr uint64_t NUM_LIMB_BITS_IN_FIELD_SIMULATION = 68;
-
 static constexpr uint32_t NUM_QUOTIENT_PARTS = 4;
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/prover/c_bind.cpp b/cpp/src/barretenberg/plonk/proof_system/prover/c_bind.cpp
index 6cd4d4c7af..ef1d1c1392 100644
--- a/cpp/src/barretenberg/plonk/proof_system/prover/c_bind.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/prover/c_bind.cpp
@@ -1,7 +1,6 @@
 #include "prover.hpp"
 #include "barretenberg/env/data_store.hpp"
 #include "barretenberg/env/crs.hpp"
-#include "barretenberg/proof_system/types/composer_type.hpp"
 
 #define WASM_EXPORT __attribute__((visibility("default")))
 
@@ -48,8 +47,8 @@ WASM_EXPORT void* test_env_load_prover_crs(size_t num_points)
 {
     return env_load_prover_crs(num_points);
 }
-typedef std::conditional_t<plonk::SYSTEM_COMPOSER == ComposerType::TURBO, plonk::TurboProver, plonk::UltraProver>
-    WasmProver;
+
+using WasmProver = plonk::UltraProver;
 
 WASM_EXPORT void prover_process_queue(WasmProver* prover)
 {
diff --git a/cpp/src/barretenberg/plonk/proof_system/prover/c_bind_unrolled.cpp b/cpp/src/barretenberg/plonk/proof_system/prover/c_bind_unrolled.cpp
deleted file mode 100644
index 66cfdc7496..0000000000
--- a/cpp/src/barretenberg/plonk/proof_system/prover/c_bind_unrolled.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "prover.hpp"
-#include "barretenberg/proof_system/types/composer_type.hpp"
-
-#define WASM_EXPORT __attribute__((visibility("default")))
-
-using namespace barretenberg;
-
-extern "C" {
-
-// TODO(Cody): Removed "unrolled" here when the time comes, if it does.
-typedef std::conditional_t<plonk::SYSTEM_COMPOSER == ComposerType::TURBO, plonk::TurboProver, plonk::UltraProver>
-    WasmUnrolledProver;
-
-WASM_EXPORT void unrolled_prover_process_queue(WasmUnrolledProver* prover)
-{
-    prover->queue.process_queue();
-}
-
-WASM_EXPORT size_t unrolled_prover_get_circuit_size(WasmUnrolledProver* prover)
-{
-    return prover->get_circuit_size();
-}
-
-WASM_EXPORT void unrolled_prover_get_work_queue_item_info(WasmUnrolledProver* prover, uint8_t* result)
-{
-    auto info = prover->get_queued_work_item_info();
-    memcpy(result, &info, sizeof(info));
-}
-
-WASM_EXPORT fr* unrolled_prover_get_scalar_multiplication_data(WasmUnrolledProver* prover, size_t work_item_number)
-{
-    return prover->get_scalar_multiplication_data(work_item_number);
-}
-
-WASM_EXPORT size_t unrolled_prover_get_scalar_multiplication_size(WasmUnrolledProver* prover, size_t work_item_number)
-{
-    return prover->get_scalar_multiplication_size(work_item_number);
-}
-
-WASM_EXPORT void unrolled_prover_put_scalar_multiplication_data(WasmUnrolledProver* prover,
-                                                                g1::element* result,
-                                                                const size_t work_item_number)
-{
-    prover->put_scalar_multiplication_data(*result, work_item_number);
-}
-
-WASM_EXPORT fr* unrolled_prover_get_fft_data(WasmUnrolledProver* prover, fr* shift_factor, size_t work_item_number)
-{
-    auto data = prover->get_fft_data(work_item_number);
-    *shift_factor = data.shift_factor;
-    return data.data;
-}
-
-WASM_EXPORT void unrolled_prover_put_fft_data(WasmUnrolledProver* prover, fr* result, size_t work_item_number)
-{
-    prover->put_fft_data(result, work_item_number);
-}
-
-WASM_EXPORT fr* unrolled_prover_get_ifft_data(WasmUnrolledProver* prover, size_t work_item_number)
-{
-    return prover->get_ifft_data(work_item_number);
-}
-
-WASM_EXPORT void unrolled_prover_put_ifft_data(WasmUnrolledProver* prover, fr* result, size_t work_item_number)
-{
-    prover->put_ifft_data(result, work_item_number);
-}
-
-WASM_EXPORT void unrolled_prover_execute_preamble_round(WasmUnrolledProver* prover)
-{
-    prover->execute_preamble_round();
-}
-
-WASM_EXPORT void unrolled_prover_execute_first_round(WasmUnrolledProver* prover)
-{
-    prover->execute_first_round();
-}
-
-WASM_EXPORT void unrolled_prover_execute_second_round(WasmUnrolledProver* prover)
-{
-    prover->execute_second_round();
-}
-
-WASM_EXPORT void unrolled_prover_execute_third_round(WasmUnrolledProver* prover)
-{
-    prover->execute_third_round();
-}
-
-WASM_EXPORT void unrolled_prover_execute_fourth_round(WasmUnrolledProver* prover)
-{
-    prover->execute_fourth_round();
-}
-
-WASM_EXPORT void unrolled_prover_execute_fifth_round(WasmUnrolledProver* prover)
-{
-    prover->execute_fifth_round();
-}
-
-WASM_EXPORT void unrolled_prover_execute_sixth_round(WasmUnrolledProver* prover)
-{
-    prover->execute_sixth_round();
-}
-
-WASM_EXPORT size_t unrolled_prover_export_proof(WasmUnrolledProver* prover, uint8_t** proof_data_buf)
-{
-    auto& proof_data = prover->export_proof().proof_data;
-    *proof_data_buf = proof_data.data();
-    return proof_data.size();
-}
-}
diff --git a/cpp/src/barretenberg/plonk/proof_system/prover/prover.cpp b/cpp/src/barretenberg/plonk/proof_system/prover/prover.cpp
index 5e91ef8ae4..b7730585e1 100644
--- a/cpp/src/barretenberg/plonk/proof_system/prover/prover.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/prover/prover.cpp
@@ -1,5 +1,6 @@
 #include "prover.hpp"
 #include "../public_inputs/public_inputs.hpp"
+#include "barretenberg/plonk/proof_system/types/prover_settings.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include <chrono>
 #include "barretenberg/ecc/curves/bn254/scalar_multiplication/scalar_multiplication.hpp"
@@ -639,5 +640,6 @@ template class ProverBase<standard_settings>;
 template class ProverBase<turbo_settings>;
 template class ProverBase<ultra_settings>;
 template class ProverBase<ultra_to_standard_settings>;
+template class ProverBase<ultra_with_keccak_settings>;
 
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/prover/prover.hpp b/cpp/src/barretenberg/plonk/proof_system/prover/prover.hpp
index d0476608e2..6b817e5c19 100644
--- a/cpp/src/barretenberg/plonk/proof_system/prover/prover.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/prover/prover.hpp
@@ -109,5 +109,6 @@ typedef ProverBase<ultra_settings> UltraProver; // TODO(Mike): maybe just return
                                                 // need separate cases for ultra vs ultra_to_standard...???
                                                 // TODO(Cody): Make this into an issue?
 typedef ProverBase<ultra_to_standard_settings> UltraToStandardProver;
+typedef ProverBase<ultra_with_keccak_settings> UltraWithKeccakProver;
 
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp b/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp
index 65911eba38..dfdc619606 100644
--- a/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/types/polynomial_manifest.hpp
@@ -3,7 +3,7 @@
 #include <array>
 #include <vector>
 #include <string>
-#include "barretenberg/plonk/proof_system/constants.hpp"
+#include "barretenberg/proof_system/types/composer_type.hpp"
 
 namespace proof_system::plonk {
 
diff --git a/cpp/src/barretenberg/plonk/proof_system/types/program_settings.hpp b/cpp/src/barretenberg/plonk/proof_system/types/program_settings.hpp
index b4b9d5d753..39c98c2784 100644
--- a/cpp/src/barretenberg/plonk/proof_system/types/program_settings.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/types/program_settings.hpp
@@ -187,4 +187,20 @@ class ultra_to_standard_verifier_settings : public ultra_verifier_settings {
     static constexpr transcript::HashType hash_type = transcript::HashType::PedersenBlake3s;
 };
 
+// This is neededed for the Noir backend. The ultra verifier contract uses 32-byte challenges generated with Keccak256.
+class ultra_with_keccak_verifier_settings : public ultra_verifier_settings {
+  public:
+    typedef VerifierPlookupArithmeticWidget<fr, g1::affine_element, Transcript, ultra_with_keccak_settings>
+        PlookupArithmeticWidget;
+    typedef VerifierGenPermSortWidget<fr, g1::affine_element, Transcript, ultra_with_keccak_settings> GenPermSortWidget;
+    typedef VerifierTurboLogicWidget<fr, g1::affine_element, Transcript, ultra_with_keccak_settings> TurboLogicWidget;
+    typedef VerifierPermutationWidget<fr, g1::affine_element, Transcript> PermutationWidget;
+    typedef VerifierPlookupWidget<fr, g1::affine_element, Transcript> PlookupWidget;
+    typedef VerifierEllipticWidget<fr, g1::affine_element, Transcript, ultra_with_keccak_settings> EllipticWidget;
+    typedef VerifierPlookupAuxiliaryWidget<fr, g1::affine_element, Transcript, ultra_with_keccak_settings>
+        PlookupAuxiliaryWidget;
+
+    static constexpr size_t num_challenge_bytes = 32;
+    static constexpr transcript::HashType hash_type = transcript::HashType::Keccak256;
+};
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/types/prover_settings.hpp b/cpp/src/barretenberg/plonk/proof_system/types/prover_settings.hpp
index fd439df766..3fa0e35d38 100644
--- a/cpp/src/barretenberg/plonk/proof_system/types/prover_settings.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/types/prover_settings.hpp
@@ -57,4 +57,12 @@ class ultra_to_standard_settings : public ultra_settings {
     static constexpr transcript::HashType hash_type = transcript::HashType::PedersenBlake3s;
 };
 
+// Only needed because ultra-to-standard recursion requires us to use a Pedersen hash which is common to both Ultra &
+// Standard plonk i.e. the non-ultra version.
+class ultra_with_keccak_settings : public ultra_settings {
+  public:
+    static constexpr size_t num_challenge_bytes = 32;
+    static constexpr transcript::HashType hash_type = transcript::HashType::Keccak256;
+};
+
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.test.cpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.test.cpp
index 1e2a83998e..1151bf27c0 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.test.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.test.cpp
@@ -17,7 +17,8 @@ namespace proof_system::plonk::test_verification_key {
  *
  * @return verification_key_data randomly generated
  */
-verification_key_data rand_vk_data() {
+verification_key_data rand_vk_data()
+{
     verification_key_data vk_data;
     vk_data.composer_type = static_cast<uint32_t>(proof_system::ComposerType::STANDARD);
     vk_data.circuit_size = 1024; // not random - must be power of 2
@@ -40,7 +41,7 @@ void expect_compressions_eq(verification_key_data vk0_data, verification_key_dat
     // 0 hash index
     EXPECT_EQ(vk0_data.compress_native(0), vk1_data.compress_native(0));
     // nonzero hash index
-    EXPECT_EQ(vk0_data.compress_native(15), vk1_data.compress_native(15));
+    // EXPECT_EQ(vk0_data.compress_native(15), vk1_data.compress_native(15));
 }
 
 /**
@@ -52,10 +53,10 @@ void expect_compressions_eq(verification_key_data vk0_data, verification_key_dat
 void expect_compressions_ne(verification_key_data vk0_data, verification_key_data vk1_data)
 {
     EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(0));
-    EXPECT_NE(vk0_data.compress_native(15), vk1_data.compress_native(15));
+    // EXPECT_NE(vk0_data.compress_native(15), vk1_data.compress_native(15));
     // ne hash indices still lead to ne compressions
-    EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(15));
-    EXPECT_NE(vk0_data.compress_native(14), vk1_data.compress_native(15));
+    // EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(15));
+    // EXPECT_NE(vk0_data.compress_native(14), vk1_data.compress_native(15));
 }
 
 TEST(verification_key, buffer_serialization)
@@ -93,8 +94,8 @@ TEST(verification_key, compression_inequality_index_mismatch)
     verification_key_data vk0_data = rand_vk_data();
     verification_key_data vk1_data = vk0_data; // copy
     // inquality on hash index mismatch
-    EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(15));
-    EXPECT_NE(vk0_data.compress_native(14), vk1_data.compress_native(15));
+    // EXPECT_NE(vk0_data.compress_native(0), vk1_data.compress_native(15));
+    // EXPECT_NE(vk0_data.compress_native(14), vk1_data.compress_native(15));
 }
 
 TEST(verification_key, compression_inequality_composer_type)
@@ -105,7 +106,7 @@ TEST(verification_key, compression_inequality_composer_type)
     expect_compressions_ne(vk0_data, vk1_data);
 }
 
-TEST(verification_key, compression_inequality_different_circuit_size) \
+TEST(verification_key, compression_inequality_different_circuit_size)
 {
     verification_key_data vk0_data = rand_vk_data();
     verification_key_data vk1_data = vk0_data;
@@ -113,7 +114,7 @@ TEST(verification_key, compression_inequality_different_circuit_size) \
     expect_compressions_ne(vk0_data, vk1_data);
 }
 
-TEST(verification_key, compression_inequality_different_num_public_inputs) \
+TEST(verification_key, compression_inequality_different_num_public_inputs)
 {
     verification_key_data vk0_data = rand_vk_data();
     verification_key_data vk1_data = vk0_data;
@@ -121,7 +122,7 @@ TEST(verification_key, compression_inequality_different_num_public_inputs) \
     expect_compressions_ne(vk0_data, vk1_data);
 }
 
-TEST(verification_key, compression_inequality_different_commitments) \
+TEST(verification_key, compression_inequality_different_commitments)
 {
     verification_key_data vk0_data = rand_vk_data();
     verification_key_data vk1_data = vk0_data;
@@ -129,7 +130,7 @@ TEST(verification_key, compression_inequality_different_commitments) \
     expect_compressions_ne(vk0_data, vk1_data);
 }
 
-TEST(verification_key, compression_inequality_different_num_commitments) \
+TEST(verification_key, compression_inequality_different_num_commitments)
 {
     verification_key_data vk0_data = rand_vk_data();
     verification_key_data vk1_data = vk0_data;
@@ -137,7 +138,7 @@ TEST(verification_key, compression_inequality_different_num_commitments) \
     expect_compressions_ne(vk0_data, vk1_data);
 }
 
-TEST(verification_key, compression_equality_different_contains_recursive_proof) \
+TEST(verification_key, compression_equality_different_contains_recursive_proof)
 {
     verification_key_data vk0_data = rand_vk_data();
     verification_key_data vk1_data = vk0_data;
@@ -146,7 +147,7 @@ TEST(verification_key, compression_equality_different_contains_recursive_proof)
     expect_compressions_eq(vk0_data, vk1_data);
 }
 
-TEST(verification_key, compression_equality_different_recursive_proof_public_input_indices) \
+TEST(verification_key, compression_equality_different_recursive_proof_public_input_indices)
 {
     verification_key_data vk0_data = rand_vk_data();
     verification_key_data vk1_data = vk0_data;
diff --git a/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.cpp b/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.cpp
index 2a4681df5f..bee400fd36 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.cpp
@@ -241,5 +241,6 @@ template class VerifierBase<standard_verifier_settings>;
 template class VerifierBase<turbo_verifier_settings>;
 template class VerifierBase<ultra_verifier_settings>;
 template class VerifierBase<ultra_to_standard_verifier_settings>;
+template class VerifierBase<ultra_with_keccak_verifier_settings>;
 
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.hpp b/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.hpp
index 151117ba10..951cef26d6 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.hpp
@@ -32,10 +32,11 @@ extern template class VerifierBase<standard_verifier_settings>;
 extern template class VerifierBase<turbo_verifier_settings>;
 extern template class VerifierBase<ultra_verifier_settings>;
 extern template class VerifierBase<ultra_to_standard_verifier_settings>;
+extern template class VerifierBase<ultra_with_keccak_verifier_settings>;
 
 typedef VerifierBase<standard_verifier_settings> Verifier;
 typedef VerifierBase<turbo_verifier_settings> TurboVerifier;
 typedef VerifierBase<ultra_verifier_settings> UltraVerifier;
 typedef VerifierBase<ultra_to_standard_verifier_settings> UltraToStandardVerifier;
-
+typedef VerifierBase<ultra_with_keccak_verifier_settings> UltraWithKeccakVerifier;
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp b/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp
index 73039533fc..ef70eb9a18 100644
--- a/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp
+++ b/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp
@@ -222,29 +222,30 @@ PermutationMapping<program_width> compute_permutation_mapping(const CircuitConst
 }
 
 /**
- * @brief Compute Sigma polynomials for Honk from a mapping and put into polynomial cache
+ * @brief Compute Sigma/ID polynomials for Honk from a mapping and put into polynomial cache
  *
- * @details Given a mapping (effectively at table pointing witnesses to other witnesses) compute Sigma polynomials in
- * lagrange form and put them into the cache. This version distinguishes betweenr regular elements and public inputs,
- * but ignores tags
+ * @details Given a mapping (effectively at table pointing witnesses to other witnesses) compute Sigma/ID polynomials in
+ * lagrange form and put them into the cache. This version is suitable for traditional and generalized permutations.
  *
  * @tparam program_width The number of wires
- * @param sigma_mappings A table with information about permuting each element
+ * @param permutation_mappings A table with information about permuting each element
  * @param key Pointer to the proving key
  */
 template <size_t program_width>
-void compute_honk_style_sigma_lagrange_polynomials_from_mapping(
-    std::array<std::vector<permutation_subgroup_element>, program_width>& sigma_mappings, plonk::proving_key* key)
+void compute_honk_style_permutation_lagrange_polynomials_from_mapping(
+    std::string label,
+    std::array<std::vector<permutation_subgroup_element>, program_width>& permutation_mappings,
+    plonk::proving_key* key)
 {
     const size_t num_gates = key->circuit_size;
 
-    std::array<barretenberg::polynomial, program_width> sigma;
+    std::array<barretenberg::polynomial, program_width> permutation_poly; // sigma or ID poly
 
     for (size_t wire_index = 0; wire_index < program_width; wire_index++) {
-        sigma[wire_index] = barretenberg::polynomial(num_gates);
-        auto& current_sigma_polynomial = sigma[wire_index];
+        permutation_poly[wire_index] = barretenberg::polynomial(num_gates);
+        auto& current_permutation_poly = permutation_poly[wire_index];
         ITERATE_OVER_DOMAIN_START(key->small_domain)
-        const auto& current_mapping = sigma_mappings[wire_index][i];
+        const auto& current_mapping = permutation_mappings[wire_index][i];
         if (current_mapping.is_public_input) {
             // We intentionally want to break the cycles of the public input variables.
             // During the witness generation, the left and right wire polynomials at index i contain the i-th public
@@ -254,13 +255,15 @@ void compute_honk_style_sigma_lagrange_polynomials_from_mapping(
             //  -(i+1) -> (n+i)
             // These indices are chosen so they can easily be computed by the verifier. They can expect the running
             // product to be equal to the "public input delta" that is computed in <honk/utils/public_inputs.hpp>
-            current_sigma_polynomial[i] =
+            current_permutation_poly[i] =
                 -barretenberg::fr(current_mapping.row_index + 1 + num_gates * current_mapping.column_index);
+        } else if (current_mapping.is_tag) {
+            // Set evaluations to (arbitrary) values disjoint from non-tag values
+            current_permutation_poly[i] = num_gates * program_width + current_mapping.row_index;
         } else {
-            ASSERT(!current_mapping.is_tag);
             // For the regular permutation we simply point to the next location by setting the evaluation to its
             // index
-            current_sigma_polynomial[i] =
+            current_permutation_poly[i] =
                 barretenberg::fr(current_mapping.row_index + num_gates * current_mapping.column_index);
         }
         ITERATE_OVER_DOMAIN_END;
@@ -268,7 +271,7 @@ void compute_honk_style_sigma_lagrange_polynomials_from_mapping(
     // Save to polynomial cache
     for (size_t j = 0; j < program_width; j++) {
         std::string index = std::to_string(j + 1);
-        key->polynomial_store.put("sigma_" + index + "_lagrange", std::move(sigma[j]));
+        key->polynomial_store.put(label + "_" + index + "_lagrange", std::move(permutation_poly[j]));
     }
 }
 
@@ -447,7 +450,7 @@ void compute_standard_honk_sigma_permutations(CircuitConstructor& circuit_constr
     // Compute the permutation table specifying which element becomes which
     auto mapping = compute_permutation_mapping<program_width, false>(circuit_constructor, key);
     // Compute Honk-style sigma polynomial fromt the permutation table
-    compute_honk_style_sigma_lagrange_polynomials_from_mapping(mapping.sigmas, key);
+    compute_honk_style_permutation_lagrange_polynomials_from_mapping("sigma", mapping.sigmas, key);
 }
 
 /**
@@ -508,4 +511,23 @@ void compute_plonk_generalized_sigma_permutations(const CircuitConstructor& circ
     compute_monomial_and_coset_fft_polynomials_from_lagrange<program_width>("id", key);
 }
 
+/**
+ * @brief Compute generalized permutation sigmas and ids for ultra plonk
+ *
+ * @tparam program_width
+ * @tparam CircuitConstructor
+ * @param circuit_constructor
+ * @param key
+ * @return std::array<std::vector<permutation_subgroup_element>, program_width>
+ */
+template <size_t program_width, typename CircuitConstructor>
+void compute_honk_generalized_sigma_permutations(const CircuitConstructor& circuit_constructor, plonk::proving_key* key)
+{
+    auto mapping = compute_permutation_mapping<program_width, true>(circuit_constructor, key);
+
+    // Compute Honk-style sigma and ID polynomials from the corresponding mappings
+    compute_honk_style_permutation_lagrange_polynomials_from_mapping("sigma", mapping.sigmas, key);
+    compute_honk_style_permutation_lagrange_polynomials_from_mapping("id", mapping.ids, key);
+}
+
 } // namespace proof_system
diff --git a/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp b/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
index aa4457a72e..4a2ab39e8a 100644
--- a/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
+++ b/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
@@ -1,15 +1,28 @@
 #include "schnorr.hpp"
 #include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+#include "barretenberg/stdlib/primitives/field/field.hpp"
+#include "barretenberg/stdlib/primitives/bool/bool.hpp"
+#include "barretenberg/stdlib/primitives/witness/witness.hpp"
+#include "barretenberg/stdlib/primitives/point/point.hpp"
 #include <gtest/gtest.h>
-#include "barretenberg/stdlib/types/types.hpp"
 
-namespace test_stdlib_schnorr {
+namespace proof_system::test_stdlib_schnorr {
 
 using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
 using namespace proof_system::plonk::stdlib::schnorr;
 
+using Composer = plonk::UltraComposer;
+using Prover = plonk::UltraProver;
+using Verifier = plonk::UltraVerifier;
+using bool_ct = bool_t<Composer>;
+using byte_array_ct = byte_array<Composer>;
+using field_ct = field_t<Composer>;
+using point_ct = point<Composer>;
+using witness_ct = witness_t<Composer>;
+
 auto run_scalar_mul_test = [](grumpkin::fr scalar_mont, bool expect_verify) {
     Composer composer = Composer();
 
@@ -204,9 +217,9 @@ TEST(stdlib_schnorr, verify_signature)
         EXPECT_EQ(first_result, true);
 
         point_ct pub_key{ witness_ct(&composer, account.public_key.x), witness_ct(&composer, account.public_key.y) };
-        stdlib::schnorr::signature_bits sig = stdlib::schnorr::convert_signature(&composer, signature);
+        signature_bits sig = convert_signature(&composer, signature);
         byte_array_ct message(&composer, message_string);
-        stdlib::schnorr::verify_signature(message, pub_key, sig);
+        verify_signature(message, pub_key, sig);
 
         auto prover = composer.create_prover();
         info("composer gates = %zu\n", composer.get_num_gates());
@@ -248,9 +261,9 @@ TEST(stdlib_schnorr, verify_signature_failure)
 
     // check stdlib verification with account 2 public key fails
     point_ct pub_key2_ct{ witness_ct(&composer, account2.public_key.x), witness_ct(&composer, account2.public_key.y) };
-    stdlib::schnorr::signature_bits sig = stdlib::schnorr::convert_signature(&composer, signature);
+    signature_bits sig = convert_signature(&composer, signature);
     byte_array_ct message(&composer, message_string);
-    stdlib::schnorr::verify_signature(message, pub_key2_ct, sig);
+    verify_signature(message, pub_key2_ct, sig);
 
     auto prover = composer.create_prover();
 
@@ -286,14 +299,14 @@ TEST(stdlib_schnorr, signature_verification_result)
     EXPECT_EQ(first_result, true);
 
     point_ct pub_key{ witness_ct(&composer, account.public_key.x), witness_ct(&composer, account.public_key.y) };
-    stdlib::schnorr::signature_bits sig = stdlib::schnorr::convert_signature(&composer, signature);
+    signature_bits sig = convert_signature(&composer, signature);
     byte_array_ct message(&composer, longer_string);
-    bool_ct signature_result = stdlib::schnorr::signature_verification_result(message, pub_key, sig);
+    bool_ct signature_result = signature_verification_result(message, pub_key, sig);
     EXPECT_EQ(signature_result.witness_bool, true);
 
-    plonk::stdlib::types::Prover prover = composer.create_prover();
+    Prover prover = composer.create_prover();
     info("composer gates = %zu\n", composer.get_num_gates());
-    plonk::stdlib::types::Verifier verifier = composer.create_verifier();
+    Verifier verifier = composer.create_verifier();
     plonk::proof proof = prover.construct_proof();
     bool result = verifier.verify_proof(proof);
     EXPECT_EQ(result, true);
@@ -330,17 +343,17 @@ TEST(stdlib_schnorr, signature_verification_result_failure)
 
     // check stdlib verification with account 2 public key fails
     point_ct pub_key2_ct{ witness_ct(&composer, account2.public_key.x), witness_ct(&composer, account2.public_key.y) };
-    stdlib::schnorr::signature_bits sig = stdlib::schnorr::convert_signature(&composer, signature);
+    signature_bits sig = convert_signature(&composer, signature);
     byte_array_ct message(&composer, message_string);
-    bool_ct signature_result = stdlib::schnorr::signature_verification_result(message, pub_key2_ct, sig);
+    bool_ct signature_result = signature_verification_result(message, pub_key2_ct, sig);
     EXPECT_EQ(signature_result.witness_bool, false);
 
-    plonk::stdlib::types::Prover prover = composer.create_prover();
+    Prover prover = composer.create_prover();
     info("composer gates = %zu\n", composer.get_num_gates());
-    plonk::stdlib::types::Verifier verifier = composer.create_verifier();
+    Verifier verifier = composer.create_verifier();
     plonk::proof proof = prover.construct_proof();
     bool verification_result = verifier.verify_proof(proof);
     EXPECT_EQ(verification_result, true);
 }
 
-} // namespace test_stdlib_schnorr
+} // namespace proof_system::test_stdlib_schnorr
diff --git a/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp b/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp
index b61cbc305d..61e7ccc293 100644
--- a/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp
+++ b/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp
@@ -1,21 +1,27 @@
 #include "blake2s.hpp"
 #include "blake2s_plookup.hpp"
-#include "barretenberg/crypto/blake2s/blake2s.hpp"
 #include <gtest/gtest.h>
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/crypto/blake2s/blake2s.hpp"
 
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
-using namespace proof_system::plonk::stdlib::types;
-typedef stdlib::byte_array<Composer> byte_array;
-typedef stdlib::byte_array<plonk::UltraComposer> byte_array_plookup;
-typedef stdlib::public_witness_t<Composer> public_witness_t;
-typedef stdlib::public_witness_t<plonk::UltraComposer> public_witness_t_plookup;
+using namespace plonk::stdlib;
+
+using Composer = plonk::UltraComposer;
+using Prover = plonk::UltraProver;
+using Verifier = plonk::UltraVerifier;
+
+using field_ct = field_t<Composer>;
+using witness_ct = witness_t<Composer>;
+using byte_array_ct = stdlib::byte_array<Composer>;
+using byte_array_plookup = stdlib::byte_array<Composer>;
+using public_witness_t = stdlib::public_witness_t<Composer>;
+using public_witness_t_plookup = stdlib::public_witness_t<Composer>;
 
 TEST(stdlib_blake2s, test_single_block)
 {
-    Composer composer = Composer();
+    auto composer = Composer();
     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz01";
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
@@ -28,7 +34,7 @@ TEST(stdlib_blake2s, test_single_block)
 
     auto prover = composer.create_prover();
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    info("composer gates = %zu\n", composer.get_num_gates());
     auto verifier = composer.create_verifier();
 
     auto proof = prover.construct_proof();
@@ -52,7 +58,7 @@ TEST(stdlib_blake2s, test_single_block_plookup)
 
     auto prover = composer.create_prover();
     std::cout << "prover gates = " << prover.circuit_size << std::endl;
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    info("composer gates = %zu\n", composer.get_num_gates());
     auto verifier = composer.create_verifier();
 
     auto proof = prover.construct_proof();
@@ -63,7 +69,7 @@ TEST(stdlib_blake2s, test_single_block_plookup)
 
 TEST(stdlib_blake2s, test_double_block)
 {
-    Composer composer = Composer();
+    auto composer = Composer();
     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789";
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
@@ -76,7 +82,7 @@ TEST(stdlib_blake2s, test_double_block)
 
     auto prover = composer.create_prover();
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    info("composer gates = %zu\n", composer.get_num_gates());
     auto verifier = composer.create_verifier();
 
     auto proof = prover.construct_proof();
@@ -100,7 +106,7 @@ TEST(stdlib_blake2s, test_double_block_plookup)
 
     auto prover = composer.create_prover();
     std::cout << "prover gates = " << prover.circuit_size << std::endl;
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    info("composer gates = %zu\n", composer.get_num_gates());
     auto verifier = composer.create_verifier();
 
     auto proof = prover.construct_proof();
diff --git a/cpp/src/barretenberg/stdlib/hash/sha256/sha256.bench.cpp b/cpp/src/barretenberg/stdlib/hash/sha256/sha256.bench.cpp
index 1c5947c669..d912505c44 100644
--- a/cpp/src/barretenberg/stdlib/hash/sha256/sha256.bench.cpp
+++ b/cpp/src/barretenberg/stdlib/hash/sha256/sha256.bench.cpp
@@ -2,10 +2,14 @@
 #include <benchmark/benchmark.h>
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/plonk/composer/ultra_composer.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+#include "barretenberg/plonk/proof_system/prover/prover.hpp"
+#include "barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.hpp"
 
 using namespace benchmark;
-using namespace proof_system::plonk::stdlib::types;
+
+using Composer = proof_system::plonk::UltraComposer;
+using Prover = proof_system::plonk::UltraProver;
+using Verifier = proof_system::plonk::UltraVerifier;
 
 constexpr size_t NUM_HASHES = 8;
 constexpr size_t BYTES_PER_CHUNK = 512;
@@ -24,13 +28,13 @@ void generate_test_plonk_circuit(Composer& composer, size_t num_bytes)
     for (size_t i = 0; i < num_bytes; ++i) {
         in[i] = get_random_char();
     }
-    packed_byte_array_ct input(&composer, in);
-    plonk::stdlib::sha256(input);
+    proof_system::plonk::stdlib::packed_byte_array<Composer> input(&composer, in);
+    proof_system::plonk::stdlib::sha256<Composer>(input);
 }
 
-stdlib::types::Composer composers[NUM_HASHES];
-stdlib::types::Prover provers[NUM_HASHES];
-stdlib::types::Verifier verifiers[NUM_HASHES];
+Composer composers[NUM_HASHES];
+Prover provers[NUM_HASHES];
+Verifier verifiers[NUM_HASHES];
 plonk::proof proofs[NUM_HASHES];
 
 void construct_witnesses_bench(State& state) noexcept
diff --git a/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp b/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp
index 9379e2382a..8f9952da34 100644
--- a/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp
+++ b/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp
@@ -2,8 +2,9 @@
 #include "barretenberg/common/test.hpp"
 #include "barretenberg/crypto/sha256/sha256.hpp"
 #include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
 #include "barretenberg/plonk/composer/plookup_tables/plookup_tables.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
 
 #include "barretenberg/numeric/random/engine.hpp"
 #include "barretenberg/numeric/bitop/rotate.hpp"
@@ -13,11 +14,18 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-namespace test_stdlib_sha256 {
+namespace proof_system::test_stdlib_sha256 {
 
 using namespace barretenberg;
-using namespace proof_system::plonk;
-using namespace proof_system::plonk::stdlib::types;
+using namespace proof_system::plonk::stdlib;
+
+using Composer = plonk::UltraComposer;
+using Prover = plonk::UltraProver;
+using Verifier = plonk::UltraVerifier;
+
+using byte_array_ct = byte_array<Composer>;
+using packed_byte_array_ct = packed_byte_array<Composer>;
+using field_ct = field_t<Composer>;
 
 constexpr uint64_t ror(uint64_t val, uint64_t shift)
 {
@@ -112,8 +120,9 @@ std::array<uint64_t, 8> inner_block(std::array<uint64_t, 64>& w)
 TEST(stdlib_sha256, test_duplicate_proving_key)
 {
 
-    plonk::StandardComposer first_composer = StandardComposer();
-    stdlib::packed_byte_array input(&first_composer, "An 8 character password? Snow White and the 7 Dwarves..");
+    auto first_composer = plonk::StandardComposer();
+    plonk::stdlib::packed_byte_array<plonk::StandardComposer> input(
+        &first_composer, "An 8 character password? Snow White and the 7 Dwarves..");
     plonk::stdlib::sha256(input);
     auto prover = first_composer.create_prover();
     auto verifier = first_composer.create_verifier();
@@ -125,8 +134,9 @@ TEST(stdlib_sha256, test_duplicate_proving_key)
     auto circuit_size = prover.circuit_size;
 
     // Test a second time with same keys and different input.
-    plonk::StandardComposer second_composer = StandardComposer(proving_key, verification_key, circuit_size);
-    stdlib::packed_byte_array input2(&second_composer, "An 8 character password? Snow White and the 9 Dwarves..");
+    auto second_composer = plonk::StandardComposer(proving_key, verification_key, circuit_size);
+    plonk::stdlib::packed_byte_array<plonk::StandardComposer> input2(
+        &second_composer, "An 8 character password? Snow White and the 9 Dwarves..");
     plonk::stdlib::sha256(input2);
     auto second_prover = second_composer.create_prover();
     auto second_verifier = second_composer.create_verifier();
@@ -138,14 +148,14 @@ TEST(stdlib_sha256, test_duplicate_proving_key)
 // TEST(stdlib_sha256_plookup, test_round)
 // {
 
-//     plonk::UltraComposer composer = UltraComposer();
+//     auto composer = UltraComposer();
 
 //     std::array<uint64_t, 64> w_inputs;
 //     std::array<plonk::stdlib::field_t<plonk::UltraComposer>, 64> w_elements;
 
 //     for (size_t i = 0; i < 64; ++i) {
 //         w_inputs[i] = engine.get_random_uint32();
-//         w_elements[i] = stdlib::witness_t<plonk::UltraComposer>(&composer,
+//         w_elements[i] = plonk::stdlib::witness_t<plonk::UltraComposer>(&composer,
 //         barretenberg::fr(w_inputs[i]));
 //     }
 
@@ -169,15 +179,15 @@ TEST(stdlib_sha256, test_duplicate_proving_key)
 
 TEST(stdlib_sha256, test_plookup_55_bytes)
 {
-    typedef stdlib::field_t<plonk::UltraComposer> field_pt;
-    typedef stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
+    typedef plonk::stdlib::field_t<plonk::UltraComposer> field_pt;
+    typedef plonk::stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
 
     // 55 bytes is the largest number of bytes that can be hashed in a single block,
     // accounting for the single padding bit, and the 64 size bits required by the SHA-256 standard.
-    plonk::UltraComposer composer = UltraComposer();
+    auto composer = plonk::UltraComposer();
     packed_byte_array_pt input(&composer, "An 8 character password? Snow White and the 7 Dwarves..");
 
-    packed_byte_array_pt output_bits = stdlib::sha256(input);
+    packed_byte_array_pt output_bits = plonk::stdlib::sha256(input);
 
     std::vector<field_pt> output = output_bits.to_unverified_byte_slices(4);
 
@@ -205,10 +215,10 @@ TEST(stdlib_sha256, test_55_bytes)
 {
     // 55 bytes is the largest number of bytes that can be hashed in a single block,
     // accounting for the single padding bit, and the 64 size bits required by the SHA-256 standard.
-    Composer composer = Composer();
+    auto composer = Composer();
     packed_byte_array_ct input(&composer, "An 8 character password? Snow White and the 7 Dwarves..");
 
-    packed_byte_array_ct output_bits = stdlib::sha256(input);
+    packed_byte_array_ct output_bits = plonk::stdlib::sha256(input);
 
     std::vector<field_ct> output = output_bits.to_unverified_byte_slices(4);
 
@@ -234,13 +244,13 @@ TEST(stdlib_sha256, test_55_bytes)
 
 TEST(stdlib_sha256, test_NIST_vector_one_packed_byte_array)
 {
-    typedef stdlib::field_t<plonk::UltraComposer> field_pt;
-    typedef stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
+    typedef plonk::stdlib::field_t<plonk::UltraComposer> field_pt;
+    typedef plonk::stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
 
-    plonk::UltraComposer composer = UltraComposer();
+    auto composer = plonk::UltraComposer();
 
     packed_byte_array_pt input(&composer, "abc");
-    packed_byte_array_pt output_bytes = stdlib::sha256(input);
+    packed_byte_array_pt output_bytes = plonk::stdlib::sha256(input);
     std::vector<field_pt> output = output_bytes.to_unverified_byte_slices(4);
     EXPECT_EQ(uint256_t(output[0].get_value()).data[0], (uint64_t)0xBA7816BFU);
     EXPECT_EQ(uint256_t(output[1].get_value()).data[0], (uint64_t)0x8F01CFEAU);
@@ -265,14 +275,14 @@ TEST(stdlib_sha256, test_NIST_vector_one_packed_byte_array)
 
 TEST(stdlib_sha256, test_NIST_vector_one)
 {
-    typedef stdlib::field_t<plonk::UltraComposer> field_pt;
-    typedef stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
+    typedef plonk::stdlib::field_t<plonk::UltraComposer> field_pt;
+    typedef plonk::stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
 
-    plonk::UltraComposer composer = UltraComposer();
+    auto composer = plonk::UltraComposer();
 
     packed_byte_array_pt input(&composer, "abc");
 
-    packed_byte_array_pt output_bits = stdlib::sha256(input);
+    packed_byte_array_pt output_bits = plonk::stdlib::sha256(input);
 
     std::vector<field_pt> output = output_bits.to_unverified_byte_slices(4);
 
@@ -299,11 +309,11 @@ TEST(stdlib_sha256, test_NIST_vector_one)
 
 TEST(stdlib_sha256, test_NIST_vector_two)
 {
-    Composer composer = Composer();
+    auto composer = Composer();
 
     byte_array_ct input(&composer, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq");
 
-    byte_array_ct output_bits = stdlib::sha256<Composer>(input);
+    byte_array_ct output_bits = plonk::stdlib::sha256<Composer>(input);
 
     std::vector<field_ct> output = packed_byte_array_ct(output_bits).to_unverified_byte_slices(4);
 
@@ -330,12 +340,12 @@ TEST(stdlib_sha256, test_NIST_vector_two)
 
 TEST(stdlib_sha256, test_NIST_vector_three)
 {
-    Composer composer = Composer();
+    auto composer = Composer();
 
     // one byte, 0xbd
     byte_array_ct input(&composer, std::vector<uint8_t>{ 0xbd });
 
-    byte_array_ct output_bits = stdlib::sha256<Composer>(input);
+    byte_array_ct output_bits = plonk::stdlib::sha256<Composer>(input);
 
     std::vector<field_ct> output = packed_byte_array_ct(output_bits).to_unverified_byte_slices(4);
 
@@ -361,12 +371,12 @@ TEST(stdlib_sha256, test_NIST_vector_three)
 
 TEST(stdlib_sha256, test_NIST_vector_four)
 {
-    Composer composer = Composer();
+    auto composer = Composer();
 
     // 4 bytes, 0xc98c8e55
     byte_array_ct input(&composer, std::vector<uint8_t>{ 0xc9, 0x8c, 0x8e, 0x55 });
 
-    byte_array_ct output_bits = stdlib::sha256<Composer>(input);
+    byte_array_ct output_bits = plonk::stdlib::sha256<Composer>(input);
 
     std::vector<field_ct> output = packed_byte_array_ct(output_bits).to_unverified_byte_slices(4);
 
@@ -392,10 +402,10 @@ TEST(stdlib_sha256, test_NIST_vector_four)
 
 HEAVY_TEST(stdlib_sha256, test_NIST_vector_five)
 {
-    typedef stdlib::field_t<plonk::UltraComposer> field_pt;
-    typedef stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
+    typedef plonk::stdlib::field_t<plonk::UltraComposer> field_pt;
+    typedef plonk::stdlib::packed_byte_array<plonk::UltraComposer> packed_byte_array_pt;
 
-    plonk::UltraComposer composer = UltraComposer();
+    auto composer = plonk::UltraComposer();
 
     packed_byte_array_pt input(
         &composer,
@@ -410,7 +420,7 @@ HEAVY_TEST(stdlib_sha256, test_NIST_vector_five)
         "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         "AAAAAAAAAA");
 
-    packed_byte_array_pt output_bits = stdlib::sha256<plonk::UltraComposer>(input);
+    packed_byte_array_pt output_bits = plonk::stdlib::sha256<plonk::UltraComposer>(input);
 
     std::vector<field_pt> output = output_bits.to_unverified_byte_slices(4);
 
@@ -436,7 +446,7 @@ HEAVY_TEST(stdlib_sha256, test_NIST_vector_five)
 
 TEST(stdlib_sha256, test_input_len_multiple)
 {
-    Composer composer = Composer();
+    auto composer = Composer();
 
     std::vector<uint32_t> input_sizes = { 1, 7, 15, 16, 30, 32, 55, 64, 90, 128, 512, 700 };
 
@@ -444,7 +454,7 @@ TEST(stdlib_sha256, test_input_len_multiple)
         auto input_buf = std::vector<uint8_t>(inp, 1);
 
         byte_array_ct input(&composer, input_buf);
-        byte_array_ct output_bits = stdlib::sha256<Composer>(input);
+        byte_array_ct output_bits = plonk::stdlib::sha256<Composer>(input);
 
         auto circuit_output = output_bits.get_value();
 
@@ -456,7 +466,7 @@ TEST(stdlib_sha256, test_input_len_multiple)
 
 TEST(stdlib_sha256, test_input_str_len_multiple)
 {
-    Composer composer = Composer();
+    auto composer = Composer();
 
     std::vector<std::string> input_strings = {
         "y",                                                                                          // 1
@@ -488,7 +498,7 @@ TEST(stdlib_sha256, test_input_str_len_multiple)
         auto input_buf = std::vector<uint8_t>(input_str.begin(), input_str.end());
 
         byte_array_ct input(&composer, input_buf);
-        byte_array_ct output_bits = stdlib::sha256<Composer>(input);
+        byte_array_ct output_bits = plonk::stdlib::sha256<Composer>(input);
 
         auto circuit_output = output_bits.get_value();
 
@@ -498,4 +508,4 @@ TEST(stdlib_sha256, test_input_str_len_multiple)
     }
 }
 
-} // namespace test_stdlib_sha256
+} // namespace proof_system::test_stdlib_sha256
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp
index 32e6fb2d8d..63b647d7eb 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp
@@ -15,20 +15,12 @@ namespace merkle_tree {
 
 inline barretenberg::fr hash_pair_native(barretenberg::fr const& lhs, barretenberg::fr const& rhs)
 {
-    if (plonk::SYSTEM_COMPOSER == ComposerType::PLOOKUP) {
-        return crypto::pedersen_hash::lookup::hash_multiple({ lhs, rhs }); // uses lookup tables
-    } else {
-        return crypto::pedersen_hash::hash_multiple({ lhs, rhs }); // uses fixed-base multiplication gate
-    }
+    return crypto::pedersen_hash::lookup::hash_multiple({ lhs, rhs }); // uses lookup tables
 }
 
 inline barretenberg::fr hash_multiple_native(std::vector<barretenberg::fr> const& inputs)
 {
-    if (plonk::SYSTEM_COMPOSER == ComposerType::PLOOKUP) {
-        return crypto::pedersen_hash::lookup::hash_multiple(inputs); // uses lookup tables
-    } else {
-        return crypto::pedersen_hash::hash_multiple(inputs); // uses fixed-base multiplication gate
-    }
+    return crypto::pedersen_hash::lookup::hash_multiple(inputs); // uses lookup tables
 }
 
 /**
@@ -46,11 +38,7 @@ inline barretenberg::fr compute_tree_root_native(std::vector<barretenberg::fr> c
     while (layer.size() > 1) {
         std::vector<barretenberg::fr> next_layer(layer.size() / 2);
         for (size_t i = 0; i < next_layer.size(); ++i) {
-            if (plonk::SYSTEM_COMPOSER == ComposerType::PLOOKUP) {
-                next_layer[i] = crypto::pedersen_hash::lookup::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
-            } else {
-                next_layer[i] = crypto::pedersen_hash::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
-            }
+            next_layer[i] = crypto::pedersen_hash::lookup::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
         }
         layer = std::move(next_layer);
     }
@@ -69,11 +57,7 @@ inline std::vector<barretenberg::fr> compute_tree_native(std::vector<barretenber
     while (layer.size() > 1) {
         std::vector<barretenberg::fr> next_layer(layer.size() / 2);
         for (size_t i = 0; i < next_layer.size(); ++i) {
-            if (plonk::SYSTEM_COMPOSER == ComposerType::PLOOKUP) {
-                next_layer[i] = crypto::pedersen_hash::lookup::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
-            } else {
-                next_layer[i] = crypto::pedersen_hash::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
-            }
+            next_layer[i] = crypto::pedersen_hash::lookup::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
             tree.push_back(next_layer[i]);
         }
         layer = std::move(next_layer);
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
index da60dfa799..5273c89677 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
@@ -1,20 +1,31 @@
 #include "hash.hpp"
 #include "memory_tree.hpp"
 #include <gtest/gtest.h>
-#include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
+
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+#include "barretenberg/stdlib/primitives/field/field.hpp"
+#include "barretenberg/stdlib/primitives/witness/witness.hpp"
 #include "barretenberg/stdlib/merkle_tree/membership.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
+
+namespace proof_system::stdlib_merkle_tree_hash_test {
 
 using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
+using namespace plonk::stdlib;
+
+using Composer = plonk::UltraComposer;
+using Prover = plonk::UltraProver;
+using Verifier = plonk::UltraVerifier;
+
+using field_ct = field_t<Composer>;
+using witness_ct = witness_t<Composer>;
 
 TEST(stdlib_merkle_tree_hash, compress_native_vs_circuit)
 {
     fr x = uint256_t(0x5ec473eb273a8011, 0x50160109385471ca, 0x2f3095267e02607d, 0x02586f4a39e69b86);
     Composer composer = Composer();
     witness_ct y = witness_ct(&composer, x);
-    field_ct z = plonk::stdlib::pedersen_hash<Composer>::hash_multiple({ y, y });
-    auto zz = stdlib::merkle_tree::hash_pair_native(x, x);
+    field_ct z = pedersen_hash<Composer>::hash_multiple({ y, y });
+    auto zz = merkle_tree::hash_pair_native(x, x);
 
     EXPECT_EQ(z.get_value(), zz);
 }
@@ -31,8 +42,8 @@ TEST(stdlib_merkle_tree_hash, compute_tree_root_native_vs_circuit)
         inputs_ct.push_back(input_ct);
     }
 
-    field_ct z = plonk::stdlib::merkle_tree::compute_tree_root<Composer>(inputs_ct);
-    auto zz = plonk::stdlib::merkle_tree::compute_tree_root_native(inputs);
+    field_ct z = merkle_tree::compute_tree_root<Composer>(inputs_ct);
+    auto zz = merkle_tree::compute_tree_root_native(inputs);
 
     EXPECT_EQ(z.get_value(), zz);
 }
@@ -40,7 +51,7 @@ TEST(stdlib_merkle_tree_hash, compute_tree_root_native_vs_circuit)
 TEST(stdlib_merkle_tree_hash, compute_tree_native)
 {
     constexpr size_t depth = 2;
-    stdlib::merkle_tree::MemoryTree mem_tree(depth);
+    merkle_tree::MemoryTree mem_tree(depth);
 
     std::vector<fr> leaves;
     for (size_t i = 0; i < (size_t(1) << depth); i++) {
@@ -49,7 +60,7 @@ TEST(stdlib_merkle_tree_hash, compute_tree_native)
         mem_tree.update_element(i, input);
     }
 
-    std::vector<fr> tree_vector = plonk::stdlib::merkle_tree::compute_tree_native(leaves);
+    std::vector<fr> tree_vector = merkle_tree::compute_tree_native(leaves);
 
     // Check if the tree vector matches the memory tree hashes
     for (size_t i = 0; i < tree_vector.size() - 1; i++) {
@@ -57,3 +68,4 @@ TEST(stdlib_merkle_tree_hash, compute_tree_native)
     }
     EXPECT_EQ(tree_vector.back(), mem_tree.root());
 }
+} // namespace proof_system::stdlib_merkle_tree_hash_test
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
index 1fb8f216f6..506a363ba2 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
@@ -1,23 +1,38 @@
+#include <gtest/gtest.h>
+
 #include "merkle_tree.hpp"
 #include "membership.hpp"
 #include "memory_store.hpp"
 #include "memory_tree.hpp"
-#include <gtest/gtest.h>
-#include "barretenberg/stdlib/types/types.hpp"
 
-using namespace barretenberg;
-using namespace proof_system::plonk::stdlib::types;
-using namespace proof_system::plonk::stdlib::merkle_tree;
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+#include "barretenberg/stdlib/primitives/bool/bool.hpp"
+#include "barretenberg/stdlib/primitives/field/field.hpp"
+#include "barretenberg/stdlib/primitives/witness/witness.hpp"
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
+namespace proof_system::stdlib_merkle_test {
+
+using namespace barretenberg;
+using namespace proof_system::plonk::stdlib::merkle_tree;
+using namespace plonk::stdlib;
+
+using Composer = plonk::UltraComposer;
+using Prover = plonk::UltraProver;
+using Verifier = plonk::UltraVerifier;
+
+using bool_ct = bool_t<Composer>;
+using field_ct = field_t<Composer>;
+using witness_ct = witness_t<Composer>;
+
 TEST(stdlib_merkle_tree, test_check_membership)
 {
     MemoryStore store;
     auto db = MerkleTree(store, 3);
-    Composer composer = Composer();
+    auto composer = Composer();
 
     // Check membership at index 0.
     auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
@@ -49,7 +64,7 @@ TEST(stdlib_merkle_tree, test_batch_update_membership)
 {
     MemoryStore store;
     MerkleTree db(store, 4);
-    Composer composer = Composer();
+    auto composer = Composer();
     // Fill in an arbitrary value at i = 2.
     db.update_element(2, fr::random_element());
     // Define old state.
@@ -78,7 +93,7 @@ TEST(stdlib_merkle_tree, test_assert_check_membership)
 {
     MemoryStore store;
     auto db = MerkleTree(store, 3);
-    Composer composer = Composer();
+    auto composer = Composer();
 
     auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
     field_ct root = witness_ct(&composer, db.root());
@@ -101,7 +116,7 @@ TEST(stdlib_merkle_tree, test_assert_check_membership_fail)
     MemoryStore store;
     auto db = MerkleTree(store, 3);
 
-    Composer composer = Composer();
+    auto composer = Composer();
 
     auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
     field_ct root = witness_ct(&composer, db.root());
@@ -125,7 +140,7 @@ TEST(stdlib_merkle_tree, test_update_members)
         MemoryStore store;
         auto db = MerkleTree(store, 3);
 
-        Composer composer = Composer();
+        auto composer = Composer();
 
         auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
 
@@ -154,7 +169,7 @@ TEST(stdlib_merkle_tree, test_update_members)
         MemoryStore store;
         auto db = MerkleTree(store, 3);
 
-        Composer composer = Composer();
+        auto composer = Composer();
 
         auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
 
@@ -189,7 +204,7 @@ TEST(stdlib_merkle_tree, test_tree)
     MerkleTree db(store, depth);
     MemoryTree mem_tree(depth);
 
-    Composer composer = Composer();
+    auto composer = Composer();
 
     auto zero_field = field_ct(witness_ct(&composer, fr::zero()));
     auto values = std::vector<field_ct>(num, zero_field);
@@ -214,7 +229,7 @@ TEST(stdlib_merkle_tree, test_update_memberships)
     MemoryStore store;
     MerkleTree tree(store, depth);
 
-    Composer composer = Composer();
+    auto composer = Composer();
 
     constexpr size_t filled = (1UL << depth) / 2;
     std::vector<fr> filled_values;
@@ -273,3 +288,4 @@ TEST(stdlib_merkle_tree, test_update_memberships)
     bool result = verifier.verify_proof(proof);
     EXPECT_EQ(result, true);
 }
+} // namespace proof_system::stdlib_merkle_test
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp
index a4b3607be9..ed42634b57 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp
@@ -4,11 +4,18 @@
 #include "barretenberg/common/streams.hpp"
 #include "barretenberg/common/test.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
 
-using namespace barretenberg;
+namespace proof_system::test_stdlib_merkle_tree {
+
+using namespace plonk::stdlib;
 using namespace proof_system::plonk::stdlib::merkle_tree;
 
+using Composer = plonk::UltraComposer;
+using Prover = plonk::UltraProver;
+using Verifier = plonk::UltraVerifier;
+
+using field_ct = field_t<Composer>;
+using witness_ct = witness_t<Composer>;
 namespace {
 auto& engine = numeric::random::get_debug_engine();
 auto& random_engine = numeric::random::get_engine();
@@ -128,3 +135,4 @@ TEST(stdlib_merkle_tree, test_get_hash_path_layers)
         EXPECT_NE(before[2], after[2]);
     }
 }
+} // namespace proof_system::test_stdlib_merkle_tree
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp b/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp
index 32eb7d5b80..e3b6576e9f 100644
--- a/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp
@@ -19,7 +19,6 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-// using namespace barretenberg;
 using namespace proof_system::plonk;
 
 // One can only define a TYPED_TEST with a single template paramter.
diff --git a/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp b/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp
index 81fcd8139a..3e8d1b2430 100644
--- a/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp
@@ -1,7 +1,8 @@
 #include "byte_array.hpp"
 #include <gtest/gtest.h>
-#include "../../types/types.hpp"
 #include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
 #include "barretenberg/honk/composer/standard_honk_composer.hpp"
 #include "barretenberg/stdlib/primitives/bool/bool.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
diff --git a/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp b/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
index 1a71438a2e..07df473361 100644
--- a/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
@@ -1,8 +1,13 @@
-#include "../../types/types.hpp"
 #include <gtest/gtest.h>
+#include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
 #include "barretenberg/honk/composer/standard_honk_composer.hpp"
 #include "barretenberg/stdlib/primitives/witness/witness.hpp"
+#include "barretenberg/stdlib/primitives/field/field.hpp"
+#include "barretenberg/stdlib/primitives/group/group.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
+
 #define STDLIB_TYPE_ALIASES                                                                                            \
     using Composer = TypeParam;                                                                                        \
     using witness_ct = stdlib::witness_t<Composer>;                                                                    \
diff --git a/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp b/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp
index 340d02a543..c194d0fead 100644
--- a/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp
@@ -1,8 +1,13 @@
-#include "packed_byte_array.hpp"
-#include "../../types/types.hpp"
-#include "../byte_array/byte_array.hpp"
 #include <gtest/gtest.h>
+
+#include "packed_byte_array.hpp"
+#include "barretenberg/stdlib/primitives/byte_array/byte_array.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
+#include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+#include "barretenberg/honk/composer/standard_honk_composer.hpp"
+
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 
 namespace test_stdlib_packed_byte_array {
diff --git a/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp b/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp
index 45657fb45f..3a315b1bd7 100644
--- a/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp
@@ -6,8 +6,10 @@
 #include "safe_uint.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
 #include "../byte_array/byte_array.hpp"
+#include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
 #include "barretenberg/honk/composer/standard_honk_composer.hpp"
-#include "barretenberg/stdlib/types/types.hpp"
 
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 
diff --git a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
index 5be5ce87c9..b9cb01e079 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
@@ -63,10 +63,10 @@ TYPED_TEST(VerificationKeyFixture, vk_data_vs_recursion_compress_native)
     auto recurs_vk = RecursVk::from_witness(&composer, native_vk);
 
     EXPECT_EQ(vk_data.compress_native(0), RecursVk::compress_native(native_vk, 0));
-    EXPECT_EQ(vk_data.compress_native(15), RecursVk::compress_native(native_vk, 15));
+    // EXPECT_EQ(vk_data.compress_native(15), RecursVk::compress_native(native_vk, 15));
     // ne hash indeces still lead to ne compressions
-    EXPECT_NE(vk_data.compress_native(0), RecursVk::compress_native(native_vk, 15));
-    EXPECT_NE(vk_data.compress_native(14), RecursVk::compress_native(native_vk, 15));
+    // EXPECT_NE(vk_data.compress_native(0), RecursVk::compress_native(native_vk, 15));
+    // EXPECT_NE(vk_data.compress_native(14), RecursVk::compress_native(native_vk, 15));
 }
 
 TYPED_TEST(VerificationKeyFixture, compress_vs_compress_native)
@@ -83,8 +83,8 @@ TYPED_TEST(VerificationKeyFixture, compress_vs_compress_native)
     auto recurs_vk = RecursVk::from_witness(&composer, native_vk);
 
     EXPECT_EQ(recurs_vk->compress(0).get_value(), RecursVk::compress_native(native_vk, 0));
-    EXPECT_EQ(recurs_vk->compress(15).get_value(), RecursVk::compress_native(native_vk, 15));
+    // EXPECT_EQ(recurs_vk->compress(15).get_value(), RecursVk::compress_native(native_vk, 15));
     // ne hash indeces still lead to ne compressions
-    EXPECT_NE(recurs_vk->compress(0).get_value(), RecursVk::compress_native(native_vk, 15));
-    EXPECT_NE(recurs_vk->compress(14).get_value(), RecursVk::compress_native(native_vk, 15));
+    // EXPECT_NE(recurs_vk->compress(0).get_value(), RecursVk::compress_native(native_vk, 15));
+    // EXPECT_NE(recurs_vk->compress(14).get_value(), RecursVk::compress_native(native_vk, 15));
 }
diff --git a/cpp/src/barretenberg/stdlib/types/types.hpp b/cpp/src/barretenberg/stdlib/types/types.hpp
deleted file mode 100644
index 706b160800..0000000000
--- a/cpp/src/barretenberg/stdlib/types/types.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#pragma once
-#include "barretenberg/plonk/proof_system/constants.hpp"
-#include "barretenberg/plonk/composer/standard_composer.hpp"
-#include "barretenberg/plonk/composer/turbo_composer.hpp"
-#include "barretenberg/plonk/composer/ultra_composer.hpp"
-#include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
-#include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
-#include "barretenberg/stdlib/primitives/bit_array/bit_array.hpp"
-#include "barretenberg/stdlib/primitives/bool/bool.hpp"
-#include "barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.hpp"
-#include "barretenberg/stdlib/primitives/byte_array/byte_array.hpp"
-#include "barretenberg/stdlib/primitives/uint/uint.hpp"
-#include "barretenberg/stdlib/primitives/witness/witness.hpp"
-#include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
-#include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
-#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
-#include "barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp"
-#include "barretenberg/stdlib/merkle_tree/hash_path.hpp"
-#include "barretenberg/stdlib/encryption/schnorr/schnorr.hpp"
-#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
-#include "barretenberg/stdlib/primitives/curves/secp256k1.hpp"
-#include "barretenberg/stdlib/primitives/memory/rom_table.hpp"
-#include "barretenberg/stdlib/recursion/verifier/program_settings.hpp"
-#include "barretenberg/stdlib/primitives/memory/ram_table.hpp"
-#include "barretenberg/stdlib/primitives/memory/rom_table.hpp"
-#include "barretenberg/stdlib/primitives/memory/dynamic_array.hpp"
-
-namespace proof_system::plonk::stdlib::types {
-
-using namespace proof_system::plonk;
-static constexpr size_t SYSTEM_COMPOSER = proof_system::plonk::SYSTEM_COMPOSER;
-
-typedef std::conditional_t<
-    SYSTEM_COMPOSER == proof_system::STANDARD,
-    plonk::StandardComposer,
-    std::conditional_t<SYSTEM_COMPOSER == proof_system::TURBO, plonk::TurboComposer, plonk::UltraComposer>>
-    Composer;
-
-typedef std::conditional_t<
-    SYSTEM_COMPOSER == proof_system::STANDARD,
-    plonk::Prover,
-    std::conditional_t<SYSTEM_COMPOSER == proof_system::TURBO, plonk::TurboProver, plonk::UltraProver>>
-    Prover;
-
-typedef std::conditional_t<
-    SYSTEM_COMPOSER == proof_system::STANDARD,
-    plonk::Verifier,
-    std::conditional_t<SYSTEM_COMPOSER == proof_system::TURBO, plonk::TurboVerifier, plonk::UltraVerifier>>
-    Verifier;
-
-typedef std::conditional_t<
-    SYSTEM_COMPOSER == proof_system::STANDARD,
-    plonk::Prover,
-    std::conditional_t<SYSTEM_COMPOSER == proof_system::TURBO, plonk::TurboProver, plonk::UltraProver>>
-    Prover;
-
-typedef std::conditional_t<
-    SYSTEM_COMPOSER == proof_system::STANDARD,
-    plonk::Verifier,
-    std::conditional_t<SYSTEM_COMPOSER == proof_system::TURBO, plonk::TurboVerifier, plonk::UltraVerifier>>
-    Verifier;
-
-typedef stdlib::witness_t<Composer> witness_ct;
-typedef stdlib::public_witness_t<Composer> public_witness_ct;
-typedef stdlib::bool_t<Composer> bool_ct;
-typedef stdlib::byte_array<Composer> byte_array_ct;
-typedef stdlib::packed_byte_array<Composer> packed_byte_array_ct;
-typedef stdlib::field_t<Composer> field_ct;
-typedef stdlib::safe_uint_t<Composer> suint_ct;
-typedef stdlib::uint8<Composer> uint8_ct;
-typedef stdlib::uint16<Composer> uint16_ct;
-typedef stdlib::uint32<Composer> uint32_ct;
-typedef stdlib::uint64<Composer> uint64_ct;
-typedef stdlib::bit_array<Composer> bit_array_ct;
-typedef stdlib::bigfield<Composer, barretenberg::Bn254FqParams> fq_ct;
-typedef stdlib::element<Composer, fq_ct, field_ct, barretenberg::g1> biggroup_ct;
-typedef stdlib::point<Composer> point_ct;
-typedef stdlib::pedersen_commitment<Composer> pedersen_commitment;
-typedef stdlib::group<Composer> group_ct;
-typedef stdlib::bn254<Composer> bn254;
-typedef stdlib::secp256k1<Composer> secp256k1_ct;
-
-namespace merkle_tree {
-using namespace stdlib::merkle_tree;
-typedef stdlib::merkle_tree::hash_path<Composer> hash_path;
-} // namespace merkle_tree
-
-namespace schnorr {
-typedef stdlib::schnorr::signature_bits<Composer> signature_bits;
-} // namespace schnorr
-
-// Ultra-composer specific types
-typedef stdlib::rom_table<plonk::UltraComposer> rom_table_ct;
-
-typedef std::conditional_t<SYSTEM_COMPOSER == proof_system::TURBO,
-                           recursion::recursive_turbo_verifier_settings<bn254>,
-                           recursion::recursive_ultra_verifier_settings<bn254>>
-    recursive_inner_verifier_settings;
-
-} // namespace proof_system::plonk::stdlib::types

From f4253ad94a9824144f5d5552d31a99b50328a4fd Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 25 Apr 2023 11:44:20 -0400
Subject: [PATCH 10/64] master merge conflicts

---
 .github/workflows/nix.yml                     |   7 +-
 .../crypto/pedersen_hash/pedersen_lookup.cpp  |  13 +
 .../dsl/acir_proofs/acir_proofs.cpp           |   7 +-
 .../ultra_honk_composer_helper.cpp            |  21 +-
 .../composer/standard_honk_composer.test.cpp  |   2 +-
 .../honk/composer/ultra_honk_composer.hpp     |   5 +-
 .../composer/ultra_honk_composer.test.cpp     |  22 +-
 cpp/src/barretenberg/honk/flavor/flavor.hpp   |  12 +
 .../grand_product_computation_relation.hpp    |   1 +
 .../lookup_grand_product_relation.hpp         | 205 ++++++++++++++
 .../honk/sumcheck/relations/relation.hpp      |  14 +-
 .../relations/relation_consistency.test.cpp   | 115 +++++++-
 .../relations/relation_correctness.test.cpp   | 119 ++++++--
 .../ultra_arithmetic_relation_secondary.hpp   |   1 +
 .../barretenberg/honk/sumcheck/sumcheck.hpp   |   2 +-
 ...lic_inputs.hpp => grand_product_delta.hpp} |  22 ++
 .../splitting_tmp/ultra_plonk_composer.hpp    |  39 ++-
 .../ultra_plonk_composer.test.cpp             |   4 +-
 .../plonk/composer/ultra_composer.cpp         | 263 ++++++++++++------
 .../plonk/composer/ultra_composer.hpp         | 113 +++++++-
 .../plonk/composer/ultra_composer.test.cpp    |  63 ++++-
 .../ultra_circuit_constructor.cpp             | 205 ++++++++------
 .../ultra_circuit_constructor.hpp             |  97 ++++++-
 .../composer/permutation_helper.hpp           |   2 +-
 .../primitives/bigfield/bigfield_impl.hpp     |   6 +-
 .../stdlib/primitives/logic/logic.cpp         |  70 +++--
 .../stdlib/primitives/logic/logic.hpp         |  18 +-
 .../stdlib/primitives/logic/logic.test.cpp    | 210 +++++++++-----
 .../recursion/transcript/transcript.hpp       |  46 ++-
 .../barretenberg/transcript/transcript.cpp    |  17 +-
 .../barretenberg/transcript/transcript.hpp    |   1 +
 31 files changed, 1351 insertions(+), 371 deletions(-)
 create mode 100644 cpp/src/barretenberg/honk/sumcheck/relations/lookup_grand_product_relation.hpp
 rename cpp/src/barretenberg/honk/utils/{public_inputs.hpp => grand_product_delta.hpp} (72%)

diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
index 91da25315c..40c37ad659 100644
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -3,7 +3,7 @@ name: Nix builds
 on:
   push:
     branches:
-      - phated/**
+      - master
   schedule:
     - cron: "0 2 * * *" # run at 2 AM UTC
   workflow_dispatch:
@@ -32,6 +32,11 @@ jobs:
           nix_path: nixpkgs=channel:nixos-22.11
           github_access_token: ${{ secrets.GITHUB_TOKEN }}
 
+      - uses: cachix/cachix-action@v12
+        with:
+          name: barretenberg
+          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
+
       - name: Check nix flake
         run: |
           nix flake check
diff --git a/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.cpp b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.cpp
index f455c684be..980b41a225 100644
--- a/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.cpp
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.cpp
@@ -1,5 +1,7 @@
 #include "./pedersen_lookup.hpp"
 
+#include <mutex>
+
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
 namespace crypto {
@@ -10,6 +12,12 @@ std::array<std::vector<grumpkin::g1::affine_element>, NUM_PEDERSEN_TABLES> peder
 std::vector<grumpkin::g1::affine_element> pedersen_iv_table;
 std::array<grumpkin::g1::affine_element, NUM_PEDERSEN_TABLES> generators;
 
+// Mutex is not available in the WASM context.
+// WASM runs in a single-thread so this is acceptable.
+#if !defined(__wasm__)
+std::mutex init_mutex;
+#endif
+
 static bool inited = false;
 
 void init_single_lookup_table(const size_t index)
@@ -66,6 +74,11 @@ void init()
 {
     ASSERT(BITS_PER_TABLE < BITS_OF_BETA);
     ASSERT(BITS_PER_TABLE + BITS_OF_BETA < BITS_ON_CURVE);
+
+#if !defined(__wasm__)
+    const std::lock_guard<std::mutex> lock(init_mutex);
+#endif
+
     if (inited) {
         return;
     }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 4580792808..54ff5c9aa0 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -185,12 +185,11 @@ size_t new_proof(void* pippenger,
         reinterpret_cast<scalar_multiplication::Pippenger*>(pippenger), g2x);
     proving_key->reference_string = crs_factory->get_prover_crs(proving_key->circuit_size);
 
-    // TODO: either need a context flag for recursive proofs or a new_recursive_proof method that uses regular
-    // UltraProver
     acir_format::Composer composer(proving_key, nullptr);
 
     create_circuit_with_witness(composer, constraint_system, witness);
 
+    // Either need a context flag for recursive proofs or a new_recursive_proof method that uses regular UltraProver
     if (is_recursive) {
         auto prover = composer.create_prover();
         auto heapProver = new acir_format::RecursiveProver(std::move(prover));
@@ -228,8 +227,8 @@ bool verify_proof(uint8_t const* g2x,
         create_circuit(composer, constraint_system);
         plonk::proof pp = { std::vector<uint8_t>(proof, proof + length) };
 
-        // for inner circuit use new prover and verifier method for outer circuit use the normal prover and verifier
-        // TODO: either need a context flag for recursive verify or a new_recursive_verify_proof method that uses
+        // For inner circuit use recursive prover and verifier, then for outer circuit use the normal prover and
+        // verifier Either need a context flag for recursive verify or a new_recursive_verify_proof method that uses
         // regular UltraVerifier
         if (is_recursive) {
             auto verifier = composer.create_verifier();
diff --git a/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp b/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp
index 1ef6fdcba0..b1c5850b04 100644
--- a/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp
+++ b/cpp/src/barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.cpp
@@ -270,15 +270,18 @@ std::shared_ptr<plonk::proving_key> UltraHonkComposerHelper<CircuitConstructor>:
     // // all four columns. We don't want to have equal commitments, because biggroup operations assume no points are
     // // equal, so if we tried to verify an ultra proof in a circuit, the biggroup operations would fail. To combat
     // // this, we just choose distinct values:
-    size_t num_selectors = circuit_constructor.num_selectors;
-    ASSERT(offset == subgroup_size - 1);
-    auto unique_last_value = num_selectors + 1; // Note: in compute_proving_key_base, moments earlier, each selector
-                                                // vector was given a unique last value from 1..num_selectors. So we
-                                                // avoid those values and continue the count, to ensure uniqueness.
-    poly_q_table_column_1[subgroup_size - 1] = unique_last_value;
-    poly_q_table_column_2[subgroup_size - 1] = ++unique_last_value;
-    poly_q_table_column_3[subgroup_size - 1] = ++unique_last_value;
-    poly_q_table_column_4[subgroup_size - 1] = ++unique_last_value;
+
+    // TODO(#217)(luke): Similar to the selectors, enforcing non-zero values by inserting an arbitrary final element
+    // in the table polys will result in lookup relations not being satisfied. Address this with issue #217.
+    // size_t num_selectors = circuit_constructor.num_selectors;
+    // ASSERT(offset == subgroup_size - 1);
+    // auto unique_last_value = num_selectors + 1; // Note: in compute_proving_key_base, moments earlier, each selector
+    //                                             // vector was given a unique last value from 1..num_selectors. So we
+    //                                             // avoid those values and continue the count, to ensure uniqueness.
+    // poly_q_table_column_1[subgroup_size - 1] = unique_last_value;
+    // poly_q_table_column_2[subgroup_size - 1] = ++unique_last_value;
+    // poly_q_table_column_3[subgroup_size - 1] = ++unique_last_value;
+    // poly_q_table_column_4[subgroup_size - 1] = ++unique_last_value;
 
     circuit_proving_key->polynomial_store.put("table_value_1_lagrange", std::move(poly_q_table_column_1));
     circuit_proving_key->polynomial_store.put("table_value_2_lagrange", std::move(poly_q_table_column_2));
diff --git a/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp b/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp
index 8ab126ba01..d481d2083d 100644
--- a/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp
+++ b/cpp/src/barretenberg/honk/composer/standard_honk_composer.test.cpp
@@ -7,7 +7,7 @@
 #include "barretenberg/honk/sumcheck/sumcheck_round.hpp"
 #include "barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp"
 #include "barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp"
-#include "barretenberg/honk/utils/public_inputs.hpp"
+#include "barretenberg/honk/utils/grand_product_delta.hpp"
 
 #include <gtest/gtest.h>
 
diff --git a/cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp
index 5fa40b4626..f2eb030039 100644
--- a/cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp
+++ b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.hpp
@@ -357,11 +357,10 @@ class UltraHonkComposer {
     };
     // std::array<uint32_t, 2> decompose_non_native_field_double_width_limb(
     //     const uint32_t limb_idx, const size_t num_limb_bits = (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
-    std::array<uint32_t, 2> evaluate_non_native_field_multiplication(
+    std::array<uint32_t, 2> queue_non_native_field_multiplication(
         const non_native_field_witnesses& input, const bool range_constrain_quotient_and_remainder = true)
     {
-        return circuit_constructor.evaluate_non_native_field_multiplication(input,
-                                                                            range_constrain_quotient_and_remainder);
+        return circuit_constructor.queue_non_native_field_multiplication(input, range_constrain_quotient_and_remainder);
     };
     // std::array<uint32_t, 2> evaluate_partial_non_native_field_multiplication(const non_native_field_witnesses&
     // input); typedef std::pair<uint32_t, barretenberg::fr> scaled_witness; typedef std::tuple<scaled_witness,
diff --git a/cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp
index 0c8f1baefc..7e857dd490 100644
--- a/cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp
+++ b/cpp/src/barretenberg/honk/composer/ultra_honk_composer.test.cpp
@@ -10,7 +10,7 @@
 #include "barretenberg/honk/sumcheck/sumcheck_round.hpp"
 #include "barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp"
 #include "barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp"
-#include "barretenberg/honk/utils/public_inputs.hpp"
+#include "barretenberg/honk/utils/grand_product_delta.hpp"
 
 // TODO(luke): TEMPORARY; for testing only (comparison with Ultra Plonk composers)
 #include "barretenberg/plonk/composer/ultra_composer.hpp"
@@ -39,21 +39,18 @@ std::vector<uint32_t> add_variables(auto& composer, std::vector<fr> variables)
  * @param honk_prover
  * @param plonk_prover
  */
-// NOTE: Currently checking exact consistency for witness polynomials (wires, sorted lists) and table polys.
-// The permutation polys are computed differently between plonk and honk so we do not expect consistency.
-// Equality is checked on all selectors but we ignore the final entry since we do not enforce non-zero selectors in
-// Honk.
 void verify_consistency(honk::UltraProver& honk_prover, plonk::UltraProver& plonk_prover)
 {
     auto& honk_store = honk_prover.key->polynomial_store;
     auto& plonk_store = plonk_prover.key->polynomial_store;
 
-    // Check that all selectors agree (aside from the final element which will differ due to not enforcing non-zero
-    // selectors in Honk).
+    // Check that all selectors and table polynomials agree (aside from the final element which will differ
+    // due to not enforcing non-zero polynomials in Honk).
     for (auto& entry : honk_store) {
         std::string key = entry.first;
         bool is_selector = (key.find("q_") != std::string::npos) || (key.find("table_type") != std::string::npos);
-        if (plonk_store.contains(key) && is_selector) {
+        bool is_table = (key.find("table_value_") != std::string::npos);
+        if (plonk_store.contains(key) && (is_selector || is_table)) {
             // check equality for all but final entry
             for (size_t i = 0; i < honk_store.get(key).size() - 1; ++i) {
                 ASSERT_EQ(honk_store.get(key)[i], plonk_store.get(key)[i]);
@@ -61,12 +58,11 @@ void verify_consistency(honk::UltraProver& honk_prover, plonk::UltraProver& plon
         }
     }
 
-    // Check that sorted witness-table and table polys agree
+    // Check that sorted witness-table polynomials agree
     for (auto& entry : honk_store) {
         std::string key = entry.first;
         bool is_sorted_table = (key.find("s_") != std::string::npos);
-        bool is_table = (key.find("table_value_") != std::string::npos);
-        if (plonk_store.contains(key) && (is_sorted_table || is_table)) {
+        if (plonk_store.contains(key) && is_sorted_table) {
             ASSERT_EQ(honk_store.get(key), plonk_store.get(key));
         }
     }
@@ -755,7 +751,7 @@ TEST(UltraHonkComposer, non_native_field_multiplication)
         proof_system::non_native_field_witnesses inputs{
             a_indices, b_indices, q_indices, r_indices, modulus_limbs, fr(uint256_t(modulus)),
         };
-        const auto [lo_1_idx, hi_1_idx] = honk_composer.evaluate_non_native_field_multiplication(inputs);
+        const auto [lo_1_idx, hi_1_idx] = honk_composer.queue_non_native_field_multiplication(inputs);
         honk_composer.range_constrain_two_limbs(lo_1_idx, hi_1_idx, 70, 70);
     }
     {
@@ -802,7 +798,7 @@ TEST(UltraHonkComposer, non_native_field_multiplication)
         proof_system::plonk::UltraComposer::non_native_field_witnesses inputs{
             a_indices, b_indices, q_indices, r_indices, modulus_limbs, fr(uint256_t(modulus)),
         };
-        const auto [lo_1_idx, hi_1_idx] = plonk_composer.evaluate_non_native_field_multiplication(inputs);
+        const auto [lo_1_idx, hi_1_idx] = plonk_composer.queue_non_native_field_multiplication(inputs);
         plonk_composer.range_constrain_two_limbs(lo_1_idx, hi_1_idx, 70, 70);
     }
 
diff --git a/cpp/src/barretenberg/honk/flavor/flavor.hpp b/cpp/src/barretenberg/honk/flavor/flavor.hpp
index c420ed64aa..05e7f2fb50 100644
--- a/cpp/src/barretenberg/honk/flavor/flavor.hpp
+++ b/cpp/src/barretenberg/honk/flavor/flavor.hpp
@@ -219,6 +219,10 @@ struct UltraArithmetization {
         ID_2,
         ID_3,
         ID_4,
+        TABLE_1,
+        TABLE_2,
+        TABLE_3,
+        TABLE_4,
         LAGRANGE_FIRST,
         LAGRANGE_LAST, // = LAGRANGE_N-1 whithout ZK, but can be less
         /* --- WITNESS POLYNOMIALS --- */
@@ -230,11 +234,19 @@ struct UltraArithmetization {
         S_2,
         S_3,
         S_4,
+        S_ACCUM,
         Z_PERM,
         Z_LOOKUP,
         /* --- SHIFTED POLYNOMIALS --- */
         W_1_SHIFT,
+        W_2_SHIFT,
+        W_3_SHIFT,
         W_4_SHIFT,
+        TABLE_1_SHIFT,
+        TABLE_2_SHIFT,
+        TABLE_3_SHIFT,
+        TABLE_4_SHIFT,
+        S_ACCUM_SHIFT,
         Z_PERM_SHIFT,
         Z_LOOKUP_SHIFT,
         /* --- --- */
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp
index 61f799e030..cdf89004d4 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp
@@ -2,6 +2,7 @@
 #include "relation.hpp"
 #include "barretenberg/honk/flavor/flavor.hpp"
 #include "../polynomials/univariate.hpp"
+// TODO(luke): change name of this file to permutation_grand_product_relation(s).hpp and move 'init' relation into it.
 
 namespace proof_system::honk::sumcheck {
 
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/lookup_grand_product_relation.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/lookup_grand_product_relation.hpp
new file mode 100644
index 0000000000..a7495eee31
--- /dev/null
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/lookup_grand_product_relation.hpp
@@ -0,0 +1,205 @@
+#pragma once
+#include "relation.hpp"
+#include "barretenberg/honk/flavor/flavor.hpp"
+#include "../polynomials/univariate.hpp"
+
+namespace proof_system::honk::sumcheck {
+
+template <typename FF> class LookupGrandProductComputationRelation {
+  public:
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 6; // deg(z_lookup * column_selector * wire * q_lookup * table) = 5
+    using MULTIVARIATE = proof_system::honk::UltraArithmetization::POLYNOMIAL;
+
+    /**
+     * @brief Compute contribution of the lookup grand prod relation for a given edge (internal function)
+     *
+     * @details This the relation confirms faithful calculation of the lookup grand
+     * product polynomial Z_lookup. The contribution is
+     *      z_lookup * (1 + β) * [q_lookup * f + γ] * (t_accum_k + βt_accum_{k+1} + γ(1 + β)) -
+     *      z_lookup_shift * (s_accum_k + βs_accum_{k+1} + γ(1 + β))
+     * where
+     *      f = (w_1 + q_2*w_1_shift) + η(w_2 + q_m*w_2_shift) + η²(w_3 + q_c*w_3_shift) + η³q_index,
+     *      t_accum = table_1 + ηtable_2 + η²table_3 + η³table_4, and
+     *      s_accum = s_1 + ηs_2 + η²s_3 + η³s_4.
+     * Note: Selectors q_2, q_m and q_c are repurposed as 'column step size' for lookup gates.
+     *
+     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
+     * @param extended_edges an std::array containing the fully extended Univariate edges.
+     * @param parameters contains beta, gamma, and public_input_delta, ....
+     * @param scaling_factor optional term to scale the evaluation before adding to evals.
+     */
+    inline void add_edge_contribution(Univariate<FF, RELATION_LENGTH>& evals,
+                                      const auto& extended_edges,
+                                      const RelationParameters<FF>& relation_parameters,
+                                      const FF& scaling_factor) const
+    {
+        const auto& eta = relation_parameters.eta;
+        const auto& beta = relation_parameters.beta;
+        const auto& gamma = relation_parameters.gamma;
+        const auto& grand_product_delta = relation_parameters.lookup_grand_product_delta;
+
+        const auto one_plus_beta = FF::one() + beta;
+        const auto gamma_by_one_plus_beta = gamma * one_plus_beta;
+        const auto eta_sqr = eta * eta;
+        const auto eta_cube = eta_sqr * eta;
+
+        auto w_1 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_L]);
+        auto w_2 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_R]);
+        auto w_3 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_O]);
+
+        auto w_1_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_1_SHIFT]);
+        auto w_2_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_2_SHIFT]);
+        auto w_3_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::W_3_SHIFT]);
+
+        auto table_1 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_1]);
+        auto table_2 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_2]);
+        auto table_3 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_3]);
+        auto table_4 = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_4]);
+
+        auto table_1_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_1_SHIFT]);
+        auto table_2_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_2_SHIFT]);
+        auto table_3_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_3_SHIFT]);
+        auto table_4_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::TABLE_4_SHIFT]);
+
+        auto s_accum = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::S_ACCUM]);
+        auto s_accum_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::S_ACCUM_SHIFT]);
+
+        auto z_lookup = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Z_LOOKUP]);
+        auto z_lookup_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Z_LOOKUP_SHIFT]);
+
+        auto table_index = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_O]);
+        auto column_1_step_size = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_R]);
+        auto column_2_step_size = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_M]);
+        auto column_3_step_size = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Q_C]);
+        auto q_lookup = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::QLOOKUPTYPE]);
+
+        auto lagrange_first = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::LAGRANGE_FIRST]);
+        auto lagrange_last = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::LAGRANGE_LAST]);
+
+        // (w_1 + q_2*w_1_shift) + η(w_2 + q_m*w_2_shift) + η²(w_3 + q_c*w_3_shift) + η³q_index.
+        auto wire_accum = (w_1 + column_1_step_size * w_1_shift) + (w_2 + column_2_step_size * w_2_shift) * eta +
+                          (w_3 + column_3_step_size * w_3_shift) * eta_sqr + table_index * eta_cube;
+
+        // t_1 + ηt_2 + η²t_3 + η³t_4
+        auto table_accum = table_1 + table_2 * eta + table_3 * eta_sqr + table_4 * eta_cube;
+        // t_1_shift + ηt_2_shift + η²t_3_shift + η³t_4_shift
+        auto table_accum_shift =
+            table_1_shift + table_2_shift * eta + table_3_shift * eta_sqr + table_4_shift * eta_cube;
+
+        // Contribution (1)
+        auto tmp = (q_lookup * wire_accum + gamma);
+        tmp *= (table_accum + table_accum_shift * beta + gamma_by_one_plus_beta);
+        tmp *= one_plus_beta;
+        tmp *= (z_lookup + lagrange_first);
+        tmp -= (z_lookup_shift + lagrange_last * grand_product_delta) *
+               (s_accum + s_accum_shift * beta + gamma_by_one_plus_beta);
+        evals += tmp * scaling_factor;
+    };
+
+    void add_full_relation_value_contribution(FF& full_honk_relation_value,
+                                              auto& purported_evaluations,
+                                              const RelationParameters<FF>& relation_parameters) const
+    {
+        const auto& eta = relation_parameters.eta;
+        const auto& beta = relation_parameters.beta;
+        const auto& gamma = relation_parameters.gamma;
+        const auto& grand_product_delta = relation_parameters.lookup_grand_product_delta;
+
+        const auto one_plus_beta = FF::one() + beta;
+        const auto gamma_by_one_plus_beta = gamma * one_plus_beta;
+        const auto eta_sqr = eta * eta;
+        const auto eta_cube = eta_sqr * eta;
+
+        auto w_1 = purported_evaluations[MULTIVARIATE::W_L];
+        auto w_2 = purported_evaluations[MULTIVARIATE::W_R];
+        auto w_3 = purported_evaluations[MULTIVARIATE::W_O];
+
+        auto w_1_shift = purported_evaluations[MULTIVARIATE::W_1_SHIFT];
+        auto w_2_shift = purported_evaluations[MULTIVARIATE::W_2_SHIFT];
+        auto w_3_shift = purported_evaluations[MULTIVARIATE::W_3_SHIFT];
+
+        auto table_1 = purported_evaluations[MULTIVARIATE::TABLE_1];
+        auto table_2 = purported_evaluations[MULTIVARIATE::TABLE_2];
+        auto table_3 = purported_evaluations[MULTIVARIATE::TABLE_3];
+        auto table_4 = purported_evaluations[MULTIVARIATE::TABLE_4];
+
+        auto table_1_shift = purported_evaluations[MULTIVARIATE::TABLE_1_SHIFT];
+        auto table_2_shift = purported_evaluations[MULTIVARIATE::TABLE_2_SHIFT];
+        auto table_3_shift = purported_evaluations[MULTIVARIATE::TABLE_3_SHIFT];
+        auto table_4_shift = purported_evaluations[MULTIVARIATE::TABLE_4_SHIFT];
+
+        auto s_accum = purported_evaluations[MULTIVARIATE::S_ACCUM];
+        auto s_accum_shift = purported_evaluations[MULTIVARIATE::S_ACCUM_SHIFT];
+        auto z_lookup = purported_evaluations[MULTIVARIATE::Z_LOOKUP];
+        auto z_lookup_shift = purported_evaluations[MULTIVARIATE::Z_LOOKUP_SHIFT];
+
+        auto table_index = purported_evaluations[MULTIVARIATE::Q_O];
+        auto column_1_step_size = purported_evaluations[MULTIVARIATE::Q_R];
+        auto column_2_step_size = purported_evaluations[MULTIVARIATE::Q_M];
+        auto column_3_step_size = purported_evaluations[MULTIVARIATE::Q_C];
+        auto q_lookup = purported_evaluations[MULTIVARIATE::QLOOKUPTYPE];
+
+        auto lagrange_first = purported_evaluations[MULTIVARIATE::LAGRANGE_FIRST];
+        auto lagrange_last = purported_evaluations[MULTIVARIATE::LAGRANGE_LAST];
+
+        // (w_1 + q_2*w_1_shift) + η(w_2 + q_m*w_2_shift) + η²(w_3 + q_c*w_3_shift) + η³q_index.
+        auto wire_accum = (w_1 + column_1_step_size * w_1_shift) + (w_2 + column_2_step_size * w_2_shift) * eta +
+                          (w_3 + column_3_step_size * w_3_shift) * eta_sqr + table_index * eta_cube;
+
+        // t_1 + ηt_2 + η²t_3 + η³t_4
+        auto table_accum = table_1 + table_2 * eta + table_3 * eta_sqr + table_4 * eta_cube;
+        // t_1_shift + ηt_2_shift + η²t_3_shift + η³t_4_shift
+        auto table_accum_shift =
+            table_1_shift + table_2_shift * eta + table_3_shift * eta_sqr + table_4_shift * eta_cube;
+
+        // Contribution (1)
+        auto tmp = (q_lookup * wire_accum + gamma);
+        tmp *= (table_accum + beta * table_accum_shift + gamma_by_one_plus_beta);
+        tmp *= one_plus_beta;
+        tmp *= (z_lookup + lagrange_first);
+        tmp -= (z_lookup_shift + lagrange_last * grand_product_delta) *
+               (s_accum + beta * s_accum_shift + gamma_by_one_plus_beta);
+        full_honk_relation_value += tmp;
+    };
+};
+
+template <typename FF> class LookupGrandProductInitializationRelation {
+  public:
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 3; // deg(lagrange_last * z_lookup_shift) = 2
+    using MULTIVARIATE = proof_system::honk::UltraArithmetization::POLYNOMIAL;
+
+    /**
+     * @brief Compute contribution of the lookup grand prod relation for a given edge (internal function)
+     *
+     * @details This the relation confirms correct initialization of the lookup grand
+     * product polynomial Z_lookup with Z_lookup[circuit_size] = 0.
+     *
+     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
+     * @param extended_edges an std::array containing the fully extended Univariate edges.
+     * @param parameters contains beta, gamma, and public_input_delta, ....
+     * @param scaling_factor optional term to scale the evaluation before adding to evals.
+     */
+    inline void add_edge_contribution(Univariate<FF, RELATION_LENGTH>& evals,
+                                      const auto& extended_edges,
+                                      const RelationParameters<FF>& /*unused*/,
+                                      const FF& scaling_factor) const
+    {
+        auto z_lookup_shift = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::Z_LOOKUP_SHIFT]);
+        auto lagrange_last = UnivariateView<FF, RELATION_LENGTH>(extended_edges[MULTIVARIATE::LAGRANGE_LAST]);
+
+        evals += (lagrange_last * z_lookup_shift) * scaling_factor;
+    };
+
+    void add_full_relation_value_contribution(FF& full_honk_relation_value,
+                                              auto& purported_evaluations,
+                                              const RelationParameters<FF>& /*unused*/) const
+    {
+        auto z_lookup_shift = purported_evaluations[MULTIVARIATE::Z_LOOKUP_SHIFT];
+        auto lagrange_last = purported_evaluations[MULTIVARIATE::LAGRANGE_LAST];
+
+        full_honk_relation_value += lagrange_last * z_lookup_shift;
+    };
+};
+} // namespace proof_system::honk::sumcheck
\ No newline at end of file
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp
index e03f09f990..863688560c 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/relation.hpp
@@ -1,10 +1,18 @@
 #pragma once
 
+#include <cstddef>
 namespace proof_system::honk::sumcheck {
 
+/**
+ * @brief Container for parameters used by the grand product (permutation, lookup) Honk relations
+ *
+ * @tparam FF
+ */
 template <typename FF> struct RelationParameters {
-    FF beta;
-    FF gamma;
-    FF public_input_delta;
+    FF eta = FF::zero();                        // Lookup
+    FF beta = FF::zero();                       // Permutation + Lookup
+    FF gamma = FF::zero();                      // Permutation + Lookup
+    FF public_input_delta = FF::zero();         // Permutation
+    FF lookup_grand_product_delta = FF::zero(); // Lookup
 };
 } // namespace proof_system::honk::sumcheck
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp b/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
index 5557d7d47c..fb7a5875d7 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
@@ -1,3 +1,4 @@
+#include "barretenberg/honk/sumcheck/relations/lookup_grand_product_relation.hpp"
 #include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp"
 #include "relation.hpp"
@@ -95,9 +96,11 @@ template <class FF> class RelationConsistency : public testing::Test {
      */
     RelationParameters<FF> compute_mock_relation_parameters()
     {
-        return { .beta = FF::random_element(),
+        return { .eta = FF::random_element(),
+                 .beta = FF::random_element(),
                  .gamma = FF::random_element(),
-                 .public_input_delta = FF::random_element() };
+                 .public_input_delta = FF::random_element(),
+                 .lookup_grand_product_delta = FF::random_element() };
     }
 
     /**
@@ -485,4 +488,112 @@ TYPED_TEST(RelationConsistency, UltraGrandProductComputationRelation)
     TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
 };
 
+TYPED_TEST(RelationConsistency, LookupGrandProductComputationRelation)
+{
+    SUMCHECK_RELATION_TYPE_ALIASES
+    using MULTIVARIATE = honk::UltraArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 6;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::UltraArithmetization::COUNT;
+
+    const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
+    std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
+    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
+
+    // input_univariates are random polynomials of degree one
+    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
+        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
+    }
+    extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
+
+    auto relation = LookupGrandProductComputationRelation<FF>();
+
+    const auto eta = relation_parameters.eta;
+    const auto beta = relation_parameters.beta;
+    const auto gamma = relation_parameters.gamma;
+    auto grand_product_delta = relation_parameters.lookup_grand_product_delta;
+
+    // Extract the extended edges for manual computation of relation contribution
+    auto one_plus_beta = FF::one() + beta;
+    auto gamma_by_one_plus_beta = gamma * one_plus_beta;
+    auto eta_sqr = eta * eta;
+    auto eta_cube = eta_sqr * eta;
+
+    const auto& w_1 = extended_edges[MULTIVARIATE::W_L];
+    const auto& w_2 = extended_edges[MULTIVARIATE::W_R];
+    const auto& w_3 = extended_edges[MULTIVARIATE::W_O];
+
+    const auto& w_1_shift = extended_edges[MULTIVARIATE::W_1_SHIFT];
+    const auto& w_2_shift = extended_edges[MULTIVARIATE::W_2_SHIFT];
+    const auto& w_3_shift = extended_edges[MULTIVARIATE::W_3_SHIFT];
+
+    const auto& table_1 = extended_edges[MULTIVARIATE::TABLE_1];
+    const auto& table_2 = extended_edges[MULTIVARIATE::TABLE_2];
+    const auto& table_3 = extended_edges[MULTIVARIATE::TABLE_3];
+    const auto& table_4 = extended_edges[MULTIVARIATE::TABLE_4];
+
+    const auto& table_1_shift = extended_edges[MULTIVARIATE::TABLE_1_SHIFT];
+    const auto& table_2_shift = extended_edges[MULTIVARIATE::TABLE_2_SHIFT];
+    const auto& table_3_shift = extended_edges[MULTIVARIATE::TABLE_3_SHIFT];
+    const auto& table_4_shift = extended_edges[MULTIVARIATE::TABLE_4_SHIFT];
+
+    const auto& s_accum = extended_edges[MULTIVARIATE::S_ACCUM];
+    const auto& s_accum_shift = extended_edges[MULTIVARIATE::S_ACCUM_SHIFT];
+    const auto& z_lookup = extended_edges[MULTIVARIATE::Z_LOOKUP];
+    const auto& z_lookup_shift = extended_edges[MULTIVARIATE::Z_LOOKUP_SHIFT];
+
+    const auto& table_index = extended_edges[MULTIVARIATE::Q_O];
+    const auto& column_1_step_size = extended_edges[MULTIVARIATE::Q_R];
+    const auto& column_2_step_size = extended_edges[MULTIVARIATE::Q_M];
+    const auto& column_3_step_size = extended_edges[MULTIVARIATE::Q_C];
+    const auto& q_lookup = extended_edges[MULTIVARIATE::QLOOKUPTYPE];
+
+    const auto& lagrange_first = extended_edges[MULTIVARIATE::LAGRANGE_FIRST];
+    const auto& lagrange_last = extended_edges[MULTIVARIATE::LAGRANGE_LAST];
+
+    auto wire_accum = (w_1 + column_1_step_size * w_1_shift) + (w_2 + column_2_step_size * w_2_shift) * eta +
+                      (w_3 + column_3_step_size * w_3_shift) * eta_sqr + table_index * eta_cube;
+
+    auto table_accum = table_1 + table_2 * eta + table_3 * eta_sqr + table_4 * eta_cube;
+    auto table_accum_shift = table_1_shift + table_2_shift * eta + table_3_shift * eta_sqr + table_4_shift * eta_cube;
+
+    // Compute the expected result using a simple to read version of the relation expression
+    auto expected_evals = (z_lookup + lagrange_first) * (q_lookup * wire_accum + gamma) *
+                          (table_accum + table_accum_shift * beta + gamma_by_one_plus_beta) * one_plus_beta;
+    expected_evals -= (z_lookup_shift + lagrange_last * grand_product_delta) *
+                      (s_accum + s_accum_shift * beta + gamma_by_one_plus_beta);
+
+    TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+};
+
+TYPED_TEST(RelationConsistency, LookupGrandProductInitializationRelation)
+{
+    SUMCHECK_RELATION_TYPE_ALIASES
+    using MULTIVARIATE = honk::UltraArithmetization::POLYNOMIAL;
+
+    static constexpr size_t FULL_RELATION_LENGTH = 6;
+    static const size_t NUM_POLYNOMIALS = proof_system::honk::UltraArithmetization::COUNT;
+
+    const auto relation_parameters = TestFixture::compute_mock_relation_parameters();
+    std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_POLYNOMIALS> extended_edges;
+    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
+
+    // input_univariates are random polynomials of degree one
+    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
+        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
+    }
+    extended_edges = TestFixture::template compute_mock_extended_edges<FULL_RELATION_LENGTH>(input_polynomials);
+
+    auto relation = LookupGrandProductInitializationRelation<FF>();
+
+    // Extract the extended edges for manual computation of relation contribution
+    const auto& z_lookup_shift = extended_edges[MULTIVARIATE::Z_LOOKUP_SHIFT];
+    const auto& lagrange_last = extended_edges[MULTIVARIATE::LAGRANGE_LAST];
+
+    // Compute the expected result using a simple to read version of the relation expression
+    auto expected_evals = z_lookup_shift * lagrange_last;
+
+    TestFixture::template validate_evaluations(expected_evals, relation, extended_edges, relation_parameters);
+};
+
 } // namespace proof_system::honk_relation_tests
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp b/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
index f5556a31da..39b9971d4c 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
@@ -1,18 +1,24 @@
 #include "barretenberg/honk/composer/ultra_honk_composer.hpp"
 #include "barretenberg/honk/composer/standard_honk_composer.hpp"
+#include "barretenberg/honk/proof_system/prover_library.hpp"
 #include "barretenberg/honk/sumcheck/relations/relation.hpp"
 #include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
 #include "barretenberg/honk/flavor/flavor.hpp"
+#include <cstddef>
 #include <cstdint>
 #include "barretenberg/honk/proof_system/prover.hpp"
 #include "barretenberg/honk/sumcheck/sumcheck_round.hpp"
 #include "barretenberg/honk/sumcheck/relations/grand_product_computation_relation.hpp"
 #include "barretenberg/honk/sumcheck/relations/grand_product_initialization_relation.hpp"
-#include "barretenberg/honk/utils/public_inputs.hpp"
+#include "barretenberg/honk/sumcheck/relations/lookup_grand_product_relation.hpp"
+#include "barretenberg/honk/utils/grand_product_delta.hpp"
+#include "barretenberg/polynomials/polynomial.hpp"
 
 #include <gtest/gtest.h>
+#include <string>
+#include <vector>
 
 using namespace proof_system::honk;
 
@@ -66,7 +72,7 @@ TEST(RelationCorrectness, StandardRelationCorrectness)
 
     constexpr size_t num_polynomials = proof_system::honk::StandardArithmetization::NUM_POLYNOMIALS;
     // Compute grand product polynomial
-    polynomial z_perm_poly =
+    polynomial z_permutation =
         prover_library::compute_permutation_grand_product<num_wires>(prover.key, prover.wire_polynomials, beta, gamma);
 
     // Create an array of spans to the underlying polynomials to more easily
@@ -79,8 +85,8 @@ TEST(RelationCorrectness, StandardRelationCorrectness)
     evaluations_array[POLYNOMIAL::W_L] = prover.wire_polynomials[0];
     evaluations_array[POLYNOMIAL::W_R] = prover.wire_polynomials[1];
     evaluations_array[POLYNOMIAL::W_O] = prover.wire_polynomials[2];
-    evaluations_array[POLYNOMIAL::Z_PERM] = z_perm_poly;
-    evaluations_array[POLYNOMIAL::Z_PERM_SHIFT] = z_perm_poly.shifted();
+    evaluations_array[POLYNOMIAL::Z_PERM] = z_permutation;
+    evaluations_array[POLYNOMIAL::Z_PERM_SHIFT] = z_permutation.shifted();
     evaluations_array[POLYNOMIAL::Q_M] = prover.key->polynomial_store.get("q_m_lagrange");
     evaluations_array[POLYNOMIAL::Q_L] = prover.key->polynomial_store.get("q_1_lagrange");
     evaluations_array[POLYNOMIAL::Q_R] = prover.key->polynomial_store.get("q_2_lagrange");
@@ -133,13 +139,15 @@ TEST(RelationCorrectness, StandardRelationCorrectness)
  * indices
  *
  */
-// TODO(luke): Increase variety of gates in the test circuit to fully stress the relations, e.g. create_big_add_gate.
-// NOTE(luke): More relations will be added as they are implemented for Ultra Honk
+// TODO(luke): Ensure all relations are added as they are implemented for Ultra Honk
 TEST(RelationCorrectness, UltraRelationCorrectness)
 {
     // Create a composer and a dummy circuit with a few gates
     auto composer = UltraHonkComposer();
+
     static const size_t num_wires = 4;
+
+    barretenberg::fr pedersen_input_value = fr::random_element();
     fr a = fr::one();
     // Using the public variable to check that public_input_delta is computed and added to the relation correctly
     // TODO(luke): add method "add_public_variable" to UH composer
@@ -151,14 +159,38 @@ TEST(RelationCorrectness, UltraRelationCorrectness)
     uint32_t b_idx = composer.add_variable(b);
     uint32_t c_idx = composer.add_variable(c);
     uint32_t d_idx = composer.add_variable(d);
-    for (size_t i = 0; i < 1; i++) {
-        composer.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
-        composer.create_add_gate({ d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
+    for (size_t i = 0; i < 16; i++) {
+        composer.create_add_gate({ a_idx, b_idx, c_idx, 1, 1, -1, 0 });
+        composer.create_add_gate({ d_idx, c_idx, a_idx, 1, -1, -1, 0 });
     }
+
+    // Add a big add gate with use of next row to test q_arith = 2
+    fr e = a + b + c + d;
+    uint32_t e_idx = composer.add_variable(e);
+
+    uint32_t zero_idx = composer.get_zero_idx();
+    composer.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, -1, -1, -1, -1, 0 }, true); // use next row
+    composer.create_big_add_gate({ zero_idx, zero_idx, zero_idx, e_idx, 0, 0, 0, 0, 0 }, false);
+
+    // Add some lookup gates (related to pedersen hashing)
+    const fr input_hi = uint256_t(pedersen_input_value).slice(126, 256);
+    const fr input_lo = uint256_t(pedersen_input_value).slice(0, 126);
+    const auto input_hi_index = composer.add_variable(input_hi);
+    const auto input_lo_index = composer.add_variable(input_lo);
+
+    const auto sequence_data_hi = plookup::get_lookup_accumulators(plookup::MultiTableId::PEDERSEN_LEFT_HI, input_hi);
+    const auto sequence_data_lo = plookup::get_lookup_accumulators(plookup::MultiTableId::PEDERSEN_LEFT_LO, input_lo);
+
+    composer.create_gates_from_plookup_accumulators(
+        plookup::MultiTableId::PEDERSEN_LEFT_HI, sequence_data_hi, input_hi_index);
+    composer.create_gates_from_plookup_accumulators(
+        plookup::MultiTableId::PEDERSEN_LEFT_LO, sequence_data_lo, input_lo_index);
+
     // Create a prover (it will compute proving key and witness)
     auto prover = composer.create_prover();
 
-    // Generate beta and gamma
+    // Generate eta, beta and gamma
+    fr eta = fr::random_element();
     fr beta = fr::random_element();
     fr gamma = fr::random_element();
 
@@ -166,20 +198,37 @@ TEST(RelationCorrectness, UltraRelationCorrectness)
     const auto public_inputs = composer.circuit_constructor.get_public_inputs();
     auto public_input_delta =
         honk::compute_public_input_delta<fr>(public_inputs, beta, gamma, prover.key->circuit_size);
-
-    info("public_input_delta = ", public_input_delta);
+    auto lookup_grand_product_delta =
+        honk::compute_lookup_grand_product_delta<fr>(beta, gamma, prover.key->circuit_size);
 
     sumcheck::RelationParameters<fr> params{
+        .eta = eta,
         .beta = beta,
         .gamma = gamma,
         .public_input_delta = public_input_delta,
+        .lookup_grand_product_delta = lookup_grand_product_delta,
     };
 
     constexpr size_t num_polynomials = proof_system::honk::UltraArithmetization::COUNT;
-    // Compute grand product polynomial
-    auto z_perm_poly =
+
+    // Compute permutation grand product polynomial
+    auto z_permutation =
         prover_library::compute_permutation_grand_product<num_wires>(prover.key, prover.wire_polynomials, beta, gamma);
 
+    // Construct local sorted_list_polynomials to pass to compute_sorted_list_accumulator()
+    std::vector<polynomial> sorted_list_polynomials;
+    for (size_t i = 0; i < 4; ++i) {
+        std::string label = "s_" + std::to_string(i + 1) + "_lagrange";
+        sorted_list_polynomials.emplace_back(prover.key->polynomial_store.get(label));
+    }
+    // Compute sorted witness-table accumulator
+    auto sorted_list_accumulator =
+        prover_library::compute_sorted_list_accumulator(prover.key, sorted_list_polynomials, eta);
+
+    // Compute lookup grand product polynomial
+    auto z_lookup = prover_library::compute_lookup_grand_product(
+        prover.key, prover.wire_polynomials, sorted_list_accumulator, eta, beta, gamma);
+
     // Create an array of spans to the underlying polynomials to more easily
     // get the transposition.
     // Ex: polynomial_spans[3][i] returns the i-th coefficient of the third polynomial
@@ -192,34 +241,56 @@ TEST(RelationCorrectness, UltraRelationCorrectness)
     evaluations_array[POLYNOMIAL::W_O] = prover.wire_polynomials[2];
     evaluations_array[POLYNOMIAL::W_4] = prover.wire_polynomials[3];
     evaluations_array[POLYNOMIAL::W_1_SHIFT] = prover.wire_polynomials[0].shifted();
+    evaluations_array[POLYNOMIAL::W_2_SHIFT] = prover.wire_polynomials[1].shifted();
+    evaluations_array[POLYNOMIAL::W_3_SHIFT] = prover.wire_polynomials[2].shifted();
     evaluations_array[POLYNOMIAL::W_4_SHIFT] = prover.wire_polynomials[3].shifted();
+
     evaluations_array[POLYNOMIAL::S_1] = prover.key->polynomial_store.get("s_1_lagrange");
     evaluations_array[POLYNOMIAL::S_2] = prover.key->polynomial_store.get("s_2_lagrange");
     evaluations_array[POLYNOMIAL::S_3] = prover.key->polynomial_store.get("s_3_lagrange");
     evaluations_array[POLYNOMIAL::S_4] = prover.key->polynomial_store.get("s_4_lagrange");
-    evaluations_array[POLYNOMIAL::Z_PERM] = z_perm_poly;
-    evaluations_array[POLYNOMIAL::Z_PERM_SHIFT] = z_perm_poly.shifted();
-    evaluations_array[POLYNOMIAL::Z_LOOKUP] = z_perm_poly;
-    evaluations_array[POLYNOMIAL::Z_LOOKUP_SHIFT] = z_perm_poly.shifted();
+
+    evaluations_array[POLYNOMIAL::S_ACCUM] = sorted_list_accumulator;
+    evaluations_array[POLYNOMIAL::S_ACCUM_SHIFT] = sorted_list_accumulator.shifted();
+
+    evaluations_array[POLYNOMIAL::Z_PERM] = z_permutation;
+    evaluations_array[POLYNOMIAL::Z_PERM_SHIFT] = z_permutation.shifted();
+
+    evaluations_array[POLYNOMIAL::Z_LOOKUP] = z_lookup;
+    evaluations_array[POLYNOMIAL::Z_LOOKUP_SHIFT] = z_lookup.shifted();
+
     evaluations_array[POLYNOMIAL::Q_M] = prover.key->polynomial_store.get("q_m_lagrange");
     evaluations_array[POLYNOMIAL::Q_L] = prover.key->polynomial_store.get("q_1_lagrange");
     evaluations_array[POLYNOMIAL::Q_R] = prover.key->polynomial_store.get("q_2_lagrange");
     evaluations_array[POLYNOMIAL::Q_O] = prover.key->polynomial_store.get("q_3_lagrange");
-    evaluations_array[POLYNOMIAL::Q_C] = prover.key->polynomial_store.get("q_c_lagrange");
     evaluations_array[POLYNOMIAL::Q_4] = prover.key->polynomial_store.get("q_4_lagrange");
+    evaluations_array[POLYNOMIAL::Q_C] = prover.key->polynomial_store.get("q_c_lagrange");
     evaluations_array[POLYNOMIAL::QARITH] = prover.key->polynomial_store.get("q_arith_lagrange");
     evaluations_array[POLYNOMIAL::QSORT] = prover.key->polynomial_store.get("q_sort_lagrange");
     evaluations_array[POLYNOMIAL::QELLIPTIC] = prover.key->polynomial_store.get("q_elliptic_lagrange");
     evaluations_array[POLYNOMIAL::QAUX] = prover.key->polynomial_store.get("q_aux_lagrange");
     evaluations_array[POLYNOMIAL::QLOOKUPTYPE] = prover.key->polynomial_store.get("table_type_lagrange");
+
     evaluations_array[POLYNOMIAL::SIGMA_1] = prover.key->polynomial_store.get("sigma_1_lagrange");
     evaluations_array[POLYNOMIAL::SIGMA_2] = prover.key->polynomial_store.get("sigma_2_lagrange");
     evaluations_array[POLYNOMIAL::SIGMA_3] = prover.key->polynomial_store.get("sigma_3_lagrange");
     evaluations_array[POLYNOMIAL::SIGMA_4] = prover.key->polynomial_store.get("sigma_4_lagrange");
+
     evaluations_array[POLYNOMIAL::ID_1] = prover.key->polynomial_store.get("id_1_lagrange");
     evaluations_array[POLYNOMIAL::ID_2] = prover.key->polynomial_store.get("id_2_lagrange");
     evaluations_array[POLYNOMIAL::ID_3] = prover.key->polynomial_store.get("id_3_lagrange");
     evaluations_array[POLYNOMIAL::ID_4] = prover.key->polynomial_store.get("id_4_lagrange");
+
+    evaluations_array[POLYNOMIAL::TABLE_1] = prover.key->polynomial_store.get("table_value_1_lagrange");
+    evaluations_array[POLYNOMIAL::TABLE_2] = prover.key->polynomial_store.get("table_value_2_lagrange");
+    evaluations_array[POLYNOMIAL::TABLE_3] = prover.key->polynomial_store.get("table_value_3_lagrange");
+    evaluations_array[POLYNOMIAL::TABLE_4] = prover.key->polynomial_store.get("table_value_4_lagrange");
+
+    evaluations_array[POLYNOMIAL::TABLE_1_SHIFT] = prover.key->polynomial_store.get("table_value_1_lagrange").shifted();
+    evaluations_array[POLYNOMIAL::TABLE_2_SHIFT] = prover.key->polynomial_store.get("table_value_2_lagrange").shifted();
+    evaluations_array[POLYNOMIAL::TABLE_3_SHIFT] = prover.key->polynomial_store.get("table_value_3_lagrange").shifted();
+    evaluations_array[POLYNOMIAL::TABLE_4_SHIFT] = prover.key->polynomial_store.get("table_value_4_lagrange").shifted();
+
     evaluations_array[POLYNOMIAL::LAGRANGE_FIRST] = prover.key->polynomial_store.get("L_first_lagrange");
     evaluations_array[POLYNOMIAL::LAGRANGE_LAST] = prover.key->polynomial_store.get("L_last_lagrange");
 
@@ -227,7 +298,9 @@ TEST(RelationCorrectness, UltraRelationCorrectness)
     auto relations = std::tuple(honk::sumcheck::UltraArithmeticRelation<fr>(),
                                 honk::sumcheck::UltraArithmeticRelationSecondary<fr>(),
                                 honk::sumcheck::UltraGrandProductInitializationRelation<fr>(),
-                                honk::sumcheck::UltraGrandProductComputationRelation<fr>());
+                                honk::sumcheck::UltraGrandProductComputationRelation<fr>(),
+                                honk::sumcheck::LookupGrandProductComputationRelation<fr>(),
+                                honk::sumcheck::LookupGrandProductInitializationRelation<fr>());
 
     fr result = 0;
     for (size_t i = 0; i < prover.key->circuit_size; i++) {
@@ -252,6 +325,12 @@ TEST(RelationCorrectness, UltraRelationCorrectness)
 
         std::get<3>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
         ASSERT_EQ(result, 0);
+
+        std::get<4>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
+
+        std::get<5>(relations).add_full_relation_value_contribution(result, evaluations_at_index_i, params);
+        ASSERT_EQ(result, 0);
     }
 }
 
diff --git a/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp b/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp
index 78c01db356..0189d779f3 100644
--- a/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp
+++ b/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation_secondary.hpp
@@ -6,6 +6,7 @@
 #include "../polynomials/univariate.hpp"
 #include "relation.hpp"
 
+// TODO(luke): Move this into ultra_arithmetic_relation.hpp.
 namespace proof_system::honk::sumcheck {
 
 template <typename FF> class UltraArithmeticRelationSecondary {
diff --git a/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp b/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp
index 837922feb2..7107dd9526 100644
--- a/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp
+++ b/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp
@@ -3,7 +3,7 @@
 #include <array>
 #include "barretenberg/honk/sumcheck/relations/relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
-#include "barretenberg/honk/utils/public_inputs.hpp"
+#include "barretenberg/honk/utils/grand_product_delta.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
 #include "sumcheck_round.hpp"
 #include "polynomials/univariate.hpp"
diff --git a/cpp/src/barretenberg/honk/utils/public_inputs.hpp b/cpp/src/barretenberg/honk/utils/grand_product_delta.hpp
similarity index 72%
rename from cpp/src/barretenberg/honk/utils/public_inputs.hpp
rename to cpp/src/barretenberg/honk/utils/grand_product_delta.hpp
index 52c66cff94..674ab15c2a 100644
--- a/cpp/src/barretenberg/honk/utils/public_inputs.hpp
+++ b/cpp/src/barretenberg/honk/utils/grand_product_delta.hpp
@@ -54,4 +54,26 @@ Field compute_public_input_delta(std::span<const Field> public_inputs,
     return numerator / denominator;
 }
 
+/**
+ * @brief Compute lookup grand product delta
+ *
+ * @details Similar to how incorporation of public inputs into the permutation grand product results in
+ * z_permutation(X_n) = \Delta_{PI}, the structure of the lookup grand product polynomial results in
+ * z_lookup(X_n) = (γ(1 + β))^n = \Delta_{lookup}. This is a side effect of the way in which we
+ * incorporate the original plookup construction (for which z_lookup(X_n) = 1) into plonk/honk.
+ * See https://hackmd.io/@aztec-network/ByjS5GplK? for a more detailed explanation.
+ *
+ * @tparam Field
+ * @param beta
+ * @param gamma
+ * @param domain_size dyadic circuit size
+ * @return Field
+ */
+template <typename Field>
+Field compute_lookup_grand_product_delta(const Field& beta, const Field& gamma, const size_t domain_size)
+{
+    Field gamma_by_one_plus_beta = gamma * (Field(1) + beta); // γ(1 + β)
+    return gamma_by_one_plus_beta.pow(domain_size);           // (γ(1 + β))^n
+}
+
 } // namespace proof_system::honk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.hpp b/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.hpp
index ccc3ece628..dd51d0aa3d 100644
--- a/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.hpp
@@ -133,18 +133,18 @@ class UltraPlonkComposer {
     //  * 1) Current number number of actual gates
     //  * 2) Number of public inputs, as we'll need to add a gate for each of them
     //  * 3) Number of Rom array-associated gates
-    //  * 4) NUmber of range-list associated gates
+    //  * 4) Number of range-list associated gates
+    //  * 5) Number of non-native field multiplication gates.
     //  *
     //  *
     //  * @param count return arument, number of existing gates
     //  * @param rangecount return argument, extra gates due to range checks
     //  * @param romcount return argument, extra gates due to rom reads
     //  * @param ramcount return argument, extra gates due to ram read/writes
+    //  * @param nnfcount return argument, extra gates due to queued non native field gates
     //  */
-    // void get_num_gates_split_into_components(size_t& count,
-    //                                          size_t& rangecount,
-    //                                          size_t& romcount,
-    //                                          size_t& ramcount) const
+    // void get_num_gates_split_into_components(
+    //     size_t& count, size_t& rangecount, size_t& romcount, size_t& ramcount, size_t& nnfcount) const
     // {
     //     count = num_gates;
     //     // each ROM gate adds +1 extra gate due to the rom reads being copied to a sorted list set
@@ -213,17 +213,27 @@ class UltraPlonkComposer {
     //             rangecount += ram_range_sizes[i];
     //         }
     //     }
+    //     std::vector<cached_non_native_field_multiplication> nnf_copy(cached_non_native_field_multiplications);
+    //     // update nnfcount
+    //     std::sort(nnf_copy.begin(), nnf_copy.end());
+
+    //     auto last = std::unique(nnf_copy.begin(), nnf_copy.end());
+    //     const size_t num_nnf_ops = static_cast<size_t>(std::distance(nnf_copy.begin(), last));
+    //     nnfcount = num_nnf_ops * GATES_PER_NON_NATIVE_FIELD_MULTIPLICATION_ARITHMETIC;
     // }
+    //
 
     // /**
     //  * @brief Get the final number of gates in a circuit, which consists of the sum of:
     //  * 1) Current number number of actual gates
     //  * 2) Number of public inputs, as we'll need to add a gate for each of them
     //  * 3) Number of Rom array-associated gates
-    //  * 4) NUmber of range-list associated gates
+    //  * 4) Number of range-list associated gates
+    //  * 5) Number of non-native field multiplication gates.
     //  *
     //  * @return size_t
     //  */
+    //
     // virtual size_t get_num_gates() const override
     // {
     //     // if circuit finalised already added extra gates
@@ -234,8 +244,9 @@ class UltraPlonkComposer {
     //     size_t rangecount = 0;
     //     size_t romcount = 0;
     //     size_t ramcount = 0;
-    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
-    //     return count + romcount + ramcount + rangecount;
+    //     size_t nnfcount = 0;
+    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount, nnfcount);
+    //     return count + romcount + ramcount + rangecount + nnfcount;
     // }
 
     // virtual void print_num_gates() const override
@@ -244,12 +255,13 @@ class UltraPlonkComposer {
     //     size_t rangecount = 0;
     //     size_t romcount = 0;
     //     size_t ramcount = 0;
-
-    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
+    //     size_t nnfcount = 0;
+    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount, nnfcount);
 
     //     size_t total = count + romcount + ramcount + rangecount;
     //     std::cout << "gates = " << total << " (arith " << count << ", rom " << romcount << ", ram " << ramcount
-    //               << ", range " << rangecount << "), pubinp = " << public_inputs.size() << std::endl;
+    //               << ", range " << rangecount << ", non native field gates " << nnfcount
+    //               << "), pubinp = " << public_inputs.size() << std::endl;
     // }
 
     void assert_equal(const uint32_t a_variable_idx,
@@ -367,11 +379,10 @@ class UltraPlonkComposer {
     };
     // std::array<uint32_t, 2> decompose_non_native_field_double_width_limb(
     //     const uint32_t limb_idx, const size_t num_limb_bits = (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
-    std::array<uint32_t, 2> evaluate_non_native_field_multiplication(
+    std::array<uint32_t, 2> queue_non_native_field_multiplication(
         const non_native_field_witnesses& input, const bool range_constrain_quotient_and_remainder = true)
     {
-        return circuit_constructor.evaluate_non_native_field_multiplication(input,
-                                                                            range_constrain_quotient_and_remainder);
+        return circuit_constructor.queue_non_native_field_multiplication(input, range_constrain_quotient_and_remainder);
     };
     // std::array<uint32_t, 2> evaluate_partial_non_native_field_multiplication(const non_native_field_witnesses&
     // input); typedef std::pair<uint32_t, barretenberg::fr> scaled_witness; typedef std::tuple<scaled_witness,
diff --git a/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.test.cpp
index cc90c8de1e..cac3e754ae 100644
--- a/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/splitting_tmp/ultra_plonk_composer.test.cpp
@@ -783,7 +783,7 @@ TEST(ultra_plonk_composer_splitting_tmp, non_native_field_multiplication)
     non_native_field_witnesses inputs{
         a_indices, b_indices, q_indices, r_indices, modulus_limbs, fr(uint256_t(modulus)),
     };
-    const auto [lo_1_idx, hi_1_idx] = composer.evaluate_non_native_field_multiplication(inputs);
+    const auto [lo_1_idx, hi_1_idx] = composer.queue_non_native_field_multiplication(inputs);
     composer.range_constrain_two_limbs(lo_1_idx, hi_1_idx, 70, 70);
 
     auto prover = composer.create_prover();
@@ -914,4 +914,4 @@ TEST(ultra_plonk_composer_splitting_tmp, ram)
     EXPECT_EQ(result, true);
 }
 
-} // namespace proof_system::plonk
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
index 8782f6ab61..ad6fd54f9a 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
@@ -531,6 +531,7 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key()
      * our circuit is finalised, and we must not to execute these functions again.
      */
     if (!circuit_finalised) {
+        process_non_native_field_multiplications();
         process_ROM_arrays(public_inputs.size());
         process_RAM_arrays(public_inputs.size());
         process_range_lists();
@@ -1216,18 +1217,65 @@ void UltraComposer::create_new_range_constraint(const uint32_t variable_index,
         range_lists.insert({ target_range, create_range_list(target_range) });
     }
 
+    const auto existing_tag = real_variable_tags[real_variable_index[variable_index]];
     auto& list = range_lists[target_range];
-    assign_tag(variable_index, list.range_tag);
-    list.variable_indices.emplace_back(variable_index);
+
+    // If the variable's tag matches the target range list's tag, do nothing.
+    if (existing_tag != list.range_tag) {
+        // If the variable is 'untagged' (i.e., it has the dummy tag), assign it the appropriate tag.
+        // Otherwise, find the range for which the variable has already been tagged.
+        if (existing_tag != DUMMY_TAG) {
+            bool found_tag = false;
+            for (const auto& r : range_lists) {
+                if (r.second.range_tag == existing_tag) {
+                    found_tag = true;
+                    if (r.first < target_range) {
+                        // The variable already has a more restrictive range check, so do nothing.
+                        return;
+                    } else {
+                        // The range constraint we are trying to impose is more restrictive than the existing range
+                        // constraint. It would be difficult to remove an existing range check. Instead deep-copy the
+                        // variable and apply a range check to new variable
+                        const uint32_t copied_witness = add_variable(get_variable(variable_index));
+                        create_add_gate({ .a = variable_index,
+                                          .b = copied_witness,
+                                          .c = zero_idx,
+                                          .a_scaling = 1,
+                                          .b_scaling = -1,
+                                          .c_scaling = 0,
+                                          .const_scaling = 0 });
+                        // Recurse with new witness that has no tag attached.
+                        create_new_range_constraint(copied_witness, target_range, msg);
+                        return;
+                    }
+                }
+            }
+            ASSERT(found_tag == true);
+        }
+        assign_tag(variable_index, list.range_tag);
+        list.variable_indices.emplace_back(variable_index);
+    }
 }
 
-void UltraComposer::process_range_list(const RangeList& list)
+void UltraComposer::process_range_list(RangeList& list)
 {
     assert_valid_variables(list.variable_indices);
 
     ASSERT(list.variable_indices.size() > 0);
+
+    // replace witness index in variable_indices with the real variable index i.e. if a copy constraint has been
+    // applied on a variable after it was range constrained, this makes sure the indices in list point to the updated
+    // index in the range list so the set equivalence does not fail
+    for (uint32_t& x : list.variable_indices) {
+        x = real_variable_index[x];
+    }
+    // remove duplicate witness indices to prevent the sorted list set size being wrong!
+    std::sort(list.variable_indices.begin(), list.variable_indices.end());
+    auto back_iterator = std::unique(list.variable_indices.begin(), list.variable_indices.end());
+    list.variable_indices.erase(back_iterator, list.variable_indices.end());
+
     // go over variables
-    // for each variable, create mirror variable with same value - with tau tag
+    // iterate over each variable and create mirror variable with same value - with tau tag
     // need to make sure that, in original list, increments of at most 3
     std::vector<uint64_t> sorted_list;
     sorted_list.reserve(list.variable_indices.size());
@@ -1262,7 +1310,7 @@ void UltraComposer::process_range_list(const RangeList& list)
 
 void UltraComposer::process_range_lists()
 {
-    for (const auto& i : range_lists)
+    for (auto& i : range_lists)
         process_range_list(i.second);
 }
 
@@ -1811,18 +1859,22 @@ std::array<uint32_t, 2> UltraComposer::decompose_non_native_field_double_width_l
 }
 
 /**
- * NON NATIVE FIELD MULTIPLICATION CUSTOM GATE SEQUENCE
+ * @brief Queue up non-native field multiplication data.
+ *
+ * @details The data queued represents a non-native field multiplication identity a * b = q * p + r,
+ * where a, b, q, r are all emulated non-native field elements that are each split across 4 distinct witness variables.
  *
- * This method will evaluate the equation (a * b = q * p + r)
- * Where a, b, q, r are all emulated non-native field elements that are each split across 4 distinct witness variables
+ * Without this queue some functions, such as proof_system::plonk::stdlib::element::double_montgomery_ladder, would
+ * duplicate non-native field operations, which can be quite expensive. We queue up these operations, and remove
+ * duplicates in the circuit finishing stage of the proving key computation.
  *
  * The non-native field modulus, p, is a circuit constant
  *
  * The return value are the witness indices of the two remainder limbs `lo_1, hi_2`
  *
- * N.B. this method does NOT evaluate the prime field component of non-native field multiplications
+ * N.B.: This method does NOT evaluate the prime field component of non-native field multiplications.
  **/
-std::array<uint32_t, 2> UltraComposer::evaluate_non_native_field_multiplication(
+std::array<uint32_t, 2> UltraComposer::queue_non_native_field_multiplication(
     const non_native_field_witnesses& input, const bool range_constrain_quotient_and_remainder)
 {
 
@@ -1854,8 +1906,6 @@ std::array<uint32_t, 2> UltraComposer::evaluate_non_native_field_multiplication(
     constexpr barretenberg::fr LIMB_SHIFT = uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS;
     constexpr barretenberg::fr LIMB_SHIFT_2 = uint256_t(1) << (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
     constexpr barretenberg::fr LIMB_SHIFT_3 = uint256_t(1) << (3 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
-    constexpr barretenberg::fr LIMB_RSHIFT =
-        barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
     constexpr barretenberg::fr LIMB_RSHIFT_2 =
         barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
 
@@ -1904,82 +1954,127 @@ std::array<uint32_t, 2> UltraComposer::evaluate_non_native_field_multiplication(
         range_constrain_two_limbs(input.q[2], input.q[3]);
     }
 
-    // product gate 1
-    // (lo_0 + q_0(p_0 + p_1*2^b) + q_1(p_0*2^b) - (r_1)2^b)2^-2b - lo_1 = 0
-    create_big_add_gate({ input.q[0],
-                          input.q[1],
-                          input.r[1],
-                          lo_1_idx,
-                          input.neg_modulus[0] + input.neg_modulus[1] * LIMB_SHIFT,
-                          input.neg_modulus[0] * LIMB_SHIFT,
-                          -LIMB_SHIFT,
-                          -LIMB_SHIFT.sqr(),
-                          0 },
-                        true);
+    // Add witnesses into the multiplication cache
+    // (when finalising the circuit, we will remove duplicates; several dups produced by biggroup.hpp methods)
+    cached_non_native_field_multiplication cache_entry{
+        .a = input.a,
+        .b = input.b,
+        .q = input.q,
+        .r = input.r,
+        .cross_terms = { lo_0_idx, lo_1_idx, hi_0_idx, hi_1_idx, hi_2_idx, hi_3_idx },
+        .neg_modulus = input.neg_modulus,
+    };
+    cached_non_native_field_multiplications.emplace_back(cache_entry);
 
-    w_l.emplace_back(input.a[1]);
-    w_r.emplace_back(input.b[1]);
-    w_o.emplace_back(input.r[0]);
-    w_4.emplace_back(lo_0_idx);
-    apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_1);
-    ++num_gates;
-    w_l.emplace_back(input.a[0]);
-    w_r.emplace_back(input.b[0]);
-    w_o.emplace_back(input.a[3]);
-    w_4.emplace_back(input.b[3]);
-    apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_2);
-    ++num_gates;
-    w_l.emplace_back(input.a[2]);
-    w_r.emplace_back(input.b[2]);
-    w_o.emplace_back(input.r[3]);
-    w_4.emplace_back(hi_0_idx);
-    apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_3);
-    ++num_gates;
-    w_l.emplace_back(input.a[1]);
-    w_r.emplace_back(input.b[1]);
-    w_o.emplace_back(input.r[2]);
-    w_4.emplace_back(hi_1_idx);
-    apply_aux_selectors(AUX_SELECTORS::NONE);
-    ++num_gates;
+    return std::array<uint32_t, 2>{ lo_1_idx, hi_3_idx };
+}
 
-    /**
-     * product gate 6
-     *
-     * hi_2 - hi_1 - lo_1 - q[2](p[1].2^b + p[0]) - q[3](p[0].2^b) = 0
-     *
-     **/
-    create_big_add_gate(
-        {
-            input.q[2],
-            input.q[3],
-            lo_1_idx,
-            hi_1_idx,
-            -input.neg_modulus[1] * LIMB_SHIFT - input.neg_modulus[0],
-            -input.neg_modulus[0] * LIMB_SHIFT,
-            -1,
-            -1,
-            0,
-        },
-        true);
+/**
+ * @brief Called in `compute_proving_key` when finalizing circuit.
+ * Iterates over the cached_non_native_field_multiplication objects,
+ * removes duplicates, and instantiates the remainder as constraints`
+ */
+void UltraComposer::process_non_native_field_multiplications()
+{
+    std::sort(cached_non_native_field_multiplications.begin(), cached_non_native_field_multiplications.end());
 
-    /**
-     * product gate 7
-     *
-     * hi_3 - (hi_2 - q[0](p[3].2^b + p[2]) - q[1](p[2].2^b + p[1])).2^-2b
-     **/
-    create_big_add_gate({
-        hi_3_idx,
-        input.q[0],
-        input.q[1],
-        hi_2_idx,
-        -1,
-        input.neg_modulus[3] * LIMB_RSHIFT + input.neg_modulus[2] * LIMB_RSHIFT_2,
-        input.neg_modulus[2] * LIMB_RSHIFT + input.neg_modulus[1] * LIMB_RSHIFT_2,
-        LIMB_RSHIFT_2,
-        0,
-    });
+    auto last =
+        std::unique(cached_non_native_field_multiplications.begin(), cached_non_native_field_multiplications.end());
 
-    return std::array<uint32_t, 2>{ lo_1_idx, hi_3_idx };
+    auto it = cached_non_native_field_multiplications.begin();
+
+    constexpr barretenberg::fr LIMB_SHIFT = uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS;
+    constexpr barretenberg::fr LIMB_RSHIFT =
+        barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
+    constexpr barretenberg::fr LIMB_RSHIFT_2 =
+        barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
+
+    // iterate over the cached items and create constraints
+    while (it != last) {
+        const auto input = *it;
+        const uint32_t lo_0_idx = input.cross_terms.lo_0_idx;
+        const uint32_t lo_1_idx = input.cross_terms.lo_1_idx;
+        const uint32_t hi_0_idx = input.cross_terms.hi_0_idx;
+        const uint32_t hi_1_idx = input.cross_terms.hi_1_idx;
+        const uint32_t hi_2_idx = input.cross_terms.hi_2_idx;
+        const uint32_t hi_3_idx = input.cross_terms.hi_3_idx;
+
+        // product gate 1
+        // (lo_0 + q_0(p_0 + p_1*2^b) + q_1(p_0*2^b) - (r_1)2^b)2^-2b - lo_1 = 0
+        create_big_add_gate({ input.q[0],
+                              input.q[1],
+                              input.r[1],
+                              lo_1_idx,
+                              input.neg_modulus[0] + input.neg_modulus[1] * LIMB_SHIFT,
+                              input.neg_modulus[0] * LIMB_SHIFT,
+                              -LIMB_SHIFT,
+                              -LIMB_SHIFT.sqr(),
+                              0 },
+                            true);
+
+        w_l.emplace_back(input.a[1]);
+        w_r.emplace_back(input.b[1]);
+        w_o.emplace_back(input.r[0]);
+        w_4.emplace_back(lo_0_idx);
+        apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_1);
+        ++num_gates;
+        w_l.emplace_back(input.a[0]);
+        w_r.emplace_back(input.b[0]);
+        w_o.emplace_back(input.a[3]);
+        w_4.emplace_back(input.b[3]);
+        apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_2);
+        ++num_gates;
+        w_l.emplace_back(input.a[2]);
+        w_r.emplace_back(input.b[2]);
+        w_o.emplace_back(input.r[3]);
+        w_4.emplace_back(hi_0_idx);
+        apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_3);
+        ++num_gates;
+        w_l.emplace_back(input.a[1]);
+        w_r.emplace_back(input.b[1]);
+        w_o.emplace_back(input.r[2]);
+        w_4.emplace_back(hi_1_idx);
+        apply_aux_selectors(AUX_SELECTORS::NONE);
+        ++num_gates;
+
+        /**
+         * product gate 6
+         *
+         * hi_2 - hi_1 - lo_1 - q[2](p[1].2^b + p[0]) - q[3](p[0].2^b) = 0
+         *
+         **/
+        create_big_add_gate(
+            {
+                input.q[2],
+                input.q[3],
+                lo_1_idx,
+                hi_1_idx,
+                -input.neg_modulus[1] * LIMB_SHIFT - input.neg_modulus[0],
+                -input.neg_modulus[0] * LIMB_SHIFT,
+                -1,
+                -1,
+                0,
+            },
+            true);
+
+        /**
+         * product gate 7
+         *
+         * hi_3 - (hi_2 - q[0](p[3].2^b + p[2]) - q[1](p[2].2^b + p[1])).2^-2b
+         **/
+        create_big_add_gate({
+            hi_3_idx,
+            input.q[0],
+            input.q[1],
+            hi_2_idx,
+            -1,
+            input.neg_modulus[3] * LIMB_RSHIFT + input.neg_modulus[2] * LIMB_RSHIFT_2,
+            input.neg_modulus[2] * LIMB_RSHIFT + input.neg_modulus[1] * LIMB_RSHIFT_2,
+            LIMB_RSHIFT_2,
+            0,
+        });
+        ++it;
+    }
 }
 
 /**
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
index b3157639fd..d8988e3fca 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
@@ -7,6 +7,14 @@
 
 namespace proof_system::plonk {
 
+/**
+ * @brief UltraPlonK: a flavor of PlonK with plookup tables, efficient range constraints, RAM, ROM, and more!
+ *
+ * @warning The proof of PlonK's correctness uses the fact that verifier challenges are generated by a hash function
+ * standing in for a random oracle. UltraPlonK currently uses a hash function (a custom Pedersen hash that uses lookup
+ * tables) that is known to violate this random oracle assumption. We plan to switch to an algebraic hash function that
+ * is believed to have the random oracle property in a future upgrade.
+ */
 class UltraComposer : public ComposerBase {
 
   public:
@@ -27,7 +35,8 @@ class UltraComposer : public ComposerBase {
     static constexpr uint32_t UNINITIALIZED_MEMORY_RECORD = UINT32_MAX;
     static constexpr size_t NUMBER_OF_GATES_PER_RAM_ACCESS = 2;
     static constexpr size_t NUMBER_OF_ARITHMETIC_GATES_PER_RAM_ARRAY = 1;
-
+    // number of gates created per non-native field operation in process_non_native_field_multiplications
+    static constexpr size_t GATES_PER_NON_NATIVE_FIELD_MULTIPLICATION_ARITHMETIC = 7;
     struct non_native_field_witnesses {
         // first 4 array elements = limbs
         // 5th element = prime basis limb
@@ -39,6 +48,66 @@ class UltraComposer : public ComposerBase {
         barretenberg::fr modulus;
     };
 
+    struct non_native_field_multiplication_cross_terms {
+        uint32_t lo_0_idx;
+        uint32_t lo_1_idx;
+        uint32_t hi_0_idx;
+        uint32_t hi_1_idx;
+        uint32_t hi_2_idx;
+        uint32_t hi_3_idx;
+    };
+
+    /**
+     * @brief Used to store instructions to create non_native_field_multiplication gates.
+     *        We want to cache these (and remove duplicates) as the stdlib code can end up multiplying the same inputs
+     * repeatedly.
+     */
+    struct cached_non_native_field_multiplication {
+        std::array<uint32_t, 5> a;
+        std::array<uint32_t, 5> b;
+        std::array<uint32_t, 5> q;
+        std::array<uint32_t, 5> r;
+        non_native_field_multiplication_cross_terms cross_terms;
+        std::array<barretenberg::fr, 5> neg_modulus;
+
+        bool operator==(const cached_non_native_field_multiplication& other) const
+        {
+            bool valid = true;
+            for (size_t i = 0; i < 5; ++i) {
+                valid = valid && (a[i] == other.a[i]);
+                valid = valid && (b[i] == other.b[i]);
+                valid = valid && (q[i] == other.q[i]);
+                valid = valid && (r[i] == other.r[i]);
+            }
+            return valid;
+        }
+        bool operator<(const cached_non_native_field_multiplication& other) const
+        {
+            if (a < other.a) {
+                return true;
+            }
+            if (a == other.a) {
+                if (b < other.b) {
+                    return true;
+                }
+                if (b == other.b) {
+                    if (q < other.q) {
+                        return true;
+                    }
+                    if (q == other.q) {
+                        if (r < other.r) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+    };
+
+    std::vector<cached_non_native_field_multiplication> cached_non_native_field_multiplications;
+    void process_non_native_field_multiplications();
+
     enum AUX_SELECTORS {
         NONE,
         LIMB_ACCUMULATE_1,
@@ -58,6 +127,8 @@ class UltraComposer : public ComposerBase {
         uint64_t target_range;
         uint32_t range_tag;
         uint32_t tau_tag;
+        // contains the list of variable indices that are range constrained to target_range
+        // as ordered in the vector of variable indoces from the composer
         std::vector<uint32_t> variable_indices;
     };
 
@@ -242,18 +313,18 @@ class UltraComposer : public ComposerBase {
      * 1) Current number number of actual gates
      * 2) Number of public inputs, as we'll need to add a gate for each of them
      * 3) Number of Rom array-associated gates
-     * 4) NUmber of range-list associated gates
+     * 4) Number of range-list associated gates
+     * 5) Number of non-native field multiplication gates.
      *
      *
      * @param count return arument, number of existing gates
      * @param rangecount return argument, extra gates due to range checks
      * @param romcount return argument, extra gates due to rom reads
      * @param ramcount return argument, extra gates due to ram read/writes
+     * @param nnfcount return argument, extra gates due to queued non native field gates
      */
-    void get_num_gates_split_into_components(size_t& count,
-                                             size_t& rangecount,
-                                             size_t& romcount,
-                                             size_t& ramcount) const
+    void get_num_gates_split_into_components(
+        size_t& count, size_t& rangecount, size_t& romcount, size_t& ramcount, size_t& nnfcount) const
     {
         count = num_gates;
         // each ROM gate adds +1 extra gate due to the rom reads being copied to a sorted list set
@@ -321,6 +392,13 @@ class UltraComposer : public ComposerBase {
                 rangecount += ram_range_sizes[i];
             }
         }
+        std::vector<cached_non_native_field_multiplication> nnf_copy(cached_non_native_field_multiplications);
+        // update nnfcount
+        std::sort(nnf_copy.begin(), nnf_copy.end());
+
+        auto last = std::unique(nnf_copy.begin(), nnf_copy.end());
+        const size_t num_nnf_ops = static_cast<size_t>(std::distance(nnf_copy.begin(), last));
+        nnfcount = num_nnf_ops * GATES_PER_NON_NATIVE_FIELD_MULTIPLICATION_ARITHMETIC;
     }
 
     /**
@@ -328,7 +406,8 @@ class UltraComposer : public ComposerBase {
      * 1) Current number number of actual gates
      * 2) Number of public inputs, as we'll need to add a gate for each of them
      * 3) Number of Rom array-associated gates
-     * 4) NUmber of range-list associated gates
+     * 4) Number of range-list associated gates
+     * 5) Number of non-native field multiplication gates.
      *
      * @return size_t
      */
@@ -342,8 +421,9 @@ class UltraComposer : public ComposerBase {
         size_t rangecount = 0;
         size_t romcount = 0;
         size_t ramcount = 0;
-        get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
-        return count + romcount + ramcount + rangecount;
+        size_t nnfcount = 0;
+        get_num_gates_split_into_components(count, rangecount, romcount, ramcount, nnfcount);
+        return count + romcount + ramcount + rangecount + nnfcount;
     }
 
     virtual size_t get_total_circuit_size() const override
@@ -366,12 +446,13 @@ class UltraComposer : public ComposerBase {
         size_t rangecount = 0;
         size_t romcount = 0;
         size_t ramcount = 0;
-
-        get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
+        size_t nnfcount = 0;
+        get_num_gates_split_into_components(count, rangecount, romcount, ramcount, nnfcount);
 
         size_t total = count + romcount + ramcount + rangecount;
         std::cout << "gates = " << total << " (arith " << count << ", rom " << romcount << ", ram " << ramcount
-                  << ", range " << rangecount << "), pubinp = " << public_inputs.size() << std::endl;
+                  << ", range " << rangecount << ", non native field gates " << nnfcount
+                  << "), pubinp = " << public_inputs.size() << std::endl;
     }
 
     void assert_equal_constant(const uint32_t a_idx,
@@ -425,6 +506,10 @@ class UltraComposer : public ComposerBase {
     void assign_tag(const uint32_t variable_index, const uint32_t tag)
     {
         ASSERT(tag <= current_tag);
+        // If we've already assigned this tag to this variable, return (can happen due to copy constraints)
+        if (real_variable_tags[real_variable_index[variable_index]] == tag) {
+            return;
+        }
         ASSERT(real_variable_tags[real_variable_index[variable_index]] == DUMMY_TAG);
         real_variable_tags[real_variable_index[variable_index]] = tag;
     }
@@ -443,7 +528,7 @@ class UltraComposer : public ComposerBase {
     }
 
     RangeList create_range_list(const uint64_t target_range);
-    void process_range_list(const RangeList& list);
+    void process_range_list(RangeList& list);
     void process_range_lists();
 
     /**
@@ -460,7 +545,7 @@ class UltraComposer : public ComposerBase {
                                    const size_t hi_limb_bits = DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
     std::array<uint32_t, 2> decompose_non_native_field_double_width_limb(
         const uint32_t limb_idx, const size_t num_limb_bits = (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
-    std::array<uint32_t, 2> evaluate_non_native_field_multiplication(
+    std::array<uint32_t, 2> queue_non_native_field_multiplication(
         const non_native_field_witnesses& input, const bool range_constrain_quotient_and_remainder = true);
     std::array<uint32_t, 2> evaluate_partial_non_native_field_multiplication(const non_native_field_witnesses& input);
     typedef std::pair<uint32_t, barretenberg::fr> scaled_witness;
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
index eef80fa56c..9745d397e2 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
@@ -649,7 +649,7 @@ TYPED_TEST(ultra_composer, non_native_field_multiplication)
     UltraComposer::non_native_field_witnesses inputs{
         a_indices, b_indices, q_indices, r_indices, modulus_limbs, fr(uint256_t(modulus)),
     };
-    const auto [lo_1_idx, hi_1_idx] = composer.evaluate_non_native_field_multiplication(inputs);
+    const auto [lo_1_idx, hi_1_idx] = composer.queue_non_native_field_multiplication(inputs);
     composer.range_constrain_two_limbs(lo_1_idx, hi_1_idx, 70, 70);
 
     TestFixture::prove_and_verify(composer, /*expected_result=*/true);
@@ -758,4 +758,65 @@ TYPED_TEST(ultra_composer, ram)
     TestFixture::prove_and_verify(composer, /*expected_result=*/true);
 }
 
+TYPED_TEST(ultra_composer, range_checks_on_duplicates)
+{
+    UltraComposer composer = UltraComposer();
+
+    uint32_t a = composer.add_variable(100);
+    uint32_t b = composer.add_variable(100);
+    uint32_t c = composer.add_variable(100);
+    uint32_t d = composer.add_variable(100);
+
+    composer.assert_equal(a, b);
+    composer.assert_equal(a, c);
+    composer.assert_equal(a, d);
+
+    composer.create_new_range_constraint(a, 1000);
+    composer.create_new_range_constraint(b, 1001);
+    composer.create_new_range_constraint(c, 999);
+    composer.create_new_range_constraint(d, 1000);
+
+    composer.create_big_add_gate(
+        {
+            a,
+            b,
+            c,
+            d,
+            0,
+            0,
+            0,
+            0,
+            0,
+        },
+        false);
+
+    TestFixture::prove_and_verify(composer, /*expected_result=*/true);
+}
+
+// Ensure copy constraints added on variables smaller than 2^14, which have been previously
+// range constrained, do not break the set equivalence checks because of indices mismatch.
+// 2^14 is DEFAULT_PLOOKUP_RANGE_BITNUM i.e. the maximum size before a variable gets sliced
+// before range constraints are applied to it.
+TEST(ultra_composer, range_constraint_small_variable)
+{
+    auto composer = UltraComposer();
+    uint16_t mask = (1 << 8) - 1;
+    int a = engine.get_random_uint16() & mask;
+    uint32_t a_idx = composer.add_variable(fr(a));
+    uint32_t b_idx = composer.add_variable(fr(a));
+    ASSERT_NE(a_idx, b_idx);
+    uint32_t c_idx = composer.add_variable(fr(a));
+    ASSERT_NE(c_idx, b_idx);
+    composer.create_range_constraint(b_idx, 8, "bad range");
+    composer.assert_equal(a_idx, b_idx);
+    composer.create_range_constraint(c_idx, 8, "bad range");
+    composer.assert_equal(a_idx, c_idx);
+
+    auto prover = composer.create_prover();
+    auto proof = prover.construct_proof();
+    auto verifier = composer.create_verifier();
+    bool result = verifier.verify_proof(proof);
+    EXPECT_EQ(result, true);
+}
+
 } // namespace proof_system::plonk::test_ultra_composer
diff --git a/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.cpp b/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.cpp
index d606ab173d..425efbdb58 100644
--- a/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.cpp
+++ b/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.cpp
@@ -33,6 +33,7 @@ void UltraCircuitConstructor::finalize_circuit()
      * our circuit is finalised, and we must not to execute these functions again.
      */
     if (!circuit_finalised) {
+        process_non_native_field_multiplications();
         process_ROM_arrays(public_inputs.size());
         process_RAM_arrays(public_inputs.size());
         process_range_lists();
@@ -1236,18 +1237,22 @@ std::array<uint32_t, 2> UltraCircuitConstructor::decompose_non_native_field_doub
 }
 
 /**
- * NON NATIVE FIELD MULTIPLICATION CUSTOM GATE SEQUENCE
+ * @brief Queue up non-native field multiplication data.
  *
- * This method will evaluate the equation (a * b = q * p + r)
- * Where a, b, q, r are all emulated non-native field elements that are each split across 4 distinct witness variables
+ * @details The data queued represents a non-native field multiplication identity a * b = q * p + r,
+ * where a, b, q, r are all emulated non-native field elements that are each split across 4 distinct witness variables.
+ *
+ * Without this queue some functions, such as proof_system::plonk::stdlib::element::double_montgomery_ladder, would
+ * duplicate non-native field operations, which can be quite expensive. We queue up these operations, and remove
+ * duplicates in the circuit finishing stage of the proving key computation.
  *
  * The non-native field modulus, p, is a circuit constant
  *
  * The return value are the witness indices of the two remainder limbs `lo_1, hi_2`
  *
- * N.B. this method does NOT evaluate the prime field component of non-native field multiplications
+ * N.B.: This method does NOT evaluate the prime field component of non-native field multiplications.
  **/
-std::array<uint32_t, 2> UltraCircuitConstructor::evaluate_non_native_field_multiplication(
+std::array<uint32_t, 2> UltraCircuitConstructor::queue_non_native_field_multiplication(
     const non_native_field_witnesses& input, const bool range_constrain_quotient_and_remainder)
 {
 
@@ -1279,8 +1284,6 @@ std::array<uint32_t, 2> UltraCircuitConstructor::evaluate_non_native_field_multi
     constexpr barretenberg::fr LIMB_SHIFT = uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS;
     constexpr barretenberg::fr LIMB_SHIFT_2 = uint256_t(1) << (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
     constexpr barretenberg::fr LIMB_SHIFT_3 = uint256_t(1) << (3 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
-    constexpr barretenberg::fr LIMB_RSHIFT =
-        barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
     constexpr barretenberg::fr LIMB_RSHIFT_2 =
         barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
 
@@ -1328,83 +1331,127 @@ std::array<uint32_t, 2> UltraCircuitConstructor::evaluate_non_native_field_multi
         range_constrain_two_limbs(input.q[0], input.q[1]);
         range_constrain_two_limbs(input.q[2], input.q[3]);
     }
+    // Add witnesses into the multiplication cache
+    // (when finalising the circuit, we will remove duplicates; several dups produced by biggroup.hpp methods)
+    cached_non_native_field_multiplication cache_entry{
+        .a = input.a,
+        .b = input.b,
+        .q = input.q,
+        .r = input.r,
+        .cross_terms = { lo_0_idx, lo_1_idx, hi_0_idx, hi_1_idx, hi_2_idx, hi_3_idx },
+        .neg_modulus = input.neg_modulus,
+    };
+    cached_non_native_field_multiplications.emplace_back(cache_entry);
 
-    // product gate 1
-    // (lo_0 + q_0(p_0 + p_1*2^b) + q_1(p_0*2^b) - (r_1)2^b)2^-2b - lo_1 = 0
-    create_big_add_gate({ input.q[0],
-                          input.q[1],
-                          input.r[1],
-                          lo_1_idx,
-                          input.neg_modulus[0] + input.neg_modulus[1] * LIMB_SHIFT,
-                          input.neg_modulus[0] * LIMB_SHIFT,
-                          -LIMB_SHIFT,
-                          -LIMB_SHIFT.sqr(),
-                          0 },
-                        true);
+    return std::array<uint32_t, 2>{ lo_1_idx, hi_3_idx };
+}
 
-    w_l.emplace_back(input.a[1]);
-    w_r.emplace_back(input.b[1]);
-    w_o.emplace_back(input.r[0]);
-    w_4.emplace_back(lo_0_idx);
-    apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_1);
-    ++num_gates;
-    w_l.emplace_back(input.a[0]);
-    w_r.emplace_back(input.b[0]);
-    w_o.emplace_back(input.a[3]);
-    w_4.emplace_back(input.b[3]);
-    apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_2);
-    ++num_gates;
-    w_l.emplace_back(input.a[2]);
-    w_r.emplace_back(input.b[2]);
-    w_o.emplace_back(input.r[3]);
-    w_4.emplace_back(hi_0_idx);
-    apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_3);
-    ++num_gates;
-    w_l.emplace_back(input.a[1]);
-    w_r.emplace_back(input.b[1]);
-    w_o.emplace_back(input.r[2]);
-    w_4.emplace_back(hi_1_idx);
-    apply_aux_selectors(AUX_SELECTORS::NONE);
-    ++num_gates;
+/**
+ * @brief Called in `compute_proving_key` when finalizing circuit.
+ * Iterates over the cached_non_native_field_multiplication objects,
+ * removes duplicates, and instantiates the remainder as constraints`
+ */
+void UltraCircuitConstructor::process_non_native_field_multiplications()
+{
+    std::sort(cached_non_native_field_multiplications.begin(), cached_non_native_field_multiplications.end());
 
-    /**
-     * product gate 6
-     *
-     * hi_2 - hi_1 - lo_1 - q[2](p[1].2^b + p[0]) - q[3](p[0].2^b) = 0
-     *
-     **/
-    create_big_add_gate(
-        {
-            input.q[2],
-            input.q[3],
-            lo_1_idx,
-            hi_1_idx,
-            -input.neg_modulus[1] * LIMB_SHIFT - input.neg_modulus[0],
-            -input.neg_modulus[0] * LIMB_SHIFT,
-            -1,
-            -1,
-            0,
-        },
-        true);
+    auto last =
+        std::unique(cached_non_native_field_multiplications.begin(), cached_non_native_field_multiplications.end());
 
-    /**
-     * product gate 7
-     *
-     * hi_3 - (hi_2 - q[0](p[3].2^b + p[2]) - q[1](p[2].2^b + p[1])).2^-2b
-     **/
-    create_big_add_gate({
-        hi_3_idx,
-        input.q[0],
-        input.q[1],
-        hi_2_idx,
-        -1,
-        input.neg_modulus[3] * LIMB_RSHIFT + input.neg_modulus[2] * LIMB_RSHIFT_2,
-        input.neg_modulus[2] * LIMB_RSHIFT + input.neg_modulus[1] * LIMB_RSHIFT_2,
-        LIMB_RSHIFT_2,
-        0,
-    });
+    auto it = cached_non_native_field_multiplications.begin();
 
-    return std::array<uint32_t, 2>{ lo_1_idx, hi_3_idx };
+    constexpr barretenberg::fr LIMB_SHIFT = uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS;
+    constexpr barretenberg::fr LIMB_RSHIFT =
+        barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
+    constexpr barretenberg::fr LIMB_RSHIFT_2 =
+        barretenberg::fr(1) / barretenberg::fr(uint256_t(1) << (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
+
+    // iterate over the cached items and create constraints
+    while (it != last) {
+        const auto input = *it;
+        const uint32_t lo_0_idx = input.cross_terms.lo_0_idx;
+        const uint32_t lo_1_idx = input.cross_terms.lo_1_idx;
+        const uint32_t hi_0_idx = input.cross_terms.hi_0_idx;
+        const uint32_t hi_1_idx = input.cross_terms.hi_1_idx;
+        const uint32_t hi_2_idx = input.cross_terms.hi_2_idx;
+        const uint32_t hi_3_idx = input.cross_terms.hi_3_idx;
+
+        // product gate 1
+        // (lo_0 + q_0(p_0 + p_1*2^b) + q_1(p_0*2^b) - (r_1)2^b)2^-2b - lo_1 = 0
+        create_big_add_gate({ input.q[0],
+                              input.q[1],
+                              input.r[1],
+                              lo_1_idx,
+                              input.neg_modulus[0] + input.neg_modulus[1] * LIMB_SHIFT,
+                              input.neg_modulus[0] * LIMB_SHIFT,
+                              -LIMB_SHIFT,
+                              -LIMB_SHIFT.sqr(),
+                              0 },
+                            true);
+
+        w_l.emplace_back(input.a[1]);
+        w_r.emplace_back(input.b[1]);
+        w_o.emplace_back(input.r[0]);
+        w_4.emplace_back(lo_0_idx);
+        apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_1);
+        ++num_gates;
+        w_l.emplace_back(input.a[0]);
+        w_r.emplace_back(input.b[0]);
+        w_o.emplace_back(input.a[3]);
+        w_4.emplace_back(input.b[3]);
+        apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_2);
+        ++num_gates;
+        w_l.emplace_back(input.a[2]);
+        w_r.emplace_back(input.b[2]);
+        w_o.emplace_back(input.r[3]);
+        w_4.emplace_back(hi_0_idx);
+        apply_aux_selectors(AUX_SELECTORS::NON_NATIVE_FIELD_3);
+        ++num_gates;
+        w_l.emplace_back(input.a[1]);
+        w_r.emplace_back(input.b[1]);
+        w_o.emplace_back(input.r[2]);
+        w_4.emplace_back(hi_1_idx);
+        apply_aux_selectors(AUX_SELECTORS::NONE);
+        ++num_gates;
+
+        /**
+         * product gate 6
+         *
+         * hi_2 - hi_1 - lo_1 - q[2](p[1].2^b + p[0]) - q[3](p[0].2^b) = 0
+         *
+         **/
+        create_big_add_gate(
+            {
+                input.q[2],
+                input.q[3],
+                lo_1_idx,
+                hi_1_idx,
+                -input.neg_modulus[1] * LIMB_SHIFT - input.neg_modulus[0],
+                -input.neg_modulus[0] * LIMB_SHIFT,
+                -1,
+                -1,
+                0,
+            },
+            true);
+
+        /**
+         * product gate 7
+         *
+         * hi_3 - (hi_2 - q[0](p[3].2^b + p[2]) - q[1](p[2].2^b + p[1])).2^-2b
+         **/
+        create_big_add_gate({
+            hi_3_idx,
+            input.q[0],
+            input.q[1],
+            hi_2_idx,
+            -1,
+            input.neg_modulus[3] * LIMB_RSHIFT + input.neg_modulus[2] * LIMB_RSHIFT_2,
+            input.neg_modulus[2] * LIMB_RSHIFT + input.neg_modulus[1] * LIMB_RSHIFT_2,
+            LIMB_RSHIFT_2,
+            0,
+        });
+        ++it;
+    }
 }
 
 /**
diff --git a/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp b/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp
index 383dccb6f0..2e4803fa44 100644
--- a/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp
+++ b/cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp
@@ -29,6 +29,8 @@ static constexpr size_t DEFAULT_NON_NATIVE_FIELD_LIMB_BITS = 68;
 static constexpr uint32_t UNINITIALIZED_MEMORY_RECORD = UINT32_MAX;
 static constexpr size_t NUMBER_OF_GATES_PER_RAM_ACCESS = 2;
 static constexpr size_t NUMBER_OF_ARITHMETIC_GATES_PER_RAM_ARRAY = 1;
+// number of gates created per non-native field operation in process_non_native_field_multiplications
+static constexpr size_t GATES_PER_NON_NATIVE_FIELD_MULTIPLICATION_ARITHMETIC = 7;
 
 struct non_native_field_witnesses {
     // first 4 array elements = limbs
@@ -41,6 +43,63 @@ struct non_native_field_witnesses {
     barretenberg::fr modulus;
 };
 
+struct non_native_field_multiplication_cross_terms {
+    uint32_t lo_0_idx;
+    uint32_t lo_1_idx;
+    uint32_t hi_0_idx;
+    uint32_t hi_1_idx;
+    uint32_t hi_2_idx;
+    uint32_t hi_3_idx;
+};
+
+/**
+ * @brief Used to store instructions to create non_native_field_multiplication gates.
+ *        We want to cache these (and remove duplicates) as the stdlib code can end up multiplying the same inputs
+ * repeatedly.
+ */
+struct cached_non_native_field_multiplication {
+    std::array<uint32_t, 5> a;
+    std::array<uint32_t, 5> b;
+    std::array<uint32_t, 5> q;
+    std::array<uint32_t, 5> r;
+    non_native_field_multiplication_cross_terms cross_terms;
+    std::array<barretenberg::fr, 5> neg_modulus;
+
+    bool operator==(const cached_non_native_field_multiplication& other) const
+    {
+        bool valid = true;
+        for (size_t i = 0; i < 5; ++i) {
+            valid = valid && (a[i] == other.a[i]);
+            valid = valid && (b[i] == other.b[i]);
+            valid = valid && (q[i] == other.q[i]);
+            valid = valid && (r[i] == other.r[i]);
+        }
+        return valid;
+    }
+    bool operator<(const cached_non_native_field_multiplication& other) const
+    {
+        if (a < other.a) {
+            return true;
+        }
+        if (a == other.a) {
+            if (b < other.b) {
+                return true;
+            }
+            if (b == other.b) {
+                if (q < other.q) {
+                    return true;
+                }
+                if (q == other.q) {
+                    if (r < other.r) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+};
+
 enum AUX_SELECTORS {
     NONE,
     LIMB_ACCUMULATE_1,
@@ -201,6 +260,10 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
     // Stores gate index of RAM writes (required by proving key)
     std::vector<uint32_t> memory_write_records;
 
+    std::vector<cached_non_native_field_multiplication> cached_non_native_field_multiplications;
+
+    void process_non_native_field_multiplications();
+
     bool circuit_finalised = false;
 
     UltraCircuitConstructor(const size_t size_hint = 0)
@@ -286,18 +349,18 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
     //  * 1) Current number number of actual gates
     //  * 2) Number of public inputs, as we'll need to add a gate for each of them
     //  * 3) Number of Rom array-associated gates
-    //  * 4) NUmber of range-list associated gates
+    //  * 4) Number of range-list associated gates
+    //  * 5) Number of non-native field multiplication gates.
     //  *
     //  *
     //  * @param count return arument, number of existing gates
     //  * @param rangecount return argument, extra gates due to range checks
     //  * @param romcount return argument, extra gates due to rom reads
     //  * @param ramcount return argument, extra gates due to ram read/writes
+    //  * @param nnfcount return argument, extra gates due to queued non native field gates
     //  */
-    // void get_num_gates_split_into_components(size_t& count,
-    //                                          size_t& rangecount,
-    //                                          size_t& romcount,
-    //                                          size_t& ramcount) const
+    // void get_num_gates_split_into_components(
+    //     size_t& count, size_t& rangecount, size_t& romcount, size_t& ramcount, size_t& nnfcount) const
     // {
     //     count = num_gates;
     //     // each ROM gate adds +1 extra gate due to the rom reads being copied to a sorted list set
@@ -366,6 +429,13 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
     //             rangecount += ram_range_sizes[i];
     //         }
     //     }
+    //     std::vector<cached_non_native_field_multiplication> nnf_copy(cached_non_native_field_multiplications);
+    //     // update nnfcount
+    //     std::sort(nnf_copy.begin(), nnf_copy.end());
+
+    //     auto last = std::unique(nnf_copy.begin(), nnf_copy.end());
+    //     const size_t num_nnf_ops = static_cast<size_t>(std::distance(nnf_copy.begin(), last));
+    //     nnfcount = num_nnf_ops * GATES_PER_NON_NATIVE_FIELD_MULTIPLICATION_ARITHMETIC;
     // }
 
     // /**
@@ -373,7 +443,8 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
     //  * 1) Current number number of actual gates
     //  * 2) Number of public inputs, as we'll need to add a gate for each of them
     //  * 3) Number of Rom array-associated gates
-    //  * 4) NUmber of range-list associated gates
+    //  * 4) Number of range-list associated gates
+    //  * 5) Number of non-native field multiplication gates.
     //  *
     //  * @return size_t
     //  */
@@ -387,8 +458,9 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
     //     size_t rangecount = 0;
     //     size_t romcount = 0;
     //     size_t ramcount = 0;
-    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
-    //     return count + romcount + ramcount + rangecount;
+    //     size_t nnfcount = 0;
+    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount, nnfcount);
+    //     return count + romcount + ramcount + rangecount + nnfcount;
     // }
 
     // virtual void print_num_gates() const override
@@ -397,12 +469,13 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
     //     size_t rangecount = 0;
     //     size_t romcount = 0;
     //     size_t ramcount = 0;
-
-    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount);
+    //     size_t nnfcount = 0;
+    //     get_num_gates_split_into_components(count, rangecount, romcount, ramcount, nnfcount);
 
     //     size_t total = count + romcount + ramcount + rangecount;
     //     std::cout << "gates = " << total << " (arith " << count << ", rom " << romcount << ", ram " << ramcount
-    //               << ", range " << rangecount << "), pubinp = " << public_inputs.size() << std::endl;
+    //               << ", range " << rangecount << ", non native field gates " << nnfcount
+    //               << "), pubinp = " << public_inputs.size() << std::endl;
     // }
 
     void assert_equal_constant(const uint32_t a_idx,
@@ -491,7 +564,7 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
                                    const size_t hi_limb_bits = DEFAULT_NON_NATIVE_FIELD_LIMB_BITS);
     std::array<uint32_t, 2> decompose_non_native_field_double_width_limb(
         const uint32_t limb_idx, const size_t num_limb_bits = (2 * DEFAULT_NON_NATIVE_FIELD_LIMB_BITS));
-    std::array<uint32_t, 2> evaluate_non_native_field_multiplication(
+    std::array<uint32_t, 2> queue_non_native_field_multiplication(
         const non_native_field_witnesses& input, const bool range_constrain_quotient_and_remainder = true);
     std::array<uint32_t, 2> evaluate_partial_non_native_field_multiplication(const non_native_field_witnesses& input);
     typedef std::pair<uint32_t, barretenberg::fr> scaled_witness;
diff --git a/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp b/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp
index ef70eb9a18..8da1252278 100644
--- a/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp
+++ b/cpp/src/barretenberg/proof_system/composer/permutation_helper.hpp
@@ -254,7 +254,7 @@ void compute_honk_style_permutation_lagrange_polynomials_from_mapping(
             // repairing the cycle is add the mapping
             //  -(i+1) -> (n+i)
             // These indices are chosen so they can easily be computed by the verifier. They can expect the running
-            // product to be equal to the "public input delta" that is computed in <honk/utils/public_inputs.hpp>
+            // product to be equal to the "public input delta" that is computed in <honk/utils/grand_product_delta.hpp>
             current_permutation_poly[i] =
                 -barretenberg::fr(current_mapping.row_index + 1 + num_gates * current_mapping.column_index);
         } else if (current_mapping.is_tag) {
diff --git a/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp b/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
index b32ec8d77e..d324bcc4af 100644
--- a/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
+++ b/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
@@ -1982,7 +1982,7 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
             modulus,
         };
         // N.B. this method also evaluates the prime field component of the non-native field mul
-        const auto [lo_idx, hi_idx] = ctx->evaluate_non_native_field_multiplication(witnesses, false);
+        const auto [lo_idx, hi_idx] = ctx->queue_non_native_field_multiplication(witnesses, false);
 
         barretenberg::fr neg_prime = -barretenberg::fr(uint256_t(target_basis.modulus));
         field_t<C>::evaluate_polynomial_identity(left.prime_basis_limb,
@@ -2267,7 +2267,7 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
         // we set `neg_modulus = [2^{136}, 0, 0, 0]` and `q = [lo_1, 0, hi_1, 0]`, then we will add `lo_1` into
         // `lo`, and `lo_1/2^{136} + hi_1` into `hi`. we can then subtract off `lo_1/2^{136}` from `hi`, by setting
         // `r = [0, 0, lo_1, 0]` This saves us 2 addition gates as we don't have to add together the outputs of two
-        // calls to `evaluate_non_native_field_multiplication`
+        // calls to `queue_non_native_field_multiplication`
         std::vector<field_t<C>> limb_0_accumulator;
         std::vector<field_t<C>> limb_2_accumulator;
         std::vector<field_t<C>> prime_limb_accumulator;
@@ -2416,7 +2416,7 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
             modulus,
         };
 
-        const auto [lo_1_idx, hi_1_idx] = ctx->evaluate_non_native_field_multiplication(witnesses, false);
+        const auto [lo_1_idx, hi_1_idx] = ctx->queue_non_native_field_multiplication(witnesses, false);
 
         barretenberg::fr neg_prime = -barretenberg::fr(uint256_t(target_basis.modulus));
 
diff --git a/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp b/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp
index 47d1d848f0..033ec3b9d2 100644
--- a/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp
@@ -2,13 +2,19 @@
 
 #include "../composers/composers.hpp"
 #include "../plookup/plookup.hpp"
+#include "barretenberg/common/assert.hpp"
+#include "barretenberg/numeric/uint256/uint256.hpp"
+#include "barretenberg/stdlib/primitives/field/field.hpp"
+#include <cstddef>
 
 namespace proof_system::plonk::stdlib {
 
 /**
  * @brief A logical AND or XOR over a variable number of bits.
  *
- * @details Defaults to basic Composer method if not using plookup-compatible composer
+ * @details Defaults to basic Composer method if not using plookup-compatible composer. If the left and right operands
+ * are larger than num_bit, the result will be truncated to num_bits. However, the two operands could be
+ * range-constrained to num_bits before the call which would remove the need to range constrain inside this function.
  *
  * @tparam Composer
  * @param a
@@ -18,10 +24,17 @@ namespace proof_system::plonk::stdlib {
  * @return field_t<Composer>
  */
 template <typename Composer>
-field_t<Composer> logic<Composer>::create_logic_constraint(field_pt& a, field_pt& b, size_t num_bits, bool is_xor_gate)
+field_t<Composer> logic<Composer>::create_logic_constraint(
+    field_pt& a,
+    field_pt& b,
+    size_t num_bits,
+    bool is_xor_gate,
+    const std::function<std::pair<uint256_t, uint256_t>(uint256_t, uint256_t, size_t)>& get_chunk)
 {
-    // can't extend past field size!
+    // ensure the number of bits doesn't exceed field size and is not negatove
     ASSERT(num_bits < 254);
+    ASSERT(num_bits > 0);
+
     if (a.is_constant() && b.is_constant()) {
         uint256_t a_native(a.get_value());
         uint256_t b_native(b.get_value());
@@ -31,59 +44,72 @@ field_t<Composer> logic<Composer>::create_logic_constraint(field_pt& a, field_pt
     if (a.is_constant() && !b.is_constant()) {
         Composer* ctx = b.get_context();
         uint256_t a_native(a.get_value());
-        field_t<Composer> a_witness = field_pt::from_witness_index(ctx, ctx->put_constant_variable(a_native));
-        return create_logic_constraint(a_witness, b, num_bits, is_xor_gate);
+        field_pt a_witness = field_pt::from_witness_index(ctx, ctx->put_constant_variable(a_native));
+        return create_logic_constraint(a_witness, b, num_bits, is_xor_gate, get_chunk);
     }
     if (!a.is_constant() && b.is_constant()) {
         Composer* ctx = a.get_context();
         uint256_t b_native(b.get_value());
         field_pt b_witness = field_pt::from_witness_index(ctx, ctx->put_constant_variable(b_native));
-        return create_logic_constraint(a, b_witness, num_bits, is_xor_gate);
+        return create_logic_constraint(a, b_witness, num_bits, is_xor_gate, get_chunk);
     }
     if constexpr (Composer::type == ComposerType::PLOOKUP) {
         Composer* ctx = a.get_context();
 
         const size_t num_chunks = (num_bits / 32) + ((num_bits % 32 == 0) ? 0 : 1);
-        uint256_t left(a.get_value());
-        uint256_t right(b.get_value());
+        auto left((uint256_t)a.get_value());
+        auto right((uint256_t)b.get_value());
+
+        field_pt a_accumulator(barretenberg::fr::zero());
+        field_pt b_accumulator(barretenberg::fr::zero());
 
         field_pt res(ctx, 0);
         for (size_t i = 0; i < num_chunks; ++i) {
-            uint256_t left_chunk = left & ((uint256_t(1) << 32) - 1);
-            uint256_t right_chunk = right & ((uint256_t(1) << 32) - 1);
-
-            const field_pt a_chunk = witness_pt(ctx, left_chunk);
-            const field_pt b_chunk = witness_pt(ctx, right_chunk);
+            size_t chunk_size = (i != num_chunks - 1) ? 32 : num_bits - i * 32;
+            auto [left_chunk, right_chunk] = get_chunk(left, right, chunk_size);
 
+            field_pt a_chunk = witness_pt(ctx, left_chunk);
+            field_pt b_chunk = witness_pt(ctx, right_chunk);
             field_pt result_chunk = 0;
             if (is_xor_gate) {
                 result_chunk =
                     stdlib::plookup_read::read_from_2_to_1_table(plookup::MultiTableId::UINT32_XOR, a_chunk, b_chunk);
+
             } else {
                 result_chunk =
                     stdlib::plookup_read::read_from_2_to_1_table(plookup::MultiTableId::UINT32_AND, a_chunk, b_chunk);
             }
 
-            uint256_t scaling_factor = uint256_t(1) << (32 * i);
-            res += result_chunk * scaling_factor;
+            auto scaling_factor = uint256_t(1) << (32 * i);
+            a_accumulator += a_chunk * scaling_factor;
+            b_accumulator += b_chunk * scaling_factor;
 
-            if (i == num_chunks - 1) {
-                const size_t final_num_bits = num_bits - (i * 32);
-                if (final_num_bits != 32) {
-                    ctx->create_range_constraint(a_chunk.witness_index, final_num_bits, "bad range on a");
-                    ctx->create_range_constraint(b_chunk.witness_index, final_num_bits, "bad range on b");
-                }
+            if (chunk_size != 32) {
+                ctx->create_range_constraint(
+                    a_chunk.witness_index, chunk_size, "stdlib logic: bad range on final chunk of left operand");
+                ctx->create_range_constraint(
+                    b_chunk.witness_index, chunk_size, "stdlib logic: bad range on final chunk of right operand");
             }
 
+            res += result_chunk * scaling_factor;
+
             left = left >> 32;
             right = right >> 32;
         }
+        field_pt a_slice = a.slice(static_cast<uint8_t>(num_bits - 1), 0)[1];
+        field_pt b_slice = b.slice(static_cast<uint8_t>(num_bits - 1), 0)[1];
+        a_slice.assert_equal(a_accumulator, "stdlib logic: failed to reconstruct left operand");
+        b_slice.assert_equal(b_accumulator, "stdlib logic: failed to reconstruct right operand");
 
         return res;
     } else {
+        // If the composer doesn't have lookups we call the expensive logic constraint gate
+        // which creates constraints for each bit. We only create constraints up to num_bits.
         Composer* ctx = a.get_context();
+        field_pt a_slice = a.slice(static_cast<uint8_t>(num_bits - 1), 0)[1];
+        field_pt b_slice = b.slice(static_cast<uint8_t>(num_bits - 1), 0)[1];
         auto accumulator_triple = ctx->create_logic_constraint(
-            a.normalize().get_witness_index(), b.normalize().get_witness_index(), num_bits, is_xor_gate);
+            a_slice.normalize().get_witness_index(), b_slice.normalize().get_witness_index(), num_bits, is_xor_gate);
         auto out_idx = accumulator_triple.out[accumulator_triple.out.size() - 1];
         return field_t<Composer>::from_witness_index(ctx, out_idx);
     }
diff --git a/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp b/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp
index 2b8b99d560..1ec450de00 100644
--- a/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp
+++ b/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp
@@ -1,17 +1,31 @@
 #pragma once
+#include "barretenberg/numeric/uint256/uint256.hpp"
 #include "barretenberg/stdlib/primitives/composers/composers_fwd.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
 #include "barretenberg/stdlib/primitives/witness/witness.hpp"
+#include <cstdint>
+#include <functional>
+#include <utility>
 
 namespace proof_system::plonk::stdlib {
 
 template <typename Composer> class logic {
-  private:
+  public:
     using field_pt = field_t<Composer>;
     using witness_pt = witness_t<Composer>;
 
   public:
-    static field_pt create_logic_constraint(field_pt& a, field_pt& b, size_t num_bits, bool is_xor_gate);
+    static field_pt create_logic_constraint(
+        field_pt& a,
+        field_pt& b,
+        size_t num_bits,
+        bool is_xor_gate,
+        const std::function<std::pair<uint256_t, uint256_t>(uint256_t, uint256_t, size_t)>& get_chunk =
+            [](uint256_t left, uint256_t right, size_t chunk_size) {
+                uint256_t left_chunk = left & ((uint256_t(1) << chunk_size) - 1);
+                uint256_t right_chunk = right & ((uint256_t(1) << chunk_size) - 1);
+                return std::make_pair(left_chunk, right_chunk);
+            });
 };
 
 EXTERN_STDLIB_TYPE(logic);
diff --git a/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp b/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp
index bf1dd73e5f..188a32980c 100644
--- a/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp
@@ -1,6 +1,7 @@
 #include "../bool/bool.hpp"
+#include "barretenberg/numeric/uint256/uint256.hpp"
+#include "barretenberg/proof_system/types/composer_type.hpp"
 #include "logic.hpp"
-#include "barretenberg/plonk/proof_system/constants.hpp"
 #include <gtest/gtest.h>
 #include "barretenberg/honk/composer/standard_honk_composer.hpp"
 #include "barretenberg/plonk/composer/standard_composer.hpp"
@@ -8,6 +9,15 @@
 #include "barretenberg/plonk/composer/turbo_composer.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
 
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+
+#define STDLIB_TYPE_ALIASES                                                                                            \
+    using Composer = TypeParam;                                                                                        \
+    using witness_ct = stdlib::witness_t<Composer>;                                                                    \
+    using field_ct = stdlib::field_t<Composer>;                                                                        \
+    using bool_ct = stdlib::bool_t<Composer>;                                                                          \
+    using public_witness_ct = stdlib::public_witness_t<Composer>;
+
 namespace test_stdlib_logic {
 
 namespace {
@@ -19,81 +29,137 @@ template <class T> void ignore_unused(T&) {} // use to ignore unused variables i
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
-template <typename Composer> class stdlib_logic : public testing::Test {
-    typedef stdlib::bool_t<Composer> bool_ct;
-    typedef stdlib::field_t<Composer> field_ct;
-    typedef stdlib::witness_t<Composer> witness_ct;
-    typedef stdlib::public_witness_t<Composer> public_witness_ct;
-
-  public:
-    /**
-     * @brief Test logic
-     */
-    static void test_logic()
-    {
-        Composer composer;
-        auto run_test = [&](size_t num_bits) {
-            uint256_t mask = (uint256_t(1) << num_bits) - 1;
-
-            uint256_t a = engine.get_random_uint256() & mask;
-            uint256_t b = engine.get_random_uint256() & mask;
-
-            uint256_t and_expected = a & b;
-            uint256_t xor_expected = a ^ b;
-
-            field_ct x = witness_ct(&composer, a);
-            field_ct y = witness_ct(&composer, b);
-
-            field_ct x_const(&composer, a);
-            field_ct y_const(&composer, b);
-            field_ct and_result = stdlib::logic<Composer>::create_logic_constraint(x, y, num_bits, false);
-            field_ct xor_result = stdlib::logic<Composer>::create_logic_constraint(x, y, num_bits, true);
-
-            field_ct and_result_left_constant =
-                stdlib::logic<Composer>::create_logic_constraint(x_const, y, num_bits, false);
-            field_ct xor_result_left_constant =
-                stdlib::logic<Composer>::create_logic_constraint(x_const, y, num_bits, true);
-
-            field_ct and_result_right_constant =
-                stdlib::logic<Composer>::create_logic_constraint(x, y_const, num_bits, false);
-            field_ct xor_result_right_constant =
-                stdlib::logic<Composer>::create_logic_constraint(x, y_const, num_bits, true);
-
-            field_ct and_result_both_constant =
-                stdlib::logic<Composer>::create_logic_constraint(x_const, y_const, num_bits, false);
-            field_ct xor_result_both_constant =
-                stdlib::logic<Composer>::create_logic_constraint(x_const, y_const, num_bits, true);
-
-            EXPECT_EQ(uint256_t(and_result.get_value()), and_expected);
-            EXPECT_EQ(uint256_t(and_result_left_constant.get_value()), and_expected);
-            EXPECT_EQ(uint256_t(and_result_right_constant.get_value()), and_expected);
-            EXPECT_EQ(uint256_t(and_result_both_constant.get_value()), and_expected);
-
-            EXPECT_EQ(uint256_t(xor_result.get_value()), xor_expected);
-            EXPECT_EQ(uint256_t(xor_result_left_constant.get_value()), xor_expected);
-            EXPECT_EQ(uint256_t(xor_result_right_constant.get_value()), xor_expected);
-            EXPECT_EQ(uint256_t(xor_result_both_constant.get_value()), xor_expected);
-        };
-
-        for (size_t i = 8; i < 248; i += 8) {
-            run_test(i);
-        }
-        auto prover = composer.create_prover();
-        plonk::proof proof = prover.construct_proof();
-        auto verifier = composer.create_verifier();
-        bool result = verifier.verify_proof(proof);
+template <class Composer> class LogicTest : public testing::Test {};
 
-        EXPECT_EQ(result, true);
-    }
-};
+using ComposerTypes =
+    ::testing::Types<honk::StandardHonkComposer, plonk::StandardComposer, plonk::TurboComposer, plonk::UltraComposer>;
+
+TYPED_TEST_SUITE(LogicTest, ComposerTypes);
+
+TYPED_TEST(LogicTest, TestCorrectLogic)
+{
+    STDLIB_TYPE_ALIASES
+
+    auto run_test = [](size_t num_bits, Composer& composer) {
+        uint256_t mask = (uint256_t(1) << num_bits) - 1;
+
+        uint256_t a = engine.get_random_uint256() & mask;
+        uint256_t b = engine.get_random_uint256() & mask;
+
+        uint256_t and_expected = a & b;
+        uint256_t xor_expected = a ^ b;
+
+        field_ct x = witness_ct(&composer, a);
+        field_ct y = witness_ct(&composer, b);
+
+        field_ct x_const(&composer, a);
+        field_ct y_const(&composer, b);
+
+        field_ct and_result = stdlib::logic<Composer>::create_logic_constraint(x, y, num_bits, false);
+        field_ct xor_result = stdlib::logic<Composer>::create_logic_constraint(x, y, num_bits, true);
+
+        field_ct and_result_left_constant =
+            stdlib::logic<Composer>::create_logic_constraint(x_const, y, num_bits, false);
+        field_ct xor_result_left_constant =
+            stdlib::logic<Composer>::create_logic_constraint(x_const, y, num_bits, true);
 
-typedef testing::Types<plonk::UltraComposer, plonk::TurboComposer, plonk::StandardComposer, honk::StandardHonkComposer>
-    ComposerTypes;
+        field_ct and_result_right_constant =
+            stdlib::logic<Composer>::create_logic_constraint(x, y_const, num_bits, false);
+        field_ct xor_result_right_constant =
+            stdlib::logic<Composer>::create_logic_constraint(x, y_const, num_bits, true);
 
-TYPED_TEST_SUITE(stdlib_logic, ComposerTypes);
+        field_ct and_result_both_constant =
+            stdlib::logic<Composer>::create_logic_constraint(x_const, y_const, num_bits, false);
+        field_ct xor_result_both_constant =
+            stdlib::logic<Composer>::create_logic_constraint(x_const, y_const, num_bits, true);
 
-TYPED_TEST(stdlib_logic, test_logic)
+        EXPECT_EQ(uint256_t(and_result.get_value()), and_expected);
+        EXPECT_EQ(uint256_t(and_result_left_constant.get_value()), and_expected);
+        EXPECT_EQ(uint256_t(and_result_right_constant.get_value()), and_expected);
+        EXPECT_EQ(uint256_t(and_result_both_constant.get_value()), and_expected);
+
+        EXPECT_EQ(uint256_t(xor_result.get_value()), xor_expected);
+        EXPECT_EQ(uint256_t(xor_result_left_constant.get_value()), xor_expected);
+        EXPECT_EQ(uint256_t(xor_result_right_constant.get_value()), xor_expected);
+        EXPECT_EQ(uint256_t(xor_result_both_constant.get_value()), xor_expected);
+    };
+
+    auto composer = Composer();
+    for (size_t i = 8; i < 248; i += 8) {
+        run_test(8, composer);
+    }
+    auto prover = composer.create_prover();
+    plonk::proof proof = prover.construct_proof();
+    auto verifier = composer.create_verifier();
+    bool result = verifier.verify_proof(proof);
+    EXPECT_EQ(result, true);
+}
+
+// Tests the constraints will fail if the operands are larger than expected even though the result contains the correct
+// number of bits when using the UltraComposer This is because the range constraints on the right and left operand are
+// not being satisfied.
+TYPED_TEST(LogicTest, LargeOperands)
+{
+    STDLIB_TYPE_ALIASES
+    auto composer = Composer();
+
+    uint256_t mask = (uint256_t(1) << 48) - 1;
+    uint256_t a = engine.get_random_uint256() & mask;
+    uint256_t b = engine.get_random_uint256() & mask;
+
+    uint256_t expected_mask = (uint256_t(1) << 40) - 1;
+    uint256_t and_expected = (a & b) & expected_mask;
+    uint256_t xor_expected = (a ^ b) & expected_mask;
+
+    field_ct x = witness_ct(&composer, a);
+    field_ct y = witness_ct(&composer, b);
+
+    field_ct xor_result = stdlib::logic<Composer>::create_logic_constraint(x, y, 40, true);
+    field_ct and_result = stdlib::logic<Composer>::create_logic_constraint(x, y, 40, false);
+    EXPECT_EQ(uint256_t(and_result.get_value()), and_expected);
+    EXPECT_EQ(uint256_t(xor_result.get_value()), xor_expected);
+
+    auto prover = composer.create_prover();
+    plonk::proof proof = prover.construct_proof();
+    auto verifier = composer.create_verifier();
+    bool result = verifier.verify_proof(proof);
+    EXPECT_EQ(result, true);
+}
+
+// Ensures that malicious witnesses which produce the same result are detected. This potential security issue cannot
+// happen if the composer doesn't support lookup gates because constraints will be created for each bit of the left and
+// right operand.
+TYPED_TEST(LogicTest, DifferentWitnessSameResult)
 {
-    TestFixture::test_logic();
+
+    STDLIB_TYPE_ALIASES
+    auto composer = Composer();
+    if (Composer::type == ComposerType::PLOOKUP) {
+        uint256_t a = 3758096391;
+        uint256_t b = 2147483649;
+        field_ct x = witness_ct(&composer, uint256_t(a));
+        field_ct y = witness_ct(&composer, uint256_t(b));
+
+        uint256_t xor_expected = a ^ b;
+        const std::function<std::pair<uint256_t, uint256_t>(uint256_t, uint256_t, size_t)>& get_bad_chunk =
+            [](uint256_t left, uint256_t right, size_t chunk_size) {
+                (void)left;
+                (void)right;
+                (void)chunk_size;
+                auto left_chunk = uint256_t(2684354565);
+                auto right_chunk = uint256_t(3221225475);
+                return std::make_pair(left_chunk, right_chunk);
+            };
+
+        field_ct xor_result = stdlib::logic<Composer>::create_logic_constraint(x, y, 32, true, get_bad_chunk);
+        EXPECT_EQ(uint256_t(xor_result.get_value()), xor_expected);
+
+        auto prover = composer.create_prover();
+        plonk::proof proof = prover.construct_proof();
+        auto verifier = composer.create_verifier();
+        bool result = verifier.verify_proof(proof);
+        EXPECT_EQ(result, false);
+    }
 }
+
 } // namespace test_stdlib_logic
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
index db3d95c51b..a411e64837 100644
--- a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
@@ -183,7 +183,7 @@ template <typename Composer> class Transcript {
         }
         const size_t bytes_per_element = 31;
 
-        // split work_element into 2 limbs and insert into element_buffer
+        // split element into 2 limbs and insert into element_buffer
         // each entry in element_buffer is 31 bytes
         const auto split = [&](field_pt& work_element,
                                std::vector<field_pt>& element_buffer,
@@ -301,8 +301,23 @@ template <typename Composer> class Transcript {
         }
         byte_array<Composer> compressed_buffer(T0);
 
-        byte_array<Composer> base_hash = stdlib::blake3s(compressed_buffer);
-
+        // TODO(@zac-williamson) make this a Poseidon hash
+        byte_array<Composer> base_hash;
+        if constexpr (Composer::type == ComposerType::PLOOKUP) {
+            std::vector<field_pt> compression_buffer;
+            field_pt working_element(context);
+            size_t byte_counter = 0;
+            split(working_element, compression_buffer, field_pt(compressed_buffer), byte_counter, 32);
+            if (byte_counter != 0) {
+                const uint256_t down_shift = uint256_t(1) << uint256_t((bytes_per_element - byte_counter) * 8);
+                working_element = working_element / barretenberg::fr(down_shift);
+                working_element = working_element.normalize();
+                compression_buffer.push_back(working_element);
+            }
+            base_hash = stdlib::pedersen_plookup_commitment<Composer>::compress(compression_buffer);
+        } else {
+            base_hash = stdlib::blake3s(compressed_buffer);
+        }
         byte_array<Composer> first(field_pt(0), 16);
         first.write(base_hash.slice(0, 16));
         round_challenges.push_back(first);
@@ -313,11 +328,30 @@ template <typename Composer> class Transcript {
             round_challenges.push_back(second);
         }
 
+        // This block of code only executes for num_challenges > 2, which (currently) only happens in the nu round when
+        // we need to generate short scalars. In this case, we generate 32-byte challenges and split them in half to get
+        // the relevant challenges.
         for (size_t i = 2; i < num_challenges; i += 2) {
             byte_array<Composer> rolling_buffer = base_hash;
-            rolling_buffer.write(byte_array<Composer>(field_pt(i / 2), 1));
-            byte_array<Composer> hash_output = stdlib::blake3s(rolling_buffer);
-
+            byte_array<Composer> hash_output;
+            if constexpr (Composer::type == ComposerType::PLOOKUP) {
+                // TODO(@zac-williamson) make this a Poseidon hash not a Pedersen hash
+                std::vector<field_pt> compression_buffer;
+                field_pt working_element(context);
+                size_t byte_counter = 0;
+                split(working_element, compression_buffer, field_pt(rolling_buffer), byte_counter, 32);
+                split(working_element, compression_buffer, field_pt(field_pt(i / 2)), byte_counter, 1);
+                if (byte_counter != 0) {
+                    const uint256_t down_shift = uint256_t(1) << uint256_t((bytes_per_element - byte_counter) * 8);
+                    working_element = working_element / barretenberg::fr(down_shift);
+                    working_element = working_element.normalize();
+                    compression_buffer.push_back(working_element);
+                }
+                hash_output = stdlib::pedersen_plookup_commitment<Composer>::compress(compression_buffer);
+            } else {
+                rolling_buffer.write(byte_array<Composer>(field_pt(i / 2), 1));
+                hash_output = stdlib::blake3s(rolling_buffer);
+            }
             byte_array<Composer> hi(field_pt(0), 16);
             hi.write(hash_output.slice(0, 16));
             round_challenges.push_back(hi);
diff --git a/cpp/src/barretenberg/transcript/transcript.cpp b/cpp/src/barretenberg/transcript/transcript.cpp
index 91349628b9..9c448949c9 100644
--- a/cpp/src/barretenberg/transcript/transcript.cpp
+++ b/cpp/src/barretenberg/transcript/transcript.cpp
@@ -54,6 +54,19 @@ std::array<uint8_t, Blake3sHasher::PRNG_OUTPUT_SIZE> Blake3sHasher::hash(std::ve
     return result;
 }
 
+std::array<uint8_t, Blake3sHasher::PRNG_OUTPUT_SIZE> Blake3sHasher::hash_plookup(std::vector<uint8_t> const& buffer)
+{
+    // TODO(@zac-williamson) Change to call a Poseidon hash and create a PoseidonHasher
+    // (not making the name change right now as it will break concurrent work w. getting recursion working in Noir)
+    // We also need to implement a Poseidon gadget
+    std::vector<uint8_t> compressed_buffer = crypto::pedersen_commitment::lookup::compress_native(buffer);
+    std::array<uint8_t, PRNG_OUTPUT_SIZE> result;
+    for (size_t i = 0; i < PRNG_OUTPUT_SIZE; ++i) {
+        result[i] = compressed_buffer[i];
+    }
+    return result;
+}
+
 Transcript::Transcript(const std::vector<uint8_t>& input_transcript,
                        const Manifest input_manifest,
                        const HashType hash_type,
@@ -219,7 +232,7 @@ void Transcript::apply_fiat_shamir(const std::string& challenge_name /*, const b
     }
     case HashType::PlookupPedersenBlake3s: {
         std::vector<uint8_t> compressed_buffer = crypto::pedersen_commitment::lookup::compress_native(buffer);
-        base_hash = Blake3sHasher::hash(compressed_buffer);
+        base_hash = Blake3sHasher::hash_plookup(compressed_buffer);
         break;
     }
     default: {
@@ -269,7 +282,7 @@ void Transcript::apply_fiat_shamir(const std::string& challenge_name /*, const b
             break;
         }
         case HashType::PlookupPedersenBlake3s: {
-            hash_output = Blake3sHasher::hash(rolling_buffer);
+            hash_output = Blake3sHasher::hash_plookup(rolling_buffer);
             break;
         }
         default: {
diff --git a/cpp/src/barretenberg/transcript/transcript.hpp b/cpp/src/barretenberg/transcript/transcript.hpp
index 43d47e3972..92c73c77e4 100644
--- a/cpp/src/barretenberg/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/transcript/transcript.hpp
@@ -22,6 +22,7 @@ struct Blake3sHasher {
     static constexpr size_t PRNG_OUTPUT_SIZE = 32;
 
     static std::array<uint8_t, PRNG_OUTPUT_SIZE> hash(std::vector<uint8_t> const& input);
+    static std::array<uint8_t, PRNG_OUTPUT_SIZE> hash_plookup(std::vector<uint8_t> const& input);
 };
 
 enum HashType { Keccak256, PedersenBlake3s, PlookupPedersenBlake3s };

From 25f55742a84533a0e566da26356a755e5e68389f Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 25 Apr 2023 18:11:40 +0000
Subject: [PATCH 11/64] EnvReferenceString undefined reference to  error
 workaround

---
 cpp/src/barretenberg/env/crs.cpp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/cpp/src/barretenberg/env/crs.cpp b/cpp/src/barretenberg/env/crs.cpp
index 80561d1c09..47e6b52b0a 100644
--- a/cpp/src/barretenberg/env/crs.cpp
+++ b/cpp/src/barretenberg/env/crs.cpp
@@ -3,17 +3,19 @@
 #include "crs.hpp"
 
 #include "barretenberg/srs/reference_string/file_reference_string.hpp"
+// TODO: Will get `undefined reference to `bbmalloc'` error when linking
 #include "barretenberg/ecc/curves/bn254/scalar_multiplication/c_bind.hpp"
+#include "barretenberg/common/mem.hpp"
 
 const int NUM_POINTS_IN_TRANSCRIPT = 5040001;
 
-
 extern "C" {
 /**
  * @brief In WASM, loads the verifier reference string.
  * Used in native code to quickly create an in-memory reference string.
  */
-uint8_t* env_load_verifier_crs() {
+uint8_t* env_load_verifier_crs()
+{
     std::ifstream transcript;
     transcript.open("../srs_db/ignition/monomial/transcript00.dat", std::ifstream::binary);
     // We need two g2 points, each 64 bytes.
@@ -22,7 +24,7 @@ uint8_t* env_load_verifier_crs() {
     transcript.seekg(28 + NUM_POINTS_IN_TRANSCRIPT * 64);
     transcript.read((char*)g2_points.data(), (std::streamsize)g2_points_size);
     transcript.close();
-    auto* g2_points_copy = (uint8_t*)bbmalloc(g2_points_size);
+    auto* g2_points_copy = (uint8_t*)aligned_alloc(64, g2_points_size);
     memcpy(g2_points_copy, g2_points.data(), g2_points_size);
     return g2_points_copy;
 }
@@ -33,20 +35,20 @@ uint8_t* env_load_verifier_crs() {
  * In native code, not intended to be used.
  * @param num_points The number of points to load.
  */
-uint8_t* env_load_prover_crs(size_t num_points) {
+uint8_t* env_load_prover_crs(size_t num_points)
+{
     // Note: This implementation is only meant to be instructive.
     // This should only be used in c-binds to implement the C++ abstractions.
     std::ifstream transcript;
     transcript.open("../srs_db/ignition/monomial/transcript00.dat", std::ifstream::binary);
     // Each g1 point is 64 bytes.
-    size_t g1_points_size = (num_points) * 64;
+    size_t g1_points_size = (num_points)*64;
     std::vector<uint8_t> g1_points(g1_points_size);
     transcript.seekg(28);
     transcript.read((char*)g1_points.data(), (std::streamsize)g1_points_size);
     transcript.close();
-    auto* g1_points_copy = (uint8_t*)bbmalloc(g1_points_size);
+    auto* g1_points_copy = (uint8_t*)aligned_alloc(64, g1_points_size);
     memcpy(g1_points_copy, g1_points.data(), g1_points_size);
     return g1_points_copy;
 }
-
 }
\ No newline at end of file

From 1c8cc772b123088e81a8589d5df50deb963f84dd Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 25 Apr 2023 18:23:02 +0000
Subject: [PATCH 12/64] add missing recursion_constraint field from acir_format
 tests

---
 cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
index 5c17c353c1..5c6534750a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
@@ -31,6 +31,7 @@ TEST(acir_format, test_a_single_constraint_no_pub_inputs)
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .merkle_membership_constraints = {},
+        .recursion_constraints = {},
         .constraints = { constraint },
     };
 
@@ -129,6 +130,7 @@ TEST(acir_format, test_logic_gate_from_noir_circuit)
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .merkle_membership_constraints = {},
+        .recursion_constraints = {},
         .constraints = { expr_a, expr_b, expr_c, expr_d },
     };
 
@@ -193,6 +195,7 @@ TEST(acir_format, test_schnorr_verify_pass)
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .merkle_membership_constraints = {},
+        .recursion_constraints = {},
         .constraints = { poly_triple{
             .a = schnorr_constraint.result,
             .b = schnorr_constraint.result,
@@ -262,6 +265,7 @@ TEST(acir_format, test_schnorr_verify_small_range)
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .merkle_membership_constraints = {},
+        .recursion_constraints = {},
         .constraints = { poly_triple{
             .a = schnorr_constraint.result,
             .b = schnorr_constraint.result,

From 6109828cb940f8a1155d0f605b88037a504d44cb Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 25 Apr 2023 18:26:51 +0000
Subject: [PATCH 13/64] add recursion_constraints field back in
 acir_proofs.test inner circuit

---
 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index b344086ca3..cb73eea86e 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -87,6 +87,7 @@ void create_inner_circuit(acir_format::acir_format& constraint_system, std::vect
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .merkle_membership_constraints = {},
+        .recursion_constraints = {},
         .constraints = { expr_a, expr_b, expr_c, expr_d },
     };
 

From 8358741f881a3b28534f0f9f7584d59266cedc86 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 25 Apr 2023 18:29:50 +0000
Subject: [PATCH 14/64] fix inner circuit in
 RecursionConstraint.TestRecursionConstraint

---
 .../barretenberg/dsl/acir_format/recursion_constraint.test.cpp   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index 2b23dcfa07..1b49c0f128 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -92,6 +92,7 @@ acir_format::Composer create_inner_circuit()
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .merkle_membership_constraints = {},
+        .recursion_constraints = {},
         .constraints = { expr_a, expr_b, expr_c, expr_d },
     };
 

From 551277ba5d73667bbc3921585e7da2c5b9ada2b8 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 25 Apr 2023 15:23:26 -0400
Subject: [PATCH 15/64] Empty-Commit


From ce46c01cf5d716810062ce848d0e78f6d04e0a28 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Thu, 27 Apr 2023 23:19:50 -0400
Subject: [PATCH 16/64] add verify_recursive_proof method for simulating
 recursive verification in the ACVM

---
 .../dsl/acir_proofs/acir_proofs.cpp           | 91 ++++++++++++++++++-
 .../dsl/acir_proofs/acir_proofs.hpp           |  7 ++
 .../dsl/acir_proofs/acir_proofs.test.cpp      |  2 +
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   | 16 ++++
 .../barretenberg/dsl/acir_proofs/c_bind.hpp   |  7 ++
 5 files changed, 121 insertions(+), 2 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 54ff5c9aa0..26ba502cd5 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -5,6 +5,7 @@
 #include "barretenberg/dsl/types.hpp"
 #include "barretenberg/srs/reference_string/pippenger_reference_string.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/sol_gen.hpp"
+#include "barretenberg/stdlib/recursion/verifier/verifier.hpp"
 
 namespace acir_proofs {
 
@@ -228,8 +229,9 @@ bool verify_proof(uint8_t const* g2x,
         plonk::proof pp = { std::vector<uint8_t>(proof, proof + length) };
 
         // For inner circuit use recursive prover and verifier, then for outer circuit use the normal prover and
-        // verifier Either need a context flag for recursive verify or a new_recursive_verify_proof method that uses
-        // regular UltraVerifier
+        // verifier.
+        // Either need a context flag for recursive verify or a new_recursive_verify_proof method that uses regular
+        // UltraVerifier
         if (is_recursive) {
             auto verifier = composer.create_verifier();
             verified = verifier.verify_proof(pp);
@@ -247,4 +249,89 @@ bool verify_proof(uint8_t const* g2x,
     return verified;
 }
 
+/**
+ * @brief Enables simulation of recursion in the ACVM. In order to be able to simulate execute of ACIR,
+ *        a DSL needs to be able to insert into a circuit's witness the correct output aggregation state of a recursive
+ * verification. The resulting aggergation state is what will be compared against in the recursion constraint.
+ *
+ * @param proof_buf - The proof to be verified
+ * @param proof_length - The length of the proof to enable reading the proof from buffer
+ * @param vk_buf - The verification key of the circuit being verified
+ * @param vk_length - The length of the verification eky to enable reading the proof from buffer
+ * @param public_inputs_buf - The public inputs of the proof being verified. To be included when construct the input
+ * aggregation state
+ * @param input_aggregation_obj_buf - The fields represnting the two G1 points that must be fed into a pairing.
+ *                                    This will be empty if this is the first proof to be recursively.
+ * @param output_aggregation_obj_buf - Two G1 points that the top-level verifier needs to run a pairing upon to complete
+ * verification
+ */
+size_t verify_recursive_proof(uint8_t const* proof_buf,
+                              uint32_t proof_length,
+                              uint8_t const* vk_buf,
+                              uint32_t vk_length,
+                              uint8_t const* public_inputs_buf,
+                              uint8_t const* input_aggregation_obj_buf,
+                              uint8_t** output_aggregation_obj_buf)
+{
+    // TODO: not doing anything with public_inputs_buf right now because we only have one layer of recursion
+    // and the previous aggregation state will be empty. When arbitrary depth recursion is available we will have to
+    // construct the correct input aggregation_state_ct
+    (void)public_inputs_buf;
+    (void)input_aggregation_obj_buf;
+
+    acir_format::aggregation_state_ct previous_aggregation;
+    previous_aggregation.has_data = false;
+
+    std::vector<acir_format::field_ct> proof_fields(proof_length / 32);
+    std::vector<acir_format::field_ct> key_fields(vk_length / 32);
+    for (size_t i = 0; i < proof_length / 32; i++) {
+        proof_fields[i] = acir_format::field_ct(barretenberg::fr::serialize_from_buffer(&proof_buf[i * 32]));
+    }
+    for (size_t i = 0; i < vk_length / 32; i++) {
+        key_fields[i] = acir_format::field_ct(barretenberg::fr::serialize_from_buffer(&vk_buf[i * 32]));
+    }
+
+    acir_format::Composer composer;
+
+    transcript::Manifest manifest = acir_format::Composer::create_unrolled_manifest(1);
+    // We currently only support RecursionConstraint where inner_proof_contains_recursive_proof = false.
+    // We would either need a separate ACIR opcode where inner_proof_contains_recursive_proof = true,
+    // or we need non-witness data to be provided as metadata in the ACIR opcode
+    std::shared_ptr<acir_format::verification_key_ct> vkey =
+        acir_format::verification_key_ct::template from_field_pt_vector<false>(&composer, key_fields);
+    vkey->program_width = acir_format::noir_recursive_settings::program_width;
+    acir_format::Transcript_ct transcript(&composer, manifest, proof_fields, 1);
+    acir_format::aggregation_state_ct result =
+        proof_system::plonk::stdlib::recursion::verify_proof_<acir_format::bn254, acir_format::noir_recursive_settings>(
+            &composer, vkey, transcript, previous_aggregation);
+
+    // just writing the output aggregation G1 elements, and no public inputs, proof witnesses, or any other data
+    const size_t output_size_bytes = 16 * sizeof(barretenberg::fr);
+    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
+
+    for (size_t i = 0; i < 4; ++i) {
+        auto field = result.P0.x.binary_basis_limbs[i].element.get_value();
+        barretenberg::fr::serialize_to_buffer(field, &raw_buf[i * 32]);
+    }
+
+    for (size_t i = 4; i < 8; ++i) {
+        auto field = result.P0.y.binary_basis_limbs[i % 4].element.get_value();
+        barretenberg::fr::serialize_to_buffer(field, &raw_buf[i * 32]);
+    }
+
+    for (size_t i = 8; i < 12; ++i) {
+        auto field = result.P1.x.binary_basis_limbs[i % 4].element.get_value();
+        barretenberg::fr::serialize_to_buffer(field, &raw_buf[i * 32]);
+    }
+
+    for (size_t i = 12; i < 16; ++i) {
+        auto field = result.P1.y.binary_basis_limbs[i % 4].element.get_value();
+        barretenberg::fr::serialize_to_buffer(field, &raw_buf[i * 32]);
+    }
+
+    *output_aggregation_obj_buf = raw_buf;
+
+    return output_size_bytes;
+}
+
 } // namespace acir_proofs
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
index 95556f11a7..e37756a5d6 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
@@ -28,5 +28,12 @@ bool verify_proof(uint8_t const* g2x,
                   uint8_t* proof,
                   uint32_t length,
                   bool is_recursive);
+size_t verify_recursive_proof(uint8_t const* proof_buf,
+                              uint32_t proof_length,
+                              uint8_t const* vk_buf,
+                              uint32_t vk_length,
+                              uint8_t const* public_inputs_buf,
+                              uint8_t const* input_aggregation_obj_buf,
+                              uint8_t** output_aggregation_obj_buf);
 
 } // namespace acir_proofs
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index cb73eea86e..4aaa74c59b 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -251,6 +251,8 @@ TEST(AcirProofs, TestSerializationWithRecursion)
             .q_c = -vk_hash_value,
         };
 
+        std::cout << "vk_hash_value: " << vk_hash_value << std::endl;
+
         std::vector<fr> witness;
         for (size_t i = 0; i < 18; ++i) {
             witness.emplace_back(0);
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index ac26be3fd7..5ff7b29d96 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -72,4 +72,20 @@ WASM_EXPORT bool acir_proofs_verify_proof(uint8_t const* g2x,
 {
     return acir_proofs::verify_proof(g2x, vk_buf, constraint_system_buf, proof, length, is_recursive);
 }
+WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
+                                                      uint32_t proof_length,
+                                                      uint8_t const* vk_buf,
+                                                      uint32_t vk_length,
+                                                      uint8_t const* public_inputs_buf,
+                                                      uint8_t const* input_aggregation_obj_buf,
+                                                      uint8_t** output_aggregation_obj_buf)
+{
+    return acir_proofs::verify_recursive_proof(proof_buf,
+                                               proof_length,
+                                               vk_buf,
+                                               vk_length,
+                                               public_inputs_buf,
+                                               input_aggregation_obj_buf,
+                                               output_aggregation_obj_buf);
+}
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index 39591b37d1..0db08d5573 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -34,4 +34,11 @@ WASM_EXPORT bool acir_proofs_verify_proof(uint8_t const* g2x,
                                           uint8_t* proof,
                                           uint32_t length,
                                           bool is_recursive);
+WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
+                                                      uint32_t proof_length,
+                                                      uint8_t const* vk_buf,
+                                                      uint32_t vk_length,
+                                                      uint8_t const* public_inputs_buf,
+                                                      uint8_t const* input_aggregation_obj_buf,
+                                                      uint8_t** output_aggregation_obj_buf);
 }

From 11e97beb64195b6b0d1b432bc9bd62e6cb77dbc5 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 28 Apr 2023 20:20:14 +0000
Subject: [PATCH 17/64] add ecc module to env package to fix linking of
 ennv_load_prover_crs and env_load_verifier_crs

---
 cpp/src/barretenberg/env/CMakeLists.txt | 2 +-
 cpp/src/barretenberg/env/crs.cpp        | 6 ++----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/cpp/src/barretenberg/env/CMakeLists.txt b/cpp/src/barretenberg/env/CMakeLists.txt
index f4a8428e63..e084984b85 100644
--- a/cpp/src/barretenberg/env/CMakeLists.txt
+++ b/cpp/src/barretenberg/env/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(env)
\ No newline at end of file
+barretenberg_module(env ecc)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/env/crs.cpp b/cpp/src/barretenberg/env/crs.cpp
index 47e6b52b0a..923435057d 100644
--- a/cpp/src/barretenberg/env/crs.cpp
+++ b/cpp/src/barretenberg/env/crs.cpp
@@ -3,9 +3,7 @@
 #include "crs.hpp"
 
 #include "barretenberg/srs/reference_string/file_reference_string.hpp"
-// TODO: Will get `undefined reference to `bbmalloc'` error when linking
 #include "barretenberg/ecc/curves/bn254/scalar_multiplication/c_bind.hpp"
-#include "barretenberg/common/mem.hpp"
 
 const int NUM_POINTS_IN_TRANSCRIPT = 5040001;
 
@@ -24,7 +22,7 @@ uint8_t* env_load_verifier_crs()
     transcript.seekg(28 + NUM_POINTS_IN_TRANSCRIPT * 64);
     transcript.read((char*)g2_points.data(), (std::streamsize)g2_points_size);
     transcript.close();
-    auto* g2_points_copy = (uint8_t*)aligned_alloc(64, g2_points_size);
+    auto* g2_points_copy = (uint8_t*)bbmalloc(g2_points_size);
     memcpy(g2_points_copy, g2_points.data(), g2_points_size);
     return g2_points_copy;
 }
@@ -47,7 +45,7 @@ uint8_t* env_load_prover_crs(size_t num_points)
     transcript.seekg(28);
     transcript.read((char*)g1_points.data(), (std::streamsize)g1_points_size);
     transcript.close();
-    auto* g1_points_copy = (uint8_t*)aligned_alloc(64, g1_points_size);
+    auto* g1_points_copy = (uint8_t*)bbmalloc(g1_points_size);
     memcpy(g1_points_copy, g1_points.data(), g1_points_size);
     return g1_points_copy;
 }

From 941b27544c948bdb0c3ca0ae353dbea49c42e9c3 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 1 May 2023 15:31:57 +0000
Subject: [PATCH 18/64] add back reference strinng to stdlib recursion key to
 pass sol verifier generation tests

---
 cpp/src/barretenberg/solidity_helpers/CMakeLists.txt         | 2 +-
 .../solidity_helpers/circuits/recursive_circuit.hpp          | 5 ++---
 .../stdlib/recursion/verification_key/verification_key.hpp   | 4 +++-
 .../barretenberg/stdlib/recursion/verifier/verifier.test.cpp | 4 +++-
 4 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt b/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
index 085b5297e5..8ce6666afa 100644
--- a/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
+++ b/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
@@ -1,4 +1,4 @@
-barretenberg_module(stdlib_solidity_helpers plonk proof_system transcript crypto_pedersen_commitment polynomials crypto_sha256 ecc crypto_blake3s stdlib_primitives stdlib_pedersen_commitment stdlib_blake3s stdlib_blake2s)
+barretenberg_module(stdlib_solidity_helpers plonk proof_system transcript crypto_pedersen_commitment polynomials crypto_sha256 ecc crypto_blake3s stdlib_primitives stdlib_pedersen_commitment stdlib_blake3s stdlib_blake2s srs)
 
 add_executable(solidity_key_gen key_gen.cpp)
 
diff --git a/cpp/src/barretenberg/solidity_helpers/circuits/recursive_circuit.hpp b/cpp/src/barretenberg/solidity_helpers/circuits/recursive_circuit.hpp
index 1226db4ae6..9f2f7786c3 100644
--- a/cpp/src/barretenberg/solidity_helpers/circuits/recursive_circuit.hpp
+++ b/cpp/src/barretenberg/solidity_helpers/circuits/recursive_circuit.hpp
@@ -106,12 +106,11 @@ template <typename OuterComposer> class RecursiveCircuit {
   public:
     static OuterComposer generate(std::string srs_path, uint256_t inputs[])
     {
-        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
-
         InnerComposer inner_composer = InnerComposer(srs_path);
         OuterComposer outer_composer = OuterComposer(srs_path);
 
         create_inner_circuit_no_tables(inner_composer, inputs);
+
         auto circuit_output = create_outer_circuit(inner_composer, outer_composer);
 
         g1::affine_element P[2];
@@ -121,7 +120,7 @@ template <typename OuterComposer> class RecursiveCircuit {
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-            P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
+            P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
         if (inner_proof_result != barretenberg::fq12::one()) {
             throw_or_abort("inner proof result != 1");
diff --git a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index 48ce7c81ae..2cd486bbe1 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -174,6 +174,7 @@ template <typename Curve> struct verification_key {
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
         // Native data:
         key->context = ctx;
+        key->reference_string = input_key->reference_string;
         key->polynomial_manifest = input_key->polynomial_manifest;
 
         // Circuit types:
@@ -205,6 +206,7 @@ template <typename Curve> struct verification_key {
             key->commitments.insert({ tag, typename Curve::g1_ct(value) });
         }
 
+        key->reference_string = input_key->reference_string;
         key->polynomial_manifest = input_key->polynomial_manifest;
 
         return key;
@@ -328,7 +330,7 @@ template <typename Curve> struct verification_key {
     std::map<std::string, typename Curve::g1_ct> commitments;
 
     // Native data:
-
+    std::shared_ptr<VerifierReferenceString> reference_string;
     PolynomialManifest polynomial_manifest;
     // Used to check in the circuit if a proof contains any aggregated state.
     bool contains_recursive_proof = false;
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
index ad28907bfb..9b57f7f8a6 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
@@ -287,13 +287,15 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         create_inner_circuit(inner_composer, inner_inputs);
 
         auto circuit_output = create_outer_circuit(inner_composer, outer_composer);
+        std::cout << "circuit_output: " << circuit_output.aggregation_state << std::endl;
 
         g1::affine_element P[2];
         P[0].x = barretenberg::fq(circuit_output.aggregation_state.P0.x.get_value().lo);
         P[0].y = barretenberg::fq(circuit_output.aggregation_state.P0.y.get_value().lo);
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
-
+        auto g2_lines = env_crs->get_verifier_crs()->get_precomputed_g2_lines();
+        std::cout << "precompute g2 lines: " << g2_lines << std::endl;
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 

From 6d86e39d4bc5f7acdcae4e5b41be48de57137d37 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 1 May 2023 15:33:44 +0000
Subject: [PATCH 19/64] remove prints from recursive verifier test

---
 .../barretenberg/stdlib/recursion/verifier/verifier.test.cpp  | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
index 9b57f7f8a6..ad28907bfb 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
@@ -287,15 +287,13 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         create_inner_circuit(inner_composer, inner_inputs);
 
         auto circuit_output = create_outer_circuit(inner_composer, outer_composer);
-        std::cout << "circuit_output: " << circuit_output.aggregation_state << std::endl;
 
         g1::affine_element P[2];
         P[0].x = barretenberg::fq(circuit_output.aggregation_state.P0.x.get_value().lo);
         P[0].y = barretenberg::fq(circuit_output.aggregation_state.P0.y.get_value().lo);
         P[1].x = barretenberg::fq(circuit_output.aggregation_state.P1.x.get_value().lo);
         P[1].y = barretenberg::fq(circuit_output.aggregation_state.P1.y.get_value().lo);
-        auto g2_lines = env_crs->get_verifier_crs()->get_precomputed_g2_lines();
-        std::cout << "precompute g2 lines: " << g2_lines << std::endl;
+
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, env_crs->get_verifier_crs()->get_precomputed_g2_lines(), 2);
 

From 5a458d65e41cbc27e0a03cda759685f8f678dcf1 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Wed, 3 May 2023 18:54:55 +0000
Subject: [PATCH 20/64] fix dirty free for when serializing vk to fields, was
 working on macbook so not caught earlier, but need more clarity on ubuntu

---
 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp      | 7 +++++--
 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp | 2 --
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 26ba502cd5..527d944b61 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -149,18 +149,21 @@ size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
     // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o
     const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr) - 32;
+
     auto raw_buf = (uint8_t*)malloc(output_size_bytes);
+    auto vk_hash_raw_buf = (uint8_t*)malloc(32);
 
     // The serialization code below will convert out of Montgomery form before writing to the buffer
-    for (size_t i = 0; i < output.size(); ++i) {
+    for (size_t i = 0; i < output.size() - 1; ++i) {
         barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
     }
+    barretenberg::fr::serialize_to_buffer(output[output.size() - 1], vk_hash_raw_buf);
 
     // copy the vkey into serialized_vk_buf
     *serialized_vk_buf = raw_buf;
 
     // copy the vkey hash into serialized_vk_hash_buf
-    *serialized_vk_hash_buf = &raw_buf[(output.size() - 1) * 32];
+    *serialized_vk_hash_buf = vk_hash_raw_buf;
 
     return output_size_bytes;
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index 91ccff081a..bba475b798 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -251,8 +251,6 @@ TEST(AcirProofs, TestSerializationWithRecursion)
             .q_c = -vk_hash_value,
         };
 
-        std::cout << "vk_hash_value: " << vk_hash_value << std::endl;
-
         std::vector<fr> witness;
         for (size_t i = 0; i < 18; ++i) {
             witness.emplace_back(0);

From 07a22f6e3be6d9b2be90c9b8f663299be33f0786 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 5 May 2023 20:06:11 +0000
Subject: [PATCH 21/64] fix ecdsa tests after master merge

---
 .../stdlib/encryption/ecdsa/ecdsa.test.cpp             | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
index 78ac01571f..ca1f4a4940 100644
--- a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
+++ b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
@@ -80,8 +80,11 @@ TEST(stdlib_ecdsa, verify_signature_noassert_succeed)
 
     std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
     std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
+    uint8_t vv = signature.v;
 
-    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr), curve::byte_array_ct(&composer, ss) };
+    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr),
+                                            curve::byte_array_ct(&composer, ss),
+                                            stdlib::uint8<Composer>(&composer, vv) };
 
     curve::byte_array_ct message(&composer, message_string);
 
@@ -125,8 +128,11 @@ TEST(stdlib_ecdsa, verify_signature_noassert_fail)
 
     std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
     std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
+    uint8_t vv = signature.v;
 
-    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr), curve::byte_array_ct(&composer, ss) };
+    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr),
+                                            curve::byte_array_ct(&composer, ss),
+                                            stdlib::uint8<Composer>(&composer, vv) };
 
     curve::byte_array_ct message(&composer, message_string);
 

From 74a8327b40ee59cc858f9cb325c380b5ed905fb1 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 5 May 2023 20:15:14 +0000
Subject: [PATCH 22/64] missing keccak constraints fields in acir format and
 proofs tests

---
 cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp   | 2 ++
 .../barretenberg/dsl/acir_format/recursion_constraint.test.cpp  | 2 ++
 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp       | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
index 9045bab14b..57ce16d248 100644
--- a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
@@ -88,6 +88,7 @@ TEST(ECDSASecp256k1, TestECDSAConstraintSucceed)
         .ecdsa_constraints = { ecdsa_constraint },
         .sha256_constraints = {},
         .blake2s_constraints = {},
+        .keccak_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
@@ -127,6 +128,7 @@ TEST(ECDSASecp256k1, TestECDSAConstraintFail)
         .ecdsa_constraints = { ecdsa_constraint },
         .sha256_constraints = {},
         .blake2s_constraints = {},
+        .keccak_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index 63b051c478..d68444bc20 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -89,6 +89,7 @@ acir_format::Composer create_inner_circuit()
         .ecdsa_constraints = {},
         .sha256_constraints = {},
         .blake2s_constraints = {},
+        .keccak_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
@@ -178,6 +179,7 @@ TEST(RecursionConstraint, TestRecursionConstraint)
         .ecdsa_constraints = {},
         .sha256_constraints = {},
         .blake2s_constraints = {},
+        .keccak_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index bba475b798..5159cdee9a 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -84,6 +84,7 @@ void create_inner_circuit(acir_format::acir_format& constraint_system, std::vect
         .ecdsa_constraints = {},
         .sha256_constraints = {},
         .blake2s_constraints = {},
+        .keccak_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
@@ -272,6 +273,7 @@ TEST(AcirProofs, TestSerializationWithRecursion)
             .ecdsa_constraints = {},
             .sha256_constraints = {},
             .blake2s_constraints = {},
+            .keccak_constraints = {},
             .hash_to_field_constraints = {},
             .pedersen_constraints = {},
             .compute_merkle_root_constraints = {},

From 18cfb94505ce5e5c65feb7d361a6d29bdb2f7de5 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 5 May 2023 20:19:47 +0000
Subject: [PATCH 23/64] one more missing keccak constraint

---
 cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
index 13833e0003..ad8506481a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
@@ -28,6 +28,7 @@ TEST(acir_format, test_a_single_constraint_no_pub_inputs)
         .ecdsa_constraints = {},
         .sha256_constraints = {},
         .blake2s_constraints = {},
+        .keccak_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},

From 155903e1c129576d054e332d2d06208051e854a8 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 15 May 2023 18:21:12 +0000
Subject: [PATCH 24/64] mismatched acir format structs for gcc build

---
 cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp        | 1 +
 cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp   | 1 +
 cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp    | 1 +
 .../barretenberg/dsl/acir_format/recursion_constraint.test.cpp   | 1 +
 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp        | 1 +
 5 files changed, 5 insertions(+)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
index cd1e4c8e5a..e7c9a53264 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
@@ -33,6 +33,7 @@ TEST(acir_format, test_a_single_constraint_no_pub_inputs)
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
+        .block_constraints = {},
         .recursion_constraints = {},
         .constraints = { constraint },
     };
diff --git a/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp
index 66ab73e84a..ae122849cd 100644
--- a/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp
@@ -117,6 +117,7 @@ TEST(up_ram, TestBlockConstraint)
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
         .block_constraints = { block },
+        .recursion_constraints = {},
         .constraints = {},
     };
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
index b405fcdb55..f0b1aab787 100644
--- a/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
@@ -135,6 +135,7 @@ TEST(ECDSASecp256k1, TestECDSACompilesForVerifier)
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
         .block_constraints = {},
+        .recursion_constraints = {},
         .constraints = {},
     };
     auto crs_factory = std::make_unique<proof_system::ReferenceStringFactory>();
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index d68444bc20..c9904740fe 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -93,6 +93,7 @@ acir_format::Composer create_inner_circuit()
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
+        .block_constraints = {},
         .recursion_constraints = {},
         .constraints = { expr_a, expr_b, expr_c, expr_d },
     };
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index 5159cdee9a..00f3b3c26c 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -88,6 +88,7 @@ void create_inner_circuit(acir_format::acir_format& constraint_system, std::vect
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
+        .block_constraints = {},
         .recursion_constraints = {},
         .constraints = { expr_a, expr_b, expr_c, expr_d },
     };

From 683a8759f80890b718e17ceaf6af1b12684a9003 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 15 May 2023 18:43:58 +0000
Subject: [PATCH 25/64] missing block constraints in acir tests

---
 .../barretenberg/dsl/acir_format/recursion_constraint.test.cpp   | 1 +
 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp        | 1 +
 2 files changed, 2 insertions(+)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index c9904740fe..53fe69b979 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -184,6 +184,7 @@ TEST(RecursionConstraint, TestRecursionConstraint)
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
+        .block_constraints = {},
         .recursion_constraints = { recursion_constraint },
         .constraints = {},
     };
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index 00f3b3c26c..08e4e8fbea 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -278,6 +278,7 @@ TEST(AcirProofs, TestSerializationWithRecursion)
             .hash_to_field_constraints = {},
             .pedersen_constraints = {},
             .compute_merkle_root_constraints = {},
+            .block_constraints = {},
             .recursion_constraints = { recursion_constraint },
             .constraints = { vk_equality_constraint },
         };

From 7ecb574fd52fcc99de862b7ca75d7d0d9e8a5673 Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Tue, 16 May 2023 18:20:32 +0100
Subject: [PATCH 26/64] feat(dsl)!: Arbitrary depth recursion (#433)

* merge conflicts and small updates to get acir_proofs test passing with arbitrary depth cahnges

* inline with mv/noir-recursion and working double recursion acir_proofs serialization test

* cleanup and working towards supporting full nested proofs, still some bugs in acir_proofs test

* full recursive composition test working in acir_proofs

* use two public inptus for inner circuit

* delete commented out unnecessary acir proofs method

* made dummy transcript points unique to prevent point collisions

* handle nested proofs when exporting dummy transcript, export recursive proof indices when init vkey, fix full recursive comp test in acir_proofs

* update bindings on verify_recursive_proof to accept num public inputs

* missing acir_format field in tests

* missing one more correct acir_format struct in recursion constraint test

* cleanup and additional comment for recursion_constraint

* fix up comment in recursion_constraint

* remove unnecesary comments when we were including proof outputs as public inputs in the recursion constraint

---------

Co-authored-by: zac-williamson <blorktronics@gmail.com>
---
 .../dsl/acir_format/acir_format.cpp           |  70 ++-
 .../dsl/acir_format/recursion_constraint.cpp  |  39 +-
 .../dsl/acir_format/recursion_constraint.hpp  |  33 +-
 .../acir_format/recursion_constraint.test.cpp | 209 ++++++---
 .../dsl/acir_proofs/acir_proofs.cpp           |  78 +++-
 .../dsl/acir_proofs/acir_proofs.hpp           |   5 +-
 .../dsl/acir_proofs/acir_proofs.test.cpp      | 415 +++++++++++-------
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   |   9 +-
 .../barretenberg/dsl/acir_proofs/c_bind.hpp   |   5 +-
 .../honk/proof_system/ultra_prover.hpp        |   3 +-
 .../plonk/composer/composer_base.hpp          |  15 +
 .../plonk/composer/ultra_composer.hpp         |  17 +
 .../verification_key/verification_key.cpp     |  10 +-
 .../verification_key/verification_key.hpp     |  13 +-
 .../transcript/transcript_wrappers.hpp        |  38 +-
 15 files changed, 670 insertions(+), 289 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
index 28343d3b1f..97ce130665 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
@@ -95,8 +95,18 @@ void create_circuit(Composer& composer, const acir_format& constraint_system)
     }
 
     // Add recursion constraints
-    for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints<false, false>(composer, constraint);
+    for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
+        auto& constraint = constraint_system.recursion_constraints[i];
+        create_recursion_constraints<false>(composer, constraint);
+
+        // make sure the verification key records the public input indices of the final recursion output
+        // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
+        // inputs!)
+        if (i == constraint_system.recursion_constraints.size() - 1) {
+            std::vector<uint32_t> proof_output_witness_indices(constraint.output_aggregation_object.begin(),
+                                                               constraint.output_aggregation_object.end());
+            composer.set_recursive_proof(proof_output_witness_indices);
+        }
     }
 }
 
@@ -189,8 +199,18 @@ Composer create_circuit(const acir_format& constraint_system,
     }
 
     // Add recursion constraints
-    for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints<false, false>(composer, constraint);
+    for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
+        auto& constraint = constraint_system.recursion_constraints[i];
+        create_recursion_constraints<false>(composer, constraint);
+
+        // make sure the verification key records the public input indices of the final recursion output
+        // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
+        // inputs!)
+        if (i == constraint_system.recursion_constraints.size() - 1) {
+            std::vector<uint32_t> proof_output_witness_indices(constraint.output_aggregation_object.begin(),
+                                                               constraint.output_aggregation_object.end());
+            composer.set_recursive_proof(proof_output_witness_indices);
+        }
     }
 
     return composer;
@@ -288,8 +308,18 @@ Composer create_circuit_with_witness(const acir_format& constraint_system,
     }
 
     // Add recursion constraints
-    for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints<true, false>(composer, constraint);
+    for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
+        auto& constraint = constraint_system.recursion_constraints[i];
+        create_recursion_constraints<true>(composer, constraint);
+
+        // make sure the verification key records the public input indices of the final recursion output
+        // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
+        // inputs!)
+        if (i == constraint_system.recursion_constraints.size() - 1) {
+            std::vector<uint32_t> proof_output_witness_indices(constraint.output_aggregation_object.begin(),
+                                                               constraint.output_aggregation_object.end());
+            composer.set_recursive_proof(proof_output_witness_indices);
+        }
     }
 
     return composer;
@@ -384,8 +414,18 @@ Composer create_circuit_with_witness(const acir_format& constraint_system, std::
     }
 
     // Add recursion constraints
-    for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints<true, false>(composer, constraint);
+    for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
+        auto& constraint = constraint_system.recursion_constraints[i];
+        create_recursion_constraints<true>(composer, constraint);
+
+        // make sure the verification key records the public input indices of the final recursion output
+        // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
+        // inputs!)
+        if (i == constraint_system.recursion_constraints.size() - 1) {
+            std::vector<uint32_t> proof_output_witness_indices(constraint.output_aggregation_object.begin(),
+                                                               constraint.output_aggregation_object.end());
+            composer.set_recursive_proof(proof_output_witness_indices);
+        }
     }
 
     return composer;
@@ -478,8 +518,18 @@ void create_circuit_with_witness(Composer& composer, const acir_format& constrai
     }
 
     // Add recursion constraints
-    for (const auto& constraint : constraint_system.recursion_constraints) {
-        create_recursion_constraints<true, false>(composer, constraint);
+    for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
+        auto& constraint = constraint_system.recursion_constraints[i];
+        create_recursion_constraints<true>(composer, constraint);
+
+        // make sure the verification key records the public input indices of the final recursion output
+        // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
+        // inputs!)
+        if (i == constraint_system.recursion_constraints.size() - 1) {
+            std::vector<uint32_t> proof_output_witness_indices(constraint.output_aggregation_object.begin(),
+                                                               constraint.output_aggregation_object.end());
+            composer.set_recursive_proof(proof_output_witness_indices);
+        }
     }
 }
 
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 441b47c2d8..1fcf95f594 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -22,9 +22,15 @@ void generate_dummy_proof() {}
  *       We would either need a separate ACIR opcode where inner_proof_contains_recursive_proof = true,
  *       or we need non-witness data to be provided as metadata in the ACIR opcode
  */
-template <bool has_valid_witness_assignment, bool inner_proof_contains_recursive_proof>
+template <bool has_valid_witness_assignment>
 void create_recursion_constraints(Composer& composer, const RecursionConstraint& input)
 {
+    const auto& nested_aggregation_indices = input.nested_aggregation_object;
+    bool nested_aggregation_indices_all_zero = true;
+    for (const auto& idx : nested_aggregation_indices) {
+        nested_aggregation_indices_all_zero &= (idx == 0);
+    }
+    const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
 
     // If we do not have a witness, we must ensure that our dummy witness will not trigger
     // on-curve errors and inverting-zero errors
@@ -32,9 +38,10 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
         // get a fake key/proof that satisfies on-curve + inversion-zero checks
         const std::vector<fr> dummy_key = plonk::verification_key::export_dummy_key_in_recursion_format(
             PolynomialManifest(Composer::type), inner_proof_contains_recursive_proof);
-        const auto manifest = Composer::create_unrolled_manifest(1);
+        const auto manifest = Composer::create_unrolled_manifest(input.public_inputs.size());
         const std::vector<barretenberg::fr> dummy_proof =
-            transcript::StandardTranscript::export_dummy_transcript_in_recursion_format(manifest);
+            transcript::StandardTranscript::export_dummy_transcript_in_recursion_format(
+                manifest, inner_proof_contains_recursive_proof);
         for (size_t i = 0; i < input.proof.size(); ++i) {
             const auto proof_field_idx = input.proof[i];
             // if we do NOT have a witness assignment (i.e. are just building the proving/verification keys),
@@ -88,12 +95,14 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
         previous_aggregation.has_data = false;
     }
 
-    transcript::Manifest manifest = Composer::create_unrolled_manifest(1);
+    transcript::Manifest manifest = Composer::create_unrolled_manifest(input.public_inputs.size());
+
     std::vector<field_ct> key_fields;
     key_fields.reserve(input.key.size());
     for (const auto& idx : input.key) {
         key_fields.emplace_back(field_ct::from_witness_index(&composer, idx));
     }
+
     std::vector<field_ct> proof_fields;
     proof_fields.reserve(input.proof.size());
     for (const auto& idx : input.proof) {
@@ -101,24 +110,22 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 
     // recursively verify the proof
-    std::shared_ptr<verification_key_ct> vkey =
-        verification_key_ct::template from_field_pt_vector<inner_proof_contains_recursive_proof>(&composer, key_fields);
+    std::shared_ptr<verification_key_ct> vkey = verification_key_ct::from_field_pt_vector(
+        &composer, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_indices);
     vkey->program_width = noir_recursive_settings::program_width;
-    Transcript_ct transcript(&composer, manifest, proof_fields, 1);
+    Transcript_ct transcript(&composer, manifest, proof_fields, input.public_inputs.size());
     aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof_<bn254, noir_recursive_settings>(
         &composer, vkey, transcript, previous_aggregation);
 
     // Assign correct witness value to the verification key hash
     vkey->compress().assert_equal(field_ct::from_witness_index(&composer, input.key_hash));
 
-    // Assign the output aggregation object to the proof public inputs (16 field elements representing two
-    // G1 points)
-    result.add_proof_outputs_as_public_inputs();
-
-    ASSERT(result.public_inputs.size() == 1);
+    ASSERT(result.public_inputs.size() == input.public_inputs.size());
 
     // Assign the `public_input` field to the public input of the inner proof
-    result.public_inputs[0].assert_equal(field_ct::from_witness_index(&composer, input.public_input));
+    for (size_t i = 0; i < input.public_inputs.size(); ++i) {
+        result.public_inputs[i].assert_equal(field_ct::from_witness_index(&composer, input.public_inputs[i]));
+    }
 
     // Assign the recursive proof outputs to `output_aggregation_object`
     for (size_t i = 0; i < result.proof_witness_indices.size(); ++i) {
@@ -128,9 +135,7 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 }
 
-template void create_recursion_constraints<false, false>(Composer&, const RecursionConstraint&);
-template void create_recursion_constraints<false, true>(Composer&, const RecursionConstraint&);
-template void create_recursion_constraints<true, false>(Composer&, const RecursionConstraint&);
-template void create_recursion_constraints<true, true>(Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<false>(Composer&, const RecursionConstraint&);
+template void create_recursion_constraints<true>(Composer&, const RecursionConstraint&);
 
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index cfc0116349..0a0ca53d12 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -24,40 +24,52 @@ namespace acir_format {
  * (and therefore an aggregation object is present)
  * @param public_input The index of the single public input
  * @param input_aggregation_object Witness indices of pre-existing aggregation object (if it exists)
- * @param output_aggregation_object Witness indecies of the aggregation object produced by recursive verification
+ * @param output_aggregation_object Witness indices of the aggregation object produced by recursive verification
+ * @param nested_aggregation_object Public input indices of an aggregation object inside the proof.
  *
  * @note If input_aggregation_object witness indices are all zero, we interpret this to mean that the inner proof does
- * NOT contain
+ * NOT contain a previously recursively verified proof
+ * @note nested_aggregation_object is used for cases where the proof being verified contains an aggregation object in
+ * its public inputs! If this is the case, we record the public input locations in `nested_aggregation_object`. If the
+ * inner proof is of a circuit that does not have a nested aggregation object, these values are all zero.
+ *
+ * To outline the interaction between the input_aggergation_object and the nested_aggregation_object take the following
+ * example: If we have a circuit that verifies 2 proofs A and B, the recursion constraint for B will have an
+ * input_aggregation_object that points to the aggregation output produced by verifying A. If circuit B also verifies a
+ * proof, in the above example the recursion constraint for verifying B will have a nested object that describes the
+ * aggregation object in B’s public inputs as well as an input aggregation object that points to the object produced by
+ * the previous recursion constraint in the circuit (the one that verifies A)
+ *
  */
 struct RecursionConstraint {
     static constexpr size_t AGGREGATION_OBJECT_SIZE = 16; // 16 field elements
     std::vector<uint32_t> key;
     std::vector<uint32_t> proof;
-    uint32_t public_input;
+    std::vector<uint32_t> public_inputs;
     uint32_t key_hash;
     std::array<uint32_t, AGGREGATION_OBJECT_SIZE> input_aggregation_object;
     std::array<uint32_t, AGGREGATION_OBJECT_SIZE> output_aggregation_object;
+    std::array<uint32_t, AGGREGATION_OBJECT_SIZE> nested_aggregation_object;
 
     friend bool operator==(RecursionConstraint const& lhs, RecursionConstraint const& rhs) = default;
 };
 
-template <bool has_valid_witness_assignment = false, bool inner_proof_contains_recursive_proof = false>
+template <bool has_valid_witness_assignment = false>
 void create_recursion_constraints(Composer& composer, const RecursionConstraint& input);
 
-extern template void create_recursion_constraints<false, false>(Composer&, const RecursionConstraint&);
-extern template void create_recursion_constraints<false, true>(Composer&, const RecursionConstraint&);
-extern template void create_recursion_constraints<true, false>(Composer&, const RecursionConstraint&);
-extern template void create_recursion_constraints<true, true>(Composer&, const RecursionConstraint&);
+extern template void create_recursion_constraints<false>(Composer&, const RecursionConstraint&);
+extern template void create_recursion_constraints<true>(Composer&, const RecursionConstraint&);
 
 template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 {
     using serialize::read;
     read(buf, constraint.key);
     read(buf, constraint.proof);
-    read(buf, constraint.public_input);
+    read(buf, constraint.public_inputs);
     read(buf, constraint.key_hash);
     read(buf, constraint.input_aggregation_object);
     read(buf, constraint.output_aggregation_object);
+    read(buf, constraint.nested_aggregation_object);
 }
 
 template <typename B> inline void write(B& buf, RecursionConstraint const& constraint)
@@ -65,10 +77,11 @@ template <typename B> inline void write(B& buf, RecursionConstraint const& const
     using serialize::write;
     write(buf, constraint.key);
     write(buf, constraint.proof);
-    write(buf, constraint.public_input);
+    write(buf, constraint.public_inputs);
     write(buf, constraint.key_hash);
     write(buf, constraint.input_aggregation_object);
     write(buf, constraint.output_aggregation_object);
+    write(buf, constraint.nested_aggregation_object);
 }
 
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index 53fe69b979..c6b511d662 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -75,13 +75,10 @@ acir_format::Composer create_inner_circuit()
         .q_o = 0,
         .q_c = 1,
     };
-    // EXPR [ (1, _4, _5) (-1, _6) 0 ]
-    // EXPR [ (1, _4, _6) (-1, _4) 0 ]
-    // EXPR [ (-1, _6) 1 ]
 
     acir_format::acir_format constraint_system{
         .varnum = 7,
-        .public_inputs = { 2 },
+        .public_inputs = { 2, 3 },
         .fixed_base_scalar_mul_constraints = {},
         .logic_constraints = { logic_constraint },
         .range_constraints = { range_a, range_b },
@@ -112,67 +109,101 @@ acir_format::Composer create_inner_circuit()
     return composer;
 }
 
-TEST(RecursionConstraint, TestRecursionConstraint)
+/**
+ * @brief Create a circuit that recursively verifies one or more inner circuits
+ *
+ * @param inner_composers
+ * @return acir_format::Composer
+ */
+acir_format::Composer create_outer_circuit(std::vector<acir_format::Composer>& inner_composers)
 {
-    auto inner_composer = create_inner_circuit();
+    std::vector<acir_format::RecursionConstraint> recursion_constraints;
 
-    auto inner_prover = inner_composer.create_prover();
-    auto inner_proof = inner_prover.construct_proof();
-    auto inner_verifier = inner_composer.create_verifier();
+    // witness count starts at 1 (Composer reserves 1st witness to be the zero-valued zero_idx)
+    size_t witness_offset = 1;
+    std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_aggregation_object;
+    std::vector<fr> witness;
 
-    // std::vector<uint8_t> keybuf;
-    // write(keybuf, *(inner_verifier.key));
+    for (size_t i = 0; i < inner_composers.size(); ++i) {
+        const bool has_input_aggregation_object = i > 0;
 
-    std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_vars;
-    for (size_t i = 0; i < 16; ++i) {
-        // variable idx 1 = public input
-        // variable idx 2-18 = output_vars
-        output_vars[i] = (static_cast<uint32_t>(i + 3));
-    }
+        auto& inner_composer = inner_composers[i];
+        auto inner_prover = inner_composer.create_prover();
+        auto inner_proof = inner_prover.construct_proof();
+        auto inner_verifier = inner_composer.create_verifier();
 
-    transcript::StandardTranscript transcript(inner_proof.proof_data,
-                                              acir_format::Composer::create_manifest(1),
-                                              transcript::HashType::PlookupPedersenBlake3s,
-                                              16);
+        const bool has_nested_proof = inner_verifier.key->contains_recursive_proof;
+        const size_t num_inner_public_inputs = inner_composer.get_num_public_inputs();
 
-    const std::vector<barretenberg::fr> proof_witnesses = transcript.export_transcript_in_recursion_format();
-    const std::vector<barretenberg::fr> key_witnesses = inner_verifier.key->export_key_in_recursion_format();
+        transcript::StandardTranscript transcript(inner_proof.proof_data,
+                                                  acir_format::Composer::create_manifest(num_inner_public_inputs),
+                                                  transcript::HashType::PlookupPedersenBlake3s,
+                                                  16);
 
-    std::vector<uint32_t> proof_indices;
-    const size_t proof_size = proof_witnesses.size();
+        const std::vector<barretenberg::fr> proof_witnesses = transcript.export_transcript_in_recursion_format();
+        const std::vector<barretenberg::fr> key_witnesses = inner_verifier.key->export_key_in_recursion_format();
 
-    for (size_t i = 0; i < proof_size; ++i) {
-        proof_indices.emplace_back(static_cast<uint32_t>(i + 19));
-    }
+        const uint32_t key_hash_start_idx = static_cast<uint32_t>(witness_offset);
+        const uint32_t public_input_start_idx = key_hash_start_idx + 1;
+        const uint32_t output_aggregation_object_start_idx =
+            static_cast<uint32_t>(public_input_start_idx + num_inner_public_inputs + (has_nested_proof ? 16 : 0));
+        const uint32_t proof_indices_start_idx = output_aggregation_object_start_idx + 16;
+        const uint32_t key_indices_start_idx = static_cast<uint32_t>(proof_indices_start_idx + proof_witnesses.size());
 
-    std::vector<uint32_t> key_indices;
-    const size_t key_size = key_witnesses.size();
-    for (size_t i = 0; i < key_size; ++i) {
-        key_indices.emplace_back(static_cast<uint32_t>(i + 19 + proof_size));
-    }
-    acir_format::RecursionConstraint recursion_constraint{
-        .key = key_indices,
-        .proof = proof_indices,
-        .public_input = 1,
-        .key_hash = 2,
-        .input_aggregation_object = {},
-        .output_aggregation_object = output_vars,
-    };
+        std::vector<uint32_t> proof_indices;
+        std::vector<uint32_t> key_indices;
+        std::vector<uint32_t> inner_public_inputs;
+        std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> input_aggregation_object = {};
+        std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object = {};
+        if (has_input_aggregation_object) {
+            input_aggregation_object = output_aggregation_object;
+        }
+        for (size_t i = 0; i < 16; ++i) {
+            output_aggregation_object[i] = (static_cast<uint32_t>(i + output_aggregation_object_start_idx));
+        }
+        if (has_nested_proof) {
+            for (size_t i = 0; i < 16; ++i) {
+                nested_aggregation_object[i] = inner_composer.recursive_proof_public_input_indices[i];
+            }
+        }
+        for (size_t i = 0; i < proof_witnesses.size(); ++i) {
+            proof_indices.emplace_back(static_cast<uint32_t>(i + proof_indices_start_idx));
+        }
+        const size_t key_size = key_witnesses.size();
+        for (size_t i = 0; i < key_size; ++i) {
+            key_indices.emplace_back(static_cast<uint32_t>(i + key_indices_start_idx));
+        }
+        for (size_t i = 0; i < num_inner_public_inputs; ++i) {
+            inner_public_inputs.push_back(static_cast<uint32_t>(i + public_input_start_idx));
+        }
 
-    std::vector<fr> witness;
-    for (size_t i = 0; i < 18; ++i) {
-        witness.emplace_back(0);
-    }
-    for (const auto& wit : proof_witnesses) {
-        witness.emplace_back(wit);
-    }
-    for (const auto& wit : key_witnesses) {
-        witness.emplace_back(wit);
+        acir_format::RecursionConstraint recursion_constraint{
+            .key = key_indices,
+            .proof = proof_indices,
+            .public_inputs = inner_public_inputs,
+            .key_hash = key_hash_start_idx,
+            .input_aggregation_object = input_aggregation_object,
+            .output_aggregation_object = output_aggregation_object,
+            .nested_aggregation_object = nested_aggregation_object,
+        };
+        recursion_constraints.push_back(recursion_constraint);
+        for (size_t i = 0; i < proof_indices_start_idx - witness_offset; ++i) {
+            witness.emplace_back(0);
+        }
+        for (const auto& wit : proof_witnesses) {
+            witness.emplace_back(wit);
+        }
+        for (const auto& wit : key_witnesses) {
+            witness.emplace_back(wit);
+        }
+        witness_offset = key_indices_start_idx + key_witnesses.size();
     }
 
+    std::vector<uint32_t> public_inputs(output_aggregation_object.begin(), output_aggregation_object.end());
+
     acir_format::acir_format constraint_system{
         .varnum = static_cast<uint32_t>(witness.size() + 1),
-        .public_inputs = { 1 },
+        .public_inputs = public_inputs,
         .fixed_base_scalar_mul_constraints = {},
         .logic_constraints = {},
         .range_constraints = {},
@@ -185,16 +216,84 @@ TEST(RecursionConstraint, TestRecursionConstraint)
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
         .block_constraints = {},
-        .recursion_constraints = { recursion_constraint },
+        .recursion_constraints = recursion_constraints,
         .constraints = {},
     };
 
     auto composer = acir_format::create_circuit_with_witness(constraint_system, witness);
-    auto prover = composer.create_prover();
 
+    return composer;
+}
+
+TEST(RecursionConstraint, TestBasicDoubleRecursionConstraints)
+{
+    std::vector<acir_format::Composer> layer_1_composers;
+    layer_1_composers.push_back(create_inner_circuit());
+
+    layer_1_composers.push_back(create_inner_circuit());
+
+    auto layer_2_composer = create_outer_circuit(layer_1_composers);
+
+    std::cout << "composer gates = " << layer_2_composer.get_num_gates() << std::endl;
+    auto prover = layer_2_composer.create_ultra_with_keccak_prover();
+    std::cout << "prover gates = " << prover.circuit_size << std::endl;
     auto proof = prover.construct_proof();
-    auto verifier = composer.create_verifier();
+    auto verifier = layer_2_composer.create_ultra_with_keccak_verifier();
     EXPECT_EQ(verifier.verify_proof(proof), true);
+}
 
-    EXPECT_EQ(composer.get_variable(1), 10);
+TEST(RecursionConstraint, TestFullRecursionConstraints)
+{
+    /**
+     * We want to test the following:
+     * 1. circuit that verifies a proof of another circuit
+     * 2. the above, but the inner circuit contains a recursive proof output that we have to aggregate
+     * 3. the above, but the outer circuit verifies 2 proofs, the aggregation outputs from the 2 proofs (+ the recursive
+     * proof output from 2) are aggregated together
+     *
+     * A = basic circuit
+     * B = circuit that verifies proof of A
+     * C = circuit that verifies proof of B and a proof of A
+     *
+     * Layer 1 = proof of A
+     * Layer 2 = verifies proof of A and proof of B
+     * Layer 3 = verifies proof of C
+     *
+     * Attempt at a visual graphic
+     * ===========================
+     *
+     *     C
+     *     ^
+     *     |
+     *     | - B
+     *     ^   ^
+     *     |   |
+     *     |    -A
+     *     |
+     *      - A
+     *
+     * ===========================
+     *
+     * Final aggregation object contains aggregated proofs for 2 instances of A and 1 instance of B
+     */
+    std::vector<acir_format::Composer> layer_1_composers;
+    layer_1_composers.push_back(create_inner_circuit());
+    std::cout << "created first inner circuit\n";
+    std::vector<acir_format::Composer> layer_2_composers;
+
+    layer_2_composers.push_back(create_inner_circuit());
+    std::cout << "created second inner circuit\n";
+
+    layer_2_composers.push_back(create_outer_circuit(layer_1_composers));
+    std::cout << "created first outer circuit\n";
+
+    auto layer_3_composer = create_outer_circuit(layer_2_composers);
+    std::cout << "created second outer circuit\n";
+
+    std::cout << "composer gates = " << layer_3_composer.get_num_gates() << std::endl;
+    auto prover = layer_3_composer.create_ultra_with_keccak_prover();
+    std::cout << "prover gates = " << prover.circuit_size << std::endl;
+    auto proof = prover.construct_proof();
+    auto verifier = layer_3_composer.create_ultra_with_keccak_verifier();
+    EXPECT_EQ(verifier.verify_proof(proof), true);
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 527d944b61..4310342f7e 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -51,12 +51,11 @@ size_t init_proving_key(uint8_t const* constraint_system_buf, uint8_t const** pk
 {
     auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
 
-    // constraint_system.recursion_constraints[0].
-
     // We know that we don't actually need any CRS to create a proving key, so just feed in a nothing.
     // Hacky, but, right now it needs *something*.
     auto crs_factory = std::make_unique<ReferenceStringFactory>();
     auto composer = create_circuit(constraint_system, std::move(crs_factory));
+
     auto proving_key = composer.compute_proving_key();
 
     auto buffer = to_buffer(*proving_key);
@@ -86,6 +85,18 @@ size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const*
     // construct the verification key so that we have the correct polynomial manifest
     verification_key->composer_type = proof_system::ComposerType::PLOOKUP;
 
+    // Set the recursive proof indices as this is not done in `compute_verification_key_base`
+    verification_key->contains_recursive_proof = proving_key->contains_recursive_proof;
+    for (size_t i = 0; i < 16; ++i) {
+        if (proving_key->recursive_proof_public_input_indices.size() > i) {
+            verification_key->recursive_proof_public_input_indices.emplace_back(
+                proving_key->recursive_proof_public_input_indices[i]);
+        } else {
+            verification_key->recursive_proof_public_input_indices.emplace_back(0);
+            ASSERT(verification_key->contains_recursive_proof == false);
+        }
+    }
+
     auto buffer = to_buffer(*verification_key);
     auto raw_buf = (uint8_t*)malloc(buffer.size());
     memcpy(raw_buf, (void*)buffer.data(), buffer.size());
@@ -104,12 +115,15 @@ size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const*
  */
 size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
                                            uint8_t** serialized_proof_data_buf,
-                                           size_t proof_data_length)
+                                           size_t proof_data_length,
+                                           size_t num_inner_public_inputs)
 {
     plonk::proof proof = { std::vector<uint8_t>(proof_data_buf, &proof_data_buf[proof_data_length]) };
 
-    transcript::StandardTranscript transcript(
-        proof.proof_data, acir_format::Composer::create_manifest(1), transcript::HashType::PlookupPedersenBlake3s, 16);
+    transcript::StandardTranscript transcript(proof.proof_data,
+                                              acir_format::Composer::create_manifest(num_inner_public_inputs),
+                                              transcript::HashType::PlookupPedersenBlake3s,
+                                              16);
 
     std::vector<barretenberg::fr> output = transcript.export_transcript_in_recursion_format();
 
@@ -143,7 +157,6 @@ size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
     plonk::verification_key_data vk_data;
     read(vk_buf, vk_data);
     auto vkey = std::make_shared<proof_system::plonk::verification_key>(std::move(vk_data), crs);
-
     std::vector<barretenberg::fr> output = vkey->export_key_in_recursion_format();
 
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
@@ -272,18 +285,36 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
                               uint32_t proof_length,
                               uint8_t const* vk_buf,
                               uint32_t vk_length,
-                              uint8_t const* public_inputs_buf,
+                              uint32_t num_public_inputs,
                               uint8_t const* input_aggregation_obj_buf,
                               uint8_t** output_aggregation_obj_buf)
 {
-    // TODO: not doing anything with public_inputs_buf right now because we only have one layer of recursion
-    // and the previous aggregation state will be empty. When arbitrary depth recursion is available we will have to
-    // construct the correct input aggregation_state_ct
-    (void)public_inputs_buf;
-    (void)input_aggregation_obj_buf;
+
+    bool inner_aggregation_all_zero = true;
+    std::vector<barretenberg::fr> aggregation_input(16);
+    for (size_t i = 0; i < 16; i++) {
+        aggregation_input[i] = barretenberg::fr::serialize_from_buffer(&input_aggregation_obj_buf[i * 32]);
+        inner_aggregation_all_zero &= (aggregation_input[i].is_zero());
+    }
 
     acir_format::aggregation_state_ct previous_aggregation;
-    previous_aggregation.has_data = false;
+    if (!inner_aggregation_all_zero) {
+        std::array<acir_format::bn254::fq_ct, 4> aggregation_elements;
+        for (size_t i = 0; i < 4; ++i) {
+            aggregation_elements[i] = acir_format::bn254::fq_ct(acir_format::field_ct(aggregation_input[4 * i]),
+                                                                acir_format::field_ct(aggregation_input[4 * i + 1]),
+                                                                acir_format::field_ct(aggregation_input[4 * i + 2]),
+                                                                acir_format::field_ct(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
+        // in stdlib::recursion::verify_proof
+        previous_aggregation.P0 = acir_format::bn254::g1_ct(aggregation_elements[0], aggregation_elements[1]);
+        previous_aggregation.P1 = acir_format::bn254::g1_ct(aggregation_elements[2], aggregation_elements[3]);
+        previous_aggregation.has_data = true;
+    } else {
+        previous_aggregation.has_data = false;
+    }
 
     std::vector<acir_format::field_ct> proof_fields(proof_length / 32);
     std::vector<acir_format::field_ct> key_fields(vk_length / 32);
@@ -296,19 +327,30 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
 
     acir_format::Composer composer;
 
-    transcript::Manifest manifest = acir_format::Composer::create_unrolled_manifest(1);
+    transcript::Manifest manifest = acir_format::Composer::create_unrolled_manifest(num_public_inputs);
     // We currently only support RecursionConstraint where inner_proof_contains_recursive_proof = false.
     // We would either need a separate ACIR opcode where inner_proof_contains_recursive_proof = true,
     // or we need non-witness data to be provided as metadata in the ACIR opcode
-    std::shared_ptr<acir_format::verification_key_ct> vkey =
-        acir_format::verification_key_ct::template from_field_pt_vector<false>(&composer, key_fields);
+    // recursively verify the proof
+    std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object = {};
+    for (size_t i = 6; i < 22; ++i) {
+        nested_aggregation_object[i - 6] = uint32_t(key_fields[i].get_value());
+    }
+    bool nested_aggregation_indices_all_zero = true;
+    for (const auto& idx : nested_aggregation_object) {
+        nested_aggregation_indices_all_zero &= (idx == 0);
+    }
+    const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
+    std::shared_ptr<acir_format::verification_key_ct> vkey = acir_format::verification_key_ct::from_field_pt_vector(
+        &composer, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_object);
     vkey->program_width = acir_format::noir_recursive_settings::program_width;
-    acir_format::Transcript_ct transcript(&composer, manifest, proof_fields, 1);
+    acir_format::Transcript_ct transcript(&composer, manifest, proof_fields, num_public_inputs);
     acir_format::aggregation_state_ct result =
         proof_system::plonk::stdlib::recursion::verify_proof_<acir_format::bn254, acir_format::noir_recursive_settings>(
             &composer, vkey, transcript, previous_aggregation);
 
-    // just writing the output aggregation G1 elements, and no public inputs, proof witnesses, or any other data
+    // Just write the output aggregation G1 elements, and no public inputs, proof witnesses, or any other data
+    // as this should all be available elsewhere
     const size_t output_size_bytes = 16 * sizeof(barretenberg::fr);
     auto raw_buf = (uint8_t*)malloc(output_size_bytes);
 
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
index e37756a5d6..cad0d1a79f 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
@@ -14,7 +14,8 @@ size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
                                                       uint8_t** serialized_vk_hash_buf);
 size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
                                            uint8_t** serialized_proof_data_buf,
-                                           size_t proof_data_length);
+                                           size_t proof_data_length,
+                                           size_t num_inner_public_inputs);
 size_t new_proof(void* pippenger,
                  uint8_t const* g2x,
                  uint8_t const* pk_buf,
@@ -32,7 +33,7 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
                               uint32_t proof_length,
                               uint8_t const* vk_buf,
                               uint32_t vk_length,
-                              uint8_t const* public_inputs_buf,
+                              uint32_t num_public_inputs,
                               uint8_t const* input_aggregation_obj_buf,
                               uint8_t** output_aggregation_obj_buf);
 
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index 08e4e8fbea..a5554d1b82 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -76,7 +76,7 @@ void create_inner_circuit(acir_format::acir_format& constraint_system, std::vect
 
     constraint_system = acir_format::acir_format{
         .varnum = 7,
-        .public_inputs = { 2 },
+        .public_inputs = { 2, 3 },
         .fixed_base_scalar_mul_constraints = {},
         .logic_constraints = { logic_constraint },
         .range_constraints = { range_a, range_b },
@@ -141,7 +141,13 @@ TEST(AcirProofs, TestSerialization)
     EXPECT_EQ(verified, true);
 }
 
-TEST(AcirProofs, TestSerializationWithRecursion)
+struct RecursiveCircuitData {
+    std::vector<barretenberg::fr> key_witnesses;
+    std::vector<barretenberg::fr> proof_witnesses;
+    size_t num_public_inputs;
+};
+
+RecursiveCircuitData fetch_recursive_circuit_data(acir_format::acir_format constraint_system, std::vector<fr> witness)
 {
     uint8_t* proof_data_fields = nullptr;
     uint8_t* vk_fields = nullptr;
@@ -149,112 +155,148 @@ TEST(AcirProofs, TestSerializationWithRecursion)
     size_t proof_fields_size = 0;
     size_t vk_fields_size = 0;
 
-    // inner circuit
-    {
-        acir_format::acir_format constraint_system;
-        std::vector<fr> witness;
-        create_inner_circuit(constraint_system, witness);
-
-        std::vector<uint8_t> witness_buf;           // = to_buffer(witness);
-        std::vector<uint8_t> constraint_system_buf; //
-        write(constraint_system_buf, constraint_system);
-        write(witness_buf, witness);
-
-        uint8_t const* pk_buf = nullptr;
-        acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
-
-        uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
-        uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
-        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
-        auto verifier_crs = env_crs->get_verifier_crs();
-        barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
-
-        auto* pippenger_ptr_base =
-            new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
-        void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
-
-        std::vector<uint8_t> g2x_buffer(128);
-        io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
-
-        uint8_t const* vk_buf = nullptr;
-        acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
-
-        uint8_t* proof_data_buf = nullptr;
-        size_t proof_length = acir_proofs::new_proof(
-            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, true);
-        proof_fields_size =
-            acir_proofs::serialize_proof_into_field_elements(proof_data_buf, &proof_data_fields, proof_length);
-        vk_fields_size = acir_proofs::serialize_verification_key_into_field_elements(
-            &g2x_buffer[0], vk_buf, &vk_fields, &vk_hash_buf);
-
-        bool verified = acir_proofs::verify_proof(&g2x_buffer[0],
-                                                  vk_buf,
-                                                  &constraint_system_buf[0],
-                                                  proof_data_buf,
-                                                  static_cast<uint32_t>(proof_length),
-                                                  true);
-        EXPECT_EQ(verified, true);
-
-        delete pippenger_ptr_base;
-        free((void*)vk_buf);
-        free((void*)pk_buf);
-        free((void*)proof_data_buf);
+    std::vector<uint8_t> witness_buf;           // = to_buffer(witness);
+    std::vector<uint8_t> constraint_system_buf; //
+    write(constraint_system_buf, constraint_system);
+    write(witness_buf, witness);
+
+    uint8_t const* pk_buf = nullptr;
+    acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
+
+    uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
+    uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+    auto verifier_crs = env_crs->get_verifier_crs();
+    barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
+
+    auto* pippenger_ptr_base = new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
+    void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
+
+    std::vector<uint8_t> g2x_buffer(128);
+    io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
+
+    uint8_t const* vk_buf = nullptr;
+    acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
+
+    uint8_t* proof_data_buf = nullptr;
+    size_t proof_length = acir_proofs::new_proof(
+        pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, true);
+
+    auto num_public_inputs = constraint_system.public_inputs.size();
+    proof_fields_size = acir_proofs::serialize_proof_into_field_elements(
+        proof_data_buf, &proof_data_fields, proof_length, num_public_inputs);
+    vk_fields_size =
+        acir_proofs::serialize_verification_key_into_field_elements(&g2x_buffer[0], vk_buf, &vk_fields, &vk_hash_buf);
+
+    bool verified = acir_proofs::verify_proof(
+        &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length), true);
+    EXPECT_EQ(verified, true);
+
+    delete pippenger_ptr_base;
+    free((void*)vk_buf);
+    free((void*)pk_buf);
+    free((void*)proof_data_buf);
+
+    fr vk_hash_value;
+    std::vector<fr> proof_witnesses(proof_fields_size / 32);
+    std::vector<fr> key_witnesses((vk_fields_size / 32) + 1);
+    for (size_t i = 0; i < proof_fields_size / 32; i++) {
+        proof_witnesses[i] = barretenberg::fr::serialize_from_buffer(&proof_data_fields[i * 32]);
+    }
+    for (size_t i = 0; i < vk_fields_size / 32; i++) {
+        key_witnesses[i] = barretenberg::fr::serialize_from_buffer(&vk_fields[i * 32]);
     }
-    // outer circuit
-    {
-        fr vk_hash_value;
-        std::vector<fr> proof_witnesses(proof_fields_size / 32);
-        std::vector<fr> key_witnesses(vk_fields_size / 32);
-        for (size_t i = 0; i < proof_fields_size / 32; i++) {
-            proof_witnesses[i] = barretenberg::fr::serialize_from_buffer(&proof_data_fields[i * 32]);
-        }
-        for (size_t i = 0; i < vk_fields_size / 32; i++) {
-            key_witnesses[i] = barretenberg::fr::serialize_from_buffer(&vk_fields[i * 32]);
-        }
-        vk_hash_value = barretenberg::fr::serialize_from_buffer(vk_hash_buf);
 
-        std::vector<uint32_t> proof_indices;
+    free((void*)proof_data_fields);
+    free((void*)vk_fields);
 
-        const size_t proof_size = proof_witnesses.size();
-        for (size_t i = 0; i < proof_size; ++i) {
-            proof_indices.emplace_back(static_cast<uint32_t>(i + 19));
-        }
+    vk_hash_value = barretenberg::fr::serialize_from_buffer(vk_hash_buf);
+    key_witnesses[vk_fields_size / 32] = vk_hash_value;
+    auto inner_circuit = RecursiveCircuitData{ key_witnesses, proof_witnesses, num_public_inputs };
+    return inner_circuit;
+}
+
+RecursiveCircuitData fetch_inner_circuit_data()
+{
+    acir_format::acir_format constraint_system;
+    std::vector<fr> witness;
+    create_inner_circuit(constraint_system, witness);
+
+    return fetch_recursive_circuit_data(constraint_system, witness);
+}
+
+/**
+ * @brief Create a circuit that recursively verifies one or more inner circuits
+ *
+ * @param inner_composers
+ * @return acir_format::Composer
+ */
+std::pair<acir_format::acir_format, std::vector<fr>> create_outer_circuit(
+    std::vector<RecursiveCircuitData>& inner_circuits)
+{
+    std::vector<acir_format::RecursionConstraint> recursion_constraints;
+
+    // witness count starts at 1 (Composer reserves 1st witness to be the zero-valued zero_idx)
+    size_t witness_offset = 1;
+    std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_aggregation_object;
+    std::vector<fr> witness;
+
+    for (size_t i = 0; i < inner_circuits.size(); ++i) {
+        const bool has_input_aggregation_object = i > 0;
+
+        auto& inner_circuit = inner_circuits[i];
+        const std::vector<barretenberg::fr> proof_witnesses = inner_circuit.proof_witnesses;
+        const std::vector<barretenberg::fr> key_witnesses = inner_circuit.key_witnesses;
+
+        const bool has_nested_proof = uint32_t(key_witnesses[5]);
 
+        const size_t num_inner_public_inputs = inner_circuit.num_public_inputs;
+
+        const uint32_t key_hash_start_idx = static_cast<uint32_t>(witness_offset);
+        const uint32_t public_input_start_idx = key_hash_start_idx + 1;
+        const uint32_t output_aggregation_object_start_idx =
+            static_cast<uint32_t>(public_input_start_idx + num_inner_public_inputs + (has_nested_proof ? 16 : 0));
+        const uint32_t proof_indices_start_idx = output_aggregation_object_start_idx + 16;
+        const uint32_t key_indices_start_idx = static_cast<uint32_t>(proof_indices_start_idx + proof_witnesses.size());
+
+        std::vector<uint32_t> proof_indices;
         std::vector<uint32_t> key_indices;
+        std::vector<uint32_t> inner_public_inputs;
+        std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> input_aggregation_object = {};
+        std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object = {};
+        if (has_input_aggregation_object) {
+            input_aggregation_object = output_aggregation_object;
+        }
+        for (size_t i = 0; i < 16; ++i) {
+            output_aggregation_object[i] = (static_cast<uint32_t>(i + output_aggregation_object_start_idx));
+        }
+        if (has_nested_proof) {
+            for (size_t i = 6; i < 22; ++i) {
+                nested_aggregation_object[i - 6] = uint32_t(key_witnesses[i]);
+            }
+        }
+        for (size_t i = 0; i < proof_witnesses.size(); ++i) {
+            proof_indices.emplace_back(static_cast<uint32_t>(i + proof_indices_start_idx));
+        }
         const size_t key_size = key_witnesses.size();
         for (size_t i = 0; i < key_size; ++i) {
-            key_indices.emplace_back(static_cast<uint32_t>(i + 19 + proof_size));
+            key_indices.emplace_back(static_cast<uint32_t>(i + key_indices_start_idx));
         }
-
-        std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> output_vars;
-        for (size_t i = 0; i < acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE; ++i) {
-            // variable idx 1 = public input
-            // variable idx 2-18 = output_vars
-            output_vars[i] = (static_cast<uint32_t>(i + 3));
+        for (size_t i = 0; i < num_inner_public_inputs; ++i) {
+            inner_public_inputs.push_back(static_cast<uint32_t>(i + public_input_start_idx));
         }
+
         acir_format::RecursionConstraint recursion_constraint{
             .key = key_indices,
             .proof = proof_indices,
-            .public_input = 1,
-            .key_hash = 2,
-            .input_aggregation_object = {},
-            .output_aggregation_object = output_vars,
+            .public_inputs = inner_public_inputs,
+            .key_hash = key_hash_start_idx,
+            .input_aggregation_object = input_aggregation_object,
+            .output_aggregation_object = output_aggregation_object,
+            .nested_aggregation_object = nested_aggregation_object,
         };
-
-        // Add a constraint that fixes the vk hash to be the expected value!
-        poly_triple vk_equality_constraint{
-            .a = recursion_constraint.key_hash,
-            .b = 0,
-            .c = 0,
-            .q_m = 0,
-            .q_l = 1,
-            .q_r = 0,
-            .q_o = 0,
-            .q_c = -vk_hash_value,
-        };
-
-        std::vector<fr> witness;
-        for (size_t i = 0; i < 18; ++i) {
+        recursion_constraints.push_back(recursion_constraint);
+        for (size_t i = 0; i < proof_indices_start_idx - witness_offset; ++i) {
             witness.emplace_back(0);
         }
         for (const auto& wit : proof_witnesses) {
@@ -263,66 +305,129 @@ TEST(AcirProofs, TestSerializationWithRecursion)
         for (const auto& wit : key_witnesses) {
             witness.emplace_back(wit);
         }
+        witness_offset = key_indices_start_idx + key_witnesses.size();
+    }
 
-        acir_format::acir_format constraint_system{
-            .varnum = static_cast<uint32_t>(witness.size() + 1),
-            .public_inputs = { 1 },
-            .fixed_base_scalar_mul_constraints = {},
-            .logic_constraints = {},
-            .range_constraints = {},
-            .schnorr_constraints = {},
-            .ecdsa_constraints = {},
-            .sha256_constraints = {},
-            .blake2s_constraints = {},
-            .keccak_constraints = {},
-            .hash_to_field_constraints = {},
-            .pedersen_constraints = {},
-            .compute_merkle_root_constraints = {},
-            .block_constraints = {},
-            .recursion_constraints = { recursion_constraint },
-            .constraints = { vk_equality_constraint },
-        };
+    std::vector<uint32_t> public_inputs(output_aggregation_object.begin(), output_aggregation_object.end());
 
-        std::vector<uint8_t> witness_buf;
-        std::vector<uint8_t> constraint_system_buf;
-        write(constraint_system_buf, constraint_system);
-        write(witness_buf, witness);
-        uint8_t const* pk_buf = nullptr;
-        acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
-
-        uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
-        uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
-        auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
-        auto verifier_crs = env_crs->get_verifier_crs();
-        barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
-
-        auto* pippenger_ptr_base =
-            new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
-        void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
-
-        std::vector<uint8_t> g2x_buffer(128);
-        io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
-
-        uint8_t const* vk_buf = nullptr;
-        acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
-
-        uint8_t* proof_data_buf = nullptr;
-        size_t proof_length = acir_proofs::new_proof(
-            pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, false);
-
-        bool verified = acir_proofs::verify_proof(&g2x_buffer[0],
-                                                  vk_buf,
-                                                  &constraint_system_buf[0],
-                                                  proof_data_buf,
-                                                  static_cast<uint32_t>(proof_length),
-                                                  false);
-        EXPECT_EQ(verified, true);
-
-        delete pippenger_ptr_base;
-        free((void*)vk_buf);
-        free((void*)pk_buf);
-        free((void*)proof_data_buf);
-        free((void*)proof_data_fields);
-        free((void*)vk_fields);
-    }
+    acir_format::acir_format constraint_system{
+        .varnum = static_cast<uint32_t>(witness.size() + 1),
+        .public_inputs = public_inputs,
+        .fixed_base_scalar_mul_constraints = {},
+        .logic_constraints = {},
+        .range_constraints = {},
+        .schnorr_constraints = {},
+        .ecdsa_constraints = {},
+        .sha256_constraints = {},
+        .blake2s_constraints = {},
+        .keccak_constraints = {},
+        .hash_to_field_constraints = {},
+        .pedersen_constraints = {},
+        .compute_merkle_root_constraints = {},
+        .block_constraints = {},
+        .recursion_constraints = recursion_constraints,
+        .constraints = {},
+    };
+
+    return std::make_pair(constraint_system, witness);
+}
+
+// Working double recursion test
+TEST(AcirProofs, TestSerializationWithBasicDoubleRecursion)
+{
+    std::vector<RecursiveCircuitData> inner_circuits;
+    auto a = fetch_inner_circuit_data();
+    inner_circuits.push_back(a);
+
+    auto b = fetch_inner_circuit_data();
+    inner_circuits.push_back(b);
+
+    auto c = create_outer_circuit(inner_circuits);
+
+    std::vector<uint8_t> witness_buf;
+    std::vector<uint8_t> constraint_system_buf;
+    write(constraint_system_buf, c.first);
+    write(witness_buf, c.second);
+    uint8_t const* pk_buf = nullptr;
+    acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
+
+    uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
+    uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+    auto verifier_crs = env_crs->get_verifier_crs();
+    barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
+
+    auto* pippenger_ptr_base = new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
+    void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
+
+    std::vector<uint8_t> g2x_buffer(128);
+    io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
+
+    uint8_t const* vk_buf = nullptr;
+    acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
+
+    uint8_t* proof_data_buf = nullptr;
+    size_t proof_length = acir_proofs::new_proof(
+        pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, false);
+
+    bool verified = acir_proofs::verify_proof(
+        &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length), false);
+    EXPECT_EQ(verified, true);
+
+    delete pippenger_ptr_base;
+    free((void*)vk_buf);
+    free((void*)pk_buf);
+    free((void*)proof_data_buf);
+}
+
+TEST(AcirProofs, TestSerializationWithFullRecursiveComposition)
+{
+    std::vector<RecursiveCircuitData> layer_1_circuits;
+    auto a_data_circuit = fetch_inner_circuit_data();
+    layer_1_circuits.push_back(a_data_circuit);
+
+    std::vector<RecursiveCircuitData> layer_2_circuits;
+    auto a2_circuit = fetch_inner_circuit_data();
+    layer_2_circuits.push_back(a2_circuit);
+
+    auto b_cs_and_witness = create_outer_circuit(layer_1_circuits);
+    auto b_circuit = fetch_recursive_circuit_data(b_cs_and_witness.first, b_cs_and_witness.second);
+    layer_2_circuits.push_back(b_circuit);
+
+    auto c_cs_and_witness = create_outer_circuit(layer_2_circuits);
+
+    std::vector<uint8_t> witness_buf;
+    std::vector<uint8_t> constraint_system_buf;
+    write(constraint_system_buf, c_cs_and_witness.first);
+    write(witness_buf, c_cs_and_witness.second);
+    uint8_t const* pk_buf = nullptr;
+    acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
+
+    uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
+    uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+    auto verifier_crs = env_crs->get_verifier_crs();
+    barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
+
+    auto* pippenger_ptr_base = new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
+    void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
+
+    std::vector<uint8_t> g2x_buffer(128);
+    io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
+
+    uint8_t const* vk_buf = nullptr;
+    acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
+
+    uint8_t* proof_data_buf = nullptr;
+    size_t proof_length = acir_proofs::new_proof(
+        pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, false);
+
+    bool verified = acir_proofs::verify_proof(
+        &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length), false);
+    EXPECT_EQ(verified, true);
+
+    delete pippenger_ptr_base;
+    free((void*)vk_buf);
+    free((void*)pk_buf);
+    free((void*)proof_data_buf);
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index 5ff7b29d96..62621d00be 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -45,10 +45,11 @@ WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t c
 }
 WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
                                                             uint8_t** serialized_proof_data_buf,
-                                                            size_t proof_data_length)
+                                                            size_t proof_data_length,
+                                                            size_t num_inner_public_inputs)
 {
     return acir_proofs::serialize_proof_into_field_elements(
-        proof_data_buf, serialized_proof_data_buf, proof_data_length);
+        proof_data_buf, serialized_proof_data_buf, proof_data_length, num_inner_public_inputs);
 }
 
 WASM_EXPORT size_t acir_proofs_new_proof(void* pippenger,
@@ -76,7 +77,7 @@ WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
                                                       uint32_t proof_length,
                                                       uint8_t const* vk_buf,
                                                       uint32_t vk_length,
-                                                      uint8_t const* public_inputs_buf,
+                                                      uint32_t num_public_inputs,
                                                       uint8_t const* input_aggregation_obj_buf,
                                                       uint8_t** output_aggregation_obj_buf)
 {
@@ -84,7 +85,7 @@ WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
                                                proof_length,
                                                vk_buf,
                                                vk_length,
-                                               public_inputs_buf,
+                                               num_public_inputs,
                                                input_aggregation_obj_buf,
                                                output_aggregation_obj_buf);
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index 0db08d5573..452f41d1ca 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -20,7 +20,8 @@ WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t c
                                                                        uint8_t** serialized_vk_hash_buf);
 WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
                                                             uint8_t** serialized_proof_data_buf,
-                                                            size_t proof_data_length);
+                                                            size_t proof_data_length,
+                                                            size_t num_inner_public_inputs);
 WASM_EXPORT size_t acir_proofs_new_proof(void* pippenger,
                                          uint8_t const* g2x,
                                          uint8_t const* pk_buf,
@@ -38,7 +39,7 @@ WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
                                                       uint32_t proof_length,
                                                       uint8_t const* vk_buf,
                                                       uint32_t vk_length,
-                                                      uint8_t const* public_inputs_buf,
+                                                      uint32_t num_public_inputs,
                                                       uint8_t const* input_aggregation_obj_buf,
                                                       uint8_t** output_aggregation_obj_buf);
 }
diff --git a/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp b/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
index 9bbe7314f2..bcf665711c 100644
--- a/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
+++ b/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
@@ -13,8 +13,7 @@ namespace proof_system::honk {
 
 // We won't compile this class with honk::flavor::Standard, but we will like want to compile it (at least for testing)
 // with a flavor that uses the curve Grumpkin, or a flavor that does/does not have zk, etc.
-template <typename T>
-concept UltraFlavor = IsAnyOf<T, honk::flavor::Ultra>;
+template <typename T> concept UltraFlavor = IsAnyOf<T, honk::flavor::Ultra>;
 template <UltraFlavor Flavor> class UltraProver_ {
 
     using FF = typename Flavor::FF;
diff --git a/cpp/src/barretenberg/plonk/composer/composer_base.hpp b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
index a3e57bc383..b1109d2d4d 100644
--- a/cpp/src/barretenberg/plonk/composer/composer_base.hpp
+++ b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
@@ -186,6 +186,21 @@ class ComposerBase {
 
     barretenberg::fr get_public_input(const uint32_t index) const { return get_variable(public_inputs[index]); }
 
+    uint32_t get_public_input_index(const uint32_t witness_index) const
+    {
+        bool found = false;
+        uint32_t result = static_cast<uint32_t>(-1);
+        for (size_t i = 0; i < public_inputs.size(); ++i) {
+            if (real_variable_index[public_inputs[i]] == real_variable_index[witness_index]) {
+                found = true;
+                result = static_cast<uint32_t>(i);
+                break;
+            }
+        }
+        ASSERT(found == true);
+        return result;
+    }
+
     std::vector<fr> get_public_inputs() const
     {
         std::vector<fr> result;
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
index 6f22b40bb0..6a73f5f2bc 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
@@ -261,6 +261,23 @@ class UltraComposer : public ComposerBase {
         }
     }
 
+    /**
+     * @brief Update recursive_proof_public_input_indices with existing public inputs that represent a recursive proof
+     *
+     * @param proof_output_witness_indices
+     */
+    void set_recursive_proof(const std::vector<uint32_t>& proof_output_witness_indices)
+    {
+        if (contains_recursive_proof) {
+            failure("added recursive proof when one already exists");
+        }
+        contains_recursive_proof = true;
+        for (size_t i = 0; i < proof_output_witness_indices.size(); ++i) {
+            recursive_proof_public_input_indices.push_back(
+                get_public_input_index(real_variable_index[proof_output_witness_indices[i]]));
+        }
+    }
+
     void create_new_range_constraint(const uint32_t variable_index,
                                      const uint64_t target_range,
                                      std::string const msg = "create_new_range_constraint");
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
index 743f563770..f99fb5aed7 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
@@ -258,7 +258,14 @@ std::vector<barretenberg::fr> verification_key::export_dummy_key_in_recursion_fo
 
     for (const auto& descriptor : polynomial_manifest.get()) {
         if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
-            const auto element = barretenberg::g1::affine_one;
+            // the std::biggroup class creates unsatisfiable constraints when identical points are added/subtracted.
+            // (when verifying zk proofs this is acceptable as we make sure verification key points are not identical.
+            // And prover points should contain randomness for an honest Prover).
+            // This check can also trigger a runtime error due to causing 0 to be inverted.
+            // When creating dummy verification key points we must be mindful of the above and make sure that each
+            // transcript point is unique.
+            auto scalar = barretenberg::fr::random_element();
+            const auto element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
             const uint256_t x = element.x;
             const uint256_t y = element.y;
             const barretenberg::fr x_lo = x.slice(0, 136);
@@ -271,6 +278,7 @@ std::vector<barretenberg::fr> verification_key::export_dummy_key_in_recursion_fo
             output.emplace_back(y_hi);
         }
     }
+
     output.emplace_back(0); // key_hash
 
     return output;
diff --git a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index 2cd486bbe1..818f1f9d9a 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -120,10 +120,10 @@ template <typename Composer> struct evaluation_domain {
 template <typename Curve> struct verification_key {
     using Composer = typename Curve::Composer;
 
-    template <bool inner_proof_contains_recursive_proof = false>
     static std::shared_ptr<verification_key> from_field_pt_vector(
         Composer* ctx,
         const std::vector<field_t<Composer>>& fields,
+        bool inner_proof_contains_recursive_proof = false,
         std::array<uint32_t, 16> recursive_proof_public_input_indices = {})
     {
         std::vector<fr> fields_raw;
@@ -138,15 +138,10 @@ template <typename Curve> struct verification_key {
 
         // NOTE: For now `contains_recursive_proof` and `recursive_proof_public_input_indices` need to be circuit
         // constants!
-        key->contains_recursive_proof = static_cast<bool>(uint256_t(fields[5].get_value()));
+        key->contains_recursive_proof = inner_proof_contains_recursive_proof;
         for (size_t i = 0; i < 16; ++i) {
-            const uint32_t idx = static_cast<uint32_t>(uint256_t(fields[6 + i].get_value()));
-            key->recursive_proof_public_input_indices.emplace_back(idx);
-        }
-        // Apply constraints to force the recursive proof information to be circuit constants
-        fields[5].assert_equal(inner_proof_contains_recursive_proof);
-        for (size_t i = 0; i < 16; ++i) {
-            fields[6 + i].assert_equal(recursive_proof_public_input_indices[i]);
+            auto x = recursive_proof_public_input_indices[i];
+            key->recursive_proof_public_input_indices.emplace_back(x);
         }
 
         size_t count = 22;
diff --git a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
index ad849889cc..2fe0830c37 100644
--- a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
+++ b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
@@ -104,7 +104,8 @@ class StandardTranscript : public Transcript {
      * @param manifest
      * @return std::vector<barretenberg::fr>
      */
-    static std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const Manifest& manifest)
+    static std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(
+        const Manifest& manifest, const bool contains_recursive_proof)
     {
         std::vector<barretenberg::fr> fields;
         const auto num_rounds = manifest.get_num_rounds();
@@ -114,7 +115,14 @@ class StandardTranscript : public Transcript {
                     if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
                         fields.emplace_back(0);
                     } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
-                        const auto group_element = barretenberg::g1::affine_one;
+                        // the std::biggroup class creates unsatisfiable constraints when identical points are
+                        // added/subtracted.
+                        // (when verifying zk proofs this is acceptable as we make sure verification key points are not
+                        // identical. And prover points should contain randomness for an honest Prover). This check can
+                        // also trigger a runtime error due to causing 0 to be inverted. When creating dummy proof
+                        // points we must be mindful of the above and make sure that each point is unique.
+                        auto scalar = barretenberg::fr::random_element();
+                        const auto group_element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
                         const uint256_t x = group_element.x;
                         const uint256_t y = group_element.y;
                         const barretenberg::fr x_lo = x.slice(0, 136);
@@ -128,8 +136,30 @@ class StandardTranscript : public Transcript {
                     } else {
                         ASSERT(manifest_element.name == "public_inputs");
                         const size_t num_public_inputs = manifest_element.num_bytes / 32;
-                        for (size_t j = 0; j < num_public_inputs; ++j) {
-                            fields.emplace_back(0);
+                        // If we have a recursive proofs the public inputs must describe an aggregation object that
+                        // is composed of two valid G1 points on the curve. Without this conditional we will get a
+                        // runtime error that we are attempting to invert 0.
+                        if (contains_recursive_proof) {
+                            ASSERT(num_public_inputs == 16);
+                            for (size_t k = 0; k < num_public_inputs / 4; ++k) {
+                                auto scalar = barretenberg::fr::random_element();
+                                const auto group_element =
+                                    barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
+                                const uint256_t x = group_element.x;
+                                const uint256_t y = group_element.y;
+                                const barretenberg::fr x_lo = x.slice(0, 136);
+                                const barretenberg::fr x_hi = x.slice(136, 272);
+                                const barretenberg::fr y_lo = y.slice(0, 136);
+                                const barretenberg::fr y_hi = y.slice(136, 272);
+                                fields.emplace_back(x_lo);
+                                fields.emplace_back(x_hi);
+                                fields.emplace_back(y_lo);
+                                fields.emplace_back(y_hi);
+                            }
+                        } else {
+                            for (size_t j = 0; j < num_public_inputs; ++j) {
+                                fields.emplace_back(0);
+                            }
                         }
                     }
                 }

From a2f6cbbd5bc78d69d36b4a5dd1458572b1946edd Mon Sep 17 00:00:00 2001
From: Maxim Vezenov <mvezenov@gmail.com>
Date: Mon, 22 May 2023 10:33:10 -0400
Subject: [PATCH 27/64] move export key into dsl package

---
 .../dsl/acir_format/recursion_constraint.cpp  | 110 +++++++++++++++++-
 .../dsl/acir_format/recursion_constraint.hpp  |   6 +
 .../acir_format/recursion_constraint.test.cpp |   3 +-
 .../dsl/acir_proofs/acir_proofs.cpp           |   2 +-
 4 files changed, 117 insertions(+), 4 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 1fcf95f594..d47e493427 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -36,8 +36,8 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     // on-curve errors and inverting-zero errors
     {
         // get a fake key/proof that satisfies on-curve + inversion-zero checks
-        const std::vector<fr> dummy_key = plonk::verification_key::export_dummy_key_in_recursion_format(
-            PolynomialManifest(Composer::type), inner_proof_contains_recursive_proof);
+        const std::vector<fr> dummy_key = export_dummy_key_in_recursion_format(PolynomialManifest(Composer::type),
+                                                                               inner_proof_contains_recursive_proof);
         const auto manifest = Composer::create_unrolled_manifest(input.public_inputs.size());
         const std::vector<barretenberg::fr> dummy_proof =
             transcript::StandardTranscript::export_dummy_transcript_in_recursion_format(
@@ -138,4 +138,110 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
 template void create_recursion_constraints<false>(Composer&, const RecursionConstraint&);
 template void create_recursion_constraints<true>(Composer&, const RecursionConstraint&);
 
+/**
+ * @brief When recursively verifying proofs, we represent the verification key using field elements.
+ *        This method exports the key formatted in the manner our recursive verifier expects.
+ *        NOTE: only used by the dsl at the moment. Might be cleaner to make this a dsl function?
+ *
+ * @return std::vector<barretenberg::fr>
+ */
+std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<verification_key> const& vkey)
+{
+    std::vector<fr> output;
+    output.emplace_back(vkey->domain.root);
+    output.emplace_back(vkey->domain.domain);
+    output.emplace_back(vkey->domain.generator);
+    output.emplace_back(vkey->circuit_size);
+    output.emplace_back(vkey->num_public_inputs);
+    output.emplace_back(vkey->contains_recursive_proof);
+    for (size_t i = 0; i < 16; ++i) {
+        if (vkey->recursive_proof_public_input_indices.size() > i) {
+            output.emplace_back(vkey->recursive_proof_public_input_indices[i]);
+        } else {
+            output.emplace_back(0);
+            ASSERT(vkey->contains_recursive_proof == false);
+        }
+    }
+    for (const auto& descriptor : vkey->polynomial_manifest.get()) {
+        if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
+            const auto element = vkey->commitments.at(std::string(descriptor.commitment_label));
+            const uint256_t x = element.x;
+            const uint256_t y = element.y;
+            const barretenberg::fr x_lo = x.slice(0, 136);
+            const barretenberg::fr x_hi = x.slice(136, 272);
+            const barretenberg::fr y_lo = y.slice(0, 136);
+            const barretenberg::fr y_hi = y.slice(136, 272);
+            output.emplace_back(x_lo);
+            output.emplace_back(x_hi);
+            output.emplace_back(y_lo);
+            output.emplace_back(y_hi);
+        }
+    }
+
+    verification_key_data vkey_data{
+        .composer_type = vkey->composer_type,
+        .circuit_size = static_cast<uint32_t>(vkey->circuit_size),
+        .num_public_inputs = static_cast<uint32_t>(vkey->num_public_inputs),
+        .commitments = vkey->commitments,
+        .contains_recursive_proof = vkey->contains_recursive_proof,
+        .recursive_proof_public_input_indices = vkey->recursive_proof_public_input_indices,
+    };
+    output.emplace_back(vkey_data.compress_native(0)); // key_hash
+    return output;
+}
+
+/**
+ * @brief When recursively verifying proofs, we represent the verification key using field elements.
+ *        This method exports the key formatted in the manner our recursive verifier expects.
+ *        A dummy key is used when building a circuit without a valid witness assignment.
+ *        We want the transcript to contain valid G1 points to prevent on-curve errors being thrown.
+ *        We want a non-zero circuit size as this element will be inverted by the circuit
+ *        and we do not want an "inverting 0" error thrown
+ *
+ * @return std::vector<barretenberg::fr>
+ */
+std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const PolynomialManifest& polynomial_manifest,
+                                                                   const bool contains_recursive_proof)
+{
+    std::vector<fr> output;
+    output.emplace_back(1); // domain.domain (will be inverted)
+    output.emplace_back(1); // domain.root (will be inverted)
+    output.emplace_back(1); // domain.generator (will be inverted)
+
+    output.emplace_back(1); // circuit size
+    output.emplace_back(1); // num public inputs
+
+    output.emplace_back(contains_recursive_proof); // contains_recursive_proof
+    for (size_t i = 0; i < 16; ++i) {
+        output.emplace_back(0); // recursive_proof_public_input_indices
+    }
+
+    for (const auto& descriptor : polynomial_manifest.get()) {
+        if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
+            // the std::biggroup class creates unsatisfiable constraints when identical points are added/subtracted.
+            // (when verifying zk proofs this is acceptable as we make sure verification key points are not identical.
+            // And prover points should contain randomness for an honest Prover).
+            // This check can also trigger a runtime error due to causing 0 to be inverted.
+            // When creating dummy verification key points we must be mindful of the above and make sure that each
+            // transcript point is unique.
+            auto scalar = barretenberg::fr::random_element();
+            const auto element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
+            const uint256_t x = element.x;
+            const uint256_t y = element.y;
+            const barretenberg::fr x_lo = x.slice(0, 136);
+            const barretenberg::fr x_hi = x.slice(136, 272);
+            const barretenberg::fr y_lo = y.slice(0, 136);
+            const barretenberg::fr y_hi = y.slice(136, 272);
+            output.emplace_back(x_lo);
+            output.emplace_back(x_hi);
+            output.emplace_back(y_lo);
+            output.emplace_back(y_hi);
+        }
+    }
+
+    output.emplace_back(0); // key_hash
+
+    return output;
+}
+
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index 0a0ca53d12..15af19039f 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -6,6 +6,8 @@
 
 namespace acir_format {
 
+using namespace proof_system::plonk;
+
 /**
  * @brief RecursionConstraint struct contains information required to recursively verify a proof!
  *
@@ -60,6 +62,10 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
 extern template void create_recursion_constraints<false>(Composer&, const RecursionConstraint&);
 extern template void create_recursion_constraints<true>(Composer&, const RecursionConstraint&);
 
+std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<verification_key> const& vkey);
+std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const PolynomialManifest& polynomial_manifest,
+                                                                   bool contains_recursive_proof = 0);
+
 template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 {
     using serialize::read;
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index c6b511d662..2f4436c2a3 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -141,7 +141,8 @@ acir_format::Composer create_outer_circuit(std::vector<acir_format::Composer>& i
                                                   16);
 
         const std::vector<barretenberg::fr> proof_witnesses = transcript.export_transcript_in_recursion_format();
-        const std::vector<barretenberg::fr> key_witnesses = inner_verifier.key->export_key_in_recursion_format();
+        const std::vector<barretenberg::fr> key_witnesses =
+            acir_format::export_key_in_recursion_format(inner_verifier.key);
 
         const uint32_t key_hash_start_idx = static_cast<uint32_t>(witness_offset);
         const uint32_t public_input_start_idx = key_hash_start_idx + 1;
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 4310342f7e..690aec5e7a 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -157,7 +157,7 @@ size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
     plonk::verification_key_data vk_data;
     read(vk_buf, vk_data);
     auto vkey = std::make_shared<proof_system::plonk::verification_key>(std::move(vk_data), crs);
-    std::vector<barretenberg::fr> output = vkey->export_key_in_recursion_format();
+    std::vector<barretenberg::fr> output = acir_format::export_key_in_recursion_format(vkey);
 
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
     // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o

From b56d3ca9e3914abc959e82942f9c728fecc9335b Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 22 May 2023 14:34:24 +0000
Subject: [PATCH 28/64] chore: remove unused export key in recursion format
 from main proof system classes

---
 .../verification_key/verification_key.cpp     | 106 ------------------
 .../verification_key/verification_key.hpp     |   3 -
 2 files changed, 109 deletions(-)

diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
index f99fb5aed7..f6cf92bd73 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
@@ -178,110 +178,4 @@ sha256::hash verification_key::sha256_hash()
     return sha256::sha256(to_buffer(vk_data));
 }
 
-/**
- * @brief When recursively verifying proofs, we represent the verification key using field elements.
- *        This method exports the key formatted in the manner our recursive verifier expects.
- *        NOTE: only used by the dsl at the moment. Might be cleaner to make this a dsl function?
- *
- * @return std::vector<barretenberg::fr>
- */
-std::vector<barretenberg::fr> verification_key::export_key_in_recursion_format()
-{
-    std::vector<fr> output;
-    output.emplace_back(domain.root);
-    output.emplace_back(domain.domain);
-    output.emplace_back(domain.generator);
-    output.emplace_back(circuit_size);
-    output.emplace_back(num_public_inputs);
-    output.emplace_back(contains_recursive_proof);
-    for (size_t i = 0; i < 16; ++i) {
-        if (recursive_proof_public_input_indices.size() > i) {
-            output.emplace_back(recursive_proof_public_input_indices[i]);
-        } else {
-            output.emplace_back(0);
-            ASSERT(contains_recursive_proof == false);
-        }
-    }
-    for (const auto& descriptor : polynomial_manifest.get()) {
-        if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
-            const auto element = commitments.at(std::string(descriptor.commitment_label));
-            const uint256_t x = element.x;
-            const uint256_t y = element.y;
-            const barretenberg::fr x_lo = x.slice(0, 136);
-            const barretenberg::fr x_hi = x.slice(136, 272);
-            const barretenberg::fr y_lo = y.slice(0, 136);
-            const barretenberg::fr y_hi = y.slice(136, 272);
-            output.emplace_back(x_lo);
-            output.emplace_back(x_hi);
-            output.emplace_back(y_lo);
-            output.emplace_back(y_hi);
-        }
-    }
-
-    verification_key_data vkey_data{
-        .composer_type = composer_type,
-        .circuit_size = static_cast<uint32_t>(circuit_size),
-        .num_public_inputs = static_cast<uint32_t>(num_public_inputs),
-        .commitments = commitments,
-        .contains_recursive_proof = contains_recursive_proof,
-        .recursive_proof_public_input_indices = recursive_proof_public_input_indices,
-    };
-    output.emplace_back(vkey_data.compress_native(0)); // key_hash
-    return output;
-}
-
-/**
- * @brief When recursively verifying proofs, we represent the verification key using field elements.
- *        This method exports the key formatted in the manner our recursive verifier expects.
- *        A dummy key is used when building a circuit without a valid witness assignment.
- *        We want the transcript to contain valid G1 points to prevent on-curve errors being thrown.
- *        We want a non-zero circuit size as this element will be inverted by the circuit
- *        and we do not want an "inverting 0" error thrown
- *
- * @return std::vector<barretenberg::fr>
- */
-std::vector<barretenberg::fr> verification_key::export_dummy_key_in_recursion_format(
-    const PolynomialManifest& polynomial_manifest, const bool contains_recursive_proof)
-{
-    std::vector<fr> output;
-    output.emplace_back(1); // domain.domain (will be inverted)
-    output.emplace_back(1); // domain.root (will be inverted)
-    output.emplace_back(1); // domain.generator (will be inverted)
-
-    output.emplace_back(1); // circuit size
-    output.emplace_back(1); // num public inputs
-
-    output.emplace_back(contains_recursive_proof); // contains_recursive_proof
-    for (size_t i = 0; i < 16; ++i) {
-        output.emplace_back(0); // recursive_proof_public_input_indices
-    }
-
-    for (const auto& descriptor : polynomial_manifest.get()) {
-        if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
-            // the std::biggroup class creates unsatisfiable constraints when identical points are added/subtracted.
-            // (when verifying zk proofs this is acceptable as we make sure verification key points are not identical.
-            // And prover points should contain randomness for an honest Prover).
-            // This check can also trigger a runtime error due to causing 0 to be inverted.
-            // When creating dummy verification key points we must be mindful of the above and make sure that each
-            // transcript point is unique.
-            auto scalar = barretenberg::fr::random_element();
-            const auto element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
-            const uint256_t x = element.x;
-            const uint256_t y = element.y;
-            const barretenberg::fr x_lo = x.slice(0, 136);
-            const barretenberg::fr x_hi = x.slice(136, 272);
-            const barretenberg::fr y_lo = y.slice(0, 136);
-            const barretenberg::fr y_hi = y.slice(136, 272);
-            output.emplace_back(x_lo);
-            output.emplace_back(x_hi);
-            output.emplace_back(y_lo);
-            output.emplace_back(y_hi);
-        }
-    }
-
-    output.emplace_back(0); // key_hash
-
-    return output;
-}
-
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
index 974ada27b1..1e5dca35d2 100644
--- a/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
@@ -63,9 +63,6 @@ struct verification_key {
     ~verification_key() = default;
 
     sha256::hash sha256_hash();
-    std::vector<barretenberg::fr> export_key_in_recursion_format();
-    static std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(
-        const PolynomialManifest& polynomial_manifest, bool contains_recursive_proof = 0);
 
     uint32_t composer_type;
     size_t circuit_size;

From 97ede2ef96ebb19214bc2a4e4ac4ed4fedc31e10 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 22 May 2023 14:46:47 +0000
Subject: [PATCH 29/64] pr review: moved from_witness comment and renamed
 from_field_pt_vector

---
 .../dsl/acir_format/recursion_constraint.cpp     |  2 +-
 .../barretenberg/dsl/acir_proofs/acir_proofs.cpp |  2 +-
 .../verification_key/verification_key.hpp        | 16 ++++++++--------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index d47e493427..52c4bf3e94 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -110,7 +110,7 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 
     // recursively verify the proof
-    std::shared_ptr<verification_key_ct> vkey = verification_key_ct::from_field_pt_vector(
+    std::shared_ptr<verification_key_ct> vkey = verification_key_ct::from_field_elements(
         &composer, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_indices);
     vkey->program_width = noir_recursive_settings::program_width;
     Transcript_ct transcript(&composer, manifest, proof_fields, input.public_inputs.size());
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 690aec5e7a..8173cd4af0 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -341,7 +341,7 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
         nested_aggregation_indices_all_zero &= (idx == 0);
     }
     const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
-    std::shared_ptr<acir_format::verification_key_ct> vkey = acir_format::verification_key_ct::from_field_pt_vector(
+    std::shared_ptr<acir_format::verification_key_ct> vkey = acir_format::verification_key_ct::from_field_elements(
         &composer, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_object);
     vkey->program_width = acir_format::noir_recursive_settings::program_width;
     acir_format::Transcript_ct transcript(&composer, manifest, proof_fields, num_public_inputs);
diff --git a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index 818f1f9d9a..a8dcdc5787 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -25,7 +25,7 @@ namespace stdlib {
 namespace recursion {
 
 template <typename Composer> struct evaluation_domain {
-    static evaluation_domain from_field_pt_vector(const std::vector<field_t<Composer>>& fields)
+    static evaluation_domain from_field_elements(const std::vector<field_t<Composer>>& fields)
     {
         evaluation_domain domain;
         domain.root = fields[0];
@@ -112,15 +112,10 @@ template <typename Composer> struct evaluation_domain {
     uint32<Composer> size;
 };
 
-/**
- * @brief Converts a 'native' verification key into a standard library type, instantiating the `input_key` parameter as
- * circuit variables. This allows the recursive verifier to accept arbitrary verification keys, where the circuit being
- * verified is not fixed as part of the recursive circuit.
- */
 template <typename Curve> struct verification_key {
     using Composer = typename Curve::Composer;
 
-    static std::shared_ptr<verification_key> from_field_pt_vector(
+    static std::shared_ptr<verification_key> from_field_elements(
         Composer* ctx,
         const std::vector<field_t<Composer>>& fields,
         bool inner_proof_contains_recursive_proof = false,
@@ -131,7 +126,7 @@ template <typename Curve> struct verification_key {
         key->context = ctx;
 
         key->polynomial_manifest = PolynomialManifest(Composer::type);
-        key->domain = evaluation_domain<Composer>::from_field_pt_vector({ fields[0], fields[1], fields[2] });
+        key->domain = evaluation_domain<Composer>::from_field_elements({ fields[0], fields[1], fields[2] });
 
         key->n = fields[3];
         key->num_public_inputs = fields[4];
@@ -163,6 +158,11 @@ template <typename Curve> struct verification_key {
         return key;
     }
 
+    /**
+     * @brief Converts a 'native' verification key into a standard library type, instantiating the `input_key` parameter
+     * as circuit variables. This allows the recursive verifier to accept arbitrary verification keys, where the circuit
+     * being verified is not fixed as part of the recursive circuit.
+     */
     static std::shared_ptr<verification_key> from_witness(Composer* ctx,
                                                           const std::shared_ptr<plonk::verification_key>& input_key)
     {

From c64d8b5aa965c5f203151ec531c25a096e53a450 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 22 May 2023 15:09:58 +0000
Subject: [PATCH 30/64] moved export transcript in recursion format to DSL
 package

---
 .../dsl/acir_format/recursion_constraint.cpp  | 113 +++++++++++++++++-
 .../dsl/acir_format/recursion_constraint.hpp  |   4 +
 .../acir_format/recursion_constraint.test.cpp |   3 +-
 .../dsl/acir_proofs/acir_proofs.cpp           |   2 +-
 .../transcript/transcript_wrappers.hpp        | 111 -----------------
 5 files changed, 118 insertions(+), 115 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 52c4bf3e94..f6bc8795ed 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -40,8 +40,7 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
                                                                                inner_proof_contains_recursive_proof);
         const auto manifest = Composer::create_unrolled_manifest(input.public_inputs.size());
         const std::vector<barretenberg::fr> dummy_proof =
-            transcript::StandardTranscript::export_dummy_transcript_in_recursion_format(
-                manifest, inner_proof_contains_recursive_proof);
+            export_dummy_transcript_in_recursion_format(manifest, inner_proof_contains_recursive_proof);
         for (size_t i = 0; i < input.proof.size(); ++i) {
             const auto proof_field_idx = input.proof[i];
             // if we do NOT have a witness assignment (i.e. are just building the proving/verification keys),
@@ -244,4 +243,114 @@ std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const Polynom
     return output;
 }
 
+/**
+ * @brief Returns transcript represented as a vector of barretenberg::fr.
+ *        Used to represent recursive proofs (i.e. proof represented as circuit-native field elements)
+ *
+ * @return std::vector<barretenberg::fr>
+ */
+std::vector<barretenberg::fr> export_transcript_in_recursion_format(const transcript::StandardTranscript& transcript)
+{
+    std::vector<barretenberg::fr> fields;
+    const auto num_rounds = transcript.get_manifest().get_num_rounds();
+    for (size_t i = 0; i < num_rounds; ++i) {
+        for (const auto& manifest_element : transcript.get_manifest().get_round_manifest(i).elements) {
+            if (!manifest_element.derived_by_verifier) {
+                if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
+                    fields.emplace_back(transcript.get_field_element(manifest_element.name));
+                } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
+                    const auto group_element = transcript.get_group_element(manifest_element.name);
+                    const uint256_t x = group_element.x;
+                    const uint256_t y = group_element.y;
+                    const barretenberg::fr x_lo = x.slice(0, 136);
+                    const barretenberg::fr x_hi = x.slice(136, 272);
+                    const barretenberg::fr y_lo = y.slice(0, 136);
+                    const barretenberg::fr y_hi = y.slice(136, 272);
+                    fields.emplace_back(x_lo);
+                    fields.emplace_back(x_hi);
+                    fields.emplace_back(y_lo);
+                    fields.emplace_back(y_hi);
+                } else {
+                    ASSERT(manifest_element.name == "public_inputs");
+                    const auto public_inputs_vector = transcript.get_field_element_vector(manifest_element.name);
+                    for (const auto& ele : public_inputs_vector) {
+                        fields.emplace_back(ele);
+                    }
+                }
+            }
+        }
+    }
+    return fields;
+}
+
+/**
+ * @brief Get a dummy fake proof for recursion. All elliptic curve group elements are still valid points to prevent
+ * errors being thrown.
+ *
+ * @param manifest
+ * @return std::vector<barretenberg::fr>
+ */
+std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const transcript::Manifest& manifest,
+                                                                          const bool contains_recursive_proof)
+{
+    std::vector<barretenberg::fr> fields;
+    const auto num_rounds = manifest.get_num_rounds();
+    for (size_t i = 0; i < num_rounds; ++i) {
+        for (const auto& manifest_element : manifest.get_round_manifest(i).elements) {
+            if (!manifest_element.derived_by_verifier) {
+                if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
+                    fields.emplace_back(0);
+                } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
+                    // the std::biggroup class creates unsatisfiable constraints when identical points are
+                    // added/subtracted.
+                    // (when verifying zk proofs this is acceptable as we make sure verification key points are not
+                    // identical. And prover points should contain randomness for an honest Prover). This check can
+                    // also trigger a runtime error due to causing 0 to be inverted. When creating dummy proof
+                    // points we must be mindful of the above and make sure that each point is unique.
+                    auto scalar = barretenberg::fr::random_element();
+                    const auto group_element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
+                    const uint256_t x = group_element.x;
+                    const uint256_t y = group_element.y;
+                    const barretenberg::fr x_lo = x.slice(0, 136);
+                    const barretenberg::fr x_hi = x.slice(136, 272);
+                    const barretenberg::fr y_lo = y.slice(0, 136);
+                    const barretenberg::fr y_hi = y.slice(136, 272);
+                    fields.emplace_back(x_lo);
+                    fields.emplace_back(x_hi);
+                    fields.emplace_back(y_lo);
+                    fields.emplace_back(y_hi);
+                } else {
+                    ASSERT(manifest_element.name == "public_inputs");
+                    const size_t num_public_inputs = manifest_element.num_bytes / 32;
+                    // If we have a recursive proofs the public inputs must describe an aggregation object that
+                    // is composed of two valid G1 points on the curve. Without this conditional we will get a
+                    // runtime error that we are attempting to invert 0.
+                    if (contains_recursive_proof) {
+                        ASSERT(num_public_inputs == 16);
+                        for (size_t k = 0; k < num_public_inputs / 4; ++k) {
+                            auto scalar = barretenberg::fr::random_element();
+                            const auto group_element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
+                            const uint256_t x = group_element.x;
+                            const uint256_t y = group_element.y;
+                            const barretenberg::fr x_lo = x.slice(0, 136);
+                            const barretenberg::fr x_hi = x.slice(136, 272);
+                            const barretenberg::fr y_lo = y.slice(0, 136);
+                            const barretenberg::fr y_hi = y.slice(136, 272);
+                            fields.emplace_back(x_lo);
+                            fields.emplace_back(x_hi);
+                            fields.emplace_back(y_lo);
+                            fields.emplace_back(y_hi);
+                        }
+                    } else {
+                        for (size_t j = 0; j < num_public_inputs; ++j) {
+                            fields.emplace_back(0);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return fields;
+}
+
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index 15af19039f..615f23a553 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -66,6 +66,10 @@ std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<ver
 std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const PolynomialManifest& polynomial_manifest,
                                                                    bool contains_recursive_proof = 0);
 
+std::vector<barretenberg::fr> export_transcript_in_recursion_format(const transcript::StandardTranscript& transcript);
+std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const transcript::Manifest& manifest,
+                                                                          const bool contains_recursive_proof);
+
 template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 {
     using serialize::read;
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index 2f4436c2a3..82e6135622 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -140,7 +140,8 @@ acir_format::Composer create_outer_circuit(std::vector<acir_format::Composer>& i
                                                   transcript::HashType::PlookupPedersenBlake3s,
                                                   16);
 
-        const std::vector<barretenberg::fr> proof_witnesses = transcript.export_transcript_in_recursion_format();
+        const std::vector<barretenberg::fr> proof_witnesses =
+            acir_format::export_transcript_in_recursion_format(transcript);
         const std::vector<barretenberg::fr> key_witnesses =
             acir_format::export_key_in_recursion_format(inner_verifier.key);
 
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 8173cd4af0..319c74a34f 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -125,7 +125,7 @@ size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
                                               transcript::HashType::PlookupPedersenBlake3s,
                                               16);
 
-    std::vector<barretenberg::fr> output = transcript.export_transcript_in_recursion_format();
+    std::vector<barretenberg::fr> output = acir_format::export_transcript_in_recursion_format(transcript);
 
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
     const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr);
diff --git a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
index 2fe0830c37..bd33eff800 100644
--- a/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
+++ b/cpp/src/barretenberg/transcript/transcript_wrappers.hpp
@@ -56,117 +56,6 @@ class StandardTranscript : public Transcript {
 
     // TODO(luke): temporary function for debugging
     barretenberg::fr get_mock_challenge() { return barretenberg::fr::random_element(); };
-
-    /**
-     * @brief Returns transcript represented as a vector of barretenberg::fr.
-     *        Used to represent recursive proofs (i.e. proof represented as circuit-native field elements)
-     *
-     * @return std::vector<barretenberg::fr>
-     */
-    std::vector<barretenberg::fr> export_transcript_in_recursion_format()
-    {
-        std::vector<barretenberg::fr> fields;
-        const auto num_rounds = get_manifest().get_num_rounds();
-        for (size_t i = 0; i < num_rounds; ++i) {
-            for (const auto& manifest_element : get_manifest().get_round_manifest(i).elements) {
-                if (!manifest_element.derived_by_verifier) {
-                    if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
-                        fields.emplace_back(get_field_element(manifest_element.name));
-                    } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
-                        const auto group_element = get_group_element(manifest_element.name);
-                        const uint256_t x = group_element.x;
-                        const uint256_t y = group_element.y;
-                        const barretenberg::fr x_lo = x.slice(0, 136);
-                        const barretenberg::fr x_hi = x.slice(136, 272);
-                        const barretenberg::fr y_lo = y.slice(0, 136);
-                        const barretenberg::fr y_hi = y.slice(136, 272);
-                        fields.emplace_back(x_lo);
-                        fields.emplace_back(x_hi);
-                        fields.emplace_back(y_lo);
-                        fields.emplace_back(y_hi);
-                    } else {
-                        ASSERT(manifest_element.name == "public_inputs");
-                        const auto public_inputs_vector = get_field_element_vector(manifest_element.name);
-                        for (const auto& ele : public_inputs_vector) {
-                            fields.emplace_back(ele);
-                        }
-                    }
-                }
-            }
-        }
-        return fields;
-    }
-
-    /**
-     * @brief Get a dummy fake proof for recursion. All elliptic curve group elements are still valid points to prevent
-     * errors being thrown.
-     *
-     * @param manifest
-     * @return std::vector<barretenberg::fr>
-     */
-    static std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(
-        const Manifest& manifest, const bool contains_recursive_proof)
-    {
-        std::vector<barretenberg::fr> fields;
-        const auto num_rounds = manifest.get_num_rounds();
-        for (size_t i = 0; i < num_rounds; ++i) {
-            for (const auto& manifest_element : manifest.get_round_manifest(i).elements) {
-                if (!manifest_element.derived_by_verifier) {
-                    if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
-                        fields.emplace_back(0);
-                    } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
-                        // the std::biggroup class creates unsatisfiable constraints when identical points are
-                        // added/subtracted.
-                        // (when verifying zk proofs this is acceptable as we make sure verification key points are not
-                        // identical. And prover points should contain randomness for an honest Prover). This check can
-                        // also trigger a runtime error due to causing 0 to be inverted. When creating dummy proof
-                        // points we must be mindful of the above and make sure that each point is unique.
-                        auto scalar = barretenberg::fr::random_element();
-                        const auto group_element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
-                        const uint256_t x = group_element.x;
-                        const uint256_t y = group_element.y;
-                        const barretenberg::fr x_lo = x.slice(0, 136);
-                        const barretenberg::fr x_hi = x.slice(136, 272);
-                        const barretenberg::fr y_lo = y.slice(0, 136);
-                        const barretenberg::fr y_hi = y.slice(136, 272);
-                        fields.emplace_back(x_lo);
-                        fields.emplace_back(x_hi);
-                        fields.emplace_back(y_lo);
-                        fields.emplace_back(y_hi);
-                    } else {
-                        ASSERT(manifest_element.name == "public_inputs");
-                        const size_t num_public_inputs = manifest_element.num_bytes / 32;
-                        // If we have a recursive proofs the public inputs must describe an aggregation object that
-                        // is composed of two valid G1 points on the curve. Without this conditional we will get a
-                        // runtime error that we are attempting to invert 0.
-                        if (contains_recursive_proof) {
-                            ASSERT(num_public_inputs == 16);
-                            for (size_t k = 0; k < num_public_inputs / 4; ++k) {
-                                auto scalar = barretenberg::fr::random_element();
-                                const auto group_element =
-                                    barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
-                                const uint256_t x = group_element.x;
-                                const uint256_t y = group_element.y;
-                                const barretenberg::fr x_lo = x.slice(0, 136);
-                                const barretenberg::fr x_hi = x.slice(136, 272);
-                                const barretenberg::fr y_lo = y.slice(0, 136);
-                                const barretenberg::fr y_hi = y.slice(136, 272);
-                                fields.emplace_back(x_lo);
-                                fields.emplace_back(x_hi);
-                                fields.emplace_back(y_lo);
-                                fields.emplace_back(y_hi);
-                            }
-                        } else {
-                            for (size_t j = 0; j < num_public_inputs; ++j) {
-                                fields.emplace_back(0);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return fields;
-    }
 };
 
 } // namespace transcript

From f3baab0fea65f6e04a4ecac96af37a13a5e76fc9 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 22 May 2023 18:28:28 +0000
Subject: [PATCH 31/64] move order of acir functions

---
 .../dsl/acir_proofs/acir_proofs.cpp           | 152 +++++++++---------
 .../dsl/acir_proofs/acir_proofs.hpp           |  18 ++-
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   |  33 ++--
 .../barretenberg/dsl/acir_proofs/c_bind.hpp   |  18 ++-
 cpp/src/barretenberg/dsl/types.hpp            |   2 +-
 5 files changed, 113 insertions(+), 110 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 319c74a34f..877921f217 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -105,82 +105,6 @@ size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const*
     return buffer.size();
 }
 
-/**
- * @brief Takes in a proof buffer and converts into a vector of field elements.
- *        The Recursion opcode requires the proof serialized as a vector of witnesses.
- *        Use this method to get the witness values!
- *
- * @param proof_data_buf
- * @param serialized_proof_data_buf
- */
-size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
-                                           uint8_t** serialized_proof_data_buf,
-                                           size_t proof_data_length,
-                                           size_t num_inner_public_inputs)
-{
-    plonk::proof proof = { std::vector<uint8_t>(proof_data_buf, &proof_data_buf[proof_data_length]) };
-
-    transcript::StandardTranscript transcript(proof.proof_data,
-                                              acir_format::Composer::create_manifest(num_inner_public_inputs),
-                                              transcript::HashType::PlookupPedersenBlake3s,
-                                              16);
-
-    std::vector<barretenberg::fr> output = acir_format::export_transcript_in_recursion_format(transcript);
-
-    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
-    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr);
-    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
-
-    // The serialization code below will convert out of Montgomery form before writing to the buffer
-    for (size_t i = 0; i < output.size(); ++i) {
-        barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
-    }
-    *serialized_proof_data_buf = raw_buf;
-
-    return output_size_bytes;
-}
-
-/**
- * @brief Takes in a verification key buffer and converts into a vector of field elements.
- *        The Recursion opcode requires the vk serialized as a vector of witnesses.
- *        Use this method to get the witness values!
- *
- * @param vk_buf
- * @param serialized_vk_buf
- */
-size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
-                                                      uint8_t const* vk_buf,
-                                                      uint8_t** serialized_vk_buf,
-                                                      uint8_t** serialized_vk_hash_buf)
-{
-    auto crs = std::make_shared<VerifierMemReferenceString>(g2x);
-    plonk::verification_key_data vk_data;
-    read(vk_buf, vk_data);
-    auto vkey = std::make_shared<proof_system::plonk::verification_key>(std::move(vk_data), crs);
-    std::vector<barretenberg::fr> output = acir_format::export_key_in_recursion_format(vkey);
-
-    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
-    // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o
-    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr) - 32;
-
-    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
-    auto vk_hash_raw_buf = (uint8_t*)malloc(32);
-
-    // The serialization code below will convert out of Montgomery form before writing to the buffer
-    for (size_t i = 0; i < output.size() - 1; ++i) {
-        barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
-    }
-    barretenberg::fr::serialize_to_buffer(output[output.size() - 1], vk_hash_raw_buf);
-
-    // copy the vkey into serialized_vk_buf
-    *serialized_vk_buf = raw_buf;
-
-    // copy the vkey hash into serialized_vk_hash_buf
-    *serialized_vk_hash_buf = vk_hash_raw_buf;
-
-    return output_size_bytes;
-}
-
 size_t new_proof(void* pippenger,
                  uint8_t const* g2x,
                  uint8_t const* pk_buf,
@@ -379,4 +303,80 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
     return output_size_bytes;
 }
 
+/**
+ * @brief Takes in a proof buffer and converts into a vector of field elements.
+ *        The Recursion opcode requires the proof serialized as a vector of witnesses.
+ *        Use this method to get the witness values!
+ *
+ * @param proof_data_buf
+ * @param serialized_proof_data_buf
+ */
+size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                           uint8_t** serialized_proof_data_buf,
+                                           size_t proof_data_length,
+                                           size_t num_inner_public_inputs)
+{
+    plonk::proof proof = { std::vector<uint8_t>(proof_data_buf, &proof_data_buf[proof_data_length]) };
+
+    transcript::StandardTranscript transcript(proof.proof_data,
+                                              acir_format::Composer::create_manifest(num_inner_public_inputs),
+                                              transcript::HashType::PlookupPedersenBlake3s,
+                                              16);
+
+    std::vector<barretenberg::fr> output = acir_format::export_transcript_in_recursion_format(transcript);
+
+    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
+    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr);
+    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
+
+    // The serialization code below will convert out of Montgomery form before writing to the buffer
+    for (size_t i = 0; i < output.size(); ++i) {
+        barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
+    }
+    *serialized_proof_data_buf = raw_buf;
+
+    return output_size_bytes;
+}
+
+/**
+ * @brief Takes in a verification key buffer and converts into a vector of field elements.
+ *        The Recursion opcode requires the vk serialized as a vector of witnesses.
+ *        Use this method to get the witness values!
+ *
+ * @param vk_buf
+ * @param serialized_vk_buf
+ */
+size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                      uint8_t const* vk_buf,
+                                                      uint8_t** serialized_vk_buf,
+                                                      uint8_t** serialized_vk_hash_buf)
+{
+    auto crs = std::make_shared<VerifierMemReferenceString>(g2x);
+    plonk::verification_key_data vk_data;
+    read(vk_buf, vk_data);
+    auto vkey = std::make_shared<proof_system::plonk::verification_key>(std::move(vk_data), crs);
+    std::vector<barretenberg::fr> output = acir_format::export_key_in_recursion_format(vkey);
+
+    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
+    // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o
+    const size_t output_size_bytes = output.size() * sizeof(barretenberg::fr) - 32;
+
+    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
+    auto vk_hash_raw_buf = (uint8_t*)malloc(32);
+
+    // The serialization code below will convert out of Montgomery form before writing to the buffer
+    for (size_t i = 0; i < output.size() - 1; ++i) {
+        barretenberg::fr::serialize_to_buffer(output[i], &raw_buf[i * 32]);
+    }
+    barretenberg::fr::serialize_to_buffer(output[output.size() - 1], vk_hash_raw_buf);
+
+    // copy the vkey into serialized_vk_buf
+    *serialized_vk_buf = raw_buf;
+
+    // copy the vkey hash into serialized_vk_hash_buf
+    *serialized_vk_hash_buf = vk_hash_raw_buf;
+
+    return output_size_bytes;
+}
+
 } // namespace acir_proofs
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
index cad0d1a79f..24df5e4f3e 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.hpp
@@ -8,14 +8,6 @@ uint32_t get_exact_circuit_size(uint8_t const* constraint_system_buf);
 uint32_t get_total_circuit_size(uint8_t const* constraint_system_buf);
 size_t init_proving_key(uint8_t const* constraint_system_buf, uint8_t const** pk_buf);
 size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const* pk_buf, uint8_t const** vk_buf);
-size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
-                                                      uint8_t const* vk_buf,
-                                                      uint8_t** serialized_vk_buf,
-                                                      uint8_t** serialized_vk_hash_buf);
-size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
-                                           uint8_t** serialized_proof_data_buf,
-                                           size_t proof_data_length,
-                                           size_t num_inner_public_inputs);
 size_t new_proof(void* pippenger,
                  uint8_t const* g2x,
                  uint8_t const* pk_buf,
@@ -29,6 +21,8 @@ bool verify_proof(uint8_t const* g2x,
                   uint8_t* proof,
                   uint32_t length,
                   bool is_recursive);
+
+// Recursion specific methods
 size_t verify_recursive_proof(uint8_t const* proof_buf,
                               uint32_t proof_length,
                               uint8_t const* vk_buf,
@@ -36,5 +30,13 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
                               uint32_t num_public_inputs,
                               uint8_t const* input_aggregation_obj_buf,
                               uint8_t** output_aggregation_obj_buf);
+size_t serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                      uint8_t const* vk_buf,
+                                                      uint8_t** serialized_vk_buf,
+                                                      uint8_t** serialized_vk_hash_buf);
+size_t serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                           uint8_t** serialized_proof_data_buf,
+                                           size_t proof_data_length,
+                                           size_t num_inner_public_inputs);
 
 } // namespace acir_proofs
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index 62621d00be..34b735c67e 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -35,23 +35,6 @@ WASM_EXPORT size_t acir_proofs_init_verification_key(void* pippenger,
     return acir_proofs::init_verification_key(pippenger, g2x, pk_buf, vk_buf);
 }
 
-WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t const* g2x,
-                                                                       uint8_t const* vk_buf,
-                                                                       uint8_t** serialized_vk_buf,
-                                                                       uint8_t** serialized_vk_hash_buf)
-{
-    return acir_proofs::serialize_verification_key_into_field_elements(
-        g2x, vk_buf, serialized_vk_buf, serialized_vk_hash_buf);
-}
-WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
-                                                            uint8_t** serialized_proof_data_buf,
-                                                            size_t proof_data_length,
-                                                            size_t num_inner_public_inputs)
-{
-    return acir_proofs::serialize_proof_into_field_elements(
-        proof_data_buf, serialized_proof_data_buf, proof_data_length, num_inner_public_inputs);
-}
-
 WASM_EXPORT size_t acir_proofs_new_proof(void* pippenger,
                                          uint8_t const* g2x,
                                          uint8_t const* pk_buf,
@@ -89,4 +72,20 @@ WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
                                                input_aggregation_obj_buf,
                                                output_aggregation_obj_buf);
 }
+WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                                       uint8_t const* vk_buf,
+                                                                       uint8_t** serialized_vk_buf,
+                                                                       uint8_t** serialized_vk_hash_buf)
+{
+    return acir_proofs::serialize_verification_key_into_field_elements(
+        g2x, vk_buf, serialized_vk_buf, serialized_vk_hash_buf);
+}
+WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                                            uint8_t** serialized_proof_data_buf,
+                                                            size_t proof_data_length,
+                                                            size_t num_inner_public_inputs)
+{
+    return acir_proofs::serialize_proof_into_field_elements(
+        proof_data_buf, serialized_proof_data_buf, proof_data_length, num_inner_public_inputs);
+}
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index 452f41d1ca..5e42747b57 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -14,14 +14,6 @@ WASM_EXPORT size_t acir_proofs_init_verification_key(void* pippenger,
                                                      uint8_t const* g2x,
                                                      uint8_t const* pk_buf,
                                                      uint8_t const** vk_buf);
-WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t const* g2x,
-                                                                       uint8_t const* vk_buf,
-                                                                       uint8_t** serialized_vk_buf,
-                                                                       uint8_t** serialized_vk_hash_buf);
-WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
-                                                            uint8_t** serialized_proof_data_buf,
-                                                            size_t proof_data_length,
-                                                            size_t num_inner_public_inputs);
 WASM_EXPORT size_t acir_proofs_new_proof(void* pippenger,
                                          uint8_t const* g2x,
                                          uint8_t const* pk_buf,
@@ -35,6 +27,8 @@ WASM_EXPORT bool acir_proofs_verify_proof(uint8_t const* g2x,
                                           uint8_t* proof,
                                           uint32_t length,
                                           bool is_recursive);
+
+// Recursion specific methods
 WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
                                                       uint32_t proof_length,
                                                       uint8_t const* vk_buf,
@@ -42,4 +36,12 @@ WASM_EXPORT size_t acir_proofs_verify_recursive_proof(uint8_t const* proof_buf,
                                                       uint32_t num_public_inputs,
                                                       uint8_t const* input_aggregation_obj_buf,
                                                       uint8_t** output_aggregation_obj_buf);
+WASM_EXPORT size_t acir_serialize_verification_key_into_field_elements(uint8_t const* g2x,
+                                                                       uint8_t const* vk_buf,
+                                                                       uint8_t** serialized_vk_buf,
+                                                                       uint8_t** serialized_vk_hash_buf);
+WASM_EXPORT size_t acir_serialize_proof_into_field_elements(uint8_t const* proof_data_buf,
+                                                            uint8_t** serialized_proof_data_buf,
+                                                            size_t proof_data_length,
+                                                            size_t num_inner_public_inputs);
 }
diff --git a/cpp/src/barretenberg/dsl/types.hpp b/cpp/src/barretenberg/dsl/types.hpp
index 192fc10fe9..f9823984bf 100644
--- a/cpp/src/barretenberg/dsl/types.hpp
+++ b/cpp/src/barretenberg/dsl/types.hpp
@@ -64,7 +64,7 @@ using hash_path_ct = proof_system::plonk::stdlib::merkle_tree::hash_path<Compose
 
 using schnorr_signature_bits_ct = proof_system::plonk::stdlib::schnorr::signature_bits<Composer>;
 
-// Ultra-composer specific typesv
+// Ultra-composer specific types
 using rom_table_ct = proof_system::plonk::stdlib::rom_table<plonk::UltraComposer>;
 using ram_table_ct = proof_system::plonk::stdlib::ram_table<plonk::UltraComposer>;
 

From a793b2dbc9a17c4beddee1bddc984e97b7c790c8 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 22 May 2023 18:28:58 +0000
Subject: [PATCH 32/64] remove ecc bb_module declaration in env package

---
 cpp/src/barretenberg/env/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/barretenberg/env/CMakeLists.txt b/cpp/src/barretenberg/env/CMakeLists.txt
index e084984b85..f4a8428e63 100644
--- a/cpp/src/barretenberg/env/CMakeLists.txt
+++ b/cpp/src/barretenberg/env/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(env ecc)
\ No newline at end of file
+barretenberg_module(env)
\ No newline at end of file

From f9542663b34bf5c10d439898f782309a86a66c46 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Mon, 22 May 2023 19:15:37 +0000
Subject: [PATCH 33/64] chore: remove usage of magic numbers when slicing
 g1::affine_element into barretenberg::fr

---
 .../dsl/acir_format/recursion_constraint.cpp  | 90 +++++++++----------
 .../dsl/acir_format/recursion_constraint.hpp  | 11 +++
 2 files changed, 51 insertions(+), 50 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index f6bc8795ed..92e2e52de1 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -8,6 +8,9 @@ namespace acir_format {
 
 using namespace proof_system::plonk;
 
+static constexpr uint64_t TWO_LIMBS_BITS_IN_FIELD_SIMULATION = NUM_LIMB_BITS_IN_FIELD_SIMULATION * 2;
+static constexpr uint64_t FOUR_LIMBS_BITS_IN_FIELD_SIMULATION = NUM_LIMB_BITS_IN_FIELD_SIMULATION * 4;
+
 void generate_dummy_proof() {}
 /**
  * @brief Add constraints required to recursively verify an UltraPlonk proof
@@ -164,16 +167,11 @@ std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<ver
     for (const auto& descriptor : vkey->polynomial_manifest.get()) {
         if (descriptor.source == PolynomialSource::SELECTOR || descriptor.source == PolynomialSource::PERMUTATION) {
             const auto element = vkey->commitments.at(std::string(descriptor.commitment_label));
-            const uint256_t x = element.x;
-            const uint256_t y = element.y;
-            const barretenberg::fr x_lo = x.slice(0, 136);
-            const barretenberg::fr x_hi = x.slice(136, 272);
-            const barretenberg::fr y_lo = y.slice(0, 136);
-            const barretenberg::fr y_hi = y.slice(136, 272);
-            output.emplace_back(x_lo);
-            output.emplace_back(x_hi);
-            output.emplace_back(y_lo);
-            output.emplace_back(y_hi);
+            auto g1_as_fields = export_g1_affine_element_as_fields(element);
+            output.emplace_back(g1_as_fields.x_lo);
+            output.emplace_back(g1_as_fields.x_hi);
+            output.emplace_back(g1_as_fields.y_lo);
+            output.emplace_back(g1_as_fields.y_hi);
         }
     }
 
@@ -225,16 +223,11 @@ std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const Polynom
             // transcript point is unique.
             auto scalar = barretenberg::fr::random_element();
             const auto element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
-            const uint256_t x = element.x;
-            const uint256_t y = element.y;
-            const barretenberg::fr x_lo = x.slice(0, 136);
-            const barretenberg::fr x_hi = x.slice(136, 272);
-            const barretenberg::fr y_lo = y.slice(0, 136);
-            const barretenberg::fr y_hi = y.slice(136, 272);
-            output.emplace_back(x_lo);
-            output.emplace_back(x_hi);
-            output.emplace_back(y_lo);
-            output.emplace_back(y_hi);
+            auto g1_as_fields = export_g1_affine_element_as_fields(element);
+            output.emplace_back(g1_as_fields.x_lo);
+            output.emplace_back(g1_as_fields.x_hi);
+            output.emplace_back(g1_as_fields.y_lo);
+            output.emplace_back(g1_as_fields.y_hi);
         }
     }
 
@@ -260,16 +253,11 @@ std::vector<barretenberg::fr> export_transcript_in_recursion_format(const transc
                     fields.emplace_back(transcript.get_field_element(manifest_element.name));
                 } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
                     const auto group_element = transcript.get_group_element(manifest_element.name);
-                    const uint256_t x = group_element.x;
-                    const uint256_t y = group_element.y;
-                    const barretenberg::fr x_lo = x.slice(0, 136);
-                    const barretenberg::fr x_hi = x.slice(136, 272);
-                    const barretenberg::fr y_lo = y.slice(0, 136);
-                    const barretenberg::fr y_hi = y.slice(136, 272);
-                    fields.emplace_back(x_lo);
-                    fields.emplace_back(x_hi);
-                    fields.emplace_back(y_lo);
-                    fields.emplace_back(y_hi);
+                    auto g1_as_fields = export_g1_affine_element_as_fields(group_element);
+                    fields.emplace_back(g1_as_fields.x_lo);
+                    fields.emplace_back(g1_as_fields.x_hi);
+                    fields.emplace_back(g1_as_fields.y_lo);
+                    fields.emplace_back(g1_as_fields.y_hi);
                 } else {
                     ASSERT(manifest_element.name == "public_inputs");
                     const auto public_inputs_vector = transcript.get_field_element_vector(manifest_element.name);
@@ -309,16 +297,11 @@ std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const
                     // points we must be mindful of the above and make sure that each point is unique.
                     auto scalar = barretenberg::fr::random_element();
                     const auto group_element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
-                    const uint256_t x = group_element.x;
-                    const uint256_t y = group_element.y;
-                    const barretenberg::fr x_lo = x.slice(0, 136);
-                    const barretenberg::fr x_hi = x.slice(136, 272);
-                    const barretenberg::fr y_lo = y.slice(0, 136);
-                    const barretenberg::fr y_hi = y.slice(136, 272);
-                    fields.emplace_back(x_lo);
-                    fields.emplace_back(x_hi);
-                    fields.emplace_back(y_lo);
-                    fields.emplace_back(y_hi);
+                    auto g1_as_fields = export_g1_affine_element_as_fields(group_element);
+                    fields.emplace_back(g1_as_fields.x_lo);
+                    fields.emplace_back(g1_as_fields.x_hi);
+                    fields.emplace_back(g1_as_fields.y_lo);
+                    fields.emplace_back(g1_as_fields.y_hi);
                 } else {
                     ASSERT(manifest_element.name == "public_inputs");
                     const size_t num_public_inputs = manifest_element.num_bytes / 32;
@@ -330,16 +313,11 @@ std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const
                         for (size_t k = 0; k < num_public_inputs / 4; ++k) {
                             auto scalar = barretenberg::fr::random_element();
                             const auto group_element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
-                            const uint256_t x = group_element.x;
-                            const uint256_t y = group_element.y;
-                            const barretenberg::fr x_lo = x.slice(0, 136);
-                            const barretenberg::fr x_hi = x.slice(136, 272);
-                            const barretenberg::fr y_lo = y.slice(0, 136);
-                            const barretenberg::fr y_hi = y.slice(136, 272);
-                            fields.emplace_back(x_lo);
-                            fields.emplace_back(x_hi);
-                            fields.emplace_back(y_lo);
-                            fields.emplace_back(y_hi);
+                            auto g1_as_fields = export_g1_affine_element_as_fields(group_element);
+                            fields.emplace_back(g1_as_fields.x_lo);
+                            fields.emplace_back(g1_as_fields.x_hi);
+                            fields.emplace_back(g1_as_fields.y_lo);
+                            fields.emplace_back(g1_as_fields.y_hi);
                         }
                     } else {
                         for (size_t j = 0; j < num_public_inputs; ++j) {
@@ -353,4 +331,16 @@ std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const
     return fields;
 }
 
+G1AsFields export_g1_affine_element_as_fields(const barretenberg::g1::affine_element& group_element)
+{
+    const uint256_t x = group_element.x;
+    const uint256_t y = group_element.y;
+    const barretenberg::fr x_lo = x.slice(0, TWO_LIMBS_BITS_IN_FIELD_SIMULATION);
+    const barretenberg::fr x_hi = x.slice(TWO_LIMBS_BITS_IN_FIELD_SIMULATION, FOUR_LIMBS_BITS_IN_FIELD_SIMULATION);
+    const barretenberg::fr y_lo = y.slice(0, TWO_LIMBS_BITS_IN_FIELD_SIMULATION);
+    const barretenberg::fr y_hi = y.slice(TWO_LIMBS_BITS_IN_FIELD_SIMULATION, FOUR_LIMBS_BITS_IN_FIELD_SIMULATION);
+
+    return G1AsFields{ x_lo, x_hi, y_lo, y_hi };
+}
+
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index 615f23a553..d98b0dbda8 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -70,6 +70,17 @@ std::vector<barretenberg::fr> export_transcript_in_recursion_format(const transc
 std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const transcript::Manifest& manifest,
                                                                           const bool contains_recursive_proof);
 
+// In order to interact with a recursive aggregation state inside of a circuit, we need to represent its internal G1
+// elements as field elements. This happens in multiple locations when creating a recursion constraint. The struct and
+// method below export a g1 affine element as fields to use as part of the recursive circuit.
+struct G1AsFields {
+    barretenberg::fr x_lo;
+    barretenberg::fr x_hi;
+    barretenberg::fr y_lo;
+    barretenberg::fr y_hi;
+};
+G1AsFields export_g1_affine_element_as_fields(const barretenberg::g1::affine_element& group_element);
+
 template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
 {
     using serialize::read;

From 0f0d519d973f347a0c3e79fe6347c2d7a4cdfb27 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 23 May 2023 01:56:54 +0000
Subject: [PATCH 34/64] introduce NUM_AGGREGATION_ELEMENTS constant and use it
 through recursion constraint

---
 .../dsl/acir_format/recursion_constraint.cpp  | 11 +++++----
 .../dsl/acir_format/recursion_constraint.hpp  |  8 +++++--
 .../dsl/acir_proofs/acir_proofs.cpp           | 23 +++++++++++--------
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 92e2e52de1..564bfd9d68 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -8,6 +8,9 @@ namespace acir_format {
 
 using namespace proof_system::plonk;
 
+// `NUM_LIMB_BITS_IN_FIELD_SIMULATION` is the limb size when simulating a non-native field using the bigfield class
+// A aggregation object is two acir_format::g1_ct types where each coordinate in a point is a non-native field.
+// Each field is represented as four limbs. We split those limbs in half when serializing to/from buffer.
 static constexpr uint64_t TWO_LIMBS_BITS_IN_FIELD_SIMULATION = NUM_LIMB_BITS_IN_FIELD_SIMULATION * 2;
 static constexpr uint64_t FOUR_LIMBS_BITS_IN_FIELD_SIMULATION = NUM_LIMB_BITS_IN_FIELD_SIMULATION * 4;
 
@@ -156,7 +159,7 @@ std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<ver
     output.emplace_back(vkey->circuit_size);
     output.emplace_back(vkey->num_public_inputs);
     output.emplace_back(vkey->contains_recursive_proof);
-    for (size_t i = 0; i < 16; ++i) {
+    for (size_t i = 0; i < RecursionConstraint::AGGREGATION_OBJECT_SIZE; ++i) {
         if (vkey->recursive_proof_public_input_indices.size() > i) {
             output.emplace_back(vkey->recursive_proof_public_input_indices[i]);
         } else {
@@ -209,7 +212,7 @@ std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const Polynom
     output.emplace_back(1); // num public inputs
 
     output.emplace_back(contains_recursive_proof); // contains_recursive_proof
-    for (size_t i = 0; i < 16; ++i) {
+    for (size_t i = 0; i < RecursionConstraint::AGGREGATION_OBJECT_SIZE; ++i) {
         output.emplace_back(0); // recursive_proof_public_input_indices
     }
 
@@ -309,8 +312,8 @@ std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const
                     // is composed of two valid G1 points on the curve. Without this conditional we will get a
                     // runtime error that we are attempting to invert 0.
                     if (contains_recursive_proof) {
-                        ASSERT(num_public_inputs == 16);
-                        for (size_t k = 0; k < num_public_inputs / 4; ++k) {
+                        ASSERT(num_public_inputs == RecursionConstraint::AGGREGATION_OBJECT_SIZE);
+                        for (size_t k = 0; k < RecursionConstraint::NUM_AGGREGATION_ELEMENTS; ++k) {
                             auto scalar = barretenberg::fr::random_element();
                             const auto group_element = barretenberg::g1::affine_element(barretenberg::g1::one * scalar);
                             auto g1_as_fields = export_g1_affine_element_as_fields(group_element);
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index d98b0dbda8..4d9b428166 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -1,6 +1,5 @@
 #pragma once
 #include <vector>
-// #include "barretenberg/stdlib/types/types.hpp"
 #include "barretenberg/dsl/types.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
 
@@ -44,7 +43,12 @@ using namespace proof_system::plonk;
  *
  */
 struct RecursionConstraint {
-    static constexpr size_t AGGREGATION_OBJECT_SIZE = 16; // 16 field elements
+    // An aggregation state is represented by two G1 affine elements. Each G1 point has
+    // two field element coordinates (x, y). Thus, four field elements
+    static constexpr size_t NUM_AGGREGATION_ELEMENTS = 4;
+    // Four limbs are used when simulating a non-native field using the bigfield class
+    static constexpr size_t AGGREGATION_OBJECT_SIZE =
+        NUM_AGGREGATION_ELEMENTS * NUM_QUOTIENT_PARTS; // 16 field elements
     std::vector<uint32_t> key;
     std::vector<uint32_t> proof;
     std::vector<uint32_t> public_inputs;
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 877921f217..8ccd5d13b3 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -87,7 +87,7 @@ size_t init_verification_key(void* pippenger, uint8_t const* g2x, uint8_t const*
 
     // Set the recursive proof indices as this is not done in `compute_verification_key_base`
     verification_key->contains_recursive_proof = proving_key->contains_recursive_proof;
-    for (size_t i = 0; i < 16; ++i) {
+    for (size_t i = 0; i < acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE; ++i) {
         if (proving_key->recursive_proof_public_input_indices.size() > i) {
             verification_key->recursive_proof_public_input_indices.emplace_back(
                 proving_key->recursive_proof_public_input_indices[i]);
@@ -213,22 +213,24 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
                               uint8_t const* input_aggregation_obj_buf,
                               uint8_t** output_aggregation_obj_buf)
 {
+    const size_t NUM_AGGREGATION_ELEMENTS = acir_format::RecursionConstraint::NUM_AGGREGATION_ELEMENTS;
 
     bool inner_aggregation_all_zero = true;
-    std::vector<barretenberg::fr> aggregation_input(16);
-    for (size_t i = 0; i < 16; i++) {
+    std::vector<barretenberg::fr> aggregation_input(acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE);
+    for (size_t i = 0; i < acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE; i++) {
         aggregation_input[i] = barretenberg::fr::serialize_from_buffer(&input_aggregation_obj_buf[i * 32]);
         inner_aggregation_all_zero &= (aggregation_input[i].is_zero());
     }
 
     acir_format::aggregation_state_ct previous_aggregation;
     if (!inner_aggregation_all_zero) {
-        std::array<acir_format::bn254::fq_ct, 4> aggregation_elements;
-        for (size_t i = 0; i < 4; ++i) {
-            aggregation_elements[i] = acir_format::bn254::fq_ct(acir_format::field_ct(aggregation_input[4 * i]),
-                                                                acir_format::field_ct(aggregation_input[4 * i + 1]),
-                                                                acir_format::field_ct(aggregation_input[4 * i + 2]),
-                                                                acir_format::field_ct(aggregation_input[4 * i + 3]));
+        std::array<acir_format::bn254::fq_ct, NUM_AGGREGATION_ELEMENTS> aggregation_elements;
+        for (size_t i = 0; i < NUM_AGGREGATION_ELEMENTS; ++i) {
+            aggregation_elements[i] =
+                acir_format::bn254::fq_ct(acir_format::field_ct(aggregation_input[NUM_AGGREGATION_ELEMENTS * i]),
+                                          acir_format::field_ct(aggregation_input[NUM_AGGREGATION_ELEMENTS * i + 1]),
+                                          acir_format::field_ct(aggregation_input[NUM_AGGREGATION_ELEMENTS * i + 2]),
+                                          acir_format::field_ct(aggregation_input[NUM_AGGREGATION_ELEMENTS * 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
@@ -275,7 +277,8 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
 
     // Just write the output aggregation G1 elements, and no public inputs, proof witnesses, or any other data
     // as this should all be available elsewhere
-    const size_t output_size_bytes = 16 * sizeof(barretenberg::fr);
+    const size_t output_size_bytes =
+        acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE * sizeof(barretenberg::fr);
     auto raw_buf = (uint8_t*)malloc(output_size_bytes);
 
     for (size_t i = 0; i < 4; ++i) {

From 294c1fae20bfeed4e1d58250ad13e78009cedfba Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 23 May 2023 02:16:56 +0000
Subject: [PATCH 35/64] nit ASSERT(result != -1) in get_public_input_index

---
 cpp/src/barretenberg/plonk/composer/composer_base.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/barretenberg/plonk/composer/composer_base.hpp b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
index b1109d2d4d..cd34897239 100644
--- a/cpp/src/barretenberg/plonk/composer/composer_base.hpp
+++ b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
@@ -197,7 +197,7 @@ class ComposerBase {
                 break;
             }
         }
-        ASSERT(found == true);
+        ASSERT(result != -1);
         return result;
     }
 

From 517ed2c77bac56f0dc324fcd1f43412aaab537b7 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 23 May 2023 02:45:36 +0000
Subject: [PATCH 36/64] remove unused found var

---
 cpp/src/barretenberg/plonk/composer/composer_base.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/cpp/src/barretenberg/plonk/composer/composer_base.hpp b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
index cd34897239..3933b6dca0 100644
--- a/cpp/src/barretenberg/plonk/composer/composer_base.hpp
+++ b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
@@ -188,11 +188,9 @@ class ComposerBase {
 
     uint32_t get_public_input_index(const uint32_t witness_index) const
     {
-        bool found = false;
         uint32_t result = static_cast<uint32_t>(-1);
         for (size_t i = 0; i < public_inputs.size(); ++i) {
             if (real_variable_index[public_inputs[i]] == real_variable_index[witness_index]) {
-                found = true;
                 result = static_cast<uint32_t>(i);
                 break;
             }

From 92159e0b899e8bc23a9b57c8fc852b15c476f0dd Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 23 May 2023 03:22:29 +0000
Subject: [PATCH 37/64] cast -1

---
 cpp/src/barretenberg/plonk/composer/composer_base.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/barretenberg/plonk/composer/composer_base.hpp b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
index 3933b6dca0..8c8a92656b 100644
--- a/cpp/src/barretenberg/plonk/composer/composer_base.hpp
+++ b/cpp/src/barretenberg/plonk/composer/composer_base.hpp
@@ -195,7 +195,7 @@ class ComposerBase {
                 break;
             }
         }
-        ASSERT(result != -1);
+        ASSERT(result != static_cast<uint32_t>(-1));
         return result;
     }
 

From d8ee38821e5c8fd0fdc99aeca9a6af4e40b3b3fa Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 23 May 2023 16:17:57 +0000
Subject: [PATCH 38/64] fix up verify_recursive_proof and add a test for it

---
 .../dsl/acir_proofs/acir_proofs.cpp           | 17 +++--
 .../dsl/acir_proofs/acir_proofs.test.cpp      | 76 +++++++++++++++++++
 2 files changed, 86 insertions(+), 7 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
index 8ccd5d13b3..62dc6460d4 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.cpp
@@ -242,22 +242,25 @@ size_t verify_recursive_proof(uint8_t const* proof_buf,
         previous_aggregation.has_data = false;
     }
 
+    acir_format::Composer composer;
+
     std::vector<acir_format::field_ct> proof_fields(proof_length / 32);
     std::vector<acir_format::field_ct> key_fields(vk_length / 32);
     for (size_t i = 0; i < proof_length / 32; i++) {
-        proof_fields[i] = acir_format::field_ct(barretenberg::fr::serialize_from_buffer(&proof_buf[i * 32]));
+        // TODO(maxim): The stdlib pairing primitives fetch the context from the elements being used in the pairing
+        // computation When attempting to simulate recursive verification without a full circuit where the context of
+        // these elements are not set we will get a seg fault. Using `witness_ct` here provides a workaround where these
+        // elements will have their context set. We should enable the native verifier to return an aggregation state so
+        // that we can avoid creating an unnecessary circuit and this workaround
+        proof_fields[i] = acir_format::field_ct(
+            acir_format::witness_ct(&composer, barretenberg::fr::serialize_from_buffer(&proof_buf[i * 32])));
     }
     for (size_t i = 0; i < vk_length / 32; i++) {
         key_fields[i] = acir_format::field_ct(barretenberg::fr::serialize_from_buffer(&vk_buf[i * 32]));
     }
 
-    acir_format::Composer composer;
-
     transcript::Manifest manifest = acir_format::Composer::create_unrolled_manifest(num_public_inputs);
-    // We currently only support RecursionConstraint where inner_proof_contains_recursive_proof = false.
-    // We would either need a separate ACIR opcode where inner_proof_contains_recursive_proof = true,
-    // or we need non-witness data to be provided as metadata in the ACIR opcode
-    // recursively verify the proof
+
     std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object = {};
     for (size_t i = 6; i < 22; ++i) {
         nested_aggregation_object[i - 6] = uint32_t(key_fields[i].get_value());
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index a5554d1b82..536d9a7342 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -141,6 +141,82 @@ TEST(AcirProofs, TestSerialization)
     EXPECT_EQ(verified, true);
 }
 
+TEST(AcirProofs, TestVerifyRecursiveProofPass)
+{
+    uint8_t* proof_data_fields = nullptr;
+    uint8_t* vk_fields = nullptr;
+    uint8_t* vk_hash_buf = nullptr;
+    size_t proof_fields_size = 0;
+    size_t vk_fields_size = 0;
+
+    acir_format::acir_format constraint_system;
+    std::vector<fr> witness;
+    create_inner_circuit(constraint_system, witness);
+
+    std::vector<uint8_t> witness_buf;
+    std::vector<uint8_t> constraint_system_buf;
+    write(constraint_system_buf, constraint_system);
+    write(witness_buf, witness);
+
+    uint32_t total_circuit_size = acir_proofs::get_total_circuit_size(&constraint_system_buf[0]);
+    uint32_t pow2_size = 1 << (numeric::get_msb(total_circuit_size) + 1);
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+    auto verifier_crs = env_crs->get_verifier_crs();
+
+    uint8_t const* pk_buf = nullptr;
+    acir_proofs::init_proving_key(&constraint_system_buf[0], &pk_buf);
+    barretenberg::g2::affine_element g2x = verifier_crs->get_g2x();
+
+    auto* pippenger_ptr_base = new scalar_multiplication::Pippenger(env_load_prover_crs(pow2_size + 1), pow2_size + 1);
+    void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
+
+    std::vector<uint8_t> g2x_buffer(128);
+    io::write_g2_elements_to_buffer(&g2x, (char*)(&g2x_buffer[0]), 1);
+
+    uint8_t const* vk_buf = nullptr;
+    acir_proofs::init_verification_key(pippenger_ptr, &g2x_buffer[0], pk_buf, &vk_buf);
+
+    uint8_t* proof_data_buf = nullptr;
+    size_t proof_length = acir_proofs::new_proof(
+        pippenger_ptr, &g2x_buffer[0], pk_buf, &constraint_system_buf[0], &witness_buf[0], &proof_data_buf, true);
+
+    auto num_public_inputs = constraint_system.public_inputs.size();
+    proof_fields_size = acir_proofs::serialize_proof_into_field_elements(
+        proof_data_buf, &proof_data_fields, proof_length, num_public_inputs);
+    vk_fields_size =
+        acir_proofs::serialize_verification_key_into_field_elements(&g2x_buffer[0], vk_buf, &vk_fields, &vk_hash_buf);
+
+    bool verified = acir_proofs::verify_proof(
+        &g2x_buffer[0], vk_buf, &constraint_system_buf[0], proof_data_buf, static_cast<uint32_t>(proof_length), true);
+    EXPECT_EQ(verified, true);
+
+    delete pippenger_ptr_base;
+    free((void*)vk_buf);
+    free((void*)pk_buf);
+    free((void*)proof_data_buf);
+
+    const size_t output_size_bytes =
+        acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE * sizeof(barretenberg::fr);
+    auto input_agg_buf = (uint8_t*)malloc(output_size_bytes);
+
+    for (size_t i = 0; i < 16; ++i) {
+        auto field = barretenberg::fr::zero();
+        barretenberg::fr::serialize_to_buffer(field, &input_agg_buf[i * 32]);
+    }
+
+    uint8_t* output_agg_buf = nullptr;
+    acir_proofs::verify_recursive_proof(proof_data_fields,
+                                        static_cast<uint32_t>(proof_fields_size),
+                                        vk_fields,
+                                        static_cast<uint32_t>(vk_fields_size),
+                                        static_cast<uint32_t>(num_public_inputs),
+                                        input_agg_buf,
+                                        &output_agg_buf);
+
+    free((void*)proof_data_fields);
+    free((void*)vk_fields);
+}
+
 struct RecursiveCircuitData {
     std::vector<barretenberg::fr> key_witnesses;
     std::vector<barretenberg::fr> proof_witnesses;

From cf9bdd63315d82c97c5b8689efa495660814bf64 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 23 May 2023 16:27:42 +0000
Subject: [PATCH 39/64] moved from tempalte for has_valid_witness_assignments
 to a flag

---
 cpp/src/barretenberg/dsl/acir_format/acir_format.cpp | 10 +++++-----
 .../dsl/acir_format/recursion_constraint.cpp         | 12 +++++-------
 .../dsl/acir_format/recursion_constraint.hpp         |  8 +++-----
 3 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
index 97ce130665..f356af7d46 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
@@ -97,7 +97,7 @@ void create_circuit(Composer& composer, const acir_format& constraint_system)
     // Add recursion constraints
     for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
         auto& constraint = constraint_system.recursion_constraints[i];
-        create_recursion_constraints<false>(composer, constraint);
+        create_recursion_constraints(composer, constraint);
 
         // make sure the verification key records the public input indices of the final recursion output
         // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
@@ -201,7 +201,7 @@ Composer create_circuit(const acir_format& constraint_system,
     // Add recursion constraints
     for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
         auto& constraint = constraint_system.recursion_constraints[i];
-        create_recursion_constraints<false>(composer, constraint);
+        create_recursion_constraints(composer, constraint);
 
         // make sure the verification key records the public input indices of the final recursion output
         // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
@@ -310,7 +310,7 @@ Composer create_circuit_with_witness(const acir_format& constraint_system,
     // Add recursion constraints
     for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
         auto& constraint = constraint_system.recursion_constraints[i];
-        create_recursion_constraints<true>(composer, constraint);
+        create_recursion_constraints(composer, constraint, true);
 
         // make sure the verification key records the public input indices of the final recursion output
         // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
@@ -416,7 +416,7 @@ Composer create_circuit_with_witness(const acir_format& constraint_system, std::
     // Add recursion constraints
     for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
         auto& constraint = constraint_system.recursion_constraints[i];
-        create_recursion_constraints<true>(composer, constraint);
+        create_recursion_constraints(composer, constraint, true);
 
         // make sure the verification key records the public input indices of the final recursion output
         // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
@@ -520,7 +520,7 @@ void create_circuit_with_witness(Composer& composer, const acir_format& constrai
     // Add recursion constraints
     for (size_t i = 0; i < constraint_system.recursion_constraints.size(); ++i) {
         auto& constraint = constraint_system.recursion_constraints[i];
-        create_recursion_constraints<true>(composer, constraint);
+        create_recursion_constraints(composer, constraint, true);
 
         // make sure the verification key records the public input indices of the final recursion output
         // (N.B. up to the ACIR description to make sure that the final output aggregation object wires are public
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 564bfd9d68..32cb775cd3 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -28,8 +28,9 @@ void generate_dummy_proof() {}
  *       We would either need a separate ACIR opcode where inner_proof_contains_recursive_proof = true,
  *       or we need non-witness data to be provided as metadata in the ACIR opcode
  */
-template <bool has_valid_witness_assignment>
-void create_recursion_constraints(Composer& composer, const RecursionConstraint& input)
+void create_recursion_constraints(Composer& composer,
+                                  const RecursionConstraint& input,
+                                  bool has_valid_witness_assignments)
 {
     const auto& nested_aggregation_indices = input.nested_aggregation_object;
     bool nested_aggregation_indices_all_zero = true;
@@ -53,7 +54,7 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
             // we add our dummy proof values as Composer variables.
             // if we DO have a valid witness assignment, we use the real witness assignment
             barretenberg::fr dummy_field =
-                has_valid_witness_assignment ? composer.get_variable(proof_field_idx) : dummy_proof[i];
+                has_valid_witness_assignments ? composer.get_variable(proof_field_idx) : dummy_proof[i];
             // Create a copy constraint between our dummy field and the witness index provided by RecursionConstraint.
             // This will make the RecursionConstraint idx equal to `dummy_field`.
             // In the case of a valid witness assignment, this does nothing (as dummy_field = real value)
@@ -64,7 +65,7 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
         for (size_t i = 0; i < input.key.size(); ++i) {
             const auto key_field_idx = input.key[i];
             barretenberg::fr dummy_field =
-                has_valid_witness_assignment ? composer.get_variable(key_field_idx) : dummy_key[i];
+                has_valid_witness_assignments ? composer.get_variable(key_field_idx) : dummy_key[i];
             composer.assert_equal(composer.add_variable(dummy_field), key_field_idx);
         }
     }
@@ -140,9 +141,6 @@ void create_recursion_constraints(Composer& composer, const RecursionConstraint&
     }
 }
 
-template void create_recursion_constraints<false>(Composer&, const RecursionConstraint&);
-template void create_recursion_constraints<true>(Composer&, const RecursionConstraint&);
-
 /**
  * @brief When recursively verifying proofs, we represent the verification key using field elements.
  *        This method exports the key formatted in the manner our recursive verifier expects.
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
index 4d9b428166..f99dc21230 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.hpp
@@ -60,11 +60,9 @@ struct RecursionConstraint {
     friend bool operator==(RecursionConstraint const& lhs, RecursionConstraint const& rhs) = default;
 };
 
-template <bool has_valid_witness_assignment = false>
-void create_recursion_constraints(Composer& composer, const RecursionConstraint& input);
-
-extern template void create_recursion_constraints<false>(Composer&, const RecursionConstraint&);
-extern template void create_recursion_constraints<true>(Composer&, const RecursionConstraint&);
+void create_recursion_constraints(Composer& composer,
+                                  const RecursionConstraint& input,
+                                  bool has_valid_witness_assignments = false);
 
 std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<verification_key> const& vkey);
 std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const PolynomialManifest& polynomial_manifest,

From 209667624f706be9106acab2cc0f7bfbdc7fa793 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 23 May 2023 16:31:46 +0000
Subject: [PATCH 40/64] chore: add comments to
 AcirProofs.TestVerifyRecursiveProofPass

---
 cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
index 536d9a7342..fadbe87d42 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_proofs.test.cpp
@@ -141,6 +141,8 @@ TEST(AcirProofs, TestSerialization)
     EXPECT_EQ(verified, true);
 }
 
+// Test that the method `verify_recursive_proof` can successfully simulate
+// an output aggregation state
 TEST(AcirProofs, TestVerifyRecursiveProofPass)
 {
     uint8_t* proof_data_fields = nullptr;

From a87fdccaee8be3ce78f3b2963c096e247fb9054f Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Thu, 25 May 2023 16:02:06 +0000
Subject: [PATCH 41/64] update prove and verify exports to handle is_recursive

---
 .../dsl/acir_proofs/acir_composer.cpp         | 27 ++++++---
 .../dsl/acir_proofs/acir_composer.hpp         |  6 +-
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   | 10 +++-
 .../barretenberg/dsl/acir_proofs/c_bind.hpp   |  6 +-
 exports.json                                  |  8 +++
 ts/exports.json                               |  0
 ts/src/barretenberg_api/index.ts              | 16 ++---
 ts/src/main.ts                                | 58 ++++++++++++++-----
 8 files changed, 97 insertions(+), 34 deletions(-)
 create mode 100644 ts/exports.json

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 1efb8aa861..14b5045292 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -40,7 +40,8 @@ void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system,
 }
 
 std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constraint_system,
-                                                acir_format::WitnessVector& witness)
+                                                acir_format::WitnessVector& witness,
+                                                bool is_recursive)
 {
     composer_ = acir_format::Composer(proving_key_, verification_key_, circuit_subgroup_size_);
     // You can't produce the verification key unless you manually set the crs. Which seems like a bug.
@@ -57,12 +58,17 @@ std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constr
     witness.clear();
     witness.shrink_to_fit();
 
-    auto prover = composer_.create_ultra_with_keccak_prover();
     std::cout << "num_gates: " << composer_.num_gates << std::endl;
     std::cout << "circuit_finalised: " << composer_.circuit_finalised << std::endl;
-    std::cout << "prover.get_circuit_size(): " << prover.get_circuit_size() << std::endl;
 
-    auto proof = prover.construct_proof().proof_data;
+    std::vector<uint8_t> proof;
+    if (is_recursive) {
+        auto prover = composer_.create_prover();
+        proof = prover.construct_proof().proof_data;
+    } else {
+        auto prover = composer_.create_ultra_with_keccak_prover();
+        proof = prover.construct_proof().proof_data;
+    }
     return proof;
 }
 
@@ -71,10 +77,17 @@ void AcirComposer::init_verification_key()
     verification_key_ = composer_.compute_verification_key();
 }
 
-bool AcirComposer::verify_proof(std::vector<uint8_t> const& proof)
+bool AcirComposer::verify_proof(std::vector<uint8_t> const& proof, bool is_recursive)
 {
-    auto verifier = composer_.create_ultra_with_keccak_verifier();
-    return verifier.verify_proof({ proof });
+    bool verified = false;
+    if (is_recursive) {
+        auto verifier = composer_.create_verifier();
+        verified = verifier.verify_proof({ proof });
+    } else {
+        auto verifier = composer_.create_ultra_with_keccak_verifier();
+        verified = verifier.verify_proof({ proof });
+    }
+    return verified;
 }
 
 std::string AcirComposer::get_solidity_verifier()
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
index 4a69e597e2..de3c9d3af8 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
@@ -13,11 +13,13 @@ class AcirComposer {
 
     void init_proving_key(acir_format::acir_format& constraint_system, size_t size_hint = 0);
 
-    std::vector<uint8_t> create_proof(acir_format::acir_format& constraint_system, acir_format::WitnessVector& witness);
+    std::vector<uint8_t> create_proof(acir_format::acir_format& constraint_system,
+                                      acir_format::WitnessVector& witness,
+                                      bool is_recursive);
 
     void init_verification_key();
 
-    bool verify_proof(std::vector<uint8_t> const& proof);
+    bool verify_proof(std::vector<uint8_t> const& proof, bool is_recursive);
 
     std::string get_solidity_verifier();
     size_t get_exact_circuit_size() { return exact_circuit_size_; };
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index f4beb0a0a4..2a85971ca8 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -38,6 +38,7 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
 WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
                                    uint8_t const* constraint_system_buf,
                                    uint8_t const* witness_buf,
+                                   bool const* is_recursive,
                                    uint8_t** out)
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
@@ -48,7 +49,7 @@ WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
     free_mem_slab_raw((void*)constraint_system_buf);
     free_mem_slab_raw((void*)witness_buf);
 
-    auto proof_data = acir_composer->create_proof(constraint_system, witness);
+    auto proof_data = acir_composer->create_proof(constraint_system, witness, ntohl(*is_recursive));
     *out = to_heap_buffer(proof_data);
 }
 
@@ -58,11 +59,14 @@ WASM_EXPORT void acir_init_verification_key(in_ptr acir_composer_ptr)
     acir_composer->init_verification_key();
 }
 
-WASM_EXPORT void acir_verify_proof(in_ptr acir_composer_ptr, uint8_t const* proof_buf, bool* result)
+WASM_EXPORT void acir_verify_proof(in_ptr acir_composer_ptr,
+                                   uint8_t const* proof_buf,
+                                   bool const* is_recursive,
+                                   bool* result)
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto proof = from_buffer<std::vector<uint8_t>>(proof_buf);
-    *result = acir_composer->verify_proof(proof);
+    *result = acir_composer->verify_proof(proof, ntohl(*is_recursive));
 }
 
 WASM_EXPORT void acir_get_solidity_verifier(in_ptr acir_composer_ptr, out_str_buf out)
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index 9c29a4d2f6..72c11f2ee1 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -20,11 +20,15 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
 WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
                                    uint8_t const* constraint_system_buf,
                                    uint8_t const* witness_buf,
+                                   bool const* is_recursive,
                                    uint8_t** out);
 
 WASM_EXPORT void acir_init_verification_key(in_ptr acir_composer_ptr);
 
-WASM_EXPORT void acir_verify_proof(in_ptr acir_composer_ptr, uint8_t const* proof_buf, bool* result);
+WASM_EXPORT void acir_verify_proof(in_ptr acir_composer_ptr,
+                                   uint8_t const* proof_buf,
+                                   bool const* is_recursive,
+                                   bool* result);
 
 WASM_EXPORT void acir_get_solidity_verifier(in_ptr acir_composer_ptr, out_str_buf out);
 
diff --git a/exports.json b/exports.json
index 8d285db274..12034c5d4f 100644
--- a/exports.json
+++ b/exports.json
@@ -688,6 +688,10 @@
       {
         "name": "witness_buf",
         "type": "const uint8_t *"
+      },
+      {
+        "name": "is_recursive",
+        "type": "const bool *"
       }
     ],
     "outArgs": [
@@ -719,6 +723,10 @@
       {
         "name": "proof_buf",
         "type": "const uint8_t *"
+      },
+      {
+        "name": "is_recursive",
+        "type": "const bool *"
       }
     ],
     "outArgs": [
diff --git a/ts/exports.json b/ts/exports.json
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/ts/src/barretenberg_api/index.ts b/ts/src/barretenberg_api/index.ts
index 8993c154e8..7f6719826b 100644
--- a/ts/src/barretenberg_api/index.ts
+++ b/ts/src/barretenberg_api/index.ts
@@ -201,8 +201,8 @@ export class BarretenbergApi {
     return;
   }
 
-  async acirCreateProof(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): Promise<Uint8Array> {
-    const result = await this.binder.callWasmExport('acir_create_proof', [acirComposerPtr, constraintSystemBuf, witnessBuf], [BufferDeserializer()]);
+  async acirCreateProof(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array, isRecursive: boolean): Promise<Uint8Array> {
+    const result = await this.binder.callWasmExport('acir_create_proof', [acirComposerPtr, constraintSystemBuf, witnessBuf, isRecursive], [BufferDeserializer()]);
     return result[0];
   }
 
@@ -211,8 +211,8 @@ export class BarretenbergApi {
     return;
   }
 
-  async acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array): Promise<boolean> {
-    const result = await this.binder.callWasmExport('acir_verify_proof', [acirComposerPtr, proofBuf], [BoolDeserializer()]);
+  async acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array, isRecursive: boolean): Promise<boolean> {
+    const result = await this.binder.callWasmExport('acir_verify_proof', [acirComposerPtr, proofBuf, isRecursive], [BoolDeserializer()]);
     return result[0];
   }
 
@@ -444,8 +444,8 @@ export class BarretenbergApiSync {
     return;
   }
 
-  acirCreateProof(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): Uint8Array {
-    const result = this.binder.callWasmExport('acir_create_proof', [acirComposerPtr, constraintSystemBuf, witnessBuf], [BufferDeserializer()]);
+  acirCreateProof(acirComposerPtr: Ptr, constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array, isRecursive: boolean): Uint8Array {
+    const result = this.binder.callWasmExport('acir_create_proof', [acirComposerPtr, constraintSystemBuf, witnessBuf, isRecursive], [BufferDeserializer()]);
     return result[0];
   }
 
@@ -454,8 +454,8 @@ export class BarretenbergApiSync {
     return;
   }
 
-  acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array): boolean {
-    const result = this.binder.callWasmExport('acir_verify_proof', [acirComposerPtr, proofBuf], [BoolDeserializer()]);
+  acirVerifyProof(acirComposerPtr: Ptr, proofBuf: Uint8Array, isRecursive: boolean): boolean {
+    const result = this.binder.callWasmExport('acir_verify_proof', [acirComposerPtr, proofBuf, isRecursive], [BoolDeserializer()]);
     return result[0];
   }
 
diff --git a/ts/src/main.ts b/ts/src/main.ts
index 9659d7a522..07c9169a81 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -43,7 +43,7 @@ async function init() {
   return { api, acirComposer };
 }
 
-export async function proveAndVerify(jsonPath: string, witnessPath: string) {
+export async function proveAndVerify(jsonPath: string, witnessPath: string, is_recursive: boolean) {
   const { api, acirComposer } = await init();
   try {
     debug('initing proving key...');
@@ -58,9 +58,9 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string) {
 
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
-    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness));
+    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), false);
 
-    const verified = await api.acirVerifyProof(acirComposer, proof);
+    const verified = await api.acirVerifyProof(acirComposer, proof, false);
     debug(`verified: ${verified}`);
     return verified;
   } finally {
@@ -68,7 +68,7 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string) {
   }
 }
 
-export async function prove(jsonPath: string, witnessPath: string, outputPath: string) {
+export async function prove(jsonPath: string, witnessPath: string, is_recursive: boolean, outputPath: string) {
   const { api, acirComposer } = await init();
   try {
     debug('initing proving key...');
@@ -80,7 +80,7 @@ export async function prove(jsonPath: string, witnessPath: string, outputPath: s
 
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
-    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness));
+    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), is_recursive);
 
     writeFileSync(outputPath, proof);
     debug('done.');
@@ -89,7 +89,7 @@ export async function prove(jsonPath: string, witnessPath: string, outputPath: s
   }
 }
 
-export async function verify(jsonPath: string, proofPath: string) {
+export async function verify(jsonPath: string, proofPath: string, is_recursive: boolean) {
   const { api, acirComposer } = await init();
   try {
     debug('initing proving key...');
@@ -99,7 +99,7 @@ export async function verify(jsonPath: string, proofPath: string) {
     debug('initing verification key...');
     await api.acirInitVerificationKey(acirComposer);
 
-    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath));
+    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), is_recursive);
     debug(`verified: ${verified}`);
     return verified;
   } finally {
@@ -129,6 +129,35 @@ export async function contract(jsonPath: string, outputPath: string) {
   }
 }
 
+export async function proof_as_fields(proofPath: string, num_inner_public_inputs: number, outputPath: string) {
+  const { api, acirComposer } = await init();
+
+  try {
+    debug('serializing proof byte array into field elements');
+    const proof_as_fields = await api.acirSerializeProofIntoFields(acirComposer, readFileSync(proofPath), num_inner_public_inputs);
+
+    writeFileSync(outputPath, proof_as_fields);
+    debug('done.');
+  } finally {
+    await api.destroy();
+  }
+}
+
+export async function vk_as_fields(proofPath: string, num_inner_public_inputs: number, vkey_oututPath: string, key_hash_outputPath: string) {
+  const { api, acirComposer } = await init();
+
+  try {
+    debug('serializing proof byte array into field elements');
+    const [vk_as_fields, vk_hash_as_fields] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
+
+    writeFileSync(vkey_oututPath, vk_as_fields);
+    writeFileSync(key_hash_outputPath, vk_hash_as_fields);
+    debug('done.');
+  } finally {
+    await api.destroy();
+  }
+}
+
 // nargo use bb.js: backend -> bb.js
 // backend prove --data-dir data --witness /foo/bar/witness.tr --json /foo/bar/main.json
 // backend verify ...
@@ -146,8 +175,9 @@ program
   .description('Generate a proof and verify it. Process exits with success or failure code.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
-  .action(async ({ jsonPath, witnessPath }) => {
-    const result = await proveAndVerify(jsonPath, witnessPath);
+  .option('-r, --recursive', 'prove and verify using recursive prover and verifier')
+  .action(async ({ jsonPath, witnessPath, is_recursive }) => {
+    const result = await proveAndVerify(jsonPath, witnessPath, is_recursive);
     process.exit(result ? 0 : 1);
   });
 
@@ -156,10 +186,11 @@ program
   .description('Generate a proof and write it to a file.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
+  .option('-r, --recursive', 'prove using recursive prover')
   .option('-o, --output-dir <path>', 'Specify the proof output dir', './proofs')
   .requiredOption('-n, --name <filename>', 'Output file name.')
-  .action(async ({ jsonPath, witnessPath, outputDir, name }) => {
-    await prove(jsonPath, witnessPath, outputDir + '/' + name);
+  .action(async ({ jsonPath, witnessPath, is_recursive, outputDir, name }) => {
+    await prove(jsonPath, witnessPath, is_recursive, outputDir + '/' + name);
   });
 
 program
@@ -167,8 +198,9 @@ program
   .description('Verify a proof. Process exists with success or failure code.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
-  .action(async ({ jsonPath, proofPath }) => {
-    await verify(jsonPath, proofPath);
+  .option('-r, --recursive', 'prove using recursive prover')
+  .action(async ({ jsonPath, proofPath, is_recursive }) => {
+    await verify(jsonPath, proofPath, is_recursive);
   });
 
 program

From 66ed1f7f53e1885eab6fb76e6a568ea9ac5a3d8d Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Thu, 25 May 2023 16:12:22 +0000
Subject: [PATCH 42/64] remove install state

---
 .yarn/install-state.gz | Bin 562500 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 .yarn/install-state.gz

diff --git a/.yarn/install-state.gz b/.yarn/install-state.gz
deleted file mode 100644
index 2ffebfb0fb7417ea10a006f9e84e9e6103c7cb56..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 562500
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


From 1fa02e77d20337b194e2e664f5a06f19cfe1e880 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Thu, 25 May 2023 18:20:45 +0000
Subject: [PATCH 43/64] remove debug output and use total_circuit_size

---
 .../barretenberg/dsl/acir_proofs/acir_composer.cpp   | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index cf15c5bf00..2fd5a8d61c 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -27,16 +27,10 @@ void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system,
     constraint_system.constraints.clear();
     constraint_system.constraints.shrink_to_fit();
 
-    exact_circuit_size_ = composer_.get_num_gates();
     total_circuit_size_ = composer_.get_total_circuit_size();
-    std::cout << "total_circuit_size_: " << total_circuit_size_ << std::endl;
-    // Exact or total fed in here?
     circuit_subgroup_size_ = composer_.get_circuit_subgroup_size(total_circuit_size_);
-    std::cout << "circuit_subgroup_size_: " << circuit_subgroup_size_ << std::endl;
 
     proving_key_ = composer_.compute_proving_key();
-
-    std::cout << "proving key circuit_size: " << proving_key_.get()->circuit_size << std::endl;
 }
 
 std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constraint_system,
@@ -46,9 +40,6 @@ std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constr
     composer_ = acir_format::Composer(proving_key_, verification_key_, circuit_subgroup_size_);
     // You can't produce the verification key unless you manually set the crs. Which seems like a bug.
     composer_.crs_factory_ = crs_factory_;
-    for (size_t i = 0; i < witness.size(); i++) {
-        std::cout << "witness: " << witness[i] << std::endl;
-    }
 
     create_circuit_with_witness(composer_, constraint_system, witness);
 
@@ -58,9 +49,6 @@ std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constr
     witness.clear();
     witness.shrink_to_fit();
 
-    std::cout << "num_gates: " << composer_.num_gates << std::endl;
-    std::cout << "circuit_finalised: " << composer_.circuit_finalised << std::endl;
-
     std::vector<uint8_t> proof;
     if (is_recursive) {
         auto prover = composer_.create_prover();

From 1bf8db25a8e31461b71c52da1fef98395b7c5907 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Thu, 25 May 2023 21:35:37 +0000
Subject: [PATCH 44/64] remove verify_recursive_proof as we might not need it
 for simulation

---
 .../dsl/acir_proofs/acir_composer.cpp         | 174 +++++++++---------
 .../dsl/acir_proofs/acir_composer.hpp         |  10 +-
 .../barretenberg/dsl/acir_proofs/c_bind.hpp   |  12 +-
 ts/src/main.ts                                |  25 ++-
 4 files changed, 123 insertions(+), 98 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 2fd5a8d61c..70be67430e 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -28,6 +28,7 @@ void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system,
     constraint_system.constraints.shrink_to_fit();
 
     total_circuit_size_ = composer_.get_total_circuit_size();
+    std::cout << "total_circuit_size_: " << total_circuit_size_ << std::endl;
     circuit_subgroup_size_ = composer_.get_circuit_subgroup_size(total_circuit_size_);
 
     proving_key_ = composer_.compute_proving_key();
@@ -85,91 +86,6 @@ std::string AcirComposer::get_solidity_verifier()
     return stream.str();
 }
 
-std::vector<barretenberg::fr> AcirComposer::verify_recursive_proof(
-    std::vector<barretenberg::fr> const& proof,
-    std::vector<barretenberg::fr> const& verification_key,
-    uint32_t num_public_inputs,
-    std::vector<barretenberg::fr> input_aggregation_object)
-{
-    const size_t NUM_AGGREGATION_ELEMENTS = acir_format::RecursionConstraint::NUM_AGGREGATION_ELEMENTS;
-
-    bool inner_aggregation_all_zero = true;
-    for (size_t i = 0; i < input_aggregation_object.size(); i++) {
-        inner_aggregation_all_zero &= (input_aggregation_object[i].is_zero());
-    }
-
-    acir_format::aggregation_state_ct previous_aggregation;
-    if (!inner_aggregation_all_zero) {
-        std::array<acir_format::bn254::fq_ct, NUM_AGGREGATION_ELEMENTS> aggregation_elements;
-        for (size_t i = 0; i < NUM_AGGREGATION_ELEMENTS; ++i) {
-            aggregation_elements[i] = acir_format::bn254::fq_ct(
-                acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i]),
-                acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i + 1]),
-                acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i + 2]),
-                acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * 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
-        // in stdlib::recursion::verify_proof
-        previous_aggregation.P0 = acir_format::bn254::g1_ct(aggregation_elements[0], aggregation_elements[1]);
-        previous_aggregation.P1 = acir_format::bn254::g1_ct(aggregation_elements[2], aggregation_elements[3]);
-        previous_aggregation.has_data = true;
-    } else {
-        previous_aggregation.has_data = false;
-    }
-
-    composer_ = acir_format::Composer();
-
-    std::vector<acir_format::field_ct> proof_fields(proof.size());
-    std::vector<acir_format::field_ct> key_fields(verification_key.size());
-    for (size_t i = 0; i < proof.size(); i++) {
-        // TODO(maxim): The stdlib pairing primitives fetch the context from the elements being used in the pairing
-        // computation When attempting to simulate recursive verification without a full circuit where the context of
-        // these elements are not set we will get a seg fault. Using `witness_ct` here provides a workaround where these
-        // elements will have their context set. We should enable the native verifier to return an aggregation state so
-        // that we can avoid creating an unnecessary circuit and this workaround
-        proof_fields[i] = acir_format::field_ct(acir_format::witness_ct(&composer_, proof[i]));
-    }
-    for (size_t i = 0; i < verification_key.size(); i++) {
-        key_fields[i] = acir_format::field_ct(verification_key[i]);
-    }
-
-    transcript::Manifest manifest = acir_format::Composer::create_unrolled_manifest(num_public_inputs);
-
-    std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object = {};
-    for (size_t i = 6; i < 22; ++i) {
-        nested_aggregation_object[i - 6] = uint32_t(key_fields[i].get_value());
-    }
-    bool nested_aggregation_indices_all_zero = true;
-    for (const auto& idx : nested_aggregation_object) {
-        nested_aggregation_indices_all_zero &= (idx == 0);
-    }
-    const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
-
-    std::shared_ptr<acir_format::verification_key_ct> vkey = acir_format::verification_key_ct::from_field_elements(
-        &composer_, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_object);
-
-    acir_format::Transcript_ct transcript(&composer_, manifest, proof_fields, num_public_inputs);
-
-    acir_format::aggregation_state_ct result =
-        proof_system::plonk::stdlib::recursion::verify_proof_<acir_format::bn254, acir_format::noir_recursive_settings>(
-            &composer_, vkey, transcript, previous_aggregation);
-
-    std::vector<barretenberg::fr> output_aggregation_object;
-    for (size_t i = 0; i < 4; ++i) {
-        auto P0_x = result.P0.x.binary_basis_limbs[i].element.get_value();
-        auto P0_y = result.P0.y.binary_basis_limbs[i].element.get_value();
-        auto P1_x = result.P1.x.binary_basis_limbs[i].element.get_value();
-        auto P1_y = result.P1.y.binary_basis_limbs[i].element.get_value();
-        output_aggregation_object.emplace_back(P0_x);
-        output_aggregation_object.emplace_back(P0_y);
-        output_aggregation_object.emplace_back(P1_x);
-        output_aggregation_object.emplace_back(P1_y);
-    }
-
-    return output_aggregation_object;
-}
-
 std::vector<barretenberg::fr> AcirComposer::serialize_proof_into_fields(std::vector<uint8_t> const& proof,
                                                                         size_t num_inner_public_inputs)
 {
@@ -189,4 +105,92 @@ std::vector<barretenberg::fr> AcirComposer::serialize_verification_key_into_fiel
     return output;
 }
 
+// std::vector<barretenberg::fr> AcirComposer::verify_recursive_proof(
+//     std::vector<barretenberg::fr> const& proof,
+//     std::vector<barretenberg::fr> const& verification_key,
+//     uint32_t num_public_inputs,
+//     std::vector<barretenberg::fr> input_aggregation_object)
+// {
+//     const size_t NUM_AGGREGATION_ELEMENTS = acir_format::RecursionConstraint::NUM_AGGREGATION_ELEMENTS;
+
+//     bool inner_aggregation_all_zero = true;
+//     for (size_t i = 0; i < input_aggregation_object.size(); i++) {
+//         inner_aggregation_all_zero &= (input_aggregation_object[i].is_zero());
+//     }
+
+//     acir_format::aggregation_state_ct previous_aggregation;
+//     if (!inner_aggregation_all_zero) {
+//         std::array<acir_format::bn254::fq_ct, NUM_AGGREGATION_ELEMENTS> aggregation_elements;
+//         for (size_t i = 0; i < NUM_AGGREGATION_ELEMENTS; ++i) {
+//             aggregation_elements[i] = acir_format::bn254::fq_ct(
+//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i]),
+//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i + 1]),
+//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i + 2]),
+//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * 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
+//         // in stdlib::recursion::verify_proof
+//         previous_aggregation.P0 = acir_format::bn254::g1_ct(aggregation_elements[0], aggregation_elements[1]);
+//         previous_aggregation.P1 = acir_format::bn254::g1_ct(aggregation_elements[2], aggregation_elements[3]);
+//         previous_aggregation.has_data = true;
+//     } else {
+//         previous_aggregation.has_data = false;
+//     }
+
+//     composer_ = acir_format::Composer();
+
+//     std::vector<acir_format::field_ct> proof_fields(proof.size());
+//     std::vector<acir_format::field_ct> key_fields(verification_key.size());
+//     for (size_t i = 0; i < proof.size(); i++) {
+//         // TODO(maxim): The stdlib pairing primitives fetch the context from the elements being used in the pairing
+//         // computation When attempting to simulate recursive verification without a full circuit where the context of
+//         // these elements are not set we will get a seg fault. Using `witness_ct` here provides a workaround where
+//         these
+//         // elements will have their context set. We should enable the native verifier to return an aggregation state
+//         so
+//         // that we can avoid creating an unnecessary circuit and this workaround
+//         proof_fields[i] = acir_format::field_ct(acir_format::witness_ct(&composer_, proof[i]));
+//     }
+//     for (size_t i = 0; i < verification_key.size(); i++) {
+//         key_fields[i] = acir_format::field_ct(verification_key[i]);
+//     }
+
+//     transcript::Manifest manifest = acir_format::Composer::create_unrolled_manifest(num_public_inputs);
+
+//     std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object = {};
+//     for (size_t i = 6; i < 22; ++i) {
+//         nested_aggregation_object[i - 6] = uint32_t(key_fields[i].get_value());
+//     }
+//     bool nested_aggregation_indices_all_zero = true;
+//     for (const auto& idx : nested_aggregation_object) {
+//         nested_aggregation_indices_all_zero &= (idx == 0);
+//     }
+//     const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
+
+//     std::shared_ptr<acir_format::verification_key_ct> vkey = acir_format::verification_key_ct::from_field_elements(
+//         &composer_, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_object);
+
+//     acir_format::Transcript_ct transcript(&composer_, manifest, proof_fields, num_public_inputs);
+
+//     acir_format::aggregation_state_ct result =
+//         proof_system::plonk::stdlib::recursion::verify_proof_<acir_format::bn254,
+//         acir_format::noir_recursive_settings>(
+//             &composer_, vkey, transcript, previous_aggregation);
+
+//     std::vector<barretenberg::fr> output_aggregation_object;
+//     for (size_t i = 0; i < 4; ++i) {
+//         auto P0_x = result.P0.x.binary_basis_limbs[i].element.get_value();
+//         auto P0_y = result.P0.y.binary_basis_limbs[i].element.get_value();
+//         auto P1_x = result.P1.x.binary_basis_limbs[i].element.get_value();
+//         auto P1_y = result.P1.y.binary_basis_limbs[i].element.get_value();
+//         output_aggregation_object.emplace_back(P0_x);
+//         output_aggregation_object.emplace_back(P0_y);
+//         output_aggregation_object.emplace_back(P1_x);
+//         output_aggregation_object.emplace_back(P1_y);
+//     }
+
+//     return output_aggregation_object;
+// }
+
 } // namespace acir_proofs
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
index 1045146dec..1105cee7ac 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
@@ -25,16 +25,16 @@ class AcirComposer {
     size_t get_exact_circuit_size() { return exact_circuit_size_; };
     size_t get_total_circuit_size() { return total_circuit_size_; };
 
-    std::vector<barretenberg::fr> verify_recursive_proof(std::vector<barretenberg::fr> const& proof,
-                                                         std::vector<barretenberg::fr> const& verification_key,
-                                                         uint32_t num_public_inputs,
-                                                         std::vector<barretenberg::fr> input_aggregation_object);
-
     std::vector<barretenberg::fr> serialize_proof_into_fields(std::vector<uint8_t> const& proof,
                                                               size_t num_inner_public_inputs);
 
     std::vector<barretenberg::fr> serialize_verification_key_into_fields();
 
+    // std::vector<barretenberg::fr> verify_recursive_proof(std::vector<barretenberg::fr> const& proof,
+    //                                                  std::vector<barretenberg::fr> const& verification_key,
+    //                                                  uint32_t num_public_inputs,
+    //                                                  std::vector<barretenberg::fr> input_aggregation_object)
+
   private:
     std::shared_ptr<proof_system::ReferenceStringFactory> crs_factory_;
     acir_format::Composer composer_;
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index dfdbe6560f..7df04f3394 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -38,11 +38,6 @@ WASM_EXPORT void acir_get_exact_circuit_size(in_ptr acir_composer_ptr, uint32_t*
 
 WASM_EXPORT void acir_get_total_circuit_size(in_ptr acir_composer_ptr, uint32_t* out);
 
-WASM_EXPORT void acir_verify_recursive_proof(in_ptr acir_composer_ptr,
-                                             uint8_t const* proof_buf,
-                                             uint32_t const* num_inner_public_inputs,
-                                             uint8_t** out);
-
 WASM_EXPORT void acir_serialize_proof_into_fields(in_ptr acir_composer_ptr,
                                                   uint8_t const* proof_buf,
                                                   uint32_t const* num_inner_public_inputs,
@@ -50,4 +45,9 @@ WASM_EXPORT void acir_serialize_proof_into_fields(in_ptr acir_composer_ptr,
 
 WASM_EXPORT void acir_serialize_verification_key_into_fields(in_ptr acir_composer_ptr,
                                                              uint8_t** out_vkey,
-                                                             uint8_t** out_key_hash);
\ No newline at end of file
+                                                             uint8_t** out_key_hash);
+
+// WASM_EXPORT void acir_verify_recursive_proof(in_ptr acir_composer_ptr,
+//                                              uint8_t const* proof_buf,
+//                                              uint32_t const* num_inner_public_inputs,
+//                                              uint8_t** out);
\ No newline at end of file
diff --git a/ts/src/main.ts b/ts/src/main.ts
index 0c5f38c0a4..6a18180d7d 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -13,7 +13,7 @@ const debug = createDebug('bb.js');
 createDebug.enable('*');
 
 // Maximum we support.
-const CIRCUIT_SIZE = 2 ** 19;
+const CIRCUIT_SIZE = 2 ** 18;
 
 function getBytecode(jsonPath: string) {
   const json = readFileSync(jsonPath, 'utf-8');
@@ -163,9 +163,11 @@ export async function proof_as_fields(proofPath: string, num_inner_public_inputs
   }
 }
 
-export async function vk_as_fields(proofPath: string, num_inner_public_inputs: number, vkey_oututPath: string, key_hash_outputPath: string) {
+export async function vk_as_fields(vkey_oututPath: string, key_hash_outputPath: string) {
   const { api, acirComposer } = await init();
 
+  // TODO: move to passing in the key so we don't have to recompute it
+  api.acirInitVerificationKey(acirComposer);
   try {
     debug('serializing proof byte array into field elements');
     const [vk_as_fields, vk_hash_as_fields] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
@@ -241,4 +243,23 @@ program
     await writeVk(jsonPath, outputPath);
   });
 
+program
+  .command('proof_as_fields')
+  .description('Return the proof as fields elements')
+  .requiredOption('-p, --proof-path <path>', 'Specify the proof path')
+  .requiredOption('-n, --num-public-inputs', 'Specify the number of public inputs')
+  .requiredOption('-o, --output-path <path>', 'Specify the path to write the proof fields')
+  .action(async ({ proofPath, numPublicInputs, outputPath }) => {
+    await proof_as_fields(proofPath, numPublicInputs, outputPath);
+  })
+
+program
+  .command('vk_as_fields')
+  .description('Return the verifiation key represented as fields elements. Also return the verification key hash.')
+  .requiredOption('-v, --vkey-output-path <path>', 'Specify the path to write the verification key fields')
+  .requiredOption('-h, --key-hash-output-path <path>', 'Specify the path to write the verification key hash')
+  .action(async ({vkey_oututPath, key_hash_outputPath }) => {
+    await vk_as_fields(vkey_oututPath, key_hash_outputPath);
+  })
+
 program.parse(process.argv);

From 381ef1daf5155069b87f0836c435d54cf0483461 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Thu, 25 May 2023 23:16:04 +0000
Subject: [PATCH 45/64] switch how we do is_recursive

---
 .../dsl/acir_proofs/acir_composer.cpp         |  1 +
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   |  7 +++---
 exports.json                                  | 24 -------------------
 ts/src/barretenberg_api/index.ts              | 10 --------
 4 files changed, 5 insertions(+), 37 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 70be67430e..8557c7db67 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -20,6 +20,7 @@ AcirComposer::AcirComposer(std::shared_ptr<proof_system::ReferenceStringFactory>
 
 void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system, size_t size_hint)
 {
+    std::cout << "about to create circuit: " << total_circuit_size_ << std::endl;
     composer_ = create_circuit(constraint_system, crs_factory_, size_hint);
 
     // We are done with the constraint system at this point, and we need the memory slab back.
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index 3885b332c4..f18fe6b4e0 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -26,9 +26,10 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
                                        uint8_t const* constraint_system_buf,
                                        uint32_t const* size_hint)
 {
+    std::cout << "got constraint_system\n";
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
-
+    std::cout << "got constraint_system\n";
     // The binder would normally free the the constraint_system_buf, but we need the memory now.
     free_mem_slab_raw((void*)constraint_system_buf);
 
@@ -49,7 +50,7 @@ WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
     free_mem_slab_raw((void*)constraint_system_buf);
     free_mem_slab_raw((void*)witness_buf);
 
-    auto proof_data = acir_composer->create_proof(constraint_system, witness, ntohl(*is_recursive));
+    auto proof_data = acir_composer->create_proof(constraint_system, witness, *is_recursive);
     *out = to_heap_buffer(proof_data);
 }
 
@@ -76,7 +77,7 @@ WASM_EXPORT void acir_verify_proof(in_ptr acir_composer_ptr,
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto proof = from_buffer<std::vector<uint8_t>>(proof_buf);
-    *result = acir_composer->verify_proof(proof, ntohl(*is_recursive));
+    *result = acir_composer->verify_proof(proof, *is_recursive);
 }
 
 WASM_EXPORT void acir_get_solidity_verifier(in_ptr acir_composer_ptr, out_str_buf out)
diff --git a/exports.json b/exports.json
index 99c57282ad..c6aea3331a 100644
--- a/exports.json
+++ b/exports.json
@@ -801,30 +801,6 @@
     ],
     "isAsync": false
   },
-  {
-    "functionName": "acir_verify_recursive_proof",
-    "inArgs": [
-      {
-        "name": "acir_composer_ptr",
-        "type": "in_ptr"
-      },
-      {
-        "name": "proof_buf",
-        "type": "const uint8_t *"
-      },
-      {
-        "name": "num_inner_public_inputs",
-        "type": "const uint32_t *"
-      }
-    ],
-    "outArgs": [
-      {
-        "name": "out",
-        "type": "uint8_t **"
-      }
-    ],
-    "isAsync": false
-  },
   {
     "functionName": "acir_serialize_proof_into_fields",
     "inArgs": [
diff --git a/ts/src/barretenberg_api/index.ts b/ts/src/barretenberg_api/index.ts
index e8eaae804e..b26c77890a 100644
--- a/ts/src/barretenberg_api/index.ts
+++ b/ts/src/barretenberg_api/index.ts
@@ -236,11 +236,6 @@ export class BarretenbergApi {
     return result[0];
   }
 
-  async acirVerifyRecursiveProof(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Promise<Uint8Array> {
-    const result = await this.binder.callWasmExport('acir_verify_recursive_proof', [acirComposerPtr, proofBuf, numInnerPublicInputs], [BufferDeserializer()]);
-    return result[0];
-  }
-
   async acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Promise<Uint8Array> {
     const result = await this.binder.callWasmExport('acir_serialize_proof_into_fields', [acirComposerPtr, proofBuf, numInnerPublicInputs], [BufferDeserializer()]);
     return result[0];
@@ -484,11 +479,6 @@ export class BarretenbergApiSync {
     return result[0];
   }
 
-  acirVerifyRecursiveProof(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Uint8Array {
-    const result = this.binder.callWasmExport('acir_verify_recursive_proof', [acirComposerPtr, proofBuf, numInnerPublicInputs], [BufferDeserializer()]);
-    return result[0];
-  }
-
   acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Uint8Array {
     const result = this.binder.callWasmExport('acir_serialize_proof_into_fields', [acirComposerPtr, proofBuf, numInnerPublicInputs], [BufferDeserializer()]);
     return result[0];

From 88e364f1c1026c11b194810640bea0e1c2f4adf8 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 26 May 2023 01:28:53 +0000
Subject: [PATCH 46/64] remove acir recursive simulation method

---
 .../dsl/acir_proofs/acir_composer.cpp         | 88 -------------------
 .../dsl/acir_proofs/acir_composer.hpp         |  5 --
 2 files changed, 93 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 8557c7db67..5a9e2047bc 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -106,92 +106,4 @@ std::vector<barretenberg::fr> AcirComposer::serialize_verification_key_into_fiel
     return output;
 }
 
-// std::vector<barretenberg::fr> AcirComposer::verify_recursive_proof(
-//     std::vector<barretenberg::fr> const& proof,
-//     std::vector<barretenberg::fr> const& verification_key,
-//     uint32_t num_public_inputs,
-//     std::vector<barretenberg::fr> input_aggregation_object)
-// {
-//     const size_t NUM_AGGREGATION_ELEMENTS = acir_format::RecursionConstraint::NUM_AGGREGATION_ELEMENTS;
-
-//     bool inner_aggregation_all_zero = true;
-//     for (size_t i = 0; i < input_aggregation_object.size(); i++) {
-//         inner_aggregation_all_zero &= (input_aggregation_object[i].is_zero());
-//     }
-
-//     acir_format::aggregation_state_ct previous_aggregation;
-//     if (!inner_aggregation_all_zero) {
-//         std::array<acir_format::bn254::fq_ct, NUM_AGGREGATION_ELEMENTS> aggregation_elements;
-//         for (size_t i = 0; i < NUM_AGGREGATION_ELEMENTS; ++i) {
-//             aggregation_elements[i] = acir_format::bn254::fq_ct(
-//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i]),
-//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i + 1]),
-//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * i + 2]),
-//                 acir_format::field_ct(input_aggregation_object[NUM_AGGREGATION_ELEMENTS * 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
-//         // in stdlib::recursion::verify_proof
-//         previous_aggregation.P0 = acir_format::bn254::g1_ct(aggregation_elements[0], aggregation_elements[1]);
-//         previous_aggregation.P1 = acir_format::bn254::g1_ct(aggregation_elements[2], aggregation_elements[3]);
-//         previous_aggregation.has_data = true;
-//     } else {
-//         previous_aggregation.has_data = false;
-//     }
-
-//     composer_ = acir_format::Composer();
-
-//     std::vector<acir_format::field_ct> proof_fields(proof.size());
-//     std::vector<acir_format::field_ct> key_fields(verification_key.size());
-//     for (size_t i = 0; i < proof.size(); i++) {
-//         // TODO(maxim): The stdlib pairing primitives fetch the context from the elements being used in the pairing
-//         // computation When attempting to simulate recursive verification without a full circuit where the context of
-//         // these elements are not set we will get a seg fault. Using `witness_ct` here provides a workaround where
-//         these
-//         // elements will have their context set. We should enable the native verifier to return an aggregation state
-//         so
-//         // that we can avoid creating an unnecessary circuit and this workaround
-//         proof_fields[i] = acir_format::field_ct(acir_format::witness_ct(&composer_, proof[i]));
-//     }
-//     for (size_t i = 0; i < verification_key.size(); i++) {
-//         key_fields[i] = acir_format::field_ct(verification_key[i]);
-//     }
-
-//     transcript::Manifest manifest = acir_format::Composer::create_unrolled_manifest(num_public_inputs);
-
-//     std::array<uint32_t, acir_format::RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object = {};
-//     for (size_t i = 6; i < 22; ++i) {
-//         nested_aggregation_object[i - 6] = uint32_t(key_fields[i].get_value());
-//     }
-//     bool nested_aggregation_indices_all_zero = true;
-//     for (const auto& idx : nested_aggregation_object) {
-//         nested_aggregation_indices_all_zero &= (idx == 0);
-//     }
-//     const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
-
-//     std::shared_ptr<acir_format::verification_key_ct> vkey = acir_format::verification_key_ct::from_field_elements(
-//         &composer_, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_object);
-
-//     acir_format::Transcript_ct transcript(&composer_, manifest, proof_fields, num_public_inputs);
-
-//     acir_format::aggregation_state_ct result =
-//         proof_system::plonk::stdlib::recursion::verify_proof_<acir_format::bn254,
-//         acir_format::noir_recursive_settings>(
-//             &composer_, vkey, transcript, previous_aggregation);
-
-//     std::vector<barretenberg::fr> output_aggregation_object;
-//     for (size_t i = 0; i < 4; ++i) {
-//         auto P0_x = result.P0.x.binary_basis_limbs[i].element.get_value();
-//         auto P0_y = result.P0.y.binary_basis_limbs[i].element.get_value();
-//         auto P1_x = result.P1.x.binary_basis_limbs[i].element.get_value();
-//         auto P1_y = result.P1.y.binary_basis_limbs[i].element.get_value();
-//         output_aggregation_object.emplace_back(P0_x);
-//         output_aggregation_object.emplace_back(P0_y);
-//         output_aggregation_object.emplace_back(P1_x);
-//         output_aggregation_object.emplace_back(P1_y);
-//     }
-
-//     return output_aggregation_object;
-// }
-
 } // namespace acir_proofs
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
index 1105cee7ac..145cc0509c 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
@@ -30,11 +30,6 @@ class AcirComposer {
 
     std::vector<barretenberg::fr> serialize_verification_key_into_fields();
 
-    // std::vector<barretenberg::fr> verify_recursive_proof(std::vector<barretenberg::fr> const& proof,
-    //                                                  std::vector<barretenberg::fr> const& verification_key,
-    //                                                  uint32_t num_public_inputs,
-    //                                                  std::vector<barretenberg::fr> input_aggregation_object)
-
   private:
     std::shared_ptr<proof_system::ReferenceStringFactory> crs_factory_;
     acir_format::Composer composer_;

From 49e238ad8580b97d2250cd4302c4e221b339ad77 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 26 May 2023 01:53:32 +0000
Subject: [PATCH 47/64] changed wasi stubs and removed cout from
 acir_init_proving_key

---
 cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp | 3 +--
 cpp/src/barretenberg/wasi/wasi_stubs.cpp        | 8 ++++----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index f18fe6b4e0..9adfee02f8 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -26,10 +26,9 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
                                        uint8_t const* constraint_system_buf,
                                        uint32_t const* size_hint)
 {
-    std::cout << "got constraint_system\n";
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
-    std::cout << "got constraint_system\n";
+
     // The binder would normally free the the constraint_system_buf, but we need the memory now.
     free_mem_slab_raw((void*)constraint_system_buf);
 
diff --git a/cpp/src/barretenberg/wasi/wasi_stubs.cpp b/cpp/src/barretenberg/wasi/wasi_stubs.cpp
index 55dd6c6900..b561da0a96 100644
--- a/cpp/src/barretenberg/wasi/wasi_stubs.cpp
+++ b/cpp/src/barretenberg/wasi/wasi_stubs.cpp
@@ -25,8 +25,8 @@ int32_t __imported_wasi_snapshot_preview1_poll_oneoff(int32_t, int32_t, int32_t,
 
 int32_t __imported_wasi_snapshot_preview1_fd_write(int32_t, int32_t, int32_t, int32_t)
 {
-    info("fd_write not implemented.");
-    abort();
+    // info("fd_write not implemented.");
+    // abort();
     return 0;
 }
 
@@ -67,8 +67,8 @@ int32_t __imported_wasi_snapshot_preview1_environ_sizes_get(int32_t, int32_t)
 
 int32_t __imported_wasi_snapshot_preview1_fd_fdstat_get(int32_t, int32_t)
 {
-    info("fd_fdstat_get not implemented.");
-    abort();
+    // info("fd_fdstat_get not implemented.");
+    // abort();
     return 0;
 }
 

From 5f195dcd88817f5fbe6e75e8aea127fbb9b3a2f3 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 26 May 2023 02:52:33 +0000
Subject: [PATCH 48/64] removed cout outs getting runtime error for func
 definition

---
 cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp | 2 --
 cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp        | 7 +------
 cpp/src/barretenberg/plonk/composer/ultra_composer.cpp | 1 -
 cpp/src/barretenberg/wasi/wasi_stubs.cpp               | 8 ++++----
 ts/src/main.ts                                         | 6 ++++--
 5 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 5a9e2047bc..25059ae6ad 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -20,7 +20,6 @@ AcirComposer::AcirComposer(std::shared_ptr<proof_system::ReferenceStringFactory>
 
 void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system, size_t size_hint)
 {
-    std::cout << "about to create circuit: " << total_circuit_size_ << std::endl;
     composer_ = create_circuit(constraint_system, crs_factory_, size_hint);
 
     // We are done with the constraint system at this point, and we need the memory slab back.
@@ -29,7 +28,6 @@ void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system,
     constraint_system.constraints.shrink_to_fit();
 
     total_circuit_size_ = composer_.get_total_circuit_size();
-    std::cout << "total_circuit_size_: " << total_circuit_size_ << std::endl;
     circuit_subgroup_size_ = composer_.get_circuit_subgroup_size(total_circuit_size_);
 
     proving_key_ = composer_.compute_proving_key();
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index 7df04f3394..c07d7c6eea 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -45,9 +45,4 @@ WASM_EXPORT void acir_serialize_proof_into_fields(in_ptr acir_composer_ptr,
 
 WASM_EXPORT void acir_serialize_verification_key_into_fields(in_ptr acir_composer_ptr,
                                                              uint8_t** out_vkey,
-                                                             uint8_t** out_key_hash);
-
-// WASM_EXPORT void acir_verify_recursive_proof(in_ptr acir_composer_ptr,
-//                                              uint8_t const* proof_buf,
-//                                              uint32_t const* num_inner_public_inputs,
-//                                              uint8_t** out);
\ No newline at end of file
+                                                             uint8_t** out_key_hash);
\ No newline at end of file
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
index 8c3e8a0d1c..bf13074fdf 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
@@ -541,7 +541,6 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key()
     }
 
     if (circuit_proving_key) {
-        std::cout << "already have proving_key\n";
         return circuit_proving_key;
     }
 
diff --git a/cpp/src/barretenberg/wasi/wasi_stubs.cpp b/cpp/src/barretenberg/wasi/wasi_stubs.cpp
index b561da0a96..55dd6c6900 100644
--- a/cpp/src/barretenberg/wasi/wasi_stubs.cpp
+++ b/cpp/src/barretenberg/wasi/wasi_stubs.cpp
@@ -25,8 +25,8 @@ int32_t __imported_wasi_snapshot_preview1_poll_oneoff(int32_t, int32_t, int32_t,
 
 int32_t __imported_wasi_snapshot_preview1_fd_write(int32_t, int32_t, int32_t, int32_t)
 {
-    // info("fd_write not implemented.");
-    // abort();
+    info("fd_write not implemented.");
+    abort();
     return 0;
 }
 
@@ -67,8 +67,8 @@ int32_t __imported_wasi_snapshot_preview1_environ_sizes_get(int32_t, int32_t)
 
 int32_t __imported_wasi_snapshot_preview1_fd_fdstat_get(int32_t, int32_t)
 {
-    // info("fd_fdstat_get not implemented.");
-    // abort();
+    info("fd_fdstat_get not implemented.");
+    abort();
     return 0;
 }
 
diff --git a/ts/src/main.ts b/ts/src/main.ts
index 6a18180d7d..e1768f2f65 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -7,13 +7,14 @@ import { gunzipSync } from 'zlib';
 import { RawBuffer } from './types/index.js';
 import { numToInt32BE } from './serialize/serialize.js';
 import { Command } from 'commander';
+import { info } from 'console';
 
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
 createDebug.enable('*');
 
 // Maximum we support.
-const CIRCUIT_SIZE = 2 ** 18;
+const CIRCUIT_SIZE = 2 ** 19;
 
 function getBytecode(jsonPath: string) {
   const json = readFileSync(jsonPath, 'utf-8');
@@ -167,6 +168,7 @@ export async function vk_as_fields(vkey_oututPath: string, key_hash_outputPath:
   const { api, acirComposer } = await init();
 
   // TODO: move to passing in the key so we don't have to recompute it
+  // or just keep it as the writeVK method currently recomputes the pkey too
   api.acirInitVerificationKey(acirComposer);
   try {
     debug('serializing proof byte array into field elements');
@@ -199,7 +201,7 @@ program
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
   .option('-r, --recursive', 'prove and verify using recursive prover and verifier')
   .action(async ({ jsonPath, witnessPath, is_recursive }) => {
-    const result = await proveAndVerify(jsonPath, witnessPath, is_recursive);
+    const result = await proveAndVerify(jsonPath, witnessPath, false);
     process.exit(result ? 0 : 1);
   });
 

From 45328c19068222a5fb945c449f64ba9398a800ad Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 26 May 2023 19:28:49 +0000
Subject: [PATCH 49/64] working recursion format funcs, but strangely getting
 errors about trying to invert zero in the field for dummy transcript and key

---
 .../dsl/acir_format/acir_format.hpp           | 18 ++---
 .../dsl/acir_format/recursion_constraint.cpp  | 23 +++++-
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   | 31 ++++----
 .../recursion/transcript/transcript.hpp       |  2 +
 .../stdlib/recursion/verifier/verifier.hpp    | 19 ++++-
 ts/src/main.ts                                | 73 ++++++++++++-------
 6 files changed, 106 insertions(+), 60 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
index 9aa57902fe..a9b60e9913 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
@@ -103,20 +103,12 @@ template <typename B> inline void write(B& buf, acir_format const& data)
     write(buf, data.hash_to_field_constraints);
     write(buf, data.fixed_base_scalar_mul_constraints);
     write(buf, data.recursion_constraints);
-    for (size_t i = 0; i < data.constraints.size(); i++) {
-        write(buf, data.constraints[i]);
-    }
-    // write(buf, data.constraints);
+    // TODO: probably delete, used for writing AcirComposer tests in CPP
+    // for (size_t i = 0; i < data.constraints.size(); i++) {
+    //     write(buf, data.constraints[i]);
+    // }
+    write(buf, data.constraints);
     write(buf, data.block_constraints);
 }
 
-// template <typename B> inline void write(&B buf, std::vector<poly_triple, ContainerSlabAllocator<poly_triple>> const&
-// constraints)
-// {
-//     using serialize::write;
-// for (size_t i = 0; i < constraints.size(); i++) {
-//     write(buf, constraints[i]);
-// }
-// }
-
 } // namespace acir_format
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 32cb775cd3..2a2a63fd91 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -38,7 +38,11 @@ void create_recursion_constraints(Composer& composer,
         nested_aggregation_indices_all_zero &= (idx == 0);
     }
     const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
+    info("inner_proof_contains_recursive_proof");
+    info(inner_proof_contains_recursive_proof);
 
+    info("has_valid_witness_assignments");
+    info(has_valid_witness_assignments);
     // If we do not have a witness, we must ensure that our dummy witness will not trigger
     // on-curve errors and inverting-zero errors
     {
@@ -82,6 +86,9 @@ void create_recursion_constraints(Composer& composer,
     for (const auto& idx : aggregation_input) {
         inner_aggregation_indices_all_zero &= (idx == 0);
     }
+    info("inner_aggregation_indices_all_zero");
+    info(inner_aggregation_indices_all_zero);
+
     if (!inner_aggregation_indices_all_zero) {
         std::array<bn254::fq_ct, 4> aggregation_elements;
         for (size_t i = 0; i < 4; ++i) {
@@ -101,18 +108,26 @@ void create_recursion_constraints(Composer& composer,
         previous_aggregation.has_data = false;
     }
 
+    info("input.public_inputs.size()");
+    info(input.public_inputs.size());
     transcript::Manifest manifest = Composer::create_unrolled_manifest(input.public_inputs.size());
 
     std::vector<field_ct> key_fields;
     key_fields.reserve(input.key.size());
+    info("key_fields");
     for (const auto& idx : input.key) {
-        key_fields.emplace_back(field_ct::from_witness_index(&composer, idx));
+        auto field = field_ct::from_witness_index(&composer, idx);
+        info(field);
+        key_fields.emplace_back(field);
     }
 
     std::vector<field_ct> proof_fields;
     proof_fields.reserve(input.proof.size());
+    info("proof_fields");
     for (const auto& idx : input.proof) {
-        proof_fields.emplace_back(field_ct::from_witness_index(&composer, idx));
+        auto field = field_ct::from_witness_index(&composer, idx);
+        info(field);
+        proof_fields.emplace_back(field);
     }
 
     // recursively verify the proof
@@ -120,8 +135,10 @@ void create_recursion_constraints(Composer& composer,
         &composer, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_indices);
     vkey->program_width = noir_recursive_settings::program_width;
     Transcript_ct transcript(&composer, manifest, proof_fields, input.public_inputs.size());
+    info("about to verify_proof_");
     aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof_<bn254, noir_recursive_settings>(
         &composer, vkey, transcript, previous_aggregation);
+    info("got agg result");
 
     // Assign correct witness value to the verification key hash
     vkey->compress().assert_equal(field_ct::from_witness_index(&composer, input.key_hash));
@@ -288,6 +305,7 @@ std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const
         for (const auto& manifest_element : manifest.get_round_manifest(i).elements) {
             if (!manifest_element.derived_by_verifier) {
                 if (manifest_element.num_bytes == 32 && manifest_element.name != "public_inputs") {
+                    // auto scalar = barretenberg::fr::random_element();
                     fields.emplace_back(0);
                 } else if (manifest_element.num_bytes == 64 && manifest_element.name != "public_inputs") {
                     // the std::biggroup class creates unsatisfiable constraints when identical points are
@@ -322,6 +340,7 @@ std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const
                         }
                     } else {
                         for (size_t j = 0; j < num_public_inputs; ++j) {
+                            // auto scalar = barretenberg::fr::random_element();
                             fields.emplace_back(0);
                         }
                     }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index 9adfee02f8..0ded4c9dcd 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -28,6 +28,7 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
+    info("got constraint_system");
 
     // The binder would normally free the the constraint_system_buf, but we need the memory now.
     free_mem_slab_raw((void*)constraint_system_buf);
@@ -109,42 +110,40 @@ WASM_EXPORT void acir_serialize_proof_into_fields(in_ptr acir_composer_ptr,
     auto proof_as_fields = acir_composer->serialize_proof_into_fields(proof, ntohl(*num_inner_public_inputs));
 
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
-    const size_t output_size_bytes = proof_as_fields.size() * sizeof(barretenberg::fr);
-    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
-
-    // TODO: possible switch to instead use fr::to_buffer inside the AcirComposer and call `to_heap_buffer`
+    std::vector<uint8_t> proof_fields_data;
     // The serialization code below will convert out of Montgomery form before writing to the buffer
     for (size_t i = 0; i < proof_as_fields.size(); ++i) {
-        barretenberg::fr::serialize_to_buffer(proof_as_fields[i], &raw_buf[i * 32]);
+        auto proof_field = proof_as_fields[i].to_buffer();
+        copy(proof_field.begin(), proof_field.end(), std::back_inserter(proof_fields_data));
     }
-    *out = raw_buf;
+    *out = to_heap_buffer(proof_fields_data);
 }
 
 WASM_EXPORT void acir_serialize_verification_key_into_fields(in_ptr acir_composer_ptr,
                                                              uint8_t** out_vkey,
                                                              uint8_t** out_key_hash)
 {
+    info("about to serialize vkey");
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
 
     auto vkey_as_fields = acir_composer->serialize_verification_key_into_fields();
 
-    // TODO: possible switch to instead use fr::to_buffer inside the AcirComposer and call `to_heap_buffer`
     // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
     // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o
-    const size_t output_size_bytes = vkey_as_fields.size() * sizeof(barretenberg::fr) - 32;
-
-    auto raw_buf = (uint8_t*)malloc(output_size_bytes);
-    auto vk_hash_raw_buf = (uint8_t*)malloc(32);
-
+    std::vector<uint8_t> vk_fields_data;
     // The serialization code below will convert out of Montgomery form before writing to the buffer
     for (size_t i = 0; i < vkey_as_fields.size() - 1; ++i) {
-        barretenberg::fr::serialize_to_buffer(vkey_as_fields[i], &raw_buf[i * 32]);
+        auto vk_field = vkey_as_fields[i].to_buffer();
+        copy(vk_field.begin(), vk_field.end(), std::back_inserter(vk_fields_data));
     }
-    barretenberg::fr::serialize_to_buffer(vkey_as_fields[vkey_as_fields.size() - 1], vk_hash_raw_buf);
+
+    std::vector<uint8_t> vk_hash_data;
+    auto vk_hash_field = vkey_as_fields[vkey_as_fields.size() - 1].to_buffer();
+    copy(vk_hash_field.begin(), vk_hash_field.end(), std::back_inserter(vk_hash_data));
 
     // copy the vkey into serialized_vk_buf
-    *out_vkey = raw_buf;
+    *out_vkey = to_heap_buffer(vk_fields_data);
 
     // copy the vkey hash into serialized_vk_hash_buf
-    *out_key_hash = vk_hash_raw_buf;
+    *out_key_hash = to_heap_buffer(vk_hash_data);
 }
diff --git a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
index 34a983b362..ed9bbce0b4 100644
--- a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
@@ -175,6 +175,8 @@ template <typename Composer> class Transcript {
 
     void apply_fiat_shamir(const std::string& challenge_name)
     {
+        info("apply_fiat_shamir");
+        info(challenge_name);
         const size_t num_challenges = get_manifest().get_round_manifest(current_round).num_challenges;
         transcript_base.apply_fiat_shamir(challenge_name);
 
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
index 7e9bb09468..b117a91c1d 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
@@ -215,6 +215,7 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
 
     const auto PI_Z = transcript.get_circuit_group_element("PI_Z");
     const auto PI_Z_OMEGA = transcript.get_circuit_group_element("PI_Z_OMEGA");
+    info("get_circuit_group_element");
 
     field_t circuit_size = key->n;
     field_t public_input_size = key->num_public_inputs;
@@ -227,6 +228,7 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
     transcript.apply_fiat_shamir("beta");
     transcript.apply_fiat_shamir("alpha");
     transcript.apply_fiat_shamir("z");
+    info("apply_fiat_shamir");
 
     fr_ct alpha = transcript.get_challenge_field_element("alpha");
     fr_ct zeta = transcript.get_challenge_field_element("z");
@@ -234,21 +236,30 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
     key->z_pow_n = zeta.pow(key->domain.domain);
 
     lagrange_evaluations<Composer> lagrange_evals = get_lagrange_evaluations<Curve>(zeta, key->domain);
+    info("lagrange_evals");
 
     // reconstruct evaluation of quotient polynomial from prover messages
 
     fr_ct quotient_numerator_eval = fr_ct(0);
     program_settings::compute_quotient_evaluation_contribution(key.get(), alpha, transcript, quotient_numerator_eval);
-
+    info("compute_quotient_evaluation_contribution");
+    info(quotient_numerator_eval);
     fr_ct t_eval = quotient_numerator_eval / lagrange_evals.vanishing_poly;
     transcript.add_field_element("t", t_eval);
-
+    info(t_eval);
+    info("Curve::Composer::type");
+    info(Curve::Composer::type);
     transcript.apply_fiat_shamir("nu");
+    info("apply_fiat_shamir nu");
     transcript.apply_fiat_shamir("separator");
+    info("apply_fiat_shamir separator");
 
     fr_ct u = transcript.get_challenge_field_element("separator", 0);
+    info("get_challenge_field_element on separator");
 
     fr_ct batch_opening_scalar;
+    info("about to populate_kate_element_map");
+
     populate_kate_element_map<Curve, Transcript<Composer>, program_settings>(context,
                                                                              key.get(),
                                                                              transcript,
@@ -257,7 +268,7 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
                                                                              kate_fr_elements_at_zeta_large,
                                                                              kate_fr_elements_at_zeta_omega,
                                                                              batch_opening_scalar);
-
+    info("populate_kate_element_map");
     std::vector<fr_ct> double_opening_scalars;
     std::vector<g1_ct> double_opening_elements;
     std::vector<fr_ct> opening_scalars;
@@ -376,6 +387,7 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
         rhs_elements.push_back((-g1_ct(x1, y1)));
         rhs_scalars.push_back(recursion_separator_challenge);
     }
+    info("about to bn254_endo_batch_mul_with_generator");
 
     auto opening_result = g1_ct::template bn254_endo_batch_mul_with_generator(
         big_opening_elements, big_opening_scalars, opening_elements, opening_scalars, batch_opening_scalar, 128);
@@ -384,6 +396,7 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
     for (const auto& to_add : elements_to_add) {
         opening_result = opening_result + to_add;
     }
+    info("final opening_result");
 
     g1_ct rhs = g1_ct::template wnaf_batch_mul<128>(rhs_elements, rhs_scalars);
 
diff --git a/ts/src/main.ts b/ts/src/main.ts
index e1768f2f65..6ed60555ba 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -8,6 +8,7 @@ import { RawBuffer } from './types/index.js';
 import { numToInt32BE } from './serialize/serialize.js';
 import { Command } from 'commander';
 import { info } from 'console';
+import { exit } from 'process';
 
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
@@ -59,9 +60,9 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, is_r
 
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
-    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), false);
+    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), is_recursive);
 
-    const verified = await api.acirVerifyProof(acirComposer, proof, false);
+    const verified = await api.acirVerifyProof(acirComposer, proof, is_recursive);
     debug(`verified: ${verified}`);
     return verified;
   } finally {
@@ -82,8 +83,8 @@ export async function prove(jsonPath: string, witnessPath: string, is_recursive:
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
     const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), is_recursive);
-
-    writeFileSync(outputPath, proof);
+    debug(`got proof`);
+    writeFileSync(outputPath, Buffer.from(proof));
     debug('done.');
   } finally {
     await api.destroy();
@@ -155,7 +156,8 @@ export async function proof_as_fields(proofPath: string, num_inner_public_inputs
 
   try {
     debug('serializing proof byte array into field elements');
-    const proof_as_fields = await api.acirSerializeProofIntoFields(acirComposer, readFileSync(proofPath), num_inner_public_inputs);
+    const proof_as_fields_buffer = await api.acirSerializeProofIntoFields(acirComposer, readFileSync(proofPath), num_inner_public_inputs);
+    let proof_as_fields = bufferAsFieldHex(Buffer.from(proof_as_fields_buffer))
 
     writeFileSync(outputPath, proof_as_fields);
     debug('done.');
@@ -164,24 +166,42 @@ export async function proof_as_fields(proofPath: string, num_inner_public_inputs
   }
 }
 
-export async function vk_as_fields(vkey_oututPath: string, key_hash_outputPath: string) {
+export async function vk_as_fields(jsonPath: string, vkeyOutputPath: string) {
   const { api, acirComposer } = await init();
 
-  // TODO: move to passing in the key so we don't have to recompute it
-  // or just keep it as the writeVK method currently recomputes the pkey too
-  api.acirInitVerificationKey(acirComposer);
-  try {
-    debug('serializing proof byte array into field elements');
-    const [vk_as_fields, vk_hash_as_fields] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
+  // TODO: consider moving to passing in the key so we don't have to recompute it
+  // or just keep it as the writeVK method currently recomputes the pkey too ¯\_(ツ)_/¯
+  debug('initing proving key...');
+  const bytecode = getBytecode(jsonPath);
+  await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
 
-    writeFileSync(vkey_oututPath, vk_as_fields);
-    writeFileSync(key_hash_outputPath, vk_hash_as_fields);
+  await api.acirInitVerificationKey(acirComposer);
+  try {
+    debug('serializing vk byte array into field elements');
+    const [vk_as_fields_buffer, vk_hash_buffer] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
+    let vk_fields = bufferAsFieldHex(Buffer.concat([Buffer.from(vk_hash_buffer), Buffer.from(vk_as_fields_buffer)]));
+    
+    writeFileSync(vkeyOutputPath, vk_fields);
     debug('done.');
   } finally {
     await api.destroy();
   }
 }
 
+function bufferAsFieldHex(buffer: Buffer): string {
+  let hex = buffer.toString('hex');
+  let split_hex = hex.match(/.{1,64}/g);
+  if (split_hex == null) {
+    exit();
+  } else {
+    for (let i = 0; i < split_hex.length; i++) {
+      split_hex[i] = "0x".concat(split_hex[i]);
+    }
+    let separate_fields = JSON.stringify(split_hex);
+    return separate_fields;
+  }
+}
+
 // nargo use bb.js: backend -> bb.js
 // backend prove --data-dir data --witness /foo/bar/witness.tr --json /foo/bar/main.json
 // backend verify ...
@@ -200,8 +220,8 @@ program
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
   .option('-r, --recursive', 'prove and verify using recursive prover and verifier')
-  .action(async ({ jsonPath, witnessPath, is_recursive }) => {
-    const result = await proveAndVerify(jsonPath, witnessPath, false);
+  .action(async ({ jsonPath, witnessPath, recursive }) => {
+    const result = await proveAndVerify(jsonPath, witnessPath, recursive);
     process.exit(result ? 0 : 1);
   });
 
@@ -213,8 +233,8 @@ program
   .option('-r, --recursive', 'prove using recursive prover')
   .option('-o, --output-dir <path>', 'Specify the proof output dir', './proofs')
   .requiredOption('-n, --name <filename>', 'Output file name.')
-  .action(async ({ jsonPath, witnessPath, is_recursive, outputDir, name }) => {
-    await prove(jsonPath, witnessPath, is_recursive, outputDir + '/' + name);
+  .action(async ({ jsonPath, witnessPath, recursive, outputDir, name }) => {
+    await prove(jsonPath, witnessPath, recursive, outputDir + '/' + name);
   });
 
 program
@@ -223,8 +243,8 @@ program
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
   .option('-r, --recursive', 'prove using recursive prover')
-  .action(async ({ jsonPath, proofPath, is_recursive }) => {
-    await verify(jsonPath, proofPath, is_recursive);
+  .action(async ({ jsonPath, proofPath, recursive }) => {
+    await verify(jsonPath, proofPath, recursive);
   });
 
 program
@@ -249,19 +269,20 @@ program
   .command('proof_as_fields')
   .description('Return the proof as fields elements')
   .requiredOption('-p, --proof-path <path>', 'Specify the proof path')
-  .requiredOption('-n, --num-public-inputs', 'Specify the number of public inputs')
-  .requiredOption('-o, --output-path <path>', 'Specify the path to write the proof fields')
+  .requiredOption('-n, --num-public-inputs <number>', 'Specify the number of public inputs')
+  .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
   .action(async ({ proofPath, numPublicInputs, outputPath }) => {
+    console.log(numPublicInputs)
     await proof_as_fields(proofPath, numPublicInputs, outputPath);
   })
 
 program
   .command('vk_as_fields')
   .description('Return the verifiation key represented as fields elements. Also return the verification key hash.')
-  .requiredOption('-v, --vkey-output-path <path>', 'Specify the path to write the verification key fields')
-  .requiredOption('-h, --key-hash-output-path <path>', 'Specify the path to write the verification key hash')
-  .action(async ({vkey_oututPath, key_hash_outputPath }) => {
-    await vk_as_fields(vkey_oututPath, key_hash_outputPath);
+  .requiredOption('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
+  .requiredOption('-v, --vkey-output-path <path>', 'Specify the JSON path to write the verification key fields and key hash')
+  .action(async ({jsonPath, vkeyOutputPath }) => {
+    await vk_as_fields(jsonPath, vkeyOutputPath);
   })
 
 program.parse(process.argv);

From 0abc2bb2466030daddda05fd611a8b8bde21d1e0 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 26 May 2023 20:12:04 +0000
Subject: [PATCH 50/64] most recent debug output, hitting bad alloc in
 compute_proving_key_base

---
 .../barretenberg/dsl/acir_format/recursion_constraint.cpp | 8 ++++----
 cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp    | 6 ++++--
 cpp/src/barretenberg/plonk/composer/composer_base.cpp     | 3 ++-
 cpp/src/barretenberg/plonk/composer/ultra_composer.cpp    | 3 ++-
 .../stdlib/recursion/transcript/transcript.hpp            | 2 +-
 cpp/src/barretenberg/transcript/transcript.cpp            | 4 +++-
 ts/src/main.ts                                            | 5 +++--
 7 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 2a2a63fd91..81f722aa6e 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -114,19 +114,19 @@ void create_recursion_constraints(Composer& composer,
 
     std::vector<field_ct> key_fields;
     key_fields.reserve(input.key.size());
-    info("key_fields");
+    // info("key_fields");
     for (const auto& idx : input.key) {
         auto field = field_ct::from_witness_index(&composer, idx);
-        info(field);
+        // info(field);
         key_fields.emplace_back(field);
     }
 
     std::vector<field_ct> proof_fields;
     proof_fields.reserve(input.proof.size());
-    info("proof_fields");
+    // info("proof_fields");
     for (const auto& idx : input.proof) {
         auto field = field_ct::from_witness_index(&composer, idx);
-        info(field);
+        // info(field);
         proof_fields.emplace_back(field);
     }
 
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 25059ae6ad..05fabd4d90 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -20,8 +20,8 @@ AcirComposer::AcirComposer(std::shared_ptr<proof_system::ReferenceStringFactory>
 
 void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system, size_t size_hint)
 {
-    composer_ = create_circuit(constraint_system, crs_factory_, size_hint);
-
+    composer_ = acir_format::create_circuit(constraint_system, crs_factory_, size_hint);
+    info("got composer_");
     // We are done with the constraint system at this point, and we need the memory slab back.
     // constraint_system = acir_format::acir_format();
     constraint_system.constraints.clear();
@@ -29,6 +29,8 @@ void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system,
 
     total_circuit_size_ = composer_.get_total_circuit_size();
     circuit_subgroup_size_ = composer_.get_circuit_subgroup_size(total_circuit_size_);
+    info("circuit_subgroup_size_");
+    info(circuit_subgroup_size_);
 
     proving_key_ = composer_.compute_proving_key();
 }
diff --git a/cpp/src/barretenberg/plonk/composer/composer_base.cpp b/cpp/src/barretenberg/plonk/composer/composer_base.cpp
index b4fdb7b130..8cc92c204f 100644
--- a/cpp/src/barretenberg/plonk/composer/composer_base.cpp
+++ b/cpp/src/barretenberg/plonk/composer/composer_base.cpp
@@ -238,7 +238,8 @@ std::shared_ptr<proving_key> ComposerBase::compute_proving_key_base(const Compos
     const size_t num_filled_gates = num_gates + public_inputs.size();
     const size_t total_num_gates = std::max(minimum_circuit_size, num_filled_gates);
     const size_t subgroup_size = get_circuit_subgroup_size(total_num_gates + num_reserved_gates); // next power of 2
-
+    info("subgroup_size");
+    info(subgroup_size);
     // Prealloc slabs of memory for polynomials, pippenger, scratch space, etc.
     init_slab_allocator(subgroup_size);
 
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
index bf13074fdf..b0152992b7 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
@@ -565,7 +565,7 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key()
 
     // Compute selector polynomials and appropriate fft versions and put them in the proving key
     ComposerBase::compute_proving_key_base(type, tables_size + lookups_size, NUM_RESERVED_GATES);
-
+    info("got pkey base");
     const size_t subgroup_size = circuit_proving_key->circuit_size;
 
     polynomial poly_q_table_column_1(subgroup_size);
@@ -656,6 +656,7 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key()
     std::copy(memory_write_records.begin(),
               memory_write_records.end(),
               std::back_inserter(circuit_proving_key->memory_write_records));
+    info("copied memory write records");
 
     circuit_proving_key->recursive_proof_public_input_indices =
         std::vector<uint32_t>(recursive_proof_public_input_indices.begin(), recursive_proof_public_input_indices.end());
diff --git a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
index ed9bbce0b4..fbcd55e303 100644
--- a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
@@ -64,7 +64,7 @@ template <typename Composer> class Transcript {
                const std::vector<field_pt>& field_buffer,
                const size_t num_public_inputs)
         : context(in_context)
-        , transcript_base(input_manifest, transcript::HashType::PedersenBlake3s, 16)
+        , transcript_base(input_manifest, transcript::HashType::PlookupPedersenBlake3s, 16)
         , current_challenge(in_context)
     {
         size_t count = 0;
diff --git a/cpp/src/barretenberg/transcript/transcript.cpp b/cpp/src/barretenberg/transcript/transcript.cpp
index 1371a08eac..b510f312cd 100644
--- a/cpp/src/barretenberg/transcript/transcript.cpp
+++ b/cpp/src/barretenberg/transcript/transcript.cpp
@@ -233,11 +233,13 @@ void Transcript::apply_fiat_shamir(const std::string& challenge_name /*, const b
         break;
     }
     case HashType::PedersenBlake3s: {
+        info("in pedersen");
         std::vector<uint8_t> compressed_buffer = to_buffer(crypto::pedersen_commitment::compress_native(buffer));
         base_hash = Blake3sHasher::hash(compressed_buffer);
         break;
     }
     case HashType::PlookupPedersenBlake3s: {
+        info("in plookup pedersen");
         std::vector<uint8_t> compressed_buffer = crypto::pedersen_commitment::lookup::compress_native(buffer);
         base_hash = Blake3sHasher::hash_plookup(compressed_buffer);
         break;
@@ -246,7 +248,7 @@ void Transcript::apply_fiat_shamir(const std::string& challenge_name /*, const b
         throw_or_abort("no hasher was selected for the transcript");
     }
     }
-
+    info("got base_hash");
     // Depending on the settings, we might be able to chunk the bytes of a single hash across multiple challenges:
     const size_t challenges_per_hash = PRNG_OUTPUT_SIZE / num_challenge_bytes;
 
diff --git a/ts/src/main.ts b/ts/src/main.ts
index 6ed60555ba..de32a73971 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -32,7 +32,7 @@ function getWitness(witnessPath: string) {
 
 async function init() {
   // Plus 1 needed!
-  const crs = await Crs.new(CIRCUIT_SIZE + 1);
+  const crs = await Crs.new(2 ** 19 + 1);
 
   const api = await newBarretenbergApiAsync();
 
@@ -51,7 +51,8 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, is_r
     debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
     await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
-
+    debug(`got proving key`);
+    
     const exactCircuitSize = await api.acirGetExactCircuitSize(acirComposer);
     debug(`circuit size: ${exactCircuitSize}`);
 

From 826fb5969de93ab1485f3250b01a28a0b0f2078a Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Fri, 26 May 2023 20:17:19 +0000
Subject: [PATCH 51/64] delete old comment

---
 cpp/src/barretenberg/dsl/acir_format/acir_format.hpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
index a9b60e9913..fe5ab0ef56 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
@@ -103,10 +103,6 @@ template <typename B> inline void write(B& buf, acir_format const& data)
     write(buf, data.hash_to_field_constraints);
     write(buf, data.fixed_base_scalar_mul_constraints);
     write(buf, data.recursion_constraints);
-    // TODO: probably delete, used for writing AcirComposer tests in CPP
-    // for (size_t i = 0; i < data.constraints.size(); i++) {
-    //     write(buf, data.constraints[i]);
-    // }
     write(buf, data.constraints);
     write(buf, data.block_constraints);
 }

From 07e55578445cd233eab20952b04b29a17017f8e3 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Sun, 28 May 2023 21:13:34 +0000
Subject: [PATCH 52/64] bb.js cmd changes

---
 ts/src/main.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ts/src/main.ts b/ts/src/main.ts
index de32a73971..ea860813b7 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -15,7 +15,7 @@ const debug = createDebug('bb.js');
 createDebug.enable('*');
 
 // Maximum we support.
-const CIRCUIT_SIZE = 2 ** 19;
+const CIRCUIT_SIZE = 2 ** 18;
 
 function getBytecode(jsonPath: string) {
   const json = readFileSync(jsonPath, 'utf-8');
@@ -52,7 +52,7 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, is_r
     const bytecode = getBytecode(jsonPath);
     await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
     debug(`got proving key`);
-    
+
     const exactCircuitSize = await api.acirGetExactCircuitSize(acirComposer);
     debug(`circuit size: ${exactCircuitSize}`);
 
@@ -62,7 +62,7 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, is_r
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
     const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), is_recursive);
-
+    console.log(proof);
     const verified = await api.acirVerifyProof(acirComposer, proof, is_recursive);
     debug(`verified: ${verified}`);
     return verified;

From 7fb94f187511ab8e56facab3f385770057265456 Mon Sep 17 00:00:00 2001
From: Charlie Lye <karl.lye@gmail.com>
Date: Tue, 30 May 2023 14:27:49 +0000
Subject: [PATCH 53/64] Lint and default fixes.

---
 ts/bb.js-dev                                  |  4 +
 ts/package.json                               |  2 +-
 ts/src/barretenberg_wasm/barretenberg_wasm.ts |  3 -
 ts/src/main.ts                                | 79 ++++++++++---------
 4 files changed, 48 insertions(+), 40 deletions(-)
 create mode 100755 ts/bb.js-dev

diff --git a/ts/bb.js-dev b/ts/bb.js-dev
new file mode 100755
index 0000000000..79077737e6
--- /dev/null
+++ b/ts/bb.js-dev
@@ -0,0 +1,4 @@
+#!/bin/sh
+SCRIPT_PATH=$(dirname $(realpath $0))
+export TS_NODE_PROJECT="$SCRIPT_PATH/tsconfig.json"
+NODE_OPTIONS="--loader $SCRIPT_PATH/node_modules/ts-node/esm/transpile-only.mjs --no-warnings" node $SCRIPT_PATH/src/main.ts $@
diff --git a/ts/package.json b/ts/package.json
index e8bb1dc842..d997e85f80 100644
--- a/ts/package.json
+++ b/ts/package.json
@@ -9,7 +9,7 @@
   },
   "bin": {
     "bb.js": "./dest/main.js",
-    "bb.js-dev": "./src/main-dev.ts"
+    "bb.js-dev": "./bb.js-dev"
   },
   "scripts": {
     "clean": "rm -rf ./dest .tsbuildinfo",
diff --git a/ts/src/barretenberg_wasm/barretenberg_wasm.ts b/ts/src/barretenberg_wasm/barretenberg_wasm.ts
index a597f89812..f8139aa536 100644
--- a/ts/src/barretenberg_wasm/barretenberg_wasm.ts
+++ b/ts/src/barretenberg_wasm/barretenberg_wasm.ts
@@ -1,5 +1,4 @@
 import { type Worker } from 'worker_threads';
-import { EventEmitter } from 'events';
 import createDebug from 'debug';
 import { Remote, proxy } from 'comlink';
 import { randomBytes } from '../random/index.js';
@@ -10,8 +9,6 @@ import { fetchCode, getNumCpu, createWorker, getRemoteBarretenbergWasm, threadLo
 
 const debug = createDebug('wasm');
 
-EventEmitter.defaultMaxListeners = 30;
-
 export class BarretenbergWasm {
   static MAX_THREADS = 16;
   private memory!: WebAssembly.Memory;
diff --git a/ts/src/main.ts b/ts/src/main.ts
index ea860813b7..4a2bf82c6c 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -7,7 +7,6 @@ import { gunzipSync } from 'zlib';
 import { RawBuffer } from './types/index.js';
 import { numToInt32BE } from './serialize/serialize.js';
 import { Command } from 'commander';
-import { info } from 'console';
 import { exit } from 'process';
 
 createDebug.log = console.error.bind(console);
@@ -45,7 +44,7 @@ async function init() {
   return { api, acirComposer };
 }
 
-export async function proveAndVerify(jsonPath: string, witnessPath: string, is_recursive: boolean) {
+export async function proveAndVerify(jsonPath: string, witnessPath: string, isRecursive: boolean) {
   const { api, acirComposer } = await init();
   try {
     debug('initing proving key...');
@@ -61,9 +60,9 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, is_r
 
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
-    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), is_recursive);
-    console.log(proof);
-    const verified = await api.acirVerifyProof(acirComposer, proof, is_recursive);
+    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), isRecursive);
+
+    const verified = await api.acirVerifyProof(acirComposer, proof, isRecursive);
     debug(`verified: ${verified}`);
     return verified;
   } finally {
@@ -71,7 +70,7 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, is_r
   }
 }
 
-export async function prove(jsonPath: string, witnessPath: string, is_recursive: boolean, outputPath: string) {
+export async function prove(jsonPath: string, witnessPath: string, isRecursive: boolean, outputPath: string) {
   const { api, acirComposer } = await init();
   try {
     debug('initing proving key...');
@@ -83,7 +82,8 @@ export async function prove(jsonPath: string, witnessPath: string, is_recursive:
 
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
-    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), is_recursive);
+    debug({ bytecode, witness });
+    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), isRecursive);
     debug(`got proof`);
     writeFileSync(outputPath, Buffer.from(proof));
     debug('done.');
@@ -92,7 +92,7 @@ export async function prove(jsonPath: string, witnessPath: string, is_recursive:
   }
 }
 
-export async function verify(jsonPath: string, proofPath: string, is_recursive: boolean) {
+export async function verify(jsonPath: string, proofPath: string, isRecursive: boolean) {
   const { api, acirComposer } = await init();
   try {
     debug('initing proving key...');
@@ -102,7 +102,7 @@ export async function verify(jsonPath: string, proofPath: string, is_recursive:
     debug('initing verification key...');
     await api.acirInitVerificationKey(acirComposer);
 
-    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), is_recursive);
+    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
     debug(`verified: ${verified}`);
     return verified;
   } finally {
@@ -152,22 +152,26 @@ export async function writeVk(jsonPath: string, outputPath: string) {
   }
 }
 
-export async function proof_as_fields(proofPath: string, num_inner_public_inputs: number, outputPath: string) {
+export async function proofAsFields(proofPath: string, numInnerPublicInputs: number, outputPath: string) {
   const { api, acirComposer } = await init();
 
   try {
     debug('serializing proof byte array into field elements');
-    const proof_as_fields_buffer = await api.acirSerializeProofIntoFields(acirComposer, readFileSync(proofPath), num_inner_public_inputs);
-    let proof_as_fields = bufferAsFieldHex(Buffer.from(proof_as_fields_buffer))
-
-    writeFileSync(outputPath, proof_as_fields);
+    const proofAsFieldsBuffer = await api.acirSerializeProofIntoFields(
+      acirComposer,
+      readFileSync(proofPath),
+      numInnerPublicInputs,
+    );
+    const proofAsFields = bufferAsFieldHex(Buffer.from(proofAsFieldsBuffer));
+
+    writeFileSync(outputPath, proofAsFields);
     debug('done.');
   } finally {
     await api.destroy();
   }
 }
 
-export async function vk_as_fields(jsonPath: string, vkeyOutputPath: string) {
+export async function vkAsFields(jsonPath: string, vkeyOutputPath: string) {
   const { api, acirComposer } = await init();
 
   // TODO: consider moving to passing in the key so we don't have to recompute it
@@ -179,10 +183,10 @@ export async function vk_as_fields(jsonPath: string, vkeyOutputPath: string) {
   await api.acirInitVerificationKey(acirComposer);
   try {
     debug('serializing vk byte array into field elements');
-    const [vk_as_fields_buffer, vk_hash_buffer] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
-    let vk_fields = bufferAsFieldHex(Buffer.concat([Buffer.from(vk_hash_buffer), Buffer.from(vk_as_fields_buffer)]));
-    
-    writeFileSync(vkeyOutputPath, vk_fields);
+    const [vkAsFieldsBuffer, vkHashBuffer] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
+    const vkFields = bufferAsFieldHex(Buffer.concat([Buffer.from(vkHashBuffer), Buffer.from(vkAsFieldsBuffer)]));
+
+    writeFileSync(vkeyOutputPath, vkFields);
     debug('done.');
   } finally {
     await api.destroy();
@@ -190,16 +194,16 @@ export async function vk_as_fields(jsonPath: string, vkeyOutputPath: string) {
 }
 
 function bufferAsFieldHex(buffer: Buffer): string {
-  let hex = buffer.toString('hex');
-  let split_hex = hex.match(/.{1,64}/g);
-  if (split_hex == null) {
+  const hex = buffer.toString('hex');
+  const splitHex = hex.match(/.{1,64}/g);
+  if (splitHex == null) {
     exit();
   } else {
-    for (let i = 0; i < split_hex.length; i++) {
-      split_hex[i] = "0x".concat(split_hex[i]);
+    for (let i = 0; i < splitHex.length; i++) {
+      splitHex[i] = '0x'.concat(splitHex[i]);
     }
-    let separate_fields = JSON.stringify(split_hex);
-    return separate_fields;
+    const separateFields = JSON.stringify(splitHex);
+    return separateFields;
   }
 }
 
@@ -220,7 +224,7 @@ program
   .description('Generate a proof and verify it. Process exits with success or failure code.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
-  .option('-r, --recursive', 'prove and verify using recursive prover and verifier')
+  .option('-r, --recursive', 'prove and verify using recursive prover and verifier', false)
   .action(async ({ jsonPath, witnessPath, recursive }) => {
     const result = await proveAndVerify(jsonPath, witnessPath, recursive);
     process.exit(result ? 0 : 1);
@@ -231,7 +235,7 @@ program
   .description('Generate a proof and write it to a file.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
-  .option('-r, --recursive', 'prove using recursive prover')
+  .option('-r, --recursive', 'prove using recursive prover', false)
   .option('-o, --output-dir <path>', 'Specify the proof output dir', './proofs')
   .requiredOption('-n, --name <filename>', 'Output file name.')
   .action(async ({ jsonPath, witnessPath, recursive, outputDir, name }) => {
@@ -243,7 +247,7 @@ program
   .description('Verify a proof. Process exists with success or failure code.')
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
-  .option('-r, --recursive', 'prove using recursive prover')
+  .option('-r, --recursive', 'prove using recursive prover', false)
   .action(async ({ jsonPath, proofPath, recursive }) => {
     await verify(jsonPath, proofPath, recursive);
   });
@@ -273,17 +277,20 @@ program
   .requiredOption('-n, --num-public-inputs <number>', 'Specify the number of public inputs')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
   .action(async ({ proofPath, numPublicInputs, outputPath }) => {
-    console.log(numPublicInputs)
-    await proof_as_fields(proofPath, numPublicInputs, outputPath);
-  })
+    console.log(numPublicInputs);
+    await proofAsFields(proofPath, numPublicInputs, outputPath);
+  });
 
 program
   .command('vk_as_fields')
   .description('Return the verifiation key represented as fields elements. Also return the verification key hash.')
   .requiredOption('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .requiredOption('-v, --vkey-output-path <path>', 'Specify the JSON path to write the verification key fields and key hash')
-  .action(async ({jsonPath, vkeyOutputPath }) => {
-    await vk_as_fields(jsonPath, vkeyOutputPath);
-  })
+  .requiredOption(
+    '-v, --vkey-output-path <path>',
+    'Specify the JSON path to write the verification key fields and key hash',
+  )
+  .action(async ({ jsonPath, vkeyOutputPath }) => {
+    await vkAsFields(jsonPath, vkeyOutputPath);
+  });
 
 program.parse(process.argv);

From 057f77839b71a6665c8baf38d7ca4925e025be43 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 14:32:18 +0000
Subject: [PATCH 54/64] cleanup info and debug comments

---
 .../dsl/acir_format/recursion_constraint.cpp  |  14 --
 .../dsl/acir_proofs/acir_composer.cpp         |   4 +-
 .../dsl/acir_proofs/acir_composer.test.cpp    | 142 ------------------
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   |   2 -
 .../plonk/composer/composer_base.cpp          |   3 +-
 .../plonk/composer/ultra_composer.cpp         |   2 -
 .../recursion/transcript/transcript.hpp       |   2 -
 .../stdlib/recursion/verifier/verifier.hpp    |  18 +--
 .../barretenberg/transcript/transcript.cpp    |   4 +-
 ts/src/main.ts                                |   3 +-
 10 files changed, 7 insertions(+), 187 deletions(-)
 delete mode 100644 cpp/src/barretenberg/dsl/acir_proofs/acir_composer.test.cpp

diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
index 81f722aa6e..f5064788cb 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp
@@ -38,11 +38,7 @@ void create_recursion_constraints(Composer& composer,
         nested_aggregation_indices_all_zero &= (idx == 0);
     }
     const bool inner_proof_contains_recursive_proof = !nested_aggregation_indices_all_zero;
-    info("inner_proof_contains_recursive_proof");
-    info(inner_proof_contains_recursive_proof);
 
-    info("has_valid_witness_assignments");
-    info(has_valid_witness_assignments);
     // If we do not have a witness, we must ensure that our dummy witness will not trigger
     // on-curve errors and inverting-zero errors
     {
@@ -86,8 +82,6 @@ void create_recursion_constraints(Composer& composer,
     for (const auto& idx : aggregation_input) {
         inner_aggregation_indices_all_zero &= (idx == 0);
     }
-    info("inner_aggregation_indices_all_zero");
-    info(inner_aggregation_indices_all_zero);
 
     if (!inner_aggregation_indices_all_zero) {
         std::array<bn254::fq_ct, 4> aggregation_elements;
@@ -108,25 +102,19 @@ void create_recursion_constraints(Composer& composer,
         previous_aggregation.has_data = false;
     }
 
-    info("input.public_inputs.size()");
-    info(input.public_inputs.size());
     transcript::Manifest manifest = Composer::create_unrolled_manifest(input.public_inputs.size());
 
     std::vector<field_ct> key_fields;
     key_fields.reserve(input.key.size());
-    // info("key_fields");
     for (const auto& idx : input.key) {
         auto field = field_ct::from_witness_index(&composer, idx);
-        // info(field);
         key_fields.emplace_back(field);
     }
 
     std::vector<field_ct> proof_fields;
     proof_fields.reserve(input.proof.size());
-    // info("proof_fields");
     for (const auto& idx : input.proof) {
         auto field = field_ct::from_witness_index(&composer, idx);
-        // info(field);
         proof_fields.emplace_back(field);
     }
 
@@ -135,10 +123,8 @@ void create_recursion_constraints(Composer& composer,
         &composer, key_fields, inner_proof_contains_recursive_proof, nested_aggregation_indices);
     vkey->program_width = noir_recursive_settings::program_width;
     Transcript_ct transcript(&composer, manifest, proof_fields, input.public_inputs.size());
-    info("about to verify_proof_");
     aggregation_state_ct result = proof_system::plonk::stdlib::recursion::verify_proof_<bn254, noir_recursive_settings>(
         &composer, vkey, transcript, previous_aggregation);
-    info("got agg result");
 
     // Assign correct witness value to the verification key hash
     vkey->compress().assert_equal(field_ct::from_witness_index(&composer, input.key_hash));
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 05fabd4d90..e739ee81d2 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -21,7 +21,7 @@ AcirComposer::AcirComposer(std::shared_ptr<proof_system::ReferenceStringFactory>
 void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system, size_t size_hint)
 {
     composer_ = acir_format::create_circuit(constraint_system, crs_factory_, size_hint);
-    info("got composer_");
+
     // We are done with the constraint system at this point, and we need the memory slab back.
     // constraint_system = acir_format::acir_format();
     constraint_system.constraints.clear();
@@ -29,8 +29,6 @@ void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system,
 
     total_circuit_size_ = composer_.get_total_circuit_size();
     circuit_subgroup_size_ = composer_.get_circuit_subgroup_size(total_circuit_size_);
-    info("circuit_subgroup_size_");
-    info(circuit_subgroup_size_);
 
     proving_key_ = composer_.compute_proving_key();
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.test.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.test.cpp
deleted file mode 100644
index 3fe85694b9..0000000000
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.test.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-// #include <barretenberg/dsl/acir_format/acir_format.hpp>
-// #include <barretenberg/srs/io.hpp>
-// #include "barretenberg/srs/reference_string/pippenger_reference_string.hpp"
-// #include <gtest/gtest.h>
-// #include "acir_composer.hpp"
-// #include <vector>
-
-// using namespace proof_system::plonk;
-
-// void create_inner_circuit(acir_format::acir_format& constraint_system, std::vector<fr>& witness)
-// {
-//     /**
-//      * constraints produced by Noir program:
-//      * fn main(x : u32, y : pub u32) {
-//      * let z = x ^ y;
-//      *
-//      * constrain z != 10;
-//      * }
-//      **/
-//     acir_format::RangeConstraint range_a{
-//         .witness = 1,
-//         .num_bits = 32,
-//     };
-//     acir_format::RangeConstraint range_b{
-//         .witness = 2,
-//         .num_bits = 32,
-//     };
-
-//     acir_format::LogicConstraint logic_constraint{
-//         .a = 1,
-//         .b = 2,
-//         .result = 3,
-//         .num_bits = 32,
-//         .is_xor_gate = 1,
-//     };
-//     poly_triple expr_a{
-//         .a = 3,
-//         .b = 4,
-//         .c = 0,
-//         .q_m = 0,
-//         .q_l = 1,
-//         .q_r = -1,
-//         .q_o = 0,
-//         .q_c = -10,
-//     };
-//     poly_triple expr_b{
-//         .a = 4,
-//         .b = 5,
-//         .c = 6,
-//         .q_m = 1,
-//         .q_l = 0,
-//         .q_r = 0,
-//         .q_o = -1,
-//         .q_c = 0,
-//     };
-//     poly_triple expr_c{
-//         .a = 4,
-//         .b = 6,
-//         .c = 4,
-//         .q_m = 1,
-//         .q_l = 0,
-//         .q_r = 0,
-//         .q_o = -1,
-//         .q_c = 0,
-
-//     };
-//     poly_triple expr_d{
-//         .a = 6,
-//         .b = 0,
-//         .c = 0,
-//         .q_m = 0,
-//         .q_l = -1,
-//         .q_r = 0,
-//         .q_o = 0,
-//         .q_c = 1,
-//     };
-//     std::vector<poly_triple, ContainerSlabAllocator<poly_triple>> constraints = { expr_a, expr_b, expr_c, expr_d };
-
-//     constraint_system = acir_format::acir_format{
-//         .varnum = 7,
-//         .public_inputs = { 2 },
-//         .fixed_base_scalar_mul_constraints = {},
-//         .logic_constraints = { logic_constraint },
-//         .range_constraints = { range_a, range_b },
-//         .schnorr_constraints = {},
-//         .ecdsa_constraints = {},
-//         .sha256_constraints = {},
-//         .blake2s_constraints = {},
-//         .keccak_constraints = {},
-//         .hash_to_field_constraints = {},
-//         .pedersen_constraints = {},
-//         .compute_merkle_root_constraints = {},
-//         .block_constraints = {},
-//         .recursion_constraints = {},
-//         .constraints = constraints,
-//     };
-
-//     uint256_t inverse_of_five = fr(5).invert();
-
-//     witness.emplace_back(5);
-//     witness.emplace_back(10);
-//     witness.emplace_back(15);
-//     witness.emplace_back(5);
-//     witness.emplace_back(inverse_of_five);
-//     witness.emplace_back(1);
-// }
-
-// TEST(AcirComposer, TestLogicCircuit)
-// {
-//     acir_format::acir_format constraint_system;
-//     std::vector<fr> witness_inner;
-//     create_inner_circuit(constraint_system, witness_inner);
-
-//     std::vector<uint8_t> witness_buf;           // = to_buffer(witness);
-//     write(witness_buf, witness_inner);
-//     // TODO: get WitnessVector in different way
-//     auto witness = from_buffer<std::vector<fr, ContainerSlabAllocator<fr>>>(witness_buf);
-
-//     auto crs_factory = std::shared_ptr<ReferenceStringFactory>(new FileReferenceStringFactory("../srs_db/ignition"));
-//     auto g2x = crs_factory.get()->get_verifier_crs()->get_g2x().to_buffer();
-//     // uint32_t pow2_size = 1 << 19UL;
-//     uint32_t pow2_size = 8192;
-
-//     auto prover_crs = crs_factory.get()->get_prover_crs(pow2_size + 1);
-//     auto g1x = prover_crs.get()->get_monomial_points();
-//     auto* pippenger_ptr_base = new scalar_multiplication::Pippenger(g1x, pow2_size + 1);
-//     void* pippenger_ptr = reinterpret_cast<void*>(pippenger_ptr_base);
-
-//     auto pippenger_factory = std::make_shared<proof_system::PippengerReferenceStringFactory>(
-//         reinterpret_cast<barretenberg::scalar_multiplication::Pippenger*>(pippenger_ptr), g2x.data());
-
-//     auto composer = new acir_proofs::AcirComposer(pippenger_factory);
-
-//     composer->init_proving_key(constraint_system);
-//     // std::cout << "composer info: " << composer
-//     composer->init_verification_key();
-
-//     auto proof = composer->create_proof(constraint_system, witness);
-
-//     auto verified = composer->verify_proof(proof);
-//     EXPECT_EQ(verified, true);
-// }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index 0ded4c9dcd..c0e00aa771 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -28,7 +28,6 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
-    info("got constraint_system");
 
     // The binder would normally free the the constraint_system_buf, but we need the memory now.
     free_mem_slab_raw((void*)constraint_system_buf);
@@ -123,7 +122,6 @@ WASM_EXPORT void acir_serialize_verification_key_into_fields(in_ptr acir_compose
                                                              uint8_t** out_vkey,
                                                              uint8_t** out_key_hash)
 {
-    info("about to serialize vkey");
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
 
     auto vkey_as_fields = acir_composer->serialize_verification_key_into_fields();
diff --git a/cpp/src/barretenberg/plonk/composer/composer_base.cpp b/cpp/src/barretenberg/plonk/composer/composer_base.cpp
index 8cc92c204f..b4fdb7b130 100644
--- a/cpp/src/barretenberg/plonk/composer/composer_base.cpp
+++ b/cpp/src/barretenberg/plonk/composer/composer_base.cpp
@@ -238,8 +238,7 @@ std::shared_ptr<proving_key> ComposerBase::compute_proving_key_base(const Compos
     const size_t num_filled_gates = num_gates + public_inputs.size();
     const size_t total_num_gates = std::max(minimum_circuit_size, num_filled_gates);
     const size_t subgroup_size = get_circuit_subgroup_size(total_num_gates + num_reserved_gates); // next power of 2
-    info("subgroup_size");
-    info(subgroup_size);
+
     // Prealloc slabs of memory for polynomials, pippenger, scratch space, etc.
     init_slab_allocator(subgroup_size);
 
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
index b0152992b7..a9fdd96067 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp
@@ -565,7 +565,6 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key()
 
     // Compute selector polynomials and appropriate fft versions and put them in the proving key
     ComposerBase::compute_proving_key_base(type, tables_size + lookups_size, NUM_RESERVED_GATES);
-    info("got pkey base");
     const size_t subgroup_size = circuit_proving_key->circuit_size;
 
     polynomial poly_q_table_column_1(subgroup_size);
@@ -656,7 +655,6 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key()
     std::copy(memory_write_records.begin(),
               memory_write_records.end(),
               std::back_inserter(circuit_proving_key->memory_write_records));
-    info("copied memory write records");
 
     circuit_proving_key->recursive_proof_public_input_indices =
         std::vector<uint32_t>(recursive_proof_public_input_indices.begin(), recursive_proof_public_input_indices.end());
diff --git a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
index fbcd55e303..87e55977d0 100644
--- a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
@@ -175,8 +175,6 @@ template <typename Composer> class Transcript {
 
     void apply_fiat_shamir(const std::string& challenge_name)
     {
-        info("apply_fiat_shamir");
-        info(challenge_name);
         const size_t num_challenges = get_manifest().get_round_manifest(current_round).num_challenges;
         transcript_base.apply_fiat_shamir(challenge_name);
 
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
index b117a91c1d..244aa0950c 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
@@ -215,7 +215,6 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
 
     const auto PI_Z = transcript.get_circuit_group_element("PI_Z");
     const auto PI_Z_OMEGA = transcript.get_circuit_group_element("PI_Z_OMEGA");
-    info("get_circuit_group_element");
 
     field_t circuit_size = key->n;
     field_t public_input_size = key->num_public_inputs;
@@ -228,7 +227,6 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
     transcript.apply_fiat_shamir("beta");
     transcript.apply_fiat_shamir("alpha");
     transcript.apply_fiat_shamir("z");
-    info("apply_fiat_shamir");
 
     fr_ct alpha = transcript.get_challenge_field_element("alpha");
     fr_ct zeta = transcript.get_challenge_field_element("z");
@@ -236,29 +234,21 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
     key->z_pow_n = zeta.pow(key->domain.domain);
 
     lagrange_evaluations<Composer> lagrange_evals = get_lagrange_evaluations<Curve>(zeta, key->domain);
-    info("lagrange_evals");
 
     // reconstruct evaluation of quotient polynomial from prover messages
 
     fr_ct quotient_numerator_eval = fr_ct(0);
     program_settings::compute_quotient_evaluation_contribution(key.get(), alpha, transcript, quotient_numerator_eval);
-    info("compute_quotient_evaluation_contribution");
-    info(quotient_numerator_eval);
+
     fr_ct t_eval = quotient_numerator_eval / lagrange_evals.vanishing_poly;
     transcript.add_field_element("t", t_eval);
-    info(t_eval);
-    info("Curve::Composer::type");
-    info(Curve::Composer::type);
+
     transcript.apply_fiat_shamir("nu");
-    info("apply_fiat_shamir nu");
     transcript.apply_fiat_shamir("separator");
-    info("apply_fiat_shamir separator");
 
     fr_ct u = transcript.get_challenge_field_element("separator", 0);
-    info("get_challenge_field_element on separator");
 
     fr_ct batch_opening_scalar;
-    info("about to populate_kate_element_map");
 
     populate_kate_element_map<Curve, Transcript<Composer>, program_settings>(context,
                                                                              key.get(),
@@ -268,7 +258,7 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
                                                                              kate_fr_elements_at_zeta_large,
                                                                              kate_fr_elements_at_zeta_omega,
                                                                              batch_opening_scalar);
-    info("populate_kate_element_map");
+
     std::vector<fr_ct> double_opening_scalars;
     std::vector<g1_ct> double_opening_elements;
     std::vector<fr_ct> opening_scalars;
@@ -387,7 +377,6 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
         rhs_elements.push_back((-g1_ct(x1, y1)));
         rhs_scalars.push_back(recursion_separator_challenge);
     }
-    info("about to bn254_endo_batch_mul_with_generator");
 
     auto opening_result = g1_ct::template bn254_endo_batch_mul_with_generator(
         big_opening_elements, big_opening_scalars, opening_elements, opening_scalars, batch_opening_scalar, 128);
@@ -396,7 +385,6 @@ aggregation_state<Curve> verify_proof_(typename Curve::Composer* context,
     for (const auto& to_add : elements_to_add) {
         opening_result = opening_result + to_add;
     }
-    info("final opening_result");
 
     g1_ct rhs = g1_ct::template wnaf_batch_mul<128>(rhs_elements, rhs_scalars);
 
diff --git a/cpp/src/barretenberg/transcript/transcript.cpp b/cpp/src/barretenberg/transcript/transcript.cpp
index b510f312cd..1371a08eac 100644
--- a/cpp/src/barretenberg/transcript/transcript.cpp
+++ b/cpp/src/barretenberg/transcript/transcript.cpp
@@ -233,13 +233,11 @@ void Transcript::apply_fiat_shamir(const std::string& challenge_name /*, const b
         break;
     }
     case HashType::PedersenBlake3s: {
-        info("in pedersen");
         std::vector<uint8_t> compressed_buffer = to_buffer(crypto::pedersen_commitment::compress_native(buffer));
         base_hash = Blake3sHasher::hash(compressed_buffer);
         break;
     }
     case HashType::PlookupPedersenBlake3s: {
-        info("in plookup pedersen");
         std::vector<uint8_t> compressed_buffer = crypto::pedersen_commitment::lookup::compress_native(buffer);
         base_hash = Blake3sHasher::hash_plookup(compressed_buffer);
         break;
@@ -248,7 +246,7 @@ void Transcript::apply_fiat_shamir(const std::string& challenge_name /*, const b
         throw_or_abort("no hasher was selected for the transcript");
     }
     }
-    info("got base_hash");
+
     // Depending on the settings, we might be able to chunk the bytes of a single hash across multiple challenges:
     const size_t challenges_per_hash = PRNG_OUTPUT_SIZE / num_challenge_bytes;
 
diff --git a/ts/src/main.ts b/ts/src/main.ts
index ea860813b7..544155bb5e 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -62,7 +62,7 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, is_r
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
     const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), is_recursive);
-    console.log(proof);
+
     const verified = await api.acirVerifyProof(acirComposer, proof, is_recursive);
     debug(`verified: ${verified}`);
     return verified;
@@ -273,7 +273,6 @@ program
   .requiredOption('-n, --num-public-inputs <number>', 'Specify the number of public inputs')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
   .action(async ({ proofPath, numPublicInputs, outputPath }) => {
-    console.log(numPublicInputs)
     await proof_as_fields(proofPath, numPublicInputs, outputPath);
   })
 

From 0798faec9f40d24b39c14b5967ff695d94e19acf Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 14:46:49 +0000
Subject: [PATCH 55/64] add comment to recursion serialization methods

---
 .../dsl/acir_proofs/acir_composer.cpp             | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index e739ee81d2..d562c4cc1f 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -85,6 +85,14 @@ std::string AcirComposer::get_solidity_verifier()
     return stream.str();
 }
 
+/**
+ * @brief Takes in a proof buffer and converts into a vector of field elements.
+ *        The Recursion opcode requires the proof serialized as a vector of witnesses.
+ *        Use this method to get the witness values!
+ *
+ * @param proof
+ * @param num_inner_public_inputs - number of public inputs on the proof being serialized
+ */
 std::vector<barretenberg::fr> AcirComposer::serialize_proof_into_fields(std::vector<uint8_t> const& proof,
                                                                         size_t num_inner_public_inputs)
 {
@@ -97,7 +105,12 @@ std::vector<barretenberg::fr> AcirComposer::serialize_proof_into_fields(std::vec
     return output;
 }
 
-// The composer should already have a verification key initialized
+/**
+ * @brief Takes in a verification key buffer and converts into a vector of field elements.
+ *        The Recursion opcode requires the vk serialized as a vector of witnesses.
+ *        Use this method to get the witness values!
+ *        The composer should already have a verification key initialized.
+ */
 std::vector<barretenberg::fr> AcirComposer::serialize_verification_key_into_fields()
 {
     std::vector<barretenberg::fr> output = acir_format::export_key_in_recursion_format(verification_key_);

From 4da23758088dec421bee1b3223a00102435da3a1 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 15:27:11 +0000
Subject: [PATCH 56/64] match package.json on cl/acir_cbinds

---
 ts/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ts/package.json b/ts/package.json
index d997e85f80..e8bb1dc842 100644
--- a/ts/package.json
+++ b/ts/package.json
@@ -9,7 +9,7 @@
   },
   "bin": {
     "bb.js": "./dest/main.js",
-    "bb.js-dev": "./bb.js-dev"
+    "bb.js-dev": "./src/main-dev.ts"
   },
   "scripts": {
     "clean": "rm -rf ./dest .tsbuildinfo",

From 75b8fbf8df3c5f71dbe2b4604109bbfe97a1d3b6 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 15:34:54 +0000
Subject: [PATCH 57/64] don't remove EventEmitter from bb_wasm.ts

---
 ts/src/barretenberg_wasm/barretenberg_wasm.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ts/src/barretenberg_wasm/barretenberg_wasm.ts b/ts/src/barretenberg_wasm/barretenberg_wasm.ts
index f8139aa536..a597f89812 100644
--- a/ts/src/barretenberg_wasm/barretenberg_wasm.ts
+++ b/ts/src/barretenberg_wasm/barretenberg_wasm.ts
@@ -1,4 +1,5 @@
 import { type Worker } from 'worker_threads';
+import { EventEmitter } from 'events';
 import createDebug from 'debug';
 import { Remote, proxy } from 'comlink';
 import { randomBytes } from '../random/index.js';
@@ -9,6 +10,8 @@ import { fetchCode, getNumCpu, createWorker, getRemoteBarretenbergWasm, threadLo
 
 const debug = createDebug('wasm');
 
+EventEmitter.defaultMaxListeners = 30;
+
 export class BarretenbergWasm {
   static MAX_THREADS = 16;
   private memory!: WebAssembly.Memory;

From cf866900d05a5d7176cf44039cdf5eed5851438a Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 15:43:44 +0000
Subject: [PATCH 58/64] delete empty exports file

---
 .vscode/settings.json | 3 +--
 ts/exports.json       | 0
 ts/src/main.ts        | 7 ++-----
 3 files changed, 3 insertions(+), 7 deletions(-)
 delete mode 100644 ts/exports.json

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 2b6b8f70a7..0134c08493 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -105,8 +105,7 @@
     "span": "cpp",
     "*.inc": "cpp",
     "*.macros": "cpp",
-    "cuchar": "cpp",
-    "__verbose_abort": "cpp"
+    "cuchar": "cpp"
   },
   "solidity.compileUsingRemoteVersion": "v0.6.10+commit.00c0fcaf",
   "search.exclude": {
diff --git a/ts/exports.json b/ts/exports.json
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/ts/src/main.ts b/ts/src/main.ts
index bda33f7eb1..6676895eba 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -14,7 +14,7 @@ const debug = createDebug('bb.js');
 // createDebug.enable('*');
 
 // Maximum we support.
-const CIRCUIT_SIZE = 2 ** 18;
+const CIRCUIT_SIZE = 2 ** 19;
 
 function getBytecode(jsonPath: string) {
   const json = readFileSync(jsonPath, 'utf-8');
@@ -32,20 +32,17 @@ function getWitness(witnessPath: string) {
 async function init() {
   // Plus 1 needed!
   const crs = await Crs.new(CIRCUIT_SIZE + 1);
-  debug('got crs');
+
   const api = await newBarretenbergApiAsync();
 
   // Import to init slab allocator as first thing, to ensure maximum memory efficiency.
   await api.commonInitSlabAllocator(CIRCUIT_SIZE);
-  debug('got slab allocator');
 
   // Load CRS into wasm global CRS state.
   // TODO: Make RawBuffer be default behaviour, and have a specific Vector type for when wanting length prefixed.
   await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
-  debug('got srs');
 
   const acirComposer = await api.acirNewAcirComposer();
-  debug('got acirComposer');
   return { api, acirComposer };
 }
 

From e17275c26d2641726ed45d68cd307ac9538a3d1d Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 15:46:34 +0000
Subject: [PATCH 59/64] use process.exit

---
 ts/src/main.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/ts/src/main.ts b/ts/src/main.ts
index 6676895eba..fb4d4a7f75 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -7,7 +7,6 @@ import { gunzipSync } from 'zlib';
 import { RawBuffer } from './types/index.js';
 import { numToUInt32BE } from './serialize/serialize.js';
 import { Command } from 'commander';
-import { exit } from 'process';
 
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
@@ -211,7 +210,7 @@ function bufferAsFieldHex(buffer: Buffer): string {
   const hex = buffer.toString('hex');
   const splitHex = hex.match(/.{1,64}/g);
   if (splitHex == null) {
-    exit();
+    process.exit(1);
   } else {
     for (let i = 0; i < splitHex.length; i++) {
       splitHex[i] = '0x'.concat(splitHex[i]);

From 8d785e181ebe3844d23cb42b5cbf1abfb4b5c9f6 Mon Sep 17 00:00:00 2001
From: Charlie Lye <karl.lye@gmail.com>
Date: Tue, 30 May 2023 15:57:35 +0000
Subject: [PATCH 60/64] log

---
 ts/src/main.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ts/src/main.ts b/ts/src/main.ts
index c5a04d06cd..008b499042 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -62,6 +62,7 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string) {
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
     const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness));
+    debug(`done.`);
 
     const verified = await api.acirVerifyProof(acirComposer, proof);
     console.log(`verified: ${verified}`);
@@ -84,6 +85,7 @@ export async function prove(jsonPath: string, witnessPath: string, outputPath: s
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
     const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness));
+    debug(`done.`);
 
     writeFileSync(outputPath, proof);
     console.log(`proof written to: ${outputPath}`);
@@ -101,6 +103,7 @@ export async function gateCount(jsonPath: string) {
     const gates = await api.acirGetTotalCircuitSize(acirComposer);
     console.log(`${gates}`);
   } finally {
+    await api.acirDeleteAcirComposer(acirComposer);
     await api.destroy();
   }
 }

From 6723609300008696baa995fa52d87da9b6445340 Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 16:19:03 +0000
Subject: [PATCH 61/64] add comment for why CIRCUIT_SIZE is 2**18

---
 ts/src/main.ts | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/ts/src/main.ts b/ts/src/main.ts
index fb4d4a7f75..9658133c96 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -13,7 +13,9 @@ const debug = createDebug('bb.js');
 // createDebug.enable('*');
 
 // Maximum we support.
-const CIRCUIT_SIZE = 2 ** 19;
+// TODO: When generating a proving key with a recursion constraint in the circuit
+// we go over the memory limit with the circuit size set to 2**19
+const CIRCUIT_SIZE = 2 ** 18;
 
 function getBytecode(jsonPath: string) {
   const json = readFileSync(jsonPath, 'utf-8');
@@ -239,7 +241,6 @@ program
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
   .option('-r, --recursive', 'prove and verify using recursive prover and verifier', false)
   .action(async ({ jsonPath, witnessPath, recursive }) => {
-    debug(recursive);
     const result = await proveAndVerify(jsonPath, witnessPath, recursive);
     process.exit(result ? 0 : 1);
   });

From cc968764f75bd696477f7c6cb9fbcdd79dc379ec Mon Sep 17 00:00:00 2001
From: vezenovm <mvezenov@gmail.com>
Date: Tue, 30 May 2023 17:45:22 +0000
Subject: [PATCH 62/64] mising keccak var constraints in new acir format tests

---
 cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp       | 1 +
 .../barretenberg/dsl/acir_format/recursion_constraint.test.cpp  | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
index 867c3f1091..96c067805a 100644
--- a/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp
@@ -31,6 +31,7 @@ TEST(acir_format, test_a_single_constraint_no_pub_inputs)
         .sha256_constraints = {},
         .blake2s_constraints = {},
         .keccak_constraints = {},
+        .keccak_var_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
diff --git a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index ed7bf8deaf..0117b4f0a5 100644
--- a/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -87,6 +87,7 @@ acir_format::Composer create_inner_circuit()
         .sha256_constraints = {},
         .blake2s_constraints = {},
         .keccak_constraints = {},
+        .keccak_var_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},
@@ -214,6 +215,7 @@ acir_format::Composer create_outer_circuit(std::vector<acir_format::Composer>& i
         .sha256_constraints = {},
         .blake2s_constraints = {},
         .keccak_constraints = {},
+        .keccak_var_constraints = {},
         .hash_to_field_constraints = {},
         .pedersen_constraints = {},
         .compute_merkle_root_constraints = {},

From d5a5a2640a5ced240f085a0b42a0f156219f910e Mon Sep 17 00:00:00 2001
From: Charlie Lye <karl.lye@gmail.com>
Date: Thu, 1 Jun 2023 07:29:53 +0000
Subject: [PATCH 63/64] Cleanup some serialization.

---
 .../barretenberg/common/slab_allocator.cpp    |   4 +-
 .../barretenberg/common/slab_allocator.hpp    |   2 +-
 .../dsl/acir_proofs/acir_composer.cpp         |  54 ++++--
 .../dsl/acir_proofs/acir_composer.hpp         |  15 +-
 .../barretenberg/dsl/acir_proofs/c_bind.cpp   |  91 ++++-----
 .../barretenberg/dsl/acir_proofs/c_bind.hpp   |  19 +-
 exports.json                                  |  77 ++++----
 ts/package.json                               |   4 +-
 ts/src/barretenberg_api/index.ts              |  56 +++---
 ts/src/barretenberg_wasm/barretenberg_wasm.ts |   2 +
 ts/src/main.ts                                | 177 +++++++++---------
 ts/src/serialize/serialize.ts                 |   4 +
 ts/src/types/fields.ts                        |   4 +-
 13 files changed, 269 insertions(+), 240 deletions(-)

diff --git a/cpp/src/barretenberg/common/slab_allocator.cpp b/cpp/src/barretenberg/common/slab_allocator.cpp
index 89597d8cce..96be5d7426 100644
--- a/cpp/src/barretenberg/common/slab_allocator.cpp
+++ b/cpp/src/barretenberg/common/slab_allocator.cpp
@@ -195,9 +195,9 @@ SlabAllocator allocator;
 } // namespace
 
 namespace barretenberg {
-void init_slab_allocator(size_t circuit_size)
+void init_slab_allocator(size_t circuit_subgroup_size)
 {
-    allocator.init(circuit_size);
+    allocator.init(circuit_subgroup_size);
 }
 
 // auto init = ([]() {
diff --git a/cpp/src/barretenberg/common/slab_allocator.hpp b/cpp/src/barretenberg/common/slab_allocator.hpp
index 2db615b00b..be5ef6ea1b 100644
--- a/cpp/src/barretenberg/common/slab_allocator.hpp
+++ b/cpp/src/barretenberg/common/slab_allocator.hpp
@@ -25,7 +25,7 @@ namespace barretenberg {
  * TODO: De-globalise. Init the allocator and pass around. Use a PolynomialFactory (PolynomialStore?).
  * TODO: Consider removing, but once due-dilligence has been done that we no longer have memory limitations.
  */
-void init_slab_allocator(size_t circuit_size);
+void init_slab_allocator(size_t circuit_subgroup_size);
 
 /**
  * Returns a slab from the preallocated pool of slabs, or fallback to a new heap allocation (32 byte aligned).
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index dc48c0f9be..0dc392c284 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -4,43 +4,56 @@
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
 #include "barretenberg/dsl/acir_format/acir_format.hpp"
 #include "barretenberg/dsl/types.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
 #include "barretenberg/srs/factories/crs_factory.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/sol_gen.hpp"
 #include "barretenberg/srs/factories/crs_factory.hpp"
 
 namespace acir_proofs {
 
-AcirComposer::AcirComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory)
-    : crs_factory_(crs_factory)
-    , composer_(0, 0, 0)
+AcirComposer::AcirComposer()
+    : composer_(0, 0, 0)
 {}
 
-void AcirComposer::create_circuit(acir_format::acir_format& constraint_system, size_t size_hint)
+void AcirComposer::create_circuit(acir_format::acir_format& constraint_system)
 {
-    composer_ = acir_format::create_circuit(constraint_system, crs_factory_, size_hint);
+    composer_ = acir_format::create_circuit(constraint_system, nullptr);
 
     // We are done with the constraint system at this point, and we need the memory slab back.
-    // constraint_system = acir_format::acir_format();
     constraint_system.constraints.clear();
     constraint_system.constraints.shrink_to_fit();
 
+    exact_circuit_size_ = composer_.get_num_gates();
     total_circuit_size_ = composer_.get_total_circuit_size();
     circuit_subgroup_size_ = composer_.get_circuit_subgroup_size(total_circuit_size_);
 }
 
-void AcirComposer::init_proving_key(acir_format::acir_format& constraint_system, size_t size_hint)
+void AcirComposer::init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+                                    acir_format::acir_format& constraint_system,
+                                    size_t size_hint)
 {
-    create_circuit(constraint_system, size_hint);
+    composer_ = acir_format::create_circuit(constraint_system, crs_factory, size_hint);
+
+    // We are done with the constraint system at this point, and we need the memory slab back.
+    constraint_system.constraints.clear();
+    constraint_system.constraints.shrink_to_fit();
+
+    exact_circuit_size_ = composer_.get_num_gates();
+    total_circuit_size_ = composer_.get_total_circuit_size();
+    circuit_subgroup_size_ = composer_.get_circuit_subgroup_size(total_circuit_size_);
+
     proving_key_ = composer_.compute_proving_key();
 }
 
-std::vector<uint8_t> AcirComposer::create_proof(acir_format::acir_format& constraint_system,
-                                                acir_format::WitnessVector& witness,
-                                                bool is_recursive)
+std::vector<uint8_t> AcirComposer::create_proof(
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+    acir_format::acir_format& constraint_system,
+    acir_format::WitnessVector& witness,
+    bool is_recursive)
 {
     composer_ = acir_format::Composer(proving_key_, verification_key_, circuit_subgroup_size_);
     // You can't produce the verification key unless you manually set the crs. Which seems like a bug.
-    composer_.crs_factory_ = crs_factory_;
+    composer_.crs_factory_ = crs_factory;
 
     create_circuit_with_witness(composer_, constraint_system, witness);
 
@@ -66,17 +79,26 @@ std::shared_ptr<proof_system::plonk::verification_key> AcirComposer::init_verifi
     return verification_key_ = composer_.compute_verification_key();
 }
 
+void AcirComposer::load_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+                                         proof_system::plonk::verification_key_data&& data)
+{
+    verification_key_ =
+        std::make_shared<proof_system::plonk::verification_key>(std::move(data), crs_factory->get_verifier_crs());
+    composer_ = acir_format::Composer(proving_key_, verification_key_, circuit_subgroup_size_);
+}
+
 bool AcirComposer::verify_proof(std::vector<uint8_t> const& proof, bool is_recursive)
 {
-    bool verified = false;
+    // Hack. Shouldn't need to do this. 2144 is size with no public inputs.
+    composer_.public_inputs.resize((proof.size() - 2144) / 32);
+
     if (is_recursive) {
         auto verifier = composer_.create_verifier();
-        verified = verifier.verify_proof({ proof });
+        return verifier.verify_proof({ proof });
     } else {
         auto verifier = composer_.create_ultra_with_keccak_verifier();
-        verified = verifier.verify_proof({ proof });
+        return verifier.verify_proof({ proof });
     }
-    return verified;
 }
 
 std::string AcirComposer::get_solidity_verifier()
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
index b1dc7957ab..c6de53c205 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
@@ -9,16 +9,22 @@ namespace acir_proofs {
 
 class AcirComposer {
   public:
-    AcirComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory);
+    AcirComposer();
 
-    void create_circuit(acir_format::acir_format& constraint_system, size_t size_hint = 0);
+    void create_circuit(acir_format::acir_format& constraint_system);
 
-    void init_proving_key(acir_format::acir_format& constraint_system, size_t size_hint = 0);
+    void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+                          acir_format::acir_format& constraint_system,
+                          size_t size_hint = 0);
 
-    std::vector<uint8_t> create_proof(acir_format::acir_format& constraint_system,
+    std::vector<uint8_t> create_proof(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+                                      acir_format::acir_format& constraint_system,
                                       acir_format::WitnessVector& witness,
                                       bool is_recursive);
 
+    void load_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+                               proof_system::plonk::verification_key_data&& data);
+
     std::shared_ptr<proof_system::plonk::verification_key> init_verification_key();
 
     bool verify_proof(std::vector<uint8_t> const& proof, bool is_recursive);
@@ -33,7 +39,6 @@ class AcirComposer {
     std::vector<barretenberg::fr> serialize_verification_key_into_fields();
 
   private:
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory_;
     acir_format::Composer composer_;
     size_t exact_circuit_size_;
     size_t total_circuit_size_;
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
index 9e9c1c9235..8cce085b72 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.cpp
@@ -7,29 +7,30 @@
 #include "barretenberg/common/serialize.hpp"
 #include "barretenberg/common/slab_allocator.hpp"
 #include "barretenberg/dsl/acir_format/acir_format.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
 #include "barretenberg/srs/global_crs.hpp"
 
-WASM_EXPORT void acir_new_acir_composer(out_ptr out)
+WASM_EXPORT void acir_get_circuit_sizes(uint8_t const* constraint_system_buf,
+                                        uint32_t* exact,
+                                        uint32_t* total,
+                                        uint32_t* subgroup)
 {
-    *out = new acir_proofs::AcirComposer(barretenberg::srs::get_crs_factory());
+    auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
+    free_mem_slab_raw((void*)constraint_system_buf);
+    auto composer = acir_format::create_circuit(constraint_system, nullptr, 1 << 19);
+    *exact = htonl((uint32_t)composer.get_num_gates());
+    *total = htonl((uint32_t)composer.get_total_circuit_size());
+    *subgroup = htonl((uint32_t)composer.get_circuit_subgroup_size(composer.get_total_circuit_size()));
 }
 
-WASM_EXPORT void acir_delete_acir_composer(in_ptr acir_composer_ptr)
+WASM_EXPORT void acir_new_acir_composer(out_ptr out)
 {
-    delete reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
+    *out = new acir_proofs::AcirComposer();
 }
 
-WASM_EXPORT void acir_create_circuit(in_ptr acir_composer_ptr,
-                                     uint8_t const* constraint_system_buf,
-                                     uint32_t const* size_hint)
+WASM_EXPORT void acir_delete_acir_composer(in_ptr acir_composer_ptr)
 {
-    auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
-    auto constraint_system = from_buffer<acir_format::acir_format>(constraint_system_buf);
-
-    // The binder would normally free the the constraint_system_buf, but we need the memory now.
-    free_mem_slab_raw((void*)constraint_system_buf);
-
-    acir_composer->create_circuit(constraint_system, ntohl(*size_hint));
+    delete reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
 }
 
 WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
@@ -42,7 +43,7 @@ WASM_EXPORT void acir_init_proving_key(in_ptr acir_composer_ptr,
     // The binder would normally free the the constraint_system_buf, but we need the memory now.
     free_mem_slab_raw((void*)constraint_system_buf);
 
-    acir_composer->init_proving_key(constraint_system, ntohl(*size_hint));
+    acir_composer->init_proving_key(barretenberg::srs::get_crs_factory(), constraint_system, ntohl(*size_hint));
 }
 
 WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
@@ -59,10 +60,18 @@ WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
     free_mem_slab_raw((void*)constraint_system_buf);
     free_mem_slab_raw((void*)witness_buf);
 
-    auto proof_data = acir_composer->create_proof(constraint_system, witness, *is_recursive);
+    auto proof_data =
+        acir_composer->create_proof(barretenberg::srs::get_crs_factory(), constraint_system, witness, *is_recursive);
     *out = to_heap_buffer(proof_data);
 }
 
+WASM_EXPORT void acir_load_verification_key(in_ptr acir_composer_ptr, uint8_t const* vk_buf)
+{
+    auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
+    auto vk_data = from_buffer<plonk::verification_key_data>(vk_buf);
+    acir_composer->load_verification_key(barretenberg::srs::get_crs_factory(), std::move(vk_data));
+}
+
 WASM_EXPORT void acir_init_verification_key(in_ptr acir_composer_ptr)
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
@@ -96,62 +105,28 @@ WASM_EXPORT void acir_get_solidity_verifier(in_ptr acir_composer_ptr, out_str_bu
     *out = to_heap_buffer(str);
 }
 
-WASM_EXPORT void acir_get_exact_circuit_size(in_ptr acir_composer_ptr, uint32_t* out)
-{
-    auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
-    *out = htonl((uint32_t)acir_composer->get_exact_circuit_size());
-}
-
-WASM_EXPORT void acir_get_total_circuit_size(in_ptr acir_composer_ptr, uint32_t* out)
-{
-    auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
-    *out = htonl((uint32_t)acir_composer->get_total_circuit_size());
-}
-
 WASM_EXPORT void acir_serialize_proof_into_fields(in_ptr acir_composer_ptr,
                                                   uint8_t const* proof_buf,
                                                   uint32_t const* num_inner_public_inputs,
-                                                  uint8_t** out)
+                                                  fr::vec_out_buf out)
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
     auto proof = from_buffer<std::vector<uint8_t>>(proof_buf);
-
     auto proof_as_fields = acir_composer->serialize_proof_into_fields(proof, ntohl(*num_inner_public_inputs));
 
-    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
-    std::vector<uint8_t> proof_fields_data;
-    // The serialization code below will convert out of Montgomery form before writing to the buffer
-    for (size_t i = 0; i < proof_as_fields.size(); ++i) {
-        auto proof_field = proof_as_fields[i].to_buffer();
-        copy(proof_field.begin(), proof_field.end(), std::back_inserter(proof_fields_data));
-    }
-    *out = to_heap_buffer(proof_fields_data);
+    *out = to_heap_buffer(proof_as_fields);
 }
 
 WASM_EXPORT void acir_serialize_verification_key_into_fields(in_ptr acir_composer_ptr,
-                                                             uint8_t** out_vkey,
-                                                             uint8_t** out_key_hash)
+                                                             fr::vec_out_buf out_vkey,
+                                                             fr::out_buf out_key_hash)
 {
     auto acir_composer = reinterpret_cast<acir_proofs::AcirComposer*>(*acir_composer_ptr);
 
     auto vkey_as_fields = acir_composer->serialize_verification_key_into_fields();
+    auto vk_hash = vkey_as_fields.back();
+    vkey_as_fields.pop_back();
 
-    // NOTE: this output buffer will always have a fixed size! Maybe just precompute?
-    // Cut off 32 bytes as last element is the verification key hash which is not part of the key :o
-    std::vector<uint8_t> vk_fields_data;
-    // The serialization code below will convert out of Montgomery form before writing to the buffer
-    for (size_t i = 0; i < vkey_as_fields.size() - 1; ++i) {
-        auto vk_field = vkey_as_fields[i].to_buffer();
-        copy(vk_field.begin(), vk_field.end(), std::back_inserter(vk_fields_data));
-    }
-
-    std::vector<uint8_t> vk_hash_data;
-    auto vk_hash_field = vkey_as_fields[vkey_as_fields.size() - 1].to_buffer();
-    copy(vk_hash_field.begin(), vk_hash_field.end(), std::back_inserter(vk_hash_data));
-
-    // copy the vkey into serialized_vk_buf
-    *out_vkey = to_heap_buffer(vk_fields_data);
-
-    // copy the vkey hash into serialized_vk_hash_buf
-    *out_key_hash = to_heap_buffer(vk_hash_data);
+    *out_vkey = to_heap_buffer(vkey_as_fields);
+    write(out_key_hash, vk_hash);
 }
diff --git a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
index 3d70fc13d2..9fbd0be14a 100644
--- a/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
+++ b/cpp/src/barretenberg/dsl/acir_proofs/c_bind.hpp
@@ -4,6 +4,13 @@
 #include <barretenberg/common/serialize.hpp>
 #include <barretenberg/ecc/curves/bn254/fr.hpp>
 
+using namespace barretenberg;
+
+WASM_EXPORT void acir_get_circuit_sizes(uint8_t const* constraint_system_buf,
+                                        uint32_t* exact,
+                                        uint32_t* total,
+                                        uint32_t* subgroup);
+
 WASM_EXPORT void acir_new_acir_composer(out_ptr out);
 
 WASM_EXPORT void acir_delete_acir_composer(in_ptr acir_composer_ptr);
@@ -27,6 +34,8 @@ WASM_EXPORT void acir_create_proof(in_ptr acir_composer_ptr,
                                    bool const* is_recursive,
                                    uint8_t** out);
 
+WASM_EXPORT void acir_load_verification_key(in_ptr acir_composer_ptr, uint8_t const* vk_buf);
+
 WASM_EXPORT void acir_init_verification_key(in_ptr acir_composer_ptr);
 
 WASM_EXPORT void acir_get_verification_key(in_ptr acir_composer_ptr, uint8_t** out);
@@ -38,15 +47,11 @@ WASM_EXPORT void acir_verify_proof(in_ptr acir_composer_ptr,
 
 WASM_EXPORT void acir_get_solidity_verifier(in_ptr acir_composer_ptr, out_str_buf out);
 
-WASM_EXPORT void acir_get_exact_circuit_size(in_ptr acir_composer_ptr, uint32_t* out);
-
-WASM_EXPORT void acir_get_total_circuit_size(in_ptr acir_composer_ptr, uint32_t* out);
-
 WASM_EXPORT void acir_serialize_proof_into_fields(in_ptr acir_composer_ptr,
                                                   uint8_t const* proof_buf,
                                                   uint32_t const* num_inner_public_inputs,
-                                                  uint8_t** out);
+                                                  fr::vec_out_buf out);
 
 WASM_EXPORT void acir_serialize_verification_key_into_fields(in_ptr acir_composer_ptr,
-                                                             uint8_t** out_vkey,
-                                                             uint8_t** out_key_hash);
\ No newline at end of file
+                                                             fr::vec_out_buf out_vkey,
+                                                             fr::out_buf out_key_hash);
\ No newline at end of file
diff --git a/exports.json b/exports.json
index d0257c8567..60fb981dd1 100644
--- a/exports.json
+++ b/exports.json
@@ -535,6 +535,30 @@
     "outArgs": [],
     "isAsync": false
   },
+  {
+    "functionName": "acir_get_circuit_sizes",
+    "inArgs": [
+      {
+        "name": "constraint_system_buf",
+        "type": "const uint8_t *"
+      }
+    ],
+    "outArgs": [
+      {
+        "name": "exact",
+        "type": "uint32_t *"
+      },
+      {
+        "name": "total",
+        "type": "uint32_t *"
+      },
+      {
+        "name": "subgroup",
+        "type": "uint32_t *"
+      }
+    ],
+    "isAsync": false
+  },
   {
     "functionName": "acir_new_acir_composer",
     "inArgs": [],
@@ -623,6 +647,21 @@
     ],
     "isAsync": false
   },
+  {
+    "functionName": "acir_load_verification_key",
+    "inArgs": [
+      {
+        "name": "acir_composer_ptr",
+        "type": "in_ptr"
+      },
+      {
+        "name": "vk_buf",
+        "type": "const uint8_t *"
+      }
+    ],
+    "outArgs": [],
+    "isAsync": false
+  },
   {
     "functionName": "acir_init_verification_key",
     "inArgs": [
@@ -690,38 +729,6 @@
     ],
     "isAsync": false
   },
-  {
-    "functionName": "acir_get_exact_circuit_size",
-    "inArgs": [
-      {
-        "name": "acir_composer_ptr",
-        "type": "in_ptr"
-      }
-    ],
-    "outArgs": [
-      {
-        "name": "out",
-        "type": "uint32_t *"
-      }
-    ],
-    "isAsync": false
-  },
-  {
-    "functionName": "acir_get_total_circuit_size",
-    "inArgs": [
-      {
-        "name": "acir_composer_ptr",
-        "type": "in_ptr"
-      }
-    ],
-    "outArgs": [
-      {
-        "name": "out",
-        "type": "uint32_t *"
-      }
-    ],
-    "isAsync": false
-  },
   {
     "functionName": "acir_serialize_proof_into_fields",
     "inArgs": [
@@ -741,7 +748,7 @@
     "outArgs": [
       {
         "name": "out",
-        "type": "uint8_t **"
+        "type": "fr::vec_out_buf"
       }
     ],
     "isAsync": false
@@ -757,11 +764,11 @@
     "outArgs": [
       {
         "name": "out_vkey",
-        "type": "uint8_t **"
+        "type": "fr::vec_out_buf"
       },
       {
         "name": "out_key_hash",
-        "type": "uint8_t **"
+        "type": "fr::out_buf"
       }
     ],
     "isAsync": false
diff --git a/ts/package.json b/ts/package.json
index e8bb1dc842..91c469b3c9 100644
--- a/ts/package.json
+++ b/ts/package.json
@@ -15,7 +15,7 @@
     "clean": "rm -rf ./dest .tsbuildinfo",
     "build": "yarn clean && yarn build:wasm && tsc -b && webpack && chmod +x ./dest/main.js",
     "build:dev": "tsc -b --watch",
-    "build:wasm": "cd ../cpp && cmake --preset wasm-threads && cmake --build --preset wasm-threads",
+    "build:wasm": "cd ../cpp && cmake --preset wasm-threads && cmake --build --preset wasm-threads && cmake --preset wasm && cmake --build --preset wasm",
     "serve": "webpack serve",
     "formatting": "prettier --check ./src && eslint --max-warnings 0 ./src",
     "formatting:fix": "prettier -w ./src",
@@ -42,6 +42,7 @@
   "dependencies": {
     "bigint-buffer": "^1.1.5",
     "commander": "^10.0.1",
+    "ts-node": "^10.9.1",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
@@ -66,7 +67,6 @@
     "resolve-typescript-plugin": "^2.0.1",
     "ts-jest": "^29.1.0",
     "ts-loader": "^9.4.2",
-    "ts-node": "^10.9.1",
     "typescript": "^5.0.4",
     "webpack": "^5.82.1",
     "webpack-cli": "^5.1.1",
diff --git a/ts/src/barretenberg_api/index.ts b/ts/src/barretenberg_api/index.ts
index 9649dffed4..3e27fe74ae 100644
--- a/ts/src/barretenberg_api/index.ts
+++ b/ts/src/barretenberg_api/index.ts
@@ -166,6 +166,11 @@ export class BarretenbergApi {
     return;
   }
 
+  async acirGetCircuitSizes(constraintSystemBuf: Uint8Array): Promise<[number, number, number]> {
+    const result = await this.binder.callWasmExport('acir_get_circuit_sizes', [constraintSystemBuf], [NumberDeserializer(), NumberDeserializer(), NumberDeserializer()]);
+    return result as any;
+  }
+
   async acirNewAcirComposer(): Promise<Ptr> {
     const result = await this.binder.callWasmExport('acir_new_acir_composer', [], [Ptr]);
     return result[0];
@@ -191,6 +196,11 @@ export class BarretenbergApi {
     return result[0];
   }
 
+  async acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): Promise<void> {
+    const result = await this.binder.callWasmExport('acir_load_verification_key', [acirComposerPtr, vkBuf], []);
+    return;
+  }
+
   async acirInitVerificationKey(acirComposerPtr: Ptr): Promise<void> {
     const result = await this.binder.callWasmExport('acir_init_verification_key', [acirComposerPtr], []);
     return;
@@ -211,23 +221,13 @@ export class BarretenbergApi {
     return result[0];
   }
 
-  async acirGetExactCircuitSize(acirComposerPtr: Ptr): Promise<number> {
-    const result = await this.binder.callWasmExport('acir_get_exact_circuit_size', [acirComposerPtr], [NumberDeserializer()]);
-    return result[0];
-  }
-
-  async acirGetTotalCircuitSize(acirComposerPtr: Ptr): Promise<number> {
-    const result = await this.binder.callWasmExport('acir_get_total_circuit_size', [acirComposerPtr], [NumberDeserializer()]);
-    return result[0];
-  }
-
-  async acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Promise<Uint8Array> {
-    const result = await this.binder.callWasmExport('acir_serialize_proof_into_fields', [acirComposerPtr, proofBuf, numInnerPublicInputs], [BufferDeserializer()]);
+  async acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Promise<Fr[]> {
+    const result = await this.binder.callWasmExport('acir_serialize_proof_into_fields', [acirComposerPtr, proofBuf, numInnerPublicInputs], [VectorDeserializer(Fr)]);
     return result[0];
   }
 
-  async acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): Promise<[Uint8Array, Uint8Array]> {
-    const result = await this.binder.callWasmExport('acir_serialize_verification_key_into_fields', [acirComposerPtr], [BufferDeserializer(), BufferDeserializer()]);
+  async acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): Promise<[Fr[], Fr]> {
+    const result = await this.binder.callWasmExport('acir_serialize_verification_key_into_fields', [acirComposerPtr], [VectorDeserializer(Fr), Fr]);
     return result as any;
   }
 }
@@ -394,6 +394,11 @@ export class BarretenbergApiSync {
     return;
   }
 
+  acirGetCircuitSizes(constraintSystemBuf: Uint8Array): [number, number, number] {
+    const result = this.binder.callWasmExport('acir_get_circuit_sizes', [constraintSystemBuf], [NumberDeserializer(), NumberDeserializer(), NumberDeserializer()]);
+    return result as any;
+  }
+
   acirNewAcirComposer(): Ptr {
     const result = this.binder.callWasmExport('acir_new_acir_composer', [], [Ptr]);
     return result[0];
@@ -419,6 +424,11 @@ export class BarretenbergApiSync {
     return result[0];
   }
 
+  acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): void {
+    const result = this.binder.callWasmExport('acir_load_verification_key', [acirComposerPtr, vkBuf], []);
+    return;
+  }
+
   acirInitVerificationKey(acirComposerPtr: Ptr): void {
     const result = this.binder.callWasmExport('acir_init_verification_key', [acirComposerPtr], []);
     return;
@@ -439,23 +449,13 @@ export class BarretenbergApiSync {
     return result[0];
   }
 
-  acirGetExactCircuitSize(acirComposerPtr: Ptr): number {
-    const result = this.binder.callWasmExport('acir_get_exact_circuit_size', [acirComposerPtr], [NumberDeserializer()]);
-    return result[0];
-  }
-
-  acirGetTotalCircuitSize(acirComposerPtr: Ptr): number {
-    const result = this.binder.callWasmExport('acir_get_total_circuit_size', [acirComposerPtr], [NumberDeserializer()]);
-    return result[0];
-  }
-
-  acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Uint8Array {
-    const result = this.binder.callWasmExport('acir_serialize_proof_into_fields', [acirComposerPtr, proofBuf, numInnerPublicInputs], [BufferDeserializer()]);
+  acirSerializeProofIntoFields(acirComposerPtr: Ptr, proofBuf: Uint8Array, numInnerPublicInputs: number): Fr[] {
+    const result = this.binder.callWasmExport('acir_serialize_proof_into_fields', [acirComposerPtr, proofBuf, numInnerPublicInputs], [VectorDeserializer(Fr)]);
     return result[0];
   }
 
-  acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): [Uint8Array, Uint8Array] {
-    const result = this.binder.callWasmExport('acir_serialize_verification_key_into_fields', [acirComposerPtr], [BufferDeserializer(), BufferDeserializer()]);
+  acirSerializeVerificationKeyIntoFields(acirComposerPtr: Ptr): [Fr[], Fr] {
+    const result = this.binder.callWasmExport('acir_serialize_verification_key_into_fields', [acirComposerPtr], [VectorDeserializer(Fr), Fr]);
     return result as any;
   }
 }
diff --git a/ts/src/barretenberg_wasm/barretenberg_wasm.ts b/ts/src/barretenberg_wasm/barretenberg_wasm.ts
index 9b6d93e155..d94b32f989 100644
--- a/ts/src/barretenberg_wasm/barretenberg_wasm.ts
+++ b/ts/src/barretenberg_wasm/barretenberg_wasm.ts
@@ -65,6 +65,8 @@ export class BarretenbergWasm {
 
     this.memory = new WebAssembly.Memory({ initial, maximum, shared: threads > 1 });
 
+    // Annoyingly the wasm declares if it's memory is shared or not. So now we need two wasms if we want to be
+    // able to fallback on "non shared memory" situations.
     const code = await fetchCode(threads > 1 ? 'barretenberg-threads.wasm' : 'barretenberg.wasm');
     const { instance, module } = await WebAssembly.instantiate(code, this.getImportObj(this.memory));
 
diff --git a/ts/src/main.ts b/ts/src/main.ts
index e026d59313..587117832d 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -1,7 +1,7 @@
 #!/usr/bin/env -S node --no-warnings
 import { Crs } from './crs/index.js';
 import createDebug from 'debug';
-import { newBarretenbergApiAsync } from './factory/index.js';
+import { BarretenbergApiAsync, newBarretenbergApiAsync } from './factory/index.js';
 import { readFileSync, writeFileSync } from 'fs';
 import { gunzipSync } from 'zlib';
 import { RawBuffer } from './types/index.js';
@@ -10,12 +10,10 @@ import { Command } from 'commander';
 
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
-createDebug.enable('*');
+// createDebug.enable('*');
 
 // Maximum we support.
-// TODO: When generating a proving key with a recursion constraint in the circuit
-// we go over the memory limit with the circuit size set to 2**19
-const CIRCUIT_SIZE = 2 ** 19;
+const MAX_CIRCUIT_SIZE = 2 ** 19;
 
 function getBytecode(jsonPath: string) {
   const json = readFileSync(jsonPath, 'utf-8');
@@ -30,32 +28,59 @@ function getWitness(witnessPath: string) {
   return Buffer.concat([numToUInt32BE(data.length / 32), data]);
 }
 
-async function init() {
-  // Plus 1 needed!
-  const crs = await Crs.new(CIRCUIT_SIZE + 1);
+async function getCircuitSize(jsonPath: string, api: BarretenbergApiAsync) {
+  const bytecode = getBytecode(jsonPath);
+  const [exact, total, subgroup] = await api.acirGetCircuitSizes(new RawBuffer(bytecode));
+  return { exact, total, subgroup };
+}
 
+async function init(jsonPath: string) {
   const api = await newBarretenbergApiAsync();
 
-  // Import to init slab allocator as first thing, to ensure maximum memory efficiency.
-  await api.commonInitSlabAllocator(CIRCUIT_SIZE);
+  // First compute circuit size.
+  const circuitSizes = await getCircuitSize(jsonPath, api);
+  debug(`circuit size: ${circuitSizes.total}`);
+
+  if (circuitSizes.subgroup > MAX_CIRCUIT_SIZE) {
+    throw new Error(`Circuit size of ${circuitSizes.subgroup} exceeds max supported of ${MAX_CIRCUIT_SIZE}`);
+  }
+
+  // Plus 1 needed! (Move +1 into Crs?)
+  const crs = await Crs.new(circuitSizes.subgroup + 1);
+
+  // Important to init slab allocator as first thing, to ensure maximum memory efficiency.
+  await api.commonInitSlabAllocator(circuitSizes.subgroup);
 
   // Load CRS into wasm global CRS state.
   // TODO: Make RawBuffer be default behaviour, and have a specific Vector type for when wanting length prefixed.
   await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
 
+  const acirComposer = await api.acirNewAcirComposer();
+  return { api, acirComposer, circuitSize: circuitSizes.subgroup };
+}
+
+async function initLite() {
+  const api = await newBarretenbergApiAsync(1);
+
+  // Plus 1 needed! (Move +1 into Crs?)
+  const crs = await Crs.new(1);
+
+  // Load CRS into wasm global CRS state.
+  await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+
   const acirComposer = await api.acirNewAcirComposer();
   return { api, acirComposer };
 }
 
 export async function proveAndVerify(jsonPath: string, witnessPath: string, isRecursive: boolean) {
-  const { api, acirComposer } = await init();
+  const { api, acirComposer, circuitSize } = await init(jsonPath);
   try {
     debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
+    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
 
-    const exactCircuitSize = await api.acirGetExactCircuitSize(acirComposer);
-    debug(`circuit size: ${exactCircuitSize}`);
+    // const circuitSize = await api.acirGetExactCircuitSize(acirComposer);
+    // debug(`circuit size: ${circuitSize}`);
 
     debug('initing verification key...');
     await api.acirInitVerificationKey(acirComposer);
@@ -74,14 +99,14 @@ export async function proveAndVerify(jsonPath: string, witnessPath: string, isRe
 }
 
 export async function prove(jsonPath: string, witnessPath: string, isRecursive: boolean, outputPath: string) {
-  const { api, acirComposer } = await init();
+  const { api, acirComposer, circuitSize } = await init(jsonPath);
   try {
     debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
+    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
 
-    const exactCircuitSize = await api.acirGetExactCircuitSize(acirComposer);
-    debug(`circuit size: ${exactCircuitSize}`);
+    // const circuitSize = await api.acirGetExactCircuitSize(acirComposer);
+    // debug(`circuit size: ${circuitSize}`);
 
     debug(`creating proof...`);
     const witness = getWitness(witnessPath);
@@ -96,43 +121,51 @@ export async function prove(jsonPath: string, witnessPath: string, isRecursive:
 }
 
 export async function gateCount(jsonPath: string) {
-  const { api, acirComposer } = await init();
+  const api = await newBarretenbergApiAsync(1);
   try {
-    const bytecode = getBytecode(jsonPath);
-    await api.acirCreateCircuit(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
-
-    const gates = await api.acirGetTotalCircuitSize(acirComposer);
-    console.log(`${gates}`);
+    const circuitSizes = await getCircuitSize(jsonPath, api);
+    console.log(`${circuitSizes.exact}`);
   } finally {
-    await api.acirDeleteAcirComposer(acirComposer);
     await api.destroy();
   }
 }
 
-export async function verify(jsonPath: string, proofPath: string, isRecursive: boolean) {
-  const { api, acirComposer } = await init();
-  try {
-    debug('initing proving key...');
-    const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
-
-    debug('initing verification key...');
-    await api.acirInitVerificationKey(acirComposer);
-
-    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
-    debug(`verified: ${verified}`);
-    return verified;
-  } finally {
-    await api.destroy();
+export async function verify(jsonPath: string, proofPath: string, isRecursive: boolean, vkPath?: string) {
+  if (vkPath) {
+    const { api, acirComposer } = await initLite();
+    try {
+      await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
+      const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
+      console.log(`verified: ${verified}`);
+      return verified;
+    } finally {
+      await api.destroy();
+    }
+  } else {
+    const { api, acirComposer, circuitSize } = await init(jsonPath);
+    try {
+      debug('initing proving key...');
+      const bytecode = getBytecode(jsonPath);
+      await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
+
+      debug('initing verification key...');
+      await api.acirInitVerificationKey(acirComposer);
+
+      const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
+      console.log(`verified: ${verified}`);
+      return verified;
+    } finally {
+      await api.destroy();
+    }
   }
 }
 
 export async function contract(jsonPath: string, outputPath: string) {
-  const { api, acirComposer } = await init();
+  const { api, acirComposer, circuitSize } = await init(jsonPath);
   try {
     debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
+    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
 
     debug('initing verification key...');
     await api.acirInitVerificationKey(acirComposer);
@@ -150,11 +183,11 @@ export async function contract(jsonPath: string, outputPath: string) {
 }
 
 export async function writeVk(jsonPath: string, outputPath: string) {
-  const { api, acirComposer } = await init();
+  const { api, acirComposer, circuitSize } = await init(jsonPath);
   try {
     debug('initing proving key...');
     const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
+    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), circuitSize);
 
     debug('initing verification key...');
     const vk = await api.acirGetVerificationKey(acirComposer);
@@ -170,60 +203,38 @@ export async function writeVk(jsonPath: string, outputPath: string) {
 }
 
 export async function proofAsFields(proofPath: string, numInnerPublicInputs: number, outputPath: string) {
-  const { api, acirComposer } = await init();
+  const { api, acirComposer } = await initLite();
 
   try {
     debug('serializing proof byte array into field elements');
-    const proofAsFieldsBuffer = await api.acirSerializeProofIntoFields(
+    const proofAsFields = await api.acirSerializeProofIntoFields(
       acirComposer,
       readFileSync(proofPath),
       numInnerPublicInputs,
     );
-    const proofAsFields = bufferAsFieldHex(Buffer.from(proofAsFieldsBuffer));
 
-    writeFileSync(outputPath, proofAsFields);
+    writeFileSync(outputPath, JSON.stringify(proofAsFields.map(f => f.toString())));
     debug('done.');
   } finally {
     await api.destroy();
   }
 }
 
-export async function vkAsFields(jsonPath: string, vkeyOutputPath: string) {
-  const { api, acirComposer } = await init();
-
-  // TODO: consider moving to passing in the key so we don't have to recompute it
-  // or just keep it as the writeVK method currently recomputes the pkey too ¯\_(ツ)_/¯
-  debug('initing proving key...');
-  const bytecode = getBytecode(jsonPath);
-  await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode), CIRCUIT_SIZE);
+export async function vkAsFields(vkPath: string, vkeyOutputPath: string) {
+  const { api, acirComposer } = await initLite();
 
-  await api.acirInitVerificationKey(acirComposer);
   try {
     debug('serializing vk byte array into field elements');
-    const [vkAsFieldsBuffer, vkHashBuffer] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
-    const vkFields = bufferAsFieldHex(Buffer.concat([Buffer.from(vkHashBuffer), Buffer.from(vkAsFieldsBuffer)]));
-
-    writeFileSync(vkeyOutputPath, vkFields);
+    await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
+    const [vkAsFields, vkHash] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
+    const output = [vkHash, ...vkAsFields].map(f => f.toString());
+    writeFileSync(vkeyOutputPath, JSON.stringify(output));
     debug('done.');
   } finally {
     await api.destroy();
   }
 }
 
-function bufferAsFieldHex(buffer: Buffer): string {
-  const hex = buffer.toString('hex');
-  const splitHex = hex.match(/.{1,64}/g);
-  if (splitHex == null) {
-    process.exit(1);
-  } else {
-    for (let i = 0; i < splitHex.length; i++) {
-      splitHex[i] = '0x'.concat(splitHex[i]);
-    }
-    const separateFields = JSON.stringify(splitHex);
-    return separateFields;
-  }
-}
-
 // nargo use bb.js: backend -> bb.js
 // backend prove --data-dir data --witness /foo/bar/witness.tr --json /foo/bar/main.json
 // backend verify ...
@@ -273,8 +284,9 @@ program
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
   .option('-r, --recursive', 'prove using recursive prover', false)
-  .action(async ({ jsonPath, proofPath, recursive }) => {
-    await verify(jsonPath, proofPath, recursive);
+  .option('-v, --vk <path>', 'path to a verification key. avoids recomputation.')
+  .action(async ({ jsonPath, proofPath, recursive, vk }) => {
+    await verify(jsonPath, proofPath, recursive, vk);
   });
 
 program
@@ -308,13 +320,10 @@ program
 program
   .command('vk_as_fields')
   .description('Return the verifiation key represented as fields elements. Also return the verification key hash.')
-  .requiredOption('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .requiredOption(
-    '-v, --vkey-output-path <path>',
-    'Specify the JSON path to write the verification key fields and key hash',
-  )
-  .action(async ({ jsonPath, vkeyOutputPath }) => {
-    await vkAsFields(jsonPath, vkeyOutputPath);
+  .requiredOption('-i, --input-path <path>', 'Specifies the vk path (output from write_vk)')
+  .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the verification key fields and key hash')
+  .action(async ({ inputPath, outputPath }) => {
+    await vkAsFields(inputPath, outputPath);
   });
 
 program.name('bb.js').parse(process.argv);
diff --git a/ts/src/serialize/serialize.ts b/ts/src/serialize/serialize.ts
index aa3634cc73..b09caac6b0 100644
--- a/ts/src/serialize/serialize.ts
+++ b/ts/src/serialize/serialize.ts
@@ -46,6 +46,10 @@ export function concatenateUint8Arrays(arrayOfUint8Arrays: Uint8Array[]) {
   return result;
 }
 
+export function uint8ArrayToHexString(uint8Array: Uint8Array) {
+  return uint8Array.reduce((accumulator, byte) => accumulator + byte.toString(16).padStart(2, '0'), '');
+}
+
 // For serializing a buffer as a vector.
 export function serializeBufferToVector(buf: Uint8Array) {
   return concatenateUint8Arrays([numToInt32BE(buf.length), buf]);
diff --git a/ts/src/types/fields.ts b/ts/src/types/fields.ts
index b1ac2ef438..a0b095813d 100644
--- a/ts/src/types/fields.ts
+++ b/ts/src/types/fields.ts
@@ -1,6 +1,6 @@
 import { randomBytes } from '../random/index.js';
 import { toBigIntBE, toBufferBE } from '../bigint-array/index.js';
-import { BufferReader } from '../serialize/index.js';
+import { BufferReader, uint8ArrayToHexString } from '../serialize/index.js';
 
 export class Fr {
   static ZERO = new Fr(0n);
@@ -38,7 +38,7 @@ export class Fr {
   }
 
   toString() {
-    return '0x' + this.value.toString(16);
+    return '0x' + uint8ArrayToHexString(this.toBuffer());
   }
 
   equals(rhs: Fr) {

From e8e866018c68a49cb71bd2b0dfd70bd650135424 Mon Sep 17 00:00:00 2001
From: Charlie Lye <karl.lye@gmail.com>
Date: Thu, 1 Jun 2023 11:23:28 +0000
Subject: [PATCH 64/64] Cleanup for publishing. README.

---
 ts/README.md         |   117 +-
 ts/bb.js-dev         |     4 +-
 ts/package-lock.json | 11910 -----------------------------------------
 ts/package.json      |    21 +-
 ts/src/index.ts      |     2 +
 ts/src/main-dev.ts   |     2 -
 ts/src/main.ts       |    17 +-
 ts/yarn.lock         |   356 +-
 8 files changed, 307 insertions(+), 12122 deletions(-)
 delete mode 100644 ts/package-lock.json
 delete mode 100755 ts/src/main-dev.ts

diff --git a/ts/README.md b/ts/README.md
index c25f356420..a65bad3250 100644
--- a/ts/README.md
+++ b/ts/README.md
@@ -1,3 +1,116 @@
-# Barretenberg.js
+# bb.js
 
-Javascript bindings for barretenberg WASM.
+Prover/verifier executable and API for barretenberg. Default cli arguments are appropriate for running within Noir
+project structures.
+
+## Performance and limitations
+
+Max circuit size is 2^19 gates (524,288). This is due to the underlying WASM 4GB memory limit. This should improve
+with future proving systems, and/or introduction of wasm64.
+
+If running from terminal, or within browser where you can set shared memory CORS headers, multithreading is enabled.
+Note there are two independent WASM builds, one with threading enabled and one without. This is because the shared
+memory flag is set within the WASM itself. If you're running in a context where you can't have shared memory, we want
+to fallback to single threaded performance.
+
+Performance for 2^19:
+
+- 16 core x86: ~13s.
+- 10 core M1 Mac Pro: ~18s.
+
+Linear scaling was observed up to 32 cores, however we limit to 16 as 2^19 runs out of memory with 32 cores.
+This maybe resolvable.
+
+## Using as a standalone binary
+
+### Installing
+
+To install the package globally for running as a terminal application:
+
+```
+npm install -g @aztec/bb.js@alpha
+```
+
+This will install `bb.js` into your path.
+
+### Usage
+
+Run `bb.js` for further usage information, you'll see e.g.
+
+```
+% bb.js
+Usage: bb.js [options] [command]
+
+Options:
+  -v, --verbose               enable verbose logging (default: false)
+  -h, --help                  display help for command
+
+Commands:
+  prove_and_verify [options]  Generate a proof and verify it. Process exits with success or failure code.
+  prove [options]             Generate a proof and write it to a file.
+  gates [options]             Print gate count to standard output.
+  verify [options]            Verify a proof. Process exists with success or failure code.
+  contract [options]          Output solidity verification key contract.
+  write_vk [options]          Output verification key.
+  proof_as_fields [options]   Return the proof as fields elements
+  vk_as_fields [options]      Return the verifiation key represented as fields elements. Also return the verification key hash.
+  help [command]              display help for command
+```
+
+## Using as a library
+
+### Installing
+
+To install as a package to be used as a library:
+
+```
+npm install @aztec/bb.js@alpha
+```
+
+or with yarn
+
+```
+yarn add @aztec/bb.js@alpha
+```
+
+### Usage
+
+To create a multithreaded version of the API:
+
+```typescript
+const api = await newBarretenbergApiAsync(/* num_threads */);
+// Use.
+const input = Buffer.from('hello world!');
+const result = await api.blake2s(input);
+await api.destroy();
+```
+
+All methods are asynchronous. If no threads are specified, will default to number of cores with a maximum of 16.
+If `1` is specified, fallback to non multi-threaded wasm that doesn't need shared memory.
+
+You can also create a synchronous version of the api that also has no multi-threading. This is only useful in the
+browser if you don't call any multi-threaded functions. It's probably best to just always use async version of the api
+unless you're really trying to avoid the small overhead of worker communication.
+
+```typescript
+const api = await newBarretenbergApiSync();
+// Use.
+const input = Buffer.from('hello world!');
+const result = api.blake2s(input);
+await api.destroy();
+```
+
+See `src/main.ts` for one example of how to use.
+
+## Development
+
+Create a symlink to the root script `bb.js-dev` in your path. You can now run the current state of the code from
+anywhere in your filesystem with no `yarn build` required.
+
+If you change the C++ code run `yarn build:wasm`.
+
+To run the tests run `yarn test`.
+
+To run a continuous "stress tests" run `yarn simple_test` to do 10 full pk/proof/vk iterations.
+
+To run the same test in the browser run `yarn serve`, navigate to appropriate URL and open the console.
diff --git a/ts/bb.js-dev b/ts/bb.js-dev
index e32ba65206..5255fe4b37 100755
--- a/ts/bb.js-dev
+++ b/ts/bb.js-dev
@@ -1,4 +1,6 @@
 #!/bin/sh
+# Add a symlink to this somewhere in your path.
+# Now you can run bb.js-dev anywhere to execute latest code, no 'yarn build' required.
 SCRIPT_PATH=$(dirname $(realpath $0))
 export TS_NODE_PROJECT="$SCRIPT_PATH/tsconfig.json"
-DEBUG="bb.js*" NODE_OPTIONS="--loader $SCRIPT_PATH/node_modules/ts-node/esm/transpile-only.mjs --no-warnings" node $SCRIPT_PATH/src/main.ts $@
+NODE_OPTIONS="--loader $SCRIPT_PATH/node_modules/ts-node/esm/transpile-only.mjs --no-warnings" node $SCRIPT_PATH/src/main.ts $@
diff --git a/ts/package-lock.json b/ts/package-lock.json
deleted file mode 100644
index 2b533c549f..0000000000
--- a/ts/package-lock.json
+++ /dev/null
@@ -1,11910 +0,0 @@
-{
-  "name": "@aztec/barretenberg.js",
-  "version": "0.0.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "@aztec/barretenberg.js",
-      "version": "0.0.0",
-      "dependencies": {
-        "bigint-buffer": "^1.1.5",
-        "commander": "^10.0.1",
-        "tslib": "^2.4.0"
-      },
-      "bin": {
-        "bb.js": "dest/main.js",
-        "bb.js-dev": "src/main-dev.ts"
-      },
-      "devDependencies": {
-        "@jest/globals": "^29.4.3",
-        "@types/debug": "^4.1.7",
-        "@types/detect-node": "^2.0.0",
-        "@types/jest": "^29.4.0",
-        "@types/node": "^18.7.23",
-        "@types/source-map-support": "^0.5.6",
-        "@typescript-eslint/eslint-plugin": "^5.54.1",
-        "@typescript-eslint/parser": "^5.54.1",
-        "buffer": "^6.0.3",
-        "comlink": "^4.4.1",
-        "copy-webpack-plugin": "^11.0.0",
-        "debug": "^4.3.4",
-        "eslint": "^8.35.0",
-        "eslint-config-prettier": "^8.8.0",
-        "html-webpack-plugin": "^5.5.1",
-        "idb-keyval": "^6.2.1",
-        "jest": "^29.5.0",
-        "prettier": "^2.8.4",
-        "resolve-typescript-plugin": "^2.0.1",
-        "ts-jest": "^29.1.0",
-        "ts-loader": "^9.4.2",
-        "ts-node": "^10.9.1",
-        "typescript": "^5.0.4",
-        "webpack": "^5.82.1",
-        "webpack-cli": "^5.1.1",
-        "webpack-dev-server": "^4.15.0"
-      }
-    },
-    "node_modules/@ampproject/remapping": {
-      "version": "2.2.1",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.0",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@babel/code-frame": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/highlight": "^7.18.6"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/compat-data": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/core": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@ampproject/remapping": "^2.2.0",
-        "@babel/code-frame": "^7.21.4",
-        "@babel/generator": "^7.21.4",
-        "@babel/helper-compilation-targets": "^7.21.4",
-        "@babel/helper-module-transforms": "^7.21.2",
-        "@babel/helpers": "^7.21.0",
-        "@babel/parser": "^7.21.4",
-        "@babel/template": "^7.20.7",
-        "@babel/traverse": "^7.21.4",
-        "@babel/types": "^7.21.4",
-        "convert-source-map": "^1.7.0",
-        "debug": "^4.1.0",
-        "gensync": "^1.0.0-beta.2",
-        "json5": "^2.2.2",
-        "semver": "^6.3.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/babel"
-      }
-    },
-    "node_modules/@babel/core/node_modules/semver": {
-      "version": "6.3.0",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/@babel/generator": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.21.4",
-        "@jridgewell/gen-mapping": "^0.3.2",
-        "@jridgewell/trace-mapping": "^0.3.17",
-        "jsesc": "^2.5.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/compat-data": "^7.21.4",
-        "@babel/helper-validator-option": "^7.21.0",
-        "browserslist": "^4.21.3",
-        "lru-cache": "^5.1.1",
-        "semver": "^6.3.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": {
-      "version": "5.1.1",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "yallist": "^3.0.2"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets/node_modules/semver": {
-      "version": "6.3.0",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets/node_modules/yallist": {
-      "version": "3.1.1",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/@babel/helper-environment-visitor": {
-      "version": "7.18.9",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-function-name": {
-      "version": "7.21.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/template": "^7.20.7",
-        "@babel/types": "^7.21.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-hoist-variables": {
-      "version": "7.18.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.18.6"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-imports": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.21.4"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-transforms": {
-      "version": "7.21.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-environment-visitor": "^7.18.9",
-        "@babel/helper-module-imports": "^7.18.6",
-        "@babel/helper-simple-access": "^7.20.2",
-        "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/helper-validator-identifier": "^7.19.1",
-        "@babel/template": "^7.20.7",
-        "@babel/traverse": "^7.21.2",
-        "@babel/types": "^7.21.2"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.20.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-simple-access": {
-      "version": "7.20.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.20.2"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-split-export-declaration": {
-      "version": "7.18.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.18.6"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-string-parser": {
-      "version": "7.19.4",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.19.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-option": {
-      "version": "7.21.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helpers": {
-      "version": "7.21.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/template": "^7.20.7",
-        "@babel/traverse": "^7.21.0",
-        "@babel/types": "^7.21.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/highlight": {
-      "version": "7.18.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-validator-identifier": "^7.18.6",
-        "chalk": "^2.0.0",
-        "js-tokens": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/chalk": {
-      "version": "2.4.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/color-convert": {
-      "version": "1.9.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "1.1.3"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/color-name": {
-      "version": "1.1.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@babel/highlight/node_modules/has-flag": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/supports-color": {
-      "version": "5.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/parser": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "parser": "bin/babel-parser.js"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-async-generators": {
-      "version": "7.8.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-bigint": {
-      "version": "7.8.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-class-properties": {
-      "version": "7.12.13",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.12.13"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-import-meta": {
-      "version": "7.10.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.10.4"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-json-strings": {
-      "version": "7.8.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-jsx": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.20.2"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-logical-assignment-operators": {
-      "version": "7.10.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.10.4"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": {
-      "version": "7.8.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-numeric-separator": {
-      "version": "7.10.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.10.4"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-object-rest-spread": {
-      "version": "7.8.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-optional-catch-binding": {
-      "version": "7.8.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-optional-chaining": {
-      "version": "7.8.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-top-level-await": {
-      "version": "7.14.5",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.14.5"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-syntax-typescript": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.20.2"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/template": {
-      "version": "7.20.7",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.18.6",
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/traverse": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.21.4",
-        "@babel/generator": "^7.21.4",
-        "@babel/helper-environment-visitor": "^7.18.9",
-        "@babel/helper-function-name": "^7.21.0",
-        "@babel/helper-hoist-variables": "^7.18.6",
-        "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/parser": "^7.21.4",
-        "@babel/types": "^7.21.4",
-        "debug": "^4.1.0",
-        "globals": "^11.1.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/traverse/node_modules/globals": {
-      "version": "11.12.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/types": {
-      "version": "7.21.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-string-parser": "^7.19.4",
-        "@babel/helper-validator-identifier": "^7.19.1",
-        "to-fast-properties": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@bcoe/v8-coverage": {
-      "version": "0.2.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@cspotcode/source-map-support": {
-      "version": "0.8.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/trace-mapping": "0.3.9"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@cspotcode/source-map-support/node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@cspotcode/source-map-support/node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.9",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
-      }
-    },
-    "node_modules/@discoveryjs/json-ext": {
-      "version": "0.5.7",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      }
-    },
-    "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.4.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eslint-visitor-keys": "^3.3.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "peerDependencies": {
-        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
-      }
-    },
-    "node_modules/@eslint-community/regexpp": {
-      "version": "4.5.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
-      }
-    },
-    "node_modules/@eslint/eslintrc": {
-      "version": "2.0.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^6.12.4",
-        "debug": "^4.3.2",
-        "espree": "^9.5.1",
-        "globals": "^13.19.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.0",
-        "minimatch": "^3.1.2",
-        "strip-json-comments": "^3.1.1"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/ajv": {
-      "version": "6.12.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/@eslint/js": {
-      "version": "8.38.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      }
-    },
-    "node_modules/@humanwhocodes/config-array": {
-      "version": "0.11.8",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@humanwhocodes/object-schema": "^1.2.1",
-        "debug": "^4.1.1",
-        "minimatch": "^3.0.5"
-      },
-      "engines": {
-        "node": ">=10.10.0"
-      }
-    },
-    "node_modules/@humanwhocodes/module-importer": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=12.22"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@humanwhocodes/object-schema": {
-      "version": "1.2.1",
-      "dev": true,
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@istanbuljs/load-nyc-config": {
-      "version": "1.1.0",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "camelcase": "^5.3.1",
-        "find-up": "^4.1.0",
-        "get-package-type": "^0.1.0",
-        "js-yaml": "^3.13.1",
-        "resolve-from": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/@istanbuljs/load-nyc-config/node_modules/js-yaml": {
-      "version": "3.14.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^1.0.7",
-        "esprima": "^4.0.0"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/@istanbuljs/schema": {
-      "version": "0.1.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/@jest/console": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "slash": "^3.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/core": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/console": "^29.5.0",
-        "@jest/reporters": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.0.0",
-        "ci-info": "^3.2.0",
-        "exit": "^0.1.2",
-        "graceful-fs": "^4.2.9",
-        "jest-changed-files": "^29.5.0",
-        "jest-config": "^29.5.0",
-        "jest-haste-map": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-regex-util": "^29.4.3",
-        "jest-resolve": "^29.5.0",
-        "jest-resolve-dependencies": "^29.5.0",
-        "jest-runner": "^29.5.0",
-        "jest-runtime": "^29.5.0",
-        "jest-snapshot": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "jest-watcher": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "pretty-format": "^29.5.0",
-        "slash": "^3.0.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
-      },
-      "peerDependenciesMeta": {
-        "node-notifier": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@jest/environment": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/fake-timers": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "jest-mock": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/expect": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "expect": "^29.5.0",
-        "jest-snapshot": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/expect-utils": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "jest-get-type": "^29.4.3"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/fake-timers": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "^29.5.0",
-        "@sinonjs/fake-timers": "^10.0.2",
-        "@types/node": "*",
-        "jest-message-util": "^29.5.0",
-        "jest-mock": "^29.5.0",
-        "jest-util": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/globals": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/environment": "^29.5.0",
-        "@jest/expect": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "jest-mock": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/reporters": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@bcoe/v8-coverage": "^0.2.3",
-        "@jest/console": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@jridgewell/trace-mapping": "^0.3.15",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "collect-v8-coverage": "^1.0.0",
-        "exit": "^0.1.2",
-        "glob": "^7.1.3",
-        "graceful-fs": "^4.2.9",
-        "istanbul-lib-coverage": "^3.0.0",
-        "istanbul-lib-instrument": "^5.1.0",
-        "istanbul-lib-report": "^3.0.0",
-        "istanbul-lib-source-maps": "^4.0.0",
-        "istanbul-reports": "^3.1.3",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-worker": "^29.5.0",
-        "slash": "^3.0.0",
-        "string-length": "^4.0.1",
-        "strip-ansi": "^6.0.0",
-        "v8-to-istanbul": "^9.0.1"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
-      },
-      "peerDependenciesMeta": {
-        "node-notifier": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@jest/schemas": {
-      "version": "29.4.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@sinclair/typebox": "^0.25.16"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/source-map": {
-      "version": "29.4.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/trace-mapping": "^0.3.15",
-        "callsites": "^3.0.0",
-        "graceful-fs": "^4.2.9"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/test-result": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/console": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/istanbul-lib-coverage": "^2.0.0",
-        "collect-v8-coverage": "^1.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/test-sequencer": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/test-result": "^29.5.0",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "slash": "^3.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/transform": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/core": "^7.11.6",
-        "@jest/types": "^29.5.0",
-        "@jridgewell/trace-mapping": "^0.3.15",
-        "babel-plugin-istanbul": "^6.1.1",
-        "chalk": "^4.0.0",
-        "convert-source-map": "^2.0.0",
-        "fast-json-stable-stringify": "^2.1.0",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "jest-regex-util": "^29.4.3",
-        "jest-util": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "pirates": "^4.0.4",
-        "slash": "^3.0.0",
-        "write-file-atomic": "^4.0.2"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jest/transform/node_modules/convert-source-map": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jest/types": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/schemas": "^29.4.3",
-        "@types/istanbul-lib-coverage": "^2.0.0",
-        "@types/istanbul-reports": "^3.0.0",
-        "@types/node": "*",
-        "@types/yargs": "^17.0.8",
-        "chalk": "^4.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/set-array": "^1.0.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/set-array": {
-      "version": "1.1.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/source-map": {
-      "version": "0.3.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.0",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.15",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.18",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "3.1.0",
-        "@jridgewell/sourcemap-codec": "1.4.14"
-      }
-    },
-    "node_modules/@jridgewell/trace-mapping/node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.14",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@leichtgewicht/ip-codec": {
-      "version": "2.0.4",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@sinclair/typebox": {
-      "version": "0.25.24",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@sinonjs/commons": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "type-detect": "4.0.8"
-      }
-    },
-    "node_modules/@sinonjs/fake-timers": {
-      "version": "10.0.2",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "@sinonjs/commons": "^2.0.0"
-      }
-    },
-    "node_modules/@tsconfig/node10": {
-      "version": "1.0.9",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node12": {
-      "version": "1.0.11",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node14": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tsconfig/node16": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/babel__core": {
-      "version": "7.20.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7",
-        "@types/babel__generator": "*",
-        "@types/babel__template": "*",
-        "@types/babel__traverse": "*"
-      }
-    },
-    "node_modules/@types/babel__generator": {
-      "version": "7.6.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "node_modules/@types/babel__template": {
-      "version": "7.4.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.1.0",
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "node_modules/@types/babel__traverse": {
-      "version": "7.18.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.3.0"
-      }
-    },
-    "node_modules/@types/body-parser": {
-      "version": "1.19.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/connect": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/bonjour": {
-      "version": "3.5.10",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/connect": {
-      "version": "3.4.35",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/connect-history-api-fallback": {
-      "version": "1.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/express-serve-static-core": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/debug": {
-      "version": "4.1.7",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/ms": "*"
-      }
-    },
-    "node_modules/@types/detect-node": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/eslint": {
-      "version": "8.37.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "*",
-        "@types/json-schema": "*"
-      }
-    },
-    "node_modules/@types/eslint-scope": {
-      "version": "3.7.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/eslint": "*",
-        "@types/estree": "*"
-      }
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/express": {
-      "version": "4.17.17",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^4.17.33",
-        "@types/qs": "*",
-        "@types/serve-static": "*"
-      }
-    },
-    "node_modules/@types/express-serve-static-core": {
-      "version": "4.17.34",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
-      }
-    },
-    "node_modules/@types/graceful-fs": {
-      "version": "4.1.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/html-minifier-terser": {
-      "version": "6.1.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/http-proxy": {
-      "version": "1.17.11",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/istanbul-lib-coverage": {
-      "version": "2.0.4",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/istanbul-lib-report": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/istanbul-lib-coverage": "*"
-      }
-    },
-    "node_modules/@types/istanbul-reports": {
-      "version": "3.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/istanbul-lib-report": "*"
-      }
-    },
-    "node_modules/@types/jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "expect": "^29.0.0",
-        "pretty-format": "^29.0.0"
-      }
-    },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.11",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/mime": {
-      "version": "1.3.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/ms": {
-      "version": "0.7.31",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/node": {
-      "version": "18.15.11",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/prettier": {
-      "version": "2.7.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/qs": {
-      "version": "6.9.7",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/range-parser": {
-      "version": "1.2.4",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/retry": {
-      "version": "0.12.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/semver": {
-      "version": "7.3.13",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/send": {
-      "version": "0.17.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/mime": "^1",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/serve-index": {
-      "version": "1.9.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/express": "*"
-      }
-    },
-    "node_modules/@types/serve-static": {
-      "version": "1.15.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/mime": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/serve-static/node_modules/@types/mime": {
-      "version": "3.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/sockjs": {
-      "version": "0.3.33",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/source-map-support": {
-      "version": "0.5.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "source-map": "^0.6.0"
-      }
-    },
-    "node_modules/@types/stack-utils": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/ws": {
-      "version": "8.5.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/yargs": {
-      "version": "17.0.24",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/yargs-parser": "*"
-      }
-    },
-    "node_modules/@types/yargs-parser": {
-      "version": "21.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/regexpp": "^4.4.0",
-        "@typescript-eslint/scope-manager": "5.57.1",
-        "@typescript-eslint/type-utils": "5.57.1",
-        "@typescript-eslint/utils": "5.57.1",
-        "debug": "^4.3.4",
-        "grapheme-splitter": "^1.0.4",
-        "ignore": "^5.2.0",
-        "natural-compare-lite": "^1.4.0",
-        "semver": "^7.3.7",
-        "tsutils": "^3.21.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "@typescript-eslint/parser": "^5.0.0",
-        "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@typescript-eslint/parser": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "@typescript-eslint/scope-manager": "5.57.1",
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/typescript-estree": "5.57.1",
-        "debug": "^4.3.4"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@typescript-eslint/scope-manager": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/visitor-keys": "5.57.1"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@typescript-eslint/type-utils": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/typescript-estree": "5.57.1",
-        "@typescript-eslint/utils": "5.57.1",
-        "debug": "^4.3.4",
-        "tsutils": "^3.21.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "*"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@typescript-eslint/types": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/visitor-keys": "5.57.1",
-        "debug": "^4.3.4",
-        "globby": "^11.1.0",
-        "is-glob": "^4.0.3",
-        "semver": "^7.3.7",
-        "tsutils": "^3.21.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@typescript-eslint/utils": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.2.0",
-        "@types/json-schema": "^7.0.9",
-        "@types/semver": "^7.3.12",
-        "@typescript-eslint/scope-manager": "5.57.1",
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/typescript-estree": "5.57.1",
-        "eslint-scope": "^5.1.1",
-        "semver": "^7.3.7"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0"
-      }
-    },
-    "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "5.57.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "5.57.1",
-        "eslint-visitor-keys": "^3.3.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@webassemblyjs/ast": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/helper-numbers": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/floating-point-hex-parser": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-api-error": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-buffer": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-numbers": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/floating-point-hex-parser": "1.11.6",
-        "@webassemblyjs/helper-api-error": "1.11.6",
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "node_modules/@webassemblyjs/helper-wasm-bytecode": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/helper-wasm-section": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/ieee754": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@xtuc/ieee754": "^1.2.0"
-      }
-    },
-    "node_modules/@webassemblyjs/leb128": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "node_modules/@webassemblyjs/utf8": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@webassemblyjs/wasm-edit": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/helper-wasm-section": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-opt": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6",
-        "@webassemblyjs/wast-printer": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/wasm-gen": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/wasm-opt": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/wasm-parser": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-api-error": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/wast-printer": {
-      "version": "1.11.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "node_modules/@webpack-cli/configtest": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.15.0"
-      },
-      "peerDependencies": {
-        "webpack": "5.x.x",
-        "webpack-cli": "5.x.x"
-      }
-    },
-    "node_modules/@webpack-cli/info": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.15.0"
-      },
-      "peerDependencies": {
-        "webpack": "5.x.x",
-        "webpack-cli": "5.x.x"
-      }
-    },
-    "node_modules/@webpack-cli/serve": {
-      "version": "2.0.4",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.15.0"
-      },
-      "peerDependencies": {
-        "webpack": "5.x.x",
-        "webpack-cli": "5.x.x"
-      },
-      "peerDependenciesMeta": {
-        "webpack-dev-server": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@xtuc/ieee754": {
-      "version": "1.2.0",
-      "dev": true,
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/@xtuc/long": {
-      "version": "4.2.2",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/accepts": {
-      "version": "1.3.8",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mime-types": "~2.1.34",
-        "negotiator": "0.6.3"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/acorn": {
-      "version": "8.8.2",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-import-assertions": {
-      "version": "1.9.0",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^8"
-      }
-    },
-    "node_modules/acorn-jsx": {
-      "version": "5.3.2",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
-      }
-    },
-    "node_modules/acorn-walk": {
-      "version": "8.2.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/ajv": {
-      "version": "8.12.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/ajv-formats": {
-      "version": "2.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependenciesMeta": {
-        "ajv": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/ajv-keywords": {
-      "version": "5.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.3"
-      },
-      "peerDependencies": {
-        "ajv": "^8.8.2"
-      }
-    },
-    "node_modules/ajv/node_modules/json-schema-traverse": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/ansi-escapes": {
-      "version": "4.3.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "type-fest": "^0.21.3"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ansi-escapes/node_modules/type-fest": {
-      "version": "0.21.3",
-      "dev": true,
-      "license": "(MIT OR CC0-1.0)",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ansi-html-community": {
-      "version": "0.0.8",
-      "dev": true,
-      "engines": [
-        "node >= 0.8.0"
-      ],
-      "license": "Apache-2.0",
-      "bin": {
-        "ansi-html": "bin/ansi-html"
-      }
-    },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/anymatch": {
-      "version": "3.1.3",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "normalize-path": "^3.0.0",
-        "picomatch": "^2.0.4"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/arg": {
-      "version": "4.1.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/argparse": {
-      "version": "1.0.10",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "sprintf-js": "~1.0.2"
-      }
-    },
-    "node_modules/array-flatten": {
-      "version": "2.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/array-union": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/babel-jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/transform": "^29.5.0",
-        "@types/babel__core": "^7.1.14",
-        "babel-plugin-istanbul": "^6.1.1",
-        "babel-preset-jest": "^29.5.0",
-        "chalk": "^4.0.0",
-        "graceful-fs": "^4.2.9",
-        "slash": "^3.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.8.0"
-      }
-    },
-    "node_modules/babel-plugin-istanbul": {
-      "version": "6.1.1",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.0.0",
-        "@istanbuljs/load-nyc-config": "^1.0.0",
-        "@istanbuljs/schema": "^0.1.2",
-        "istanbul-lib-instrument": "^5.0.4",
-        "test-exclude": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/babel-plugin-jest-hoist": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/template": "^7.3.3",
-        "@babel/types": "^7.3.3",
-        "@types/babel__core": "^7.1.14",
-        "@types/babel__traverse": "^7.0.6"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/babel-preset-current-node-syntax": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/plugin-syntax-async-generators": "^7.8.4",
-        "@babel/plugin-syntax-bigint": "^7.8.3",
-        "@babel/plugin-syntax-class-properties": "^7.8.3",
-        "@babel/plugin-syntax-import-meta": "^7.8.3",
-        "@babel/plugin-syntax-json-strings": "^7.8.3",
-        "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3",
-        "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
-        "@babel/plugin-syntax-numeric-separator": "^7.8.3",
-        "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
-        "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
-        "@babel/plugin-syntax-optional-chaining": "^7.8.3",
-        "@babel/plugin-syntax-top-level-await": "^7.8.3"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0"
-      }
-    },
-    "node_modules/babel-preset-jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "babel-plugin-jest-hoist": "^29.5.0",
-        "babel-preset-current-node-syntax": "^1.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/base64-js": {
-      "version": "1.5.1",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/batch": {
-      "version": "0.6.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/bigint-buffer": {
-      "version": "1.1.5",
-      "hasInstallScript": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "bindings": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 10.0.0"
-      }
-    },
-    "node_modules/binary-extensions": {
-      "version": "2.2.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/bindings": {
-      "version": "1.5.0",
-      "license": "MIT",
-      "dependencies": {
-        "file-uri-to-path": "1.0.0"
-      }
-    },
-    "node_modules/body-parser": {
-      "version": "1.20.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "3.1.2",
-        "content-type": "~1.0.4",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "on-finished": "2.4.1",
-        "qs": "6.11.0",
-        "raw-body": "2.5.1",
-        "type-is": "~1.6.18",
-        "unpipe": "1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8",
-        "npm": "1.2.8000 || >= 1.4.16"
-      }
-    },
-    "node_modules/body-parser/node_modules/debug": {
-      "version": "2.6.9",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/body-parser/node_modules/ms": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/bonjour-service": {
-      "version": "1.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-flatten": "^2.1.2",
-        "dns-equal": "^1.0.0",
-        "fast-deep-equal": "^3.1.3",
-        "multicast-dns": "^7.2.5"
-      }
-    },
-    "node_modules/boolbase": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/braces": {
-      "version": "3.0.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/browserslist": {
-      "version": "4.21.5",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "caniuse-lite": "^1.0.30001449",
-        "electron-to-chromium": "^1.4.284",
-        "node-releases": "^2.0.8",
-        "update-browserslist-db": "^1.0.10"
-      },
-      "bin": {
-        "browserslist": "cli.js"
-      },
-      "engines": {
-        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
-      }
-    },
-    "node_modules/bs-logger": {
-      "version": "0.2.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-json-stable-stringify": "2.x"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/bser": {
-      "version": "2.1.1",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "node-int64": "^0.4.0"
-      }
-    },
-    "node_modules/buffer": {
-      "version": "6.0.3",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "base64-js": "^1.3.1",
-        "ieee754": "^1.2.1"
-      }
-    },
-    "node_modules/buffer-from": {
-      "version": "1.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/bytes": {
-      "version": "3.1.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/call-bind": {
-      "version": "1.0.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.1",
-        "get-intrinsic": "^1.0.2"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/camel-case": {
-      "version": "4.1.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "pascal-case": "^3.1.2",
-        "tslib": "^2.0.3"
-      }
-    },
-    "node_modules/camelcase": {
-      "version": "5.3.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/caniuse-lite": {
-      "version": "1.0.30001476",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "CC-BY-4.0"
-    },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/char-regex": {
-      "version": "1.0.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/chokidar": {
-      "version": "3.5.3",
-      "dev": true,
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://paulmillr.com/funding/"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "anymatch": "~3.1.2",
-        "braces": "~3.0.2",
-        "glob-parent": "~5.1.2",
-        "is-binary-path": "~2.1.0",
-        "is-glob": "~4.0.1",
-        "normalize-path": "~3.0.0",
-        "readdirp": "~3.6.0"
-      },
-      "engines": {
-        "node": ">= 8.10.0"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/chokidar/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/chrome-trace-event": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0"
-      }
-    },
-    "node_modules/ci-info": {
-      "version": "3.8.0",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/sibiraj-s"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/cjs-module-lexer": {
-      "version": "1.2.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/clean-css": {
-      "version": "5.3.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "source-map": "~0.6.0"
-      },
-      "engines": {
-        "node": ">= 10.0"
-      }
-    },
-    "node_modules/cliui": {
-      "version": "8.0.1",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.1",
-        "wrap-ansi": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clone-deep": {
-      "version": "4.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-plain-object": "^2.0.4",
-        "kind-of": "^6.0.2",
-        "shallow-clone": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/co": {
-      "version": "4.6.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "iojs": ">= 1.0.0",
-        "node": ">= 0.12.0"
-      }
-    },
-    "node_modules/collect-v8-coverage": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/colorette": {
-      "version": "2.0.20",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/comlink": {
-      "version": "4.4.1",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/commander": {
-      "version": "10.0.1",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14"
-      }
-    },
-    "node_modules/compressible": {
-      "version": "2.0.18",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": ">= 1.43.0 < 2"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/compression": {
-      "version": "1.7.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "accepts": "~1.3.5",
-        "bytes": "3.0.0",
-        "compressible": "~2.0.16",
-        "debug": "2.6.9",
-        "on-headers": "~1.0.2",
-        "safe-buffer": "5.1.2",
-        "vary": "~1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/compression/node_modules/bytes": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/compression/node_modules/debug": {
-      "version": "2.6.9",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/compression/node_modules/ms": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/compression/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/connect-history-api-fallback": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8"
-      }
-    },
-    "node_modules/content-disposition": {
-      "version": "0.5.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "5.2.1"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/content-type": {
-      "version": "1.0.5",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/convert-source-map": {
-      "version": "1.9.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cookie": {
-      "version": "0.5.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie-signature": {
-      "version": "1.0.6",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/copy-webpack-plugin": {
-      "version": "11.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-glob": "^3.2.11",
-        "glob-parent": "^6.0.1",
-        "globby": "^13.1.1",
-        "normalize-path": "^3.0.0",
-        "schema-utils": "^4.0.0",
-        "serialize-javascript": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 14.15.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^5.1.0"
-      }
-    },
-    "node_modules/copy-webpack-plugin/node_modules/globby": {
-      "version": "13.1.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.2.11",
-        "ignore": "^5.2.0",
-        "merge2": "^1.4.1",
-        "slash": "^4.0.0"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/copy-webpack-plugin/node_modules/slash": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/core-util-is": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/create-require": {
-      "version": "1.1.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cross-spawn": {
-      "version": "7.0.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/css-select": {
-      "version": "4.3.0",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0",
-        "css-what": "^6.0.1",
-        "domhandler": "^4.3.1",
-        "domutils": "^2.8.0",
-        "nth-check": "^2.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
-      }
-    },
-    "node_modules/css-what": {
-      "version": "6.1.0",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">= 6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.3.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.1.2"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/debug/node_modules/ms": {
-      "version": "2.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/dedent": {
-      "version": "0.7.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/deep-is": {
-      "version": "0.1.4",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/deepmerge": {
-      "version": "4.3.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/default-gateway": {
-      "version": "6.0.3",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "execa": "^5.0.0"
-      },
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/define-lazy-prop": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/depd": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/destroy": {
-      "version": "1.2.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8",
-        "npm": "1.2.8000 || >= 1.4.16"
-      }
-    },
-    "node_modules/detect-newline": {
-      "version": "3.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/detect-node": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/diff": {
-      "version": "4.0.2",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.3.1"
-      }
-    },
-    "node_modules/diff-sequences": {
-      "version": "29.4.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/dir-glob": {
-      "version": "3.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-type": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/dns-equal": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/dns-packet": {
-      "version": "5.6.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@leichtgewicht/ip-codec": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/doctrine": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "esutils": "^2.0.2"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/dom-converter": {
-      "version": "0.2.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "utila": "~0.4"
-      }
-    },
-    "node_modules/dom-serializer": {
-      "version": "1.4.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "domelementtype": "^2.0.1",
-        "domhandler": "^4.2.0",
-        "entities": "^2.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
-      }
-    },
-    "node_modules/domelementtype": {
-      "version": "2.3.0",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fb55"
-        }
-      ],
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/domhandler": {
-      "version": "4.3.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "domelementtype": "^2.2.0"
-      },
-      "engines": {
-        "node": ">= 4"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/domhandler?sponsor=1"
-      }
-    },
-    "node_modules/domutils": {
-      "version": "2.8.0",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "dom-serializer": "^1.0.1",
-        "domelementtype": "^2.2.0",
-        "domhandler": "^4.2.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/domutils?sponsor=1"
-      }
-    },
-    "node_modules/dot-case": {
-      "version": "3.0.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "no-case": "^3.0.4",
-        "tslib": "^2.0.3"
-      }
-    },
-    "node_modules/ee-first": {
-      "version": "1.1.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/electron-to-chromium": {
-      "version": "1.4.356",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/emittery": {
-      "version": "0.13.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sindresorhus/emittery?sponsor=1"
-      }
-    },
-    "node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/encodeurl": {
-      "version": "1.0.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/enhanced-resolve": {
-      "version": "5.14.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.2.4",
-        "tapable": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/entities": {
-      "version": "2.2.0",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
-    "node_modules/envinfo": {
-      "version": "7.8.1",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "envinfo": "dist/cli.js"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/error-ex": {
-      "version": "1.3.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-arrayish": "^0.2.1"
-      }
-    },
-    "node_modules/es-module-lexer": {
-      "version": "1.2.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/escalade": {
-      "version": "3.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/escape-html": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/eslint": {
-      "version": "8.38.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.4.0",
-        "@eslint/eslintrc": "^2.0.2",
-        "@eslint/js": "8.38.0",
-        "@humanwhocodes/config-array": "^0.11.8",
-        "@humanwhocodes/module-importer": "^1.0.1",
-        "@nodelib/fs.walk": "^1.2.8",
-        "ajv": "^6.10.0",
-        "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.2",
-        "debug": "^4.3.2",
-        "doctrine": "^3.0.0",
-        "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^7.1.1",
-        "eslint-visitor-keys": "^3.4.0",
-        "espree": "^9.5.1",
-        "esquery": "^1.4.2",
-        "esutils": "^2.0.2",
-        "fast-deep-equal": "^3.1.3",
-        "file-entry-cache": "^6.0.1",
-        "find-up": "^5.0.0",
-        "glob-parent": "^6.0.2",
-        "globals": "^13.19.0",
-        "grapheme-splitter": "^1.0.4",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.0.0",
-        "imurmurhash": "^0.1.4",
-        "is-glob": "^4.0.0",
-        "is-path-inside": "^3.0.3",
-        "js-sdsl": "^4.1.4",
-        "js-yaml": "^4.1.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "levn": "^0.4.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.9.1",
-        "strip-ansi": "^6.0.1",
-        "strip-json-comments": "^3.1.0",
-        "text-table": "^0.2.0"
-      },
-      "bin": {
-        "eslint": "bin/eslint.js"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint-config-prettier": {
-      "version": "8.8.0",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "eslint-config-prettier": "bin/cli.js"
-      },
-      "peerDependencies": {
-        "eslint": ">=7.0.0"
-      }
-    },
-    "node_modules/eslint-scope": {
-      "version": "5.1.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^4.1.1"
-      },
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/eslint-scope/node_modules/estraverse": {
-      "version": "4.3.0",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/eslint-visitor-keys": {
-      "version": "3.4.0",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint/node_modules/ajv": {
-      "version": "6.12.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/eslint/node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/eslint-scope": {
-      "version": "7.1.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      }
-    },
-    "node_modules/eslint/node_modules/find-up": {
-      "version": "5.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/locate-path": {
-      "version": "6.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/p-locate": {
-      "version": "5.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/espree": {
-      "version": "9.5.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "acorn": "^8.8.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^3.4.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/esprima": {
-      "version": "4.0.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "bin": {
-        "esparse": "bin/esparse.js",
-        "esvalidate": "bin/esvalidate.js"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/esquery": {
-      "version": "1.5.0",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "estraverse": "^5.1.0"
-      },
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
-    "node_modules/esrecurse": {
-      "version": "4.3.0",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/estraverse": {
-      "version": "5.3.0",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/etag": {
-      "version": "1.8.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/eventemitter3": {
-      "version": "4.0.7",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/events": {
-      "version": "3.3.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.x"
-      }
-    },
-    "node_modules/execa": {
-      "version": "5.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cross-spawn": "^7.0.3",
-        "get-stream": "^6.0.0",
-        "human-signals": "^2.1.0",
-        "is-stream": "^2.0.0",
-        "merge-stream": "^2.0.0",
-        "npm-run-path": "^4.0.1",
-        "onetime": "^5.1.2",
-        "signal-exit": "^3.0.3",
-        "strip-final-newline": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sindresorhus/execa?sponsor=1"
-      }
-    },
-    "node_modules/exit": {
-      "version": "0.1.2",
-      "dev": true,
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/expect": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/expect-utils": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "jest-matcher-utils": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/express": {
-      "version": "4.18.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "accepts": "~1.3.8",
-        "array-flatten": "1.1.1",
-        "body-parser": "1.20.1",
-        "content-disposition": "0.5.4",
-        "content-type": "~1.0.4",
-        "cookie": "0.5.0",
-        "cookie-signature": "1.0.6",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "finalhandler": "1.2.0",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
-        "merge-descriptors": "1.0.1",
-        "methods": "~1.1.2",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "path-to-regexp": "0.1.7",
-        "proxy-addr": "~2.0.7",
-        "qs": "6.11.0",
-        "range-parser": "~1.2.1",
-        "safe-buffer": "5.2.1",
-        "send": "0.18.0",
-        "serve-static": "1.15.0",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "type-is": "~1.6.18",
-        "utils-merge": "1.0.1",
-        "vary": "~1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.10.0"
-      }
-    },
-    "node_modules/express/node_modules/array-flatten": {
-      "version": "1.1.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/express/node_modules/debug": {
-      "version": "2.6.9",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/express/node_modules/ms": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-glob": {
-      "version": "3.2.12",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.4"
-      },
-      "engines": {
-        "node": ">=8.6.0"
-      }
-    },
-    "node_modules/fast-glob/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/fast-json-stable-stringify": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-levenshtein": {
-      "version": "2.0.6",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fastest-levenshtein": {
-      "version": "1.0.16",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4.9.1"
-      }
-    },
-    "node_modules/fastq": {
-      "version": "1.15.0",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "reusify": "^1.0.4"
-      }
-    },
-    "node_modules/faye-websocket": {
-      "version": "0.11.4",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "websocket-driver": ">=0.5.1"
-      },
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/fb-watchman": {
-      "version": "2.0.2",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "bser": "2.1.1"
-      }
-    },
-    "node_modules/file-entry-cache": {
-      "version": "6.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flat-cache": "^3.0.4"
-      },
-      "engines": {
-        "node": "^10.12.0 || >=12.0.0"
-      }
-    },
-    "node_modules/file-uri-to-path": {
-      "version": "1.0.0",
-      "license": "MIT"
-    },
-    "node_modules/fill-range": {
-      "version": "7.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/finalhandler": {
-      "version": "1.2.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "2.6.9",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "statuses": "2.0.1",
-        "unpipe": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/finalhandler/node_modules/debug": {
-      "version": "2.6.9",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/finalhandler/node_modules/ms": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/find-up": {
-      "version": "4.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^5.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/flat-cache": {
-      "version": "3.0.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flatted": "^3.1.0",
-        "rimraf": "^3.0.2"
-      },
-      "engines": {
-        "node": "^10.12.0 || >=12.0.0"
-      }
-    },
-    "node_modules/flatted": {
-      "version": "3.2.7",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/follow-redirects": {
-      "version": "1.15.2",
-      "dev": true,
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/RubenVerborgh"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=4.0"
-      },
-      "peerDependenciesMeta": {
-        "debug": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/forwarded": {
-      "version": "0.2.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/fresh": {
-      "version": "0.5.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/fs-monkey": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "Unlicense"
-    },
-    "node_modules/fs.realpath": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/function-bind": {
-      "version": "1.1.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/gensync": {
-      "version": "1.0.0-beta.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/get-caller-file": {
-      "version": "2.0.5",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "6.* || 8.* || >= 10.*"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.2.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.1",
-        "has": "^1.0.3",
-        "has-symbols": "^1.0.3"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-package-type": {
-      "version": "0.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/get-stream": {
-      "version": "6.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/glob": {
-      "version": "7.2.3",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.1.1",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      },
-      "engines": {
-        "node": "*"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/glob-parent": {
-      "version": "6.0.2",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.3"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/glob-to-regexp": {
-      "version": "0.4.1",
-      "dev": true,
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/globals": {
-      "version": "13.20.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "type-fest": "^0.20.2"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/globby": {
-      "version": "11.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-union": "^2.1.0",
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.2.9",
-        "ignore": "^5.2.0",
-        "merge2": "^1.4.1",
-        "slash": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/graceful-fs": {
-      "version": "4.2.11",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/grapheme-splitter": {
-      "version": "1.0.4",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/handle-thing": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/has": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4.0"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/has-symbols": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/he": {
-      "version": "1.2.0",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "he": "bin/he"
-      }
-    },
-    "node_modules/hpack.js": {
-      "version": "2.1.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "inherits": "^2.0.1",
-        "obuf": "^1.0.0",
-        "readable-stream": "^2.0.1",
-        "wbuf": "^1.1.0"
-      }
-    },
-    "node_modules/hpack.js/node_modules/readable-stream": {
-      "version": "2.3.8",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      }
-    },
-    "node_modules/hpack.js/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/hpack.js/node_modules/string_decoder": {
-      "version": "1.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "~5.1.0"
-      }
-    },
-    "node_modules/html-entities": {
-      "version": "2.3.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/html-escaper": {
-      "version": "2.0.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/html-minifier-terser": {
-      "version": "6.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "camel-case": "^4.1.2",
-        "clean-css": "^5.2.2",
-        "commander": "^8.3.0",
-        "he": "^1.2.0",
-        "param-case": "^3.0.4",
-        "relateurl": "^0.2.7",
-        "terser": "^5.10.0"
-      },
-      "bin": {
-        "html-minifier-terser": "cli.js"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/html-minifier-terser/node_modules/commander": {
-      "version": "8.3.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12"
-      }
-    },
-    "node_modules/html-webpack-plugin": {
-      "version": "5.5.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/html-minifier-terser": "^6.0.0",
-        "html-minifier-terser": "^6.0.2",
-        "lodash": "^4.17.21",
-        "pretty-error": "^4.0.0",
-        "tapable": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/html-webpack-plugin"
-      },
-      "peerDependencies": {
-        "webpack": "^5.20.0"
-      }
-    },
-    "node_modules/htmlparser2": {
-      "version": "6.1.0",
-      "dev": true,
-      "funding": [
-        "https://github.com/fb55/htmlparser2?sponsor=1",
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fb55"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "domelementtype": "^2.0.1",
-        "domhandler": "^4.0.0",
-        "domutils": "^2.5.2",
-        "entities": "^2.0.0"
-      }
-    },
-    "node_modules/http-deceiver": {
-      "version": "1.2.7",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/http-errors": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "depd": "2.0.0",
-        "inherits": "2.0.4",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "toidentifier": "1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/http-parser-js": {
-      "version": "0.5.8",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/http-proxy": {
-      "version": "1.18.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eventemitter3": "^4.0.0",
-        "follow-redirects": "^1.0.0",
-        "requires-port": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/http-proxy-middleware": {
-      "version": "2.0.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/http-proxy": "^1.17.8",
-        "http-proxy": "^1.18.1",
-        "is-glob": "^4.0.1",
-        "is-plain-obj": "^3.0.0",
-        "micromatch": "^4.0.2"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "@types/express": "^4.17.13"
-      },
-      "peerDependenciesMeta": {
-        "@types/express": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/human-signals": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=10.17.0"
-      }
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.4.24",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/idb-keyval": {
-      "version": "6.2.1",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/ieee754": {
-      "version": "1.2.1",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/ignore": {
-      "version": "5.2.4",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/import-fresh": {
-      "version": "3.3.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/import-fresh/node_modules/resolve-from": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/import-local": {
-      "version": "3.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "pkg-dir": "^4.2.0",
-        "resolve-cwd": "^3.0.0"
-      },
-      "bin": {
-        "import-local-fixture": "fixtures/cli.js"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
-      }
-    },
-    "node_modules/inflight": {
-      "version": "1.0.6",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/interpret": {
-      "version": "3.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/ipaddr.js": {
-      "version": "1.9.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/is-arrayish": {
-      "version": "0.2.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/is-binary-path": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "binary-extensions": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-core-module": {
-      "version": "2.11.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has": "^1.0.3"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-docker": {
-      "version": "2.2.1",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "is-docker": "cli.js"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-generator-fn": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/is-path-inside": {
-      "version": "3.0.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-plain-obj": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-plain-object": {
-      "version": "2.0.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "isobject": "^3.0.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-stream": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-wsl": {
-      "version": "2.2.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-docker": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/isarray": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/isobject": {
-      "version": "3.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/istanbul-lib-coverage": {
-      "version": "3.2.0",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/istanbul-lib-instrument": {
-      "version": "5.2.1",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "@babel/core": "^7.12.3",
-        "@babel/parser": "^7.14.7",
-        "@istanbuljs/schema": "^0.1.2",
-        "istanbul-lib-coverage": "^3.2.0",
-        "semver": "^6.3.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/istanbul-lib-instrument/node_modules/semver": {
-      "version": "6.3.0",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/istanbul-lib-report": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "istanbul-lib-coverage": "^3.0.0",
-        "make-dir": "^3.0.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/istanbul-lib-source-maps": {
-      "version": "4.0.1",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "debug": "^4.1.1",
-        "istanbul-lib-coverage": "^3.0.0",
-        "source-map": "^0.6.1"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/istanbul-reports": {
-      "version": "3.1.5",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "html-escaper": "^2.0.0",
-        "istanbul-lib-report": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/core": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "import-local": "^3.0.2",
-        "jest-cli": "^29.5.0"
-      },
-      "bin": {
-        "jest": "bin/jest.js"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
-      },
-      "peerDependenciesMeta": {
-        "node-notifier": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/jest-changed-files": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "execa": "^5.0.0",
-        "p-limit": "^3.1.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-circus": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/environment": "^29.5.0",
-        "@jest/expect": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "co": "^4.6.0",
-        "dedent": "^0.7.0",
-        "is-generator-fn": "^2.0.0",
-        "jest-each": "^29.5.0",
-        "jest-matcher-utils": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-runtime": "^29.5.0",
-        "jest-snapshot": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "p-limit": "^3.1.0",
-        "pretty-format": "^29.5.0",
-        "pure-rand": "^6.0.0",
-        "slash": "^3.0.0",
-        "stack-utils": "^2.0.3"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-cli": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/core": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "chalk": "^4.0.0",
-        "exit": "^0.1.2",
-        "graceful-fs": "^4.2.9",
-        "import-local": "^3.0.2",
-        "jest-config": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "prompts": "^2.0.1",
-        "yargs": "^17.3.1"
-      },
-      "bin": {
-        "jest": "bin/jest.js"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
-      },
-      "peerDependenciesMeta": {
-        "node-notifier": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/jest-config": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/core": "^7.11.6",
-        "@jest/test-sequencer": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "babel-jest": "^29.5.0",
-        "chalk": "^4.0.0",
-        "ci-info": "^3.2.0",
-        "deepmerge": "^4.2.2",
-        "glob": "^7.1.3",
-        "graceful-fs": "^4.2.9",
-        "jest-circus": "^29.5.0",
-        "jest-environment-node": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "jest-regex-util": "^29.4.3",
-        "jest-resolve": "^29.5.0",
-        "jest-runner": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "parse-json": "^5.2.0",
-        "pretty-format": "^29.5.0",
-        "slash": "^3.0.0",
-        "strip-json-comments": "^3.1.1"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "@types/node": "*",
-        "ts-node": ">=9.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "ts-node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/jest-diff": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^4.0.0",
-        "diff-sequences": "^29.4.3",
-        "jest-get-type": "^29.4.3",
-        "pretty-format": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-docblock": {
-      "version": "29.4.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "detect-newline": "^3.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-each": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "^29.5.0",
-        "chalk": "^4.0.0",
-        "jest-get-type": "^29.4.3",
-        "jest-util": "^29.5.0",
-        "pretty-format": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-environment-node": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/environment": "^29.5.0",
-        "@jest/fake-timers": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "jest-mock": "^29.5.0",
-        "jest-util": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-get-type": {
-      "version": "29.4.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-haste-map": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "^29.5.0",
-        "@types/graceful-fs": "^4.1.3",
-        "@types/node": "*",
-        "anymatch": "^3.0.3",
-        "fb-watchman": "^2.0.0",
-        "graceful-fs": "^4.2.9",
-        "jest-regex-util": "^29.4.3",
-        "jest-util": "^29.5.0",
-        "jest-worker": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "walker": "^1.0.8"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "optionalDependencies": {
-        "fsevents": "^2.3.2"
-      }
-    },
-    "node_modules/jest-leak-detector": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "jest-get-type": "^29.4.3",
-        "pretty-format": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-matcher-utils": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^4.0.0",
-        "jest-diff": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "pretty-format": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-message-util": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.12.13",
-        "@jest/types": "^29.5.0",
-        "@types/stack-utils": "^2.0.0",
-        "chalk": "^4.0.0",
-        "graceful-fs": "^4.2.9",
-        "micromatch": "^4.0.4",
-        "pretty-format": "^29.5.0",
-        "slash": "^3.0.0",
-        "stack-utils": "^2.0.3"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-mock": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "jest-util": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-pnp-resolver": {
-      "version": "1.2.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      },
-      "peerDependencies": {
-        "jest-resolve": "*"
-      },
-      "peerDependenciesMeta": {
-        "jest-resolve": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/jest-regex-util": {
-      "version": "29.4.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-resolve": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^4.0.0",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "jest-pnp-resolver": "^1.2.2",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "resolve": "^1.20.0",
-        "resolve.exports": "^2.0.0",
-        "slash": "^3.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-resolve-dependencies": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "jest-regex-util": "^29.4.3",
-        "jest-snapshot": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-runner": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/console": "^29.5.0",
-        "@jest/environment": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "emittery": "^0.13.1",
-        "graceful-fs": "^4.2.9",
-        "jest-docblock": "^29.4.3",
-        "jest-environment-node": "^29.5.0",
-        "jest-haste-map": "^29.5.0",
-        "jest-leak-detector": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-resolve": "^29.5.0",
-        "jest-runtime": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-watcher": "^29.5.0",
-        "jest-worker": "^29.5.0",
-        "p-limit": "^3.1.0",
-        "source-map-support": "0.5.13"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-runner/node_modules/source-map-support": {
-      "version": "0.5.13",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "buffer-from": "^1.0.0",
-        "source-map": "^0.6.0"
-      }
-    },
-    "node_modules/jest-runtime": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/environment": "^29.5.0",
-        "@jest/fake-timers": "^29.5.0",
-        "@jest/globals": "^29.5.0",
-        "@jest/source-map": "^29.4.3",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "cjs-module-lexer": "^1.0.0",
-        "collect-v8-coverage": "^1.0.0",
-        "glob": "^7.1.3",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-mock": "^29.5.0",
-        "jest-regex-util": "^29.4.3",
-        "jest-resolve": "^29.5.0",
-        "jest-snapshot": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "slash": "^3.0.0",
-        "strip-bom": "^4.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-snapshot": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/core": "^7.11.6",
-        "@babel/generator": "^7.7.2",
-        "@babel/plugin-syntax-jsx": "^7.7.2",
-        "@babel/plugin-syntax-typescript": "^7.7.2",
-        "@babel/traverse": "^7.7.2",
-        "@babel/types": "^7.3.3",
-        "@jest/expect-utils": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/babel__traverse": "^7.0.6",
-        "@types/prettier": "^2.1.5",
-        "babel-preset-current-node-syntax": "^1.0.0",
-        "chalk": "^4.0.0",
-        "expect": "^29.5.0",
-        "graceful-fs": "^4.2.9",
-        "jest-diff": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "jest-matcher-utils": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "natural-compare": "^1.4.0",
-        "pretty-format": "^29.5.0",
-        "semver": "^7.3.5"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-util": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "ci-info": "^3.2.0",
-        "graceful-fs": "^4.2.9",
-        "picomatch": "^2.2.3"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-validate": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "^29.5.0",
-        "camelcase": "^6.2.0",
-        "chalk": "^4.0.0",
-        "jest-get-type": "^29.4.3",
-        "leven": "^3.1.0",
-        "pretty-format": "^29.5.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-validate/node_modules/camelcase": {
-      "version": "6.3.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/jest-watcher": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/test-result": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.0.0",
-        "emittery": "^0.13.1",
-        "jest-util": "^29.5.0",
-        "string-length": "^4.0.1"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-worker": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "jest-util": "^29.5.0",
-        "merge-stream": "^2.0.0",
-        "supports-color": "^8.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/jest-worker/node_modules/supports-color": {
-      "version": "8.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/supports-color?sponsor=1"
-      }
-    },
-    "node_modules/js-sdsl": {
-      "version": "4.4.0",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/js-sdsl"
-      }
-    },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/js-yaml/node_modules/argparse": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "Python-2.0"
-    },
-    "node_modules/jsesc": {
-      "version": "2.5.2",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/json-parse-even-better-errors": {
-      "version": "2.3.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/kind-of": {
-      "version": "6.0.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/kleur": {
-      "version": "3.0.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/launch-editor": {
-      "version": "2.6.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "picocolors": "^1.0.0",
-        "shell-quote": "^1.7.3"
-      }
-    },
-    "node_modules/leven": {
-      "version": "3.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/levn": {
-      "version": "0.4.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/lines-and-columns": {
-      "version": "1.2.4",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/loader-runner": {
-      "version": "4.3.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.11.5"
-      }
-    },
-    "node_modules/locate-path": {
-      "version": "5.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^4.1.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lodash.memoize": {
-      "version": "4.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/lower-case": {
-      "version": "2.0.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.0.3"
-      }
-    },
-    "node_modules/lru-cache": {
-      "version": "6.0.0",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "yallist": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/make-dir": {
-      "version": "3.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "semver": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/make-dir/node_modules/semver": {
-      "version": "6.3.0",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/make-error": {
-      "version": "1.3.6",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/makeerror": {
-      "version": "1.0.12",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "tmpl": "1.0.5"
-      }
-    },
-    "node_modules/media-typer": {
-      "version": "0.3.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/memfs": {
-      "version": "3.5.1",
-      "dev": true,
-      "license": "Unlicense",
-      "dependencies": {
-        "fs-monkey": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 4.0.0"
-      }
-    },
-    "node_modules/merge-descriptors": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/merge-stream": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/methods": {
-      "version": "1.1.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/micromatch": {
-      "version": "4.0.5",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "braces": "^3.0.2",
-        "picomatch": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=8.6"
-      }
-    },
-    "node_modules/mime": {
-      "version": "1.6.0",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "mime": "cli.js"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/mime-db": {
-      "version": "1.52.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mime-types": {
-      "version": "2.1.35",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": "1.52.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mimic-fn": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/minimalistic-assert": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/minimatch": {
-      "version": "3.1.2",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/multicast-dns": {
-      "version": "7.2.5",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dns-packet": "^5.2.2",
-        "thunky": "^1.0.2"
-      },
-      "bin": {
-        "multicast-dns": "cli.js"
-      }
-    },
-    "node_modules/natural-compare": {
-      "version": "1.4.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/natural-compare-lite": {
-      "version": "1.4.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/negotiator": {
-      "version": "0.6.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/neo-async": {
-      "version": "2.6.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/no-case": {
-      "version": "3.0.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "lower-case": "^2.0.2",
-        "tslib": "^2.0.3"
-      }
-    },
-    "node_modules/node-forge": {
-      "version": "1.3.1",
-      "dev": true,
-      "license": "(BSD-3-Clause OR GPL-2.0)",
-      "engines": {
-        "node": ">= 6.13.0"
-      }
-    },
-    "node_modules/node-int64": {
-      "version": "0.4.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/node-releases": {
-      "version": "2.0.10",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/normalize-path": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/npm-run-path": {
-      "version": "4.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/nth-check": {
-      "version": "2.1.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/nth-check?sponsor=1"
-      }
-    },
-    "node_modules/object-inspect": {
-      "version": "1.12.3",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/obuf": {
-      "version": "1.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/on-finished": {
-      "version": "2.4.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ee-first": "1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/on-headers": {
-      "version": "1.0.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/onetime": {
-      "version": "5.1.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mimic-fn": "^2.1.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/open": {
-      "version": "8.4.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-lazy-prop": "^2.0.0",
-        "is-docker": "^2.1.1",
-        "is-wsl": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/optionator": {
-      "version": "0.9.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "deep-is": "^0.1.3",
-        "fast-levenshtein": "^2.0.6",
-        "levn": "^0.4.1",
-        "prelude-ls": "^1.2.1",
-        "type-check": "^0.4.0",
-        "word-wrap": "^1.2.3"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/p-limit": {
-      "version": "3.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "yocto-queue": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/p-locate": {
-      "version": "4.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/p-locate/node_modules/p-limit": {
-      "version": "2.3.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-try": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/p-retry": {
-      "version": "4.6.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/retry": "0.12.0",
-        "retry": "^0.13.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/p-retry/node_modules/retry": {
-      "version": "0.13.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/p-try": {
-      "version": "2.2.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/param-case": {
-      "version": "3.0.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dot-case": "^3.0.4",
-        "tslib": "^2.0.3"
-      }
-    },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "callsites": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/parse-json": {
-      "version": "5.2.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.0.0",
-        "error-ex": "^1.3.1",
-        "json-parse-even-better-errors": "^2.3.0",
-        "lines-and-columns": "^1.1.6"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/parseurl": {
-      "version": "1.3.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/pascal-case": {
-      "version": "3.1.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "no-case": "^3.0.4",
-        "tslib": "^2.0.3"
-      }
-    },
-    "node_modules/path-exists": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-is-absolute": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-parse": {
-      "version": "1.0.7",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/path-to-regexp": {
-      "version": "0.1.7",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/path-type": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/picocolors": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/picomatch": {
-      "version": "2.3.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/pirates": {
-      "version": "4.0.5",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/pkg-dir": {
-      "version": "4.2.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "find-up": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/prelude-ls": {
-      "version": "1.2.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/prettier": {
-      "version": "2.8.7",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "prettier": "bin-prettier.js"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      },
-      "funding": {
-        "url": "https://github.com/prettier/prettier?sponsor=1"
-      }
-    },
-    "node_modules/pretty-error": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "lodash": "^4.17.20",
-        "renderkid": "^3.0.0"
-      }
-    },
-    "node_modules/pretty-format": {
-      "version": "29.5.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/schemas": "^29.4.3",
-        "ansi-styles": "^5.0.0",
-        "react-is": "^18.0.0"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/pretty-format/node_modules/ansi-styles": {
-      "version": "5.2.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/process-nextick-args": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/prompts": {
-      "version": "2.4.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "kleur": "^3.0.3",
-        "sisteransi": "^1.0.5"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/proxy-addr": {
-      "version": "2.0.7",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "forwarded": "0.2.0",
-        "ipaddr.js": "1.9.1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/punycode": {
-      "version": "2.3.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/pure-rand": {
-      "version": "6.0.1",
-      "dev": true,
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/dubzzz"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fast-check"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/qs": {
-      "version": "6.11.0",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "side-channel": "^1.0.4"
-      },
-      "engines": {
-        "node": ">=0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/queue-microtask": {
-      "version": "1.2.3",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/randombytes": {
-      "version": "2.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "^5.1.0"
-      }
-    },
-    "node_modules/range-parser": {
-      "version": "1.2.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/raw-body": {
-      "version": "2.5.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "3.1.2",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "unpipe": "1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/react-is": {
-      "version": "18.2.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/readable-stream": {
-      "version": "3.6.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "inherits": "^2.0.3",
-        "string_decoder": "^1.1.1",
-        "util-deprecate": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/readdirp": {
-      "version": "3.6.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "picomatch": "^2.2.1"
-      },
-      "engines": {
-        "node": ">=8.10.0"
-      }
-    },
-    "node_modules/rechoir": {
-      "version": "0.8.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "resolve": "^1.20.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/relateurl": {
-      "version": "0.2.7",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/renderkid": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "css-select": "^4.1.3",
-        "dom-converter": "^0.2.0",
-        "htmlparser2": "^6.1.0",
-        "lodash": "^4.17.21",
-        "strip-ansi": "^6.0.1"
-      }
-    },
-    "node_modules/require-directory": {
-      "version": "2.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/require-from-string": {
-      "version": "2.0.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/requires-port": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/resolve": {
-      "version": "1.22.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-core-module": "^2.11.0",
-        "path-parse": "^1.0.7",
-        "supports-preserve-symlinks-flag": "^1.0.0"
-      },
-      "bin": {
-        "resolve": "bin/resolve"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/resolve-cwd": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "resolve-from": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/resolve-from": {
-      "version": "5.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/resolve-typescript-plugin": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "tslib": "2.5.0"
-      },
-      "engines": {
-        "node": "^14 || ^16 || >=18"
-      },
-      "peerDependencies": {
-        "webpack": "^4.0.0 || ^5.0.0"
-      }
-    },
-    "node_modules/resolve.exports": {
-      "version": "2.0.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/reusify": {
-      "version": "1.0.4",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "iojs": ">=1.0.0",
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/rimraf": {
-      "version": "3.0.2",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "glob": "^7.1.3"
-      },
-      "bin": {
-        "rimraf": "bin.js"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/run-parallel": {
-      "version": "1.2.0",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "queue-microtask": "^1.2.2"
-      }
-    },
-    "node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/schema-utils": {
-      "version": "4.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/json-schema": "^7.0.9",
-        "ajv": "^8.9.0",
-        "ajv-formats": "^2.1.1",
-        "ajv-keywords": "^5.1.0"
-      },
-      "engines": {
-        "node": ">= 12.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      }
-    },
-    "node_modules/select-hose": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/selfsigned": {
-      "version": "2.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "node-forge": "^1"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/semver": {
-      "version": "7.3.8",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "lru-cache": "^6.0.0"
-      },
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/send": {
-      "version": "0.18.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
-        "mime": "1.6.0",
-        "ms": "2.1.3",
-        "on-finished": "2.4.1",
-        "range-parser": "~1.2.1",
-        "statuses": "2.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/send/node_modules/debug": {
-      "version": "2.6.9",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/send/node_modules/debug/node_modules/ms": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/serialize-javascript": {
-      "version": "6.0.1",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "randombytes": "^2.1.0"
-      }
-    },
-    "node_modules/serve-index": {
-      "version": "1.9.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "accepts": "~1.3.4",
-        "batch": "0.6.1",
-        "debug": "2.6.9",
-        "escape-html": "~1.0.3",
-        "http-errors": "~1.6.2",
-        "mime-types": "~2.1.17",
-        "parseurl": "~1.3.2"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/serve-index/node_modules/debug": {
-      "version": "2.6.9",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/serve-index/node_modules/depd": {
-      "version": "1.1.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/serve-index/node_modules/http-errors": {
-      "version": "1.6.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "depd": "~1.1.2",
-        "inherits": "2.0.3",
-        "setprototypeof": "1.1.0",
-        "statuses": ">= 1.4.0 < 2"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/serve-index/node_modules/inherits": {
-      "version": "2.0.3",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/serve-index/node_modules/ms": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/serve-index/node_modules/setprototypeof": {
-      "version": "1.1.0",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/serve-index/node_modules/statuses": {
-      "version": "1.5.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/serve-static": {
-      "version": "1.15.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "parseurl": "~1.3.3",
-        "send": "0.18.0"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/setprototypeof": {
-      "version": "1.2.0",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/shallow-clone": {
-      "version": "3.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "kind-of": "^6.0.2"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "shebang-regex": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shell-quote": {
-      "version": "1.8.1",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel": {
-      "version": "1.0.4",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.0",
-        "get-intrinsic": "^1.0.2",
-        "object-inspect": "^1.9.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/signal-exit": {
-      "version": "3.0.7",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/sisteransi": {
-      "version": "1.0.5",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/slash": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/sockjs": {
-      "version": "0.3.24",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "faye-websocket": "^0.11.3",
-        "uuid": "^8.3.2",
-        "websocket-driver": "^0.7.4"
-      }
-    },
-    "node_modules/source-map": {
-      "version": "0.6.1",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/source-map-support": {
-      "version": "0.5.21",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "buffer-from": "^1.0.0",
-        "source-map": "^0.6.0"
-      }
-    },
-    "node_modules/spdy": {
-      "version": "4.0.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.1.0",
-        "handle-thing": "^2.0.0",
-        "http-deceiver": "^1.2.7",
-        "select-hose": "^2.0.0",
-        "spdy-transport": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/spdy-transport": {
-      "version": "3.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.1.0",
-        "detect-node": "^2.0.4",
-        "hpack.js": "^2.1.6",
-        "obuf": "^1.1.2",
-        "readable-stream": "^3.0.6",
-        "wbuf": "^1.7.3"
-      }
-    },
-    "node_modules/sprintf-js": {
-      "version": "1.0.3",
-      "dev": true,
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/stack-utils": {
-      "version": "2.0.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "escape-string-regexp": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/stack-utils/node_modules/escape-string-regexp": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/statuses": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/string_decoder": {
-      "version": "1.3.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "~5.2.0"
-      }
-    },
-    "node_modules/string-length": {
-      "version": "4.0.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "char-regex": "^1.0.2",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/string-width": {
-      "version": "4.2.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-bom": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-final-newline": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/supports-preserve-symlinks-flag": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/tapable": {
-      "version": "2.2.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/terser": {
-      "version": "5.17.3",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "@jridgewell/source-map": "^0.3.2",
-        "acorn": "^8.5.0",
-        "commander": "^2.20.0",
-        "source-map-support": "~0.5.20"
-      },
-      "bin": {
-        "terser": "bin/terser"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/terser-webpack-plugin": {
-      "version": "5.3.8",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/trace-mapping": "^0.3.17",
-        "jest-worker": "^27.4.5",
-        "schema-utils": "^3.1.1",
-        "serialize-javascript": "^6.0.1",
-        "terser": "^5.16.8"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^5.1.0"
-      },
-      "peerDependenciesMeta": {
-        "@swc/core": {
-          "optional": true
-        },
-        "esbuild": {
-          "optional": true
-        },
-        "uglify-js": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/terser-webpack-plugin/node_modules/ajv": {
-      "version": "6.12.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/terser-webpack-plugin/node_modules/ajv-keywords": {
-      "version": "3.5.2",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "ajv": "^6.9.1"
-      }
-    },
-    "node_modules/terser-webpack-plugin/node_modules/jest-worker": {
-      "version": "27.5.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "merge-stream": "^2.0.0",
-        "supports-color": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/terser-webpack-plugin/node_modules/schema-utils": {
-      "version": "3.1.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/json-schema": "^7.0.8",
-        "ajv": "^6.12.5",
-        "ajv-keywords": "^3.5.2"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      }
-    },
-    "node_modules/terser-webpack-plugin/node_modules/supports-color": {
-      "version": "8.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/supports-color?sponsor=1"
-      }
-    },
-    "node_modules/terser/node_modules/commander": {
-      "version": "2.20.3",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/test-exclude": {
-      "version": "6.0.0",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@istanbuljs/schema": "^0.1.2",
-        "glob": "^7.1.4",
-        "minimatch": "^3.0.4"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/text-table": {
-      "version": "0.2.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/thunky": {
-      "version": "1.1.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/tmpl": {
-      "version": "1.0.5",
-      "dev": true,
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/to-fast-properties": {
-      "version": "2.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
-    "node_modules/toidentifier": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.6"
-      }
-    },
-    "node_modules/ts-jest": {
-      "version": "29.1.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bs-logger": "0.x",
-        "fast-json-stable-stringify": "2.x",
-        "jest-util": "^29.0.0",
-        "json5": "^2.2.3",
-        "lodash.memoize": "4.x",
-        "make-error": "1.x",
-        "semver": "7.x",
-        "yargs-parser": "^21.0.1"
-      },
-      "bin": {
-        "ts-jest": "cli.js"
-      },
-      "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      },
-      "peerDependencies": {
-        "@babel/core": ">=7.0.0-beta.0 <8",
-        "@jest/types": "^29.0.0",
-        "babel-jest": "^29.0.0",
-        "jest": "^29.0.0",
-        "typescript": ">=4.3 <6"
-      },
-      "peerDependenciesMeta": {
-        "@babel/core": {
-          "optional": true
-        },
-        "@jest/types": {
-          "optional": true
-        },
-        "babel-jest": {
-          "optional": true
-        },
-        "esbuild": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/ts-loader": {
-      "version": "9.4.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^4.1.0",
-        "enhanced-resolve": "^5.0.0",
-        "micromatch": "^4.0.0",
-        "semver": "^7.3.4"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "typescript": "*",
-        "webpack": "^5.0.0"
-      }
-    },
-    "node_modules/ts-loader/node_modules/semver": {
-      "version": "7.5.0",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "lru-cache": "^6.0.0"
-      },
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/ts-node": {
-      "version": "10.9.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@cspotcode/source-map-support": "^0.8.0",
-        "@tsconfig/node10": "^1.0.7",
-        "@tsconfig/node12": "^1.0.7",
-        "@tsconfig/node14": "^1.0.0",
-        "@tsconfig/node16": "^1.0.2",
-        "acorn": "^8.4.1",
-        "acorn-walk": "^8.1.1",
-        "arg": "^4.1.0",
-        "create-require": "^1.1.0",
-        "diff": "^4.0.1",
-        "make-error": "^1.1.1",
-        "v8-compile-cache-lib": "^3.0.1",
-        "yn": "3.1.1"
-      },
-      "bin": {
-        "ts-node": "dist/bin.js",
-        "ts-node-cwd": "dist/bin-cwd.js",
-        "ts-node-esm": "dist/bin-esm.js",
-        "ts-node-script": "dist/bin-script.js",
-        "ts-node-transpile-only": "dist/bin-transpile.js",
-        "ts-script": "dist/bin-script-deprecated.js"
-      },
-      "peerDependencies": {
-        "@swc/core": ">=1.2.50",
-        "@swc/wasm": ">=1.2.50",
-        "@types/node": "*",
-        "typescript": ">=2.7"
-      },
-      "peerDependenciesMeta": {
-        "@swc/core": {
-          "optional": true
-        },
-        "@swc/wasm": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tslib": {
-      "version": "2.5.0",
-      "license": "0BSD"
-    },
-    "node_modules/tsutils": {
-      "version": "3.21.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^1.8.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      },
-      "peerDependencies": {
-        "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta"
-      }
-    },
-    "node_modules/tsutils/node_modules/tslib": {
-      "version": "1.14.1",
-      "dev": true,
-      "license": "0BSD"
-    },
-    "node_modules/type-check": {
-      "version": "0.4.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/type-detect": {
-      "version": "4.0.8",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/type-fest": {
-      "version": "0.20.2",
-      "dev": true,
-      "license": "(MIT OR CC0-1.0)",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/type-is": {
-      "version": "1.6.18",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "media-typer": "0.3.0",
-        "mime-types": "~2.1.24"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.0.4",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=12.20"
-      }
-    },
-    "node_modules/unpipe": {
-      "version": "1.0.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/update-browserslist-db": {
-      "version": "1.0.10",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "escalade": "^3.1.1",
-        "picocolors": "^1.0.0"
-      },
-      "bin": {
-        "browserslist-lint": "cli.js"
-      },
-      "peerDependencies": {
-        "browserslist": ">= 4.21.0"
-      }
-    },
-    "node_modules/uri-js": {
-      "version": "4.4.1",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "punycode": "^2.1.0"
-      }
-    },
-    "node_modules/util-deprecate": {
-      "version": "1.0.2",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/utila": {
-      "version": "0.4.0",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/utils-merge": {
-      "version": "1.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4.0"
-      }
-    },
-    "node_modules/uuid": {
-      "version": "8.3.2",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    },
-    "node_modules/v8-compile-cache-lib": {
-      "version": "3.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/v8-to-istanbul": {
-      "version": "9.1.0",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@jridgewell/trace-mapping": "^0.3.12",
-        "@types/istanbul-lib-coverage": "^2.0.1",
-        "convert-source-map": "^1.6.0"
-      },
-      "engines": {
-        "node": ">=10.12.0"
-      }
-    },
-    "node_modules/vary": {
-      "version": "1.1.2",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/walker": {
-      "version": "1.0.8",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "makeerror": "1.0.12"
-      }
-    },
-    "node_modules/watchpack": {
-      "version": "2.4.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.1.2"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/wbuf": {
-      "version": "1.7.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "minimalistic-assert": "^1.0.0"
-      }
-    },
-    "node_modules/webpack": {
-      "version": "5.82.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/eslint-scope": "^3.7.3",
-        "@types/estree": "^1.0.0",
-        "@webassemblyjs/ast": "^1.11.5",
-        "@webassemblyjs/wasm-edit": "^1.11.5",
-        "@webassemblyjs/wasm-parser": "^1.11.5",
-        "acorn": "^8.7.1",
-        "acorn-import-assertions": "^1.7.6",
-        "browserslist": "^4.14.5",
-        "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.14.0",
-        "es-module-lexer": "^1.2.1",
-        "eslint-scope": "5.1.1",
-        "events": "^3.2.0",
-        "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.2.9",
-        "json-parse-even-better-errors": "^2.3.1",
-        "loader-runner": "^4.2.0",
-        "mime-types": "^2.1.27",
-        "neo-async": "^2.6.2",
-        "schema-utils": "^3.1.2",
-        "tapable": "^2.1.1",
-        "terser-webpack-plugin": "^5.3.7",
-        "watchpack": "^2.4.0",
-        "webpack-sources": "^3.2.3"
-      },
-      "bin": {
-        "webpack": "bin/webpack.js"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependenciesMeta": {
-        "webpack-cli": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/webpack-cli": {
-      "version": "5.1.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@discoveryjs/json-ext": "^0.5.0",
-        "@webpack-cli/configtest": "^2.1.0",
-        "@webpack-cli/info": "^2.0.1",
-        "@webpack-cli/serve": "^2.0.4",
-        "colorette": "^2.0.14",
-        "commander": "^10.0.1",
-        "cross-spawn": "^7.0.3",
-        "envinfo": "^7.7.3",
-        "fastest-levenshtein": "^1.0.12",
-        "import-local": "^3.0.2",
-        "interpret": "^3.1.1",
-        "rechoir": "^0.8.0",
-        "webpack-merge": "^5.7.3"
-      },
-      "bin": {
-        "webpack-cli": "bin/cli.js"
-      },
-      "engines": {
-        "node": ">=14.15.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "5.x.x"
-      },
-      "peerDependenciesMeta": {
-        "@webpack-cli/generators": {
-          "optional": true
-        },
-        "webpack-bundle-analyzer": {
-          "optional": true
-        },
-        "webpack-dev-server": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/webpack-dev-middleware": {
-      "version": "5.3.3",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "colorette": "^2.0.10",
-        "memfs": "^3.4.3",
-        "mime-types": "^2.1.31",
-        "range-parser": "^1.2.1",
-        "schema-utils": "^4.0.0"
-      },
-      "engines": {
-        "node": ">= 12.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^4.0.0 || ^5.0.0"
-      }
-    },
-    "node_modules/webpack-dev-server": {
-      "version": "4.15.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/bonjour": "^3.5.9",
-        "@types/connect-history-api-fallback": "^1.3.5",
-        "@types/express": "^4.17.13",
-        "@types/serve-index": "^1.9.1",
-        "@types/serve-static": "^1.13.10",
-        "@types/sockjs": "^0.3.33",
-        "@types/ws": "^8.5.1",
-        "ansi-html-community": "^0.0.8",
-        "bonjour-service": "^1.0.11",
-        "chokidar": "^3.5.3",
-        "colorette": "^2.0.10",
-        "compression": "^1.7.4",
-        "connect-history-api-fallback": "^2.0.0",
-        "default-gateway": "^6.0.3",
-        "express": "^4.17.3",
-        "graceful-fs": "^4.2.6",
-        "html-entities": "^2.3.2",
-        "http-proxy-middleware": "^2.0.3",
-        "ipaddr.js": "^2.0.1",
-        "launch-editor": "^2.6.0",
-        "open": "^8.0.9",
-        "p-retry": "^4.5.0",
-        "rimraf": "^3.0.2",
-        "schema-utils": "^4.0.0",
-        "selfsigned": "^2.1.1",
-        "serve-index": "^1.9.1",
-        "sockjs": "^0.3.24",
-        "spdy": "^4.0.2",
-        "webpack-dev-middleware": "^5.3.1",
-        "ws": "^8.13.0"
-      },
-      "bin": {
-        "webpack-dev-server": "bin/webpack-dev-server.js"
-      },
-      "engines": {
-        "node": ">= 12.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^4.37.0 || ^5.0.0"
-      },
-      "peerDependenciesMeta": {
-        "webpack": {
-          "optional": true
-        },
-        "webpack-cli": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/webpack-dev-server/node_modules/ipaddr.js": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/webpack-merge": {
-      "version": "5.8.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "clone-deep": "^4.0.1",
-        "wildcard": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=10.0.0"
-      }
-    },
-    "node_modules/webpack-sources": {
-      "version": "3.2.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/webpack/node_modules/ajv": {
-      "version": "6.12.6",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/webpack/node_modules/ajv-keywords": {
-      "version": "3.5.2",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "ajv": "^6.9.1"
-      }
-    },
-    "node_modules/webpack/node_modules/schema-utils": {
-      "version": "3.1.2",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/json-schema": "^7.0.8",
-        "ajv": "^6.12.5",
-        "ajv-keywords": "^3.5.2"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      }
-    },
-    "node_modules/websocket-driver": {
-      "version": "0.7.4",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "http-parser-js": ">=0.5.1",
-        "safe-buffer": ">=5.1.0",
-        "websocket-extensions": ">=0.1.1"
-      },
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/websocket-extensions": {
-      "version": "0.1.4",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/wildcard": {
-      "version": "2.0.1",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/word-wrap": {
-      "version": "1.2.3",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/wrap-ansi": {
-      "version": "7.0.0",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/write-file-atomic": {
-      "version": "4.0.2",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "imurmurhash": "^0.1.4",
-        "signal-exit": "^3.0.7"
-      },
-      "engines": {
-        "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
-      }
-    },
-    "node_modules/ws": {
-      "version": "8.13.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/y18n": {
-      "version": "5.0.8",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/yallist": {
-      "version": "4.0.0",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/yargs": {
-      "version": "17.7.1",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cliui": "^8.0.1",
-        "escalade": "^3.1.1",
-        "get-caller-file": "^2.0.5",
-        "require-directory": "^2.1.1",
-        "string-width": "^4.2.3",
-        "y18n": "^5.0.5",
-        "yargs-parser": "^21.1.1"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/yargs-parser": {
-      "version": "21.1.1",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/yn": {
-      "version": "3.1.1",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    }
-  },
-  "dependencies": {
-    "@ampproject/remapping": {
-      "version": "2.2.1",
-      "dev": true,
-      "requires": {
-        "@jridgewell/gen-mapping": "^0.3.0",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      }
-    },
-    "@babel/code-frame": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/highlight": "^7.18.6"
-      }
-    },
-    "@babel/compat-data": {
-      "version": "7.21.4",
-      "dev": true
-    },
-    "@babel/core": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@ampproject/remapping": "^2.2.0",
-        "@babel/code-frame": "^7.21.4",
-        "@babel/generator": "^7.21.4",
-        "@babel/helper-compilation-targets": "^7.21.4",
-        "@babel/helper-module-transforms": "^7.21.2",
-        "@babel/helpers": "^7.21.0",
-        "@babel/parser": "^7.21.4",
-        "@babel/template": "^7.20.7",
-        "@babel/traverse": "^7.21.4",
-        "@babel/types": "^7.21.4",
-        "convert-source-map": "^1.7.0",
-        "debug": "^4.1.0",
-        "gensync": "^1.0.0-beta.2",
-        "json5": "^2.2.2",
-        "semver": "^6.3.0"
-      },
-      "dependencies": {
-        "semver": {
-          "version": "6.3.0",
-          "dev": true
-        }
-      }
-    },
-    "@babel/generator": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.21.4",
-        "@jridgewell/gen-mapping": "^0.3.2",
-        "@jridgewell/trace-mapping": "^0.3.17",
-        "jsesc": "^2.5.1"
-      }
-    },
-    "@babel/helper-compilation-targets": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/compat-data": "^7.21.4",
-        "@babel/helper-validator-option": "^7.21.0",
-        "browserslist": "^4.21.3",
-        "lru-cache": "^5.1.1",
-        "semver": "^6.3.0"
-      },
-      "dependencies": {
-        "lru-cache": {
-          "version": "5.1.1",
-          "dev": true,
-          "requires": {
-            "yallist": "^3.0.2"
-          }
-        },
-        "semver": {
-          "version": "6.3.0",
-          "dev": true
-        },
-        "yallist": {
-          "version": "3.1.1",
-          "dev": true
-        }
-      }
-    },
-    "@babel/helper-environment-visitor": {
-      "version": "7.18.9",
-      "dev": true
-    },
-    "@babel/helper-function-name": {
-      "version": "7.21.0",
-      "dev": true,
-      "requires": {
-        "@babel/template": "^7.20.7",
-        "@babel/types": "^7.21.0"
-      }
-    },
-    "@babel/helper-hoist-variables": {
-      "version": "7.18.6",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.18.6"
-      }
-    },
-    "@babel/helper-module-imports": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.21.4"
-      }
-    },
-    "@babel/helper-module-transforms": {
-      "version": "7.21.2",
-      "dev": true,
-      "requires": {
-        "@babel/helper-environment-visitor": "^7.18.9",
-        "@babel/helper-module-imports": "^7.18.6",
-        "@babel/helper-simple-access": "^7.20.2",
-        "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/helper-validator-identifier": "^7.19.1",
-        "@babel/template": "^7.20.7",
-        "@babel/traverse": "^7.21.2",
-        "@babel/types": "^7.21.2"
-      }
-    },
-    "@babel/helper-plugin-utils": {
-      "version": "7.20.2",
-      "dev": true
-    },
-    "@babel/helper-simple-access": {
-      "version": "7.20.2",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.20.2"
-      }
-    },
-    "@babel/helper-split-export-declaration": {
-      "version": "7.18.6",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.18.6"
-      }
-    },
-    "@babel/helper-string-parser": {
-      "version": "7.19.4",
-      "dev": true
-    },
-    "@babel/helper-validator-identifier": {
-      "version": "7.19.1",
-      "dev": true
-    },
-    "@babel/helper-validator-option": {
-      "version": "7.21.0",
-      "dev": true
-    },
-    "@babel/helpers": {
-      "version": "7.21.0",
-      "dev": true,
-      "requires": {
-        "@babel/template": "^7.20.7",
-        "@babel/traverse": "^7.21.0",
-        "@babel/types": "^7.21.0"
-      }
-    },
-    "@babel/highlight": {
-      "version": "7.18.6",
-      "dev": true,
-      "requires": {
-        "@babel/helper-validator-identifier": "^7.18.6",
-        "chalk": "^2.0.0",
-        "js-tokens": "^4.0.0"
-      },
-      "dependencies": {
-        "ansi-styles": {
-          "version": "3.2.1",
-          "dev": true,
-          "requires": {
-            "color-convert": "^1.9.0"
-          }
-        },
-        "chalk": {
-          "version": "2.4.2",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^3.2.1",
-            "escape-string-regexp": "^1.0.5",
-            "supports-color": "^5.3.0"
-          }
-        },
-        "color-convert": {
-          "version": "1.9.3",
-          "dev": true,
-          "requires": {
-            "color-name": "1.1.3"
-          }
-        },
-        "color-name": {
-          "version": "1.1.3",
-          "dev": true
-        },
-        "has-flag": {
-          "version": "3.0.0",
-          "dev": true
-        },
-        "supports-color": {
-          "version": "5.5.0",
-          "dev": true,
-          "requires": {
-            "has-flag": "^3.0.0"
-          }
-        }
-      }
-    },
-    "@babel/parser": {
-      "version": "7.21.4",
-      "dev": true
-    },
-    "@babel/plugin-syntax-async-generators": {
-      "version": "7.8.4",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      }
-    },
-    "@babel/plugin-syntax-bigint": {
-      "version": "7.8.3",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      }
-    },
-    "@babel/plugin-syntax-class-properties": {
-      "version": "7.12.13",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.12.13"
-      }
-    },
-    "@babel/plugin-syntax-import-meta": {
-      "version": "7.10.4",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.10.4"
-      }
-    },
-    "@babel/plugin-syntax-json-strings": {
-      "version": "7.8.3",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      }
-    },
-    "@babel/plugin-syntax-jsx": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.20.2"
-      }
-    },
-    "@babel/plugin-syntax-logical-assignment-operators": {
-      "version": "7.10.4",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.10.4"
-      }
-    },
-    "@babel/plugin-syntax-nullish-coalescing-operator": {
-      "version": "7.8.3",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      }
-    },
-    "@babel/plugin-syntax-numeric-separator": {
-      "version": "7.10.4",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.10.4"
-      }
-    },
-    "@babel/plugin-syntax-object-rest-spread": {
-      "version": "7.8.3",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      }
-    },
-    "@babel/plugin-syntax-optional-catch-binding": {
-      "version": "7.8.3",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      }
-    },
-    "@babel/plugin-syntax-optional-chaining": {
-      "version": "7.8.3",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.8.0"
-      }
-    },
-    "@babel/plugin-syntax-top-level-await": {
-      "version": "7.14.5",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.14.5"
-      }
-    },
-    "@babel/plugin-syntax-typescript": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.20.2"
-      }
-    },
-    "@babel/template": {
-      "version": "7.20.7",
-      "dev": true,
-      "requires": {
-        "@babel/code-frame": "^7.18.6",
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7"
-      }
-    },
-    "@babel/traverse": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/code-frame": "^7.21.4",
-        "@babel/generator": "^7.21.4",
-        "@babel/helper-environment-visitor": "^7.18.9",
-        "@babel/helper-function-name": "^7.21.0",
-        "@babel/helper-hoist-variables": "^7.18.6",
-        "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/parser": "^7.21.4",
-        "@babel/types": "^7.21.4",
-        "debug": "^4.1.0",
-        "globals": "^11.1.0"
-      },
-      "dependencies": {
-        "globals": {
-          "version": "11.12.0",
-          "dev": true
-        }
-      }
-    },
-    "@babel/types": {
-      "version": "7.21.4",
-      "dev": true,
-      "requires": {
-        "@babel/helper-string-parser": "^7.19.4",
-        "@babel/helper-validator-identifier": "^7.19.1",
-        "to-fast-properties": "^2.0.0"
-      }
-    },
-    "@bcoe/v8-coverage": {
-      "version": "0.2.3",
-      "dev": true
-    },
-    "@cspotcode/source-map-support": {
-      "version": "0.8.1",
-      "dev": true,
-      "requires": {
-        "@jridgewell/trace-mapping": "0.3.9"
-      },
-      "dependencies": {
-        "@jridgewell/resolve-uri": {
-          "version": "3.1.1",
-          "dev": true
-        },
-        "@jridgewell/trace-mapping": {
-          "version": "0.3.9",
-          "dev": true,
-          "requires": {
-            "@jridgewell/resolve-uri": "^3.0.3",
-            "@jridgewell/sourcemap-codec": "^1.4.10"
-          }
-        }
-      }
-    },
-    "@discoveryjs/json-ext": {
-      "version": "0.5.7",
-      "dev": true
-    },
-    "@eslint-community/eslint-utils": {
-      "version": "4.4.0",
-      "dev": true,
-      "requires": {
-        "eslint-visitor-keys": "^3.3.0"
-      }
-    },
-    "@eslint-community/regexpp": {
-      "version": "4.5.0",
-      "dev": true
-    },
-    "@eslint/eslintrc": {
-      "version": "2.0.2",
-      "dev": true,
-      "requires": {
-        "ajv": "^6.12.4",
-        "debug": "^4.3.2",
-        "espree": "^9.5.1",
-        "globals": "^13.19.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.0",
-        "minimatch": "^3.1.2",
-        "strip-json-comments": "^3.1.1"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "6.12.6",
-          "dev": true,
-          "requires": {
-            "fast-deep-equal": "^3.1.1",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.4.1",
-            "uri-js": "^4.2.2"
-          }
-        }
-      }
-    },
-    "@eslint/js": {
-      "version": "8.38.0",
-      "dev": true
-    },
-    "@humanwhocodes/config-array": {
-      "version": "0.11.8",
-      "dev": true,
-      "requires": {
-        "@humanwhocodes/object-schema": "^1.2.1",
-        "debug": "^4.1.1",
-        "minimatch": "^3.0.5"
-      }
-    },
-    "@humanwhocodes/module-importer": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "@humanwhocodes/object-schema": {
-      "version": "1.2.1",
-      "dev": true
-    },
-    "@istanbuljs/load-nyc-config": {
-      "version": "1.1.0",
-      "dev": true,
-      "requires": {
-        "camelcase": "^5.3.1",
-        "find-up": "^4.1.0",
-        "get-package-type": "^0.1.0",
-        "js-yaml": "^3.13.1",
-        "resolve-from": "^5.0.0"
-      },
-      "dependencies": {
-        "js-yaml": {
-          "version": "3.14.1",
-          "dev": true,
-          "requires": {
-            "argparse": "^1.0.7",
-            "esprima": "^4.0.0"
-          }
-        }
-      }
-    },
-    "@istanbuljs/schema": {
-      "version": "0.1.3",
-      "dev": true
-    },
-    "@jest/console": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "slash": "^3.0.0"
-      }
-    },
-    "@jest/core": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/console": "^29.5.0",
-        "@jest/reporters": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.0.0",
-        "ci-info": "^3.2.0",
-        "exit": "^0.1.2",
-        "graceful-fs": "^4.2.9",
-        "jest-changed-files": "^29.5.0",
-        "jest-config": "^29.5.0",
-        "jest-haste-map": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-regex-util": "^29.4.3",
-        "jest-resolve": "^29.5.0",
-        "jest-resolve-dependencies": "^29.5.0",
-        "jest-runner": "^29.5.0",
-        "jest-runtime": "^29.5.0",
-        "jest-snapshot": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "jest-watcher": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "pretty-format": "^29.5.0",
-        "slash": "^3.0.0",
-        "strip-ansi": "^6.0.0"
-      }
-    },
-    "@jest/environment": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/fake-timers": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "jest-mock": "^29.5.0"
-      }
-    },
-    "@jest/expect": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "expect": "^29.5.0",
-        "jest-snapshot": "^29.5.0"
-      }
-    },
-    "@jest/expect-utils": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "jest-get-type": "^29.4.3"
-      }
-    },
-    "@jest/fake-timers": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/types": "^29.5.0",
-        "@sinonjs/fake-timers": "^10.0.2",
-        "@types/node": "*",
-        "jest-message-util": "^29.5.0",
-        "jest-mock": "^29.5.0",
-        "jest-util": "^29.5.0"
-      }
-    },
-    "@jest/globals": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/environment": "^29.5.0",
-        "@jest/expect": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "jest-mock": "^29.5.0"
-      }
-    },
-    "@jest/reporters": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@bcoe/v8-coverage": "^0.2.3",
-        "@jest/console": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@jridgewell/trace-mapping": "^0.3.15",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "collect-v8-coverage": "^1.0.0",
-        "exit": "^0.1.2",
-        "glob": "^7.1.3",
-        "graceful-fs": "^4.2.9",
-        "istanbul-lib-coverage": "^3.0.0",
-        "istanbul-lib-instrument": "^5.1.0",
-        "istanbul-lib-report": "^3.0.0",
-        "istanbul-lib-source-maps": "^4.0.0",
-        "istanbul-reports": "^3.1.3",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-worker": "^29.5.0",
-        "slash": "^3.0.0",
-        "string-length": "^4.0.1",
-        "strip-ansi": "^6.0.0",
-        "v8-to-istanbul": "^9.0.1"
-      }
-    },
-    "@jest/schemas": {
-      "version": "29.4.3",
-      "dev": true,
-      "requires": {
-        "@sinclair/typebox": "^0.25.16"
-      }
-    },
-    "@jest/source-map": {
-      "version": "29.4.3",
-      "dev": true,
-      "requires": {
-        "@jridgewell/trace-mapping": "^0.3.15",
-        "callsites": "^3.0.0",
-        "graceful-fs": "^4.2.9"
-      }
-    },
-    "@jest/test-result": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/console": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/istanbul-lib-coverage": "^2.0.0",
-        "collect-v8-coverage": "^1.0.0"
-      }
-    },
-    "@jest/test-sequencer": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/test-result": "^29.5.0",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "slash": "^3.0.0"
-      }
-    },
-    "@jest/transform": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@babel/core": "^7.11.6",
-        "@jest/types": "^29.5.0",
-        "@jridgewell/trace-mapping": "^0.3.15",
-        "babel-plugin-istanbul": "^6.1.1",
-        "chalk": "^4.0.0",
-        "convert-source-map": "^2.0.0",
-        "fast-json-stable-stringify": "^2.1.0",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "jest-regex-util": "^29.4.3",
-        "jest-util": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "pirates": "^4.0.4",
-        "slash": "^3.0.0",
-        "write-file-atomic": "^4.0.2"
-      },
-      "dependencies": {
-        "convert-source-map": {
-          "version": "2.0.0",
-          "dev": true
-        }
-      }
-    },
-    "@jest/types": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/schemas": "^29.4.3",
-        "@types/istanbul-lib-coverage": "^2.0.0",
-        "@types/istanbul-reports": "^3.0.0",
-        "@types/node": "*",
-        "@types/yargs": "^17.0.8",
-        "chalk": "^4.0.0"
-      }
-    },
-    "@jridgewell/gen-mapping": {
-      "version": "0.3.3",
-      "dev": true,
-      "requires": {
-        "@jridgewell/set-array": "^1.0.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      }
-    },
-    "@jridgewell/resolve-uri": {
-      "version": "3.1.0",
-      "dev": true
-    },
-    "@jridgewell/set-array": {
-      "version": "1.1.2",
-      "dev": true
-    },
-    "@jridgewell/source-map": {
-      "version": "0.3.3",
-      "dev": true,
-      "requires": {
-        "@jridgewell/gen-mapping": "^0.3.0",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      }
-    },
-    "@jridgewell/sourcemap-codec": {
-      "version": "1.4.15",
-      "dev": true
-    },
-    "@jridgewell/trace-mapping": {
-      "version": "0.3.18",
-      "dev": true,
-      "requires": {
-        "@jridgewell/resolve-uri": "3.1.0",
-        "@jridgewell/sourcemap-codec": "1.4.14"
-      },
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": {
-          "version": "1.4.14",
-          "dev": true
-        }
-      }
-    },
-    "@leichtgewicht/ip-codec": {
-      "version": "2.0.4",
-      "dev": true
-    },
-    "@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "dev": true,
-      "requires": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      }
-    },
-    "@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "dev": true
-    },
-    "@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "dev": true,
-      "requires": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      }
-    },
-    "@sinclair/typebox": {
-      "version": "0.25.24",
-      "dev": true
-    },
-    "@sinonjs/commons": {
-      "version": "2.0.0",
-      "dev": true,
-      "requires": {
-        "type-detect": "4.0.8"
-      }
-    },
-    "@sinonjs/fake-timers": {
-      "version": "10.0.2",
-      "dev": true,
-      "requires": {
-        "@sinonjs/commons": "^2.0.0"
-      }
-    },
-    "@tsconfig/node10": {
-      "version": "1.0.9",
-      "dev": true
-    },
-    "@tsconfig/node12": {
-      "version": "1.0.11",
-      "dev": true
-    },
-    "@tsconfig/node14": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "@tsconfig/node16": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "@types/babel__core": {
-      "version": "7.20.0",
-      "dev": true,
-      "requires": {
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7",
-        "@types/babel__generator": "*",
-        "@types/babel__template": "*",
-        "@types/babel__traverse": "*"
-      }
-    },
-    "@types/babel__generator": {
-      "version": "7.6.4",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "@types/babel__template": {
-      "version": "7.4.1",
-      "dev": true,
-      "requires": {
-        "@babel/parser": "^7.1.0",
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "@types/babel__traverse": {
-      "version": "7.18.3",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.3.0"
-      }
-    },
-    "@types/body-parser": {
-      "version": "1.19.2",
-      "dev": true,
-      "requires": {
-        "@types/connect": "*",
-        "@types/node": "*"
-      }
-    },
-    "@types/bonjour": {
-      "version": "3.5.10",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/connect": {
-      "version": "3.4.35",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/connect-history-api-fallback": {
-      "version": "1.5.0",
-      "dev": true,
-      "requires": {
-        "@types/express-serve-static-core": "*",
-        "@types/node": "*"
-      }
-    },
-    "@types/debug": {
-      "version": "4.1.7",
-      "dev": true,
-      "requires": {
-        "@types/ms": "*"
-      }
-    },
-    "@types/detect-node": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "@types/eslint": {
-      "version": "8.37.0",
-      "dev": true,
-      "requires": {
-        "@types/estree": "*",
-        "@types/json-schema": "*"
-      }
-    },
-    "@types/eslint-scope": {
-      "version": "3.7.4",
-      "dev": true,
-      "requires": {
-        "@types/eslint": "*",
-        "@types/estree": "*"
-      }
-    },
-    "@types/estree": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "@types/express": {
-      "version": "4.17.17",
-      "dev": true,
-      "requires": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^4.17.33",
-        "@types/qs": "*",
-        "@types/serve-static": "*"
-      }
-    },
-    "@types/express-serve-static-core": {
-      "version": "4.17.34",
-      "dev": true,
-      "requires": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
-      }
-    },
-    "@types/graceful-fs": {
-      "version": "4.1.6",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/html-minifier-terser": {
-      "version": "6.1.0",
-      "dev": true
-    },
-    "@types/http-proxy": {
-      "version": "1.17.11",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/istanbul-lib-coverage": {
-      "version": "2.0.4",
-      "dev": true
-    },
-    "@types/istanbul-lib-report": {
-      "version": "3.0.0",
-      "dev": true,
-      "requires": {
-        "@types/istanbul-lib-coverage": "*"
-      }
-    },
-    "@types/istanbul-reports": {
-      "version": "3.0.1",
-      "dev": true,
-      "requires": {
-        "@types/istanbul-lib-report": "*"
-      }
-    },
-    "@types/jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "expect": "^29.0.0",
-        "pretty-format": "^29.0.0"
-      }
-    },
-    "@types/json-schema": {
-      "version": "7.0.11",
-      "dev": true
-    },
-    "@types/mime": {
-      "version": "1.3.2",
-      "dev": true
-    },
-    "@types/ms": {
-      "version": "0.7.31",
-      "dev": true
-    },
-    "@types/node": {
-      "version": "18.15.11",
-      "dev": true
-    },
-    "@types/prettier": {
-      "version": "2.7.2",
-      "dev": true
-    },
-    "@types/qs": {
-      "version": "6.9.7",
-      "dev": true
-    },
-    "@types/range-parser": {
-      "version": "1.2.4",
-      "dev": true
-    },
-    "@types/retry": {
-      "version": "0.12.0",
-      "dev": true
-    },
-    "@types/semver": {
-      "version": "7.3.13",
-      "dev": true
-    },
-    "@types/send": {
-      "version": "0.17.1",
-      "dev": true,
-      "requires": {
-        "@types/mime": "^1",
-        "@types/node": "*"
-      }
-    },
-    "@types/serve-index": {
-      "version": "1.9.1",
-      "dev": true,
-      "requires": {
-        "@types/express": "*"
-      }
-    },
-    "@types/serve-static": {
-      "version": "1.15.1",
-      "dev": true,
-      "requires": {
-        "@types/mime": "*",
-        "@types/node": "*"
-      },
-      "dependencies": {
-        "@types/mime": {
-          "version": "3.0.1",
-          "dev": true
-        }
-      }
-    },
-    "@types/sockjs": {
-      "version": "0.3.33",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/source-map-support": {
-      "version": "0.5.6",
-      "dev": true,
-      "requires": {
-        "source-map": "^0.6.0"
-      }
-    },
-    "@types/stack-utils": {
-      "version": "2.0.1",
-      "dev": true
-    },
-    "@types/ws": {
-      "version": "8.5.4",
-      "dev": true,
-      "requires": {
-        "@types/node": "*"
-      }
-    },
-    "@types/yargs": {
-      "version": "17.0.24",
-      "dev": true,
-      "requires": {
-        "@types/yargs-parser": "*"
-      }
-    },
-    "@types/yargs-parser": {
-      "version": "21.0.0",
-      "dev": true
-    },
-    "@typescript-eslint/eslint-plugin": {
-      "version": "5.57.1",
-      "dev": true,
-      "requires": {
-        "@eslint-community/regexpp": "^4.4.0",
-        "@typescript-eslint/scope-manager": "5.57.1",
-        "@typescript-eslint/type-utils": "5.57.1",
-        "@typescript-eslint/utils": "5.57.1",
-        "debug": "^4.3.4",
-        "grapheme-splitter": "^1.0.4",
-        "ignore": "^5.2.0",
-        "natural-compare-lite": "^1.4.0",
-        "semver": "^7.3.7",
-        "tsutils": "^3.21.0"
-      }
-    },
-    "@typescript-eslint/parser": {
-      "version": "5.57.1",
-      "dev": true,
-      "requires": {
-        "@typescript-eslint/scope-manager": "5.57.1",
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/typescript-estree": "5.57.1",
-        "debug": "^4.3.4"
-      }
-    },
-    "@typescript-eslint/scope-manager": {
-      "version": "5.57.1",
-      "dev": true,
-      "requires": {
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/visitor-keys": "5.57.1"
-      }
-    },
-    "@typescript-eslint/type-utils": {
-      "version": "5.57.1",
-      "dev": true,
-      "requires": {
-        "@typescript-eslint/typescript-estree": "5.57.1",
-        "@typescript-eslint/utils": "5.57.1",
-        "debug": "^4.3.4",
-        "tsutils": "^3.21.0"
-      }
-    },
-    "@typescript-eslint/types": {
-      "version": "5.57.1",
-      "dev": true
-    },
-    "@typescript-eslint/typescript-estree": {
-      "version": "5.57.1",
-      "dev": true,
-      "requires": {
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/visitor-keys": "5.57.1",
-        "debug": "^4.3.4",
-        "globby": "^11.1.0",
-        "is-glob": "^4.0.3",
-        "semver": "^7.3.7",
-        "tsutils": "^3.21.0"
-      }
-    },
-    "@typescript-eslint/utils": {
-      "version": "5.57.1",
-      "dev": true,
-      "requires": {
-        "@eslint-community/eslint-utils": "^4.2.0",
-        "@types/json-schema": "^7.0.9",
-        "@types/semver": "^7.3.12",
-        "@typescript-eslint/scope-manager": "5.57.1",
-        "@typescript-eslint/types": "5.57.1",
-        "@typescript-eslint/typescript-estree": "5.57.1",
-        "eslint-scope": "^5.1.1",
-        "semver": "^7.3.7"
-      }
-    },
-    "@typescript-eslint/visitor-keys": {
-      "version": "5.57.1",
-      "dev": true,
-      "requires": {
-        "@typescript-eslint/types": "5.57.1",
-        "eslint-visitor-keys": "^3.3.0"
-      }
-    },
-    "@webassemblyjs/ast": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/helper-numbers": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
-      }
-    },
-    "@webassemblyjs/floating-point-hex-parser": {
-      "version": "1.11.6",
-      "dev": true
-    },
-    "@webassemblyjs/helper-api-error": {
-      "version": "1.11.6",
-      "dev": true
-    },
-    "@webassemblyjs/helper-buffer": {
-      "version": "1.11.6",
-      "dev": true
-    },
-    "@webassemblyjs/helper-numbers": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/floating-point-hex-parser": "1.11.6",
-        "@webassemblyjs/helper-api-error": "1.11.6",
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "@webassemblyjs/helper-wasm-bytecode": {
-      "version": "1.11.6",
-      "dev": true
-    },
-    "@webassemblyjs/helper-wasm-section": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6"
-      }
-    },
-    "@webassemblyjs/ieee754": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@xtuc/ieee754": "^1.2.0"
-      }
-    },
-    "@webassemblyjs/leb128": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "@webassemblyjs/utf8": {
-      "version": "1.11.6",
-      "dev": true
-    },
-    "@webassemblyjs/wasm-edit": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/helper-wasm-section": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-opt": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6",
-        "@webassemblyjs/wast-printer": "1.11.6"
-      }
-    },
-    "@webassemblyjs/wasm-gen": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
-      }
-    },
-    "@webassemblyjs/wasm-opt": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6"
-      }
-    },
-    "@webassemblyjs/wasm-parser": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-api-error": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
-      }
-    },
-    "@webassemblyjs/wast-printer": {
-      "version": "1.11.6",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "@webpack-cli/configtest": {
-      "version": "2.1.0",
-      "dev": true,
-      "requires": {}
-    },
-    "@webpack-cli/info": {
-      "version": "2.0.1",
-      "dev": true,
-      "requires": {}
-    },
-    "@webpack-cli/serve": {
-      "version": "2.0.4",
-      "dev": true,
-      "requires": {}
-    },
-    "@xtuc/ieee754": {
-      "version": "1.2.0",
-      "dev": true
-    },
-    "@xtuc/long": {
-      "version": "4.2.2",
-      "dev": true
-    },
-    "accepts": {
-      "version": "1.3.8",
-      "dev": true,
-      "requires": {
-        "mime-types": "~2.1.34",
-        "negotiator": "0.6.3"
-      }
-    },
-    "acorn": {
-      "version": "8.8.2",
-      "dev": true
-    },
-    "acorn-import-assertions": {
-      "version": "1.9.0",
-      "dev": true,
-      "requires": {}
-    },
-    "acorn-jsx": {
-      "version": "5.3.2",
-      "dev": true,
-      "requires": {}
-    },
-    "acorn-walk": {
-      "version": "8.2.0",
-      "dev": true
-    },
-    "ajv": {
-      "version": "8.12.0",
-      "dev": true,
-      "requires": {
-        "fast-deep-equal": "^3.1.1",
-        "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2",
-        "uri-js": "^4.2.2"
-      },
-      "dependencies": {
-        "json-schema-traverse": {
-          "version": "1.0.0",
-          "dev": true
-        }
-      }
-    },
-    "ajv-formats": {
-      "version": "2.1.1",
-      "dev": true,
-      "requires": {
-        "ajv": "^8.0.0"
-      }
-    },
-    "ajv-keywords": {
-      "version": "5.1.0",
-      "dev": true,
-      "requires": {
-        "fast-deep-equal": "^3.1.3"
-      }
-    },
-    "ansi-escapes": {
-      "version": "4.3.2",
-      "dev": true,
-      "requires": {
-        "type-fest": "^0.21.3"
-      },
-      "dependencies": {
-        "type-fest": {
-          "version": "0.21.3",
-          "dev": true
-        }
-      }
-    },
-    "ansi-html-community": {
-      "version": "0.0.8",
-      "dev": true
-    },
-    "ansi-regex": {
-      "version": "5.0.1",
-      "dev": true
-    },
-    "ansi-styles": {
-      "version": "4.3.0",
-      "dev": true,
-      "requires": {
-        "color-convert": "^2.0.1"
-      }
-    },
-    "anymatch": {
-      "version": "3.1.3",
-      "dev": true,
-      "requires": {
-        "normalize-path": "^3.0.0",
-        "picomatch": "^2.0.4"
-      }
-    },
-    "arg": {
-      "version": "4.1.3",
-      "dev": true
-    },
-    "argparse": {
-      "version": "1.0.10",
-      "dev": true,
-      "requires": {
-        "sprintf-js": "~1.0.2"
-      }
-    },
-    "array-flatten": {
-      "version": "2.1.2",
-      "dev": true
-    },
-    "array-union": {
-      "version": "2.1.0",
-      "dev": true
-    },
-    "babel-jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/transform": "^29.5.0",
-        "@types/babel__core": "^7.1.14",
-        "babel-plugin-istanbul": "^6.1.1",
-        "babel-preset-jest": "^29.5.0",
-        "chalk": "^4.0.0",
-        "graceful-fs": "^4.2.9",
-        "slash": "^3.0.0"
-      }
-    },
-    "babel-plugin-istanbul": {
-      "version": "6.1.1",
-      "dev": true,
-      "requires": {
-        "@babel/helper-plugin-utils": "^7.0.0",
-        "@istanbuljs/load-nyc-config": "^1.0.0",
-        "@istanbuljs/schema": "^0.1.2",
-        "istanbul-lib-instrument": "^5.0.4",
-        "test-exclude": "^6.0.0"
-      }
-    },
-    "babel-plugin-jest-hoist": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@babel/template": "^7.3.3",
-        "@babel/types": "^7.3.3",
-        "@types/babel__core": "^7.1.14",
-        "@types/babel__traverse": "^7.0.6"
-      }
-    },
-    "babel-preset-current-node-syntax": {
-      "version": "1.0.1",
-      "dev": true,
-      "requires": {
-        "@babel/plugin-syntax-async-generators": "^7.8.4",
-        "@babel/plugin-syntax-bigint": "^7.8.3",
-        "@babel/plugin-syntax-class-properties": "^7.8.3",
-        "@babel/plugin-syntax-import-meta": "^7.8.3",
-        "@babel/plugin-syntax-json-strings": "^7.8.3",
-        "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3",
-        "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
-        "@babel/plugin-syntax-numeric-separator": "^7.8.3",
-        "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
-        "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
-        "@babel/plugin-syntax-optional-chaining": "^7.8.3",
-        "@babel/plugin-syntax-top-level-await": "^7.8.3"
-      }
-    },
-    "babel-preset-jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "babel-plugin-jest-hoist": "^29.5.0",
-        "babel-preset-current-node-syntax": "^1.0.0"
-      }
-    },
-    "balanced-match": {
-      "version": "1.0.2",
-      "dev": true
-    },
-    "base64-js": {
-      "version": "1.5.1",
-      "dev": true
-    },
-    "batch": {
-      "version": "0.6.1",
-      "dev": true
-    },
-    "bigint-buffer": {
-      "version": "1.1.5",
-      "requires": {
-        "bindings": "^1.3.0"
-      }
-    },
-    "binary-extensions": {
-      "version": "2.2.0",
-      "dev": true
-    },
-    "bindings": {
-      "version": "1.5.0",
-      "requires": {
-        "file-uri-to-path": "1.0.0"
-      }
-    },
-    "body-parser": {
-      "version": "1.20.1",
-      "dev": true,
-      "requires": {
-        "bytes": "3.1.2",
-        "content-type": "~1.0.4",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "on-finished": "2.4.1",
-        "qs": "6.11.0",
-        "raw-body": "2.5.1",
-        "type-is": "~1.6.18",
-        "unpipe": "1.0.0"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "2.6.9",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "ms": {
-          "version": "2.0.0",
-          "dev": true
-        }
-      }
-    },
-    "bonjour-service": {
-      "version": "1.1.1",
-      "dev": true,
-      "requires": {
-        "array-flatten": "^2.1.2",
-        "dns-equal": "^1.0.0",
-        "fast-deep-equal": "^3.1.3",
-        "multicast-dns": "^7.2.5"
-      }
-    },
-    "boolbase": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "brace-expansion": {
-      "version": "1.1.11",
-      "dev": true,
-      "requires": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "braces": {
-      "version": "3.0.2",
-      "dev": true,
-      "requires": {
-        "fill-range": "^7.0.1"
-      }
-    },
-    "browserslist": {
-      "version": "4.21.5",
-      "dev": true,
-      "requires": {
-        "caniuse-lite": "^1.0.30001449",
-        "electron-to-chromium": "^1.4.284",
-        "node-releases": "^2.0.8",
-        "update-browserslist-db": "^1.0.10"
-      }
-    },
-    "bs-logger": {
-      "version": "0.2.6",
-      "dev": true,
-      "requires": {
-        "fast-json-stable-stringify": "2.x"
-      }
-    },
-    "bser": {
-      "version": "2.1.1",
-      "dev": true,
-      "requires": {
-        "node-int64": "^0.4.0"
-      }
-    },
-    "buffer": {
-      "version": "6.0.3",
-      "dev": true,
-      "requires": {
-        "base64-js": "^1.3.1",
-        "ieee754": "^1.2.1"
-      }
-    },
-    "buffer-from": {
-      "version": "1.1.2",
-      "dev": true
-    },
-    "bytes": {
-      "version": "3.1.2",
-      "dev": true
-    },
-    "call-bind": {
-      "version": "1.0.2",
-      "dev": true,
-      "requires": {
-        "function-bind": "^1.1.1",
-        "get-intrinsic": "^1.0.2"
-      }
-    },
-    "callsites": {
-      "version": "3.1.0",
-      "dev": true
-    },
-    "camel-case": {
-      "version": "4.1.2",
-      "dev": true,
-      "requires": {
-        "pascal-case": "^3.1.2",
-        "tslib": "^2.0.3"
-      }
-    },
-    "camelcase": {
-      "version": "5.3.1",
-      "dev": true
-    },
-    "caniuse-lite": {
-      "version": "1.0.30001476",
-      "dev": true
-    },
-    "chalk": {
-      "version": "4.1.2",
-      "dev": true,
-      "requires": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      }
-    },
-    "char-regex": {
-      "version": "1.0.2",
-      "dev": true
-    },
-    "chokidar": {
-      "version": "3.5.3",
-      "dev": true,
-      "requires": {
-        "anymatch": "~3.1.2",
-        "braces": "~3.0.2",
-        "fsevents": "~2.3.2",
-        "glob-parent": "~5.1.2",
-        "is-binary-path": "~2.1.0",
-        "is-glob": "~4.0.1",
-        "normalize-path": "~3.0.0",
-        "readdirp": "~3.6.0"
-      },
-      "dependencies": {
-        "glob-parent": {
-          "version": "5.1.2",
-          "dev": true,
-          "requires": {
-            "is-glob": "^4.0.1"
-          }
-        }
-      }
-    },
-    "chrome-trace-event": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "ci-info": {
-      "version": "3.8.0",
-      "dev": true
-    },
-    "cjs-module-lexer": {
-      "version": "1.2.2",
-      "dev": true
-    },
-    "clean-css": {
-      "version": "5.3.2",
-      "dev": true,
-      "requires": {
-        "source-map": "~0.6.0"
-      }
-    },
-    "cliui": {
-      "version": "8.0.1",
-      "dev": true,
-      "requires": {
-        "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.1",
-        "wrap-ansi": "^7.0.0"
-      }
-    },
-    "clone-deep": {
-      "version": "4.0.1",
-      "dev": true,
-      "requires": {
-        "is-plain-object": "^2.0.4",
-        "kind-of": "^6.0.2",
-        "shallow-clone": "^3.0.0"
-      }
-    },
-    "co": {
-      "version": "4.6.0",
-      "dev": true
-    },
-    "collect-v8-coverage": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "color-convert": {
-      "version": "2.0.1",
-      "dev": true,
-      "requires": {
-        "color-name": "~1.1.4"
-      }
-    },
-    "color-name": {
-      "version": "1.1.4",
-      "dev": true
-    },
-    "colorette": {
-      "version": "2.0.20",
-      "dev": true
-    },
-    "comlink": {
-      "version": "4.4.1",
-      "dev": true
-    },
-    "commander": {
-      "version": "10.0.1"
-    },
-    "compressible": {
-      "version": "2.0.18",
-      "dev": true,
-      "requires": {
-        "mime-db": ">= 1.43.0 < 2"
-      }
-    },
-    "compression": {
-      "version": "1.7.4",
-      "dev": true,
-      "requires": {
-        "accepts": "~1.3.5",
-        "bytes": "3.0.0",
-        "compressible": "~2.0.16",
-        "debug": "2.6.9",
-        "on-headers": "~1.0.2",
-        "safe-buffer": "5.1.2",
-        "vary": "~1.1.2"
-      },
-      "dependencies": {
-        "bytes": {
-          "version": "3.0.0",
-          "dev": true
-        },
-        "debug": {
-          "version": "2.6.9",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "ms": {
-          "version": "2.0.0",
-          "dev": true
-        },
-        "safe-buffer": {
-          "version": "5.1.2",
-          "dev": true
-        }
-      }
-    },
-    "concat-map": {
-      "version": "0.0.1",
-      "dev": true
-    },
-    "connect-history-api-fallback": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "content-disposition": {
-      "version": "0.5.4",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "5.2.1"
-      }
-    },
-    "content-type": {
-      "version": "1.0.5",
-      "dev": true
-    },
-    "convert-source-map": {
-      "version": "1.9.0",
-      "dev": true
-    },
-    "cookie": {
-      "version": "0.5.0",
-      "dev": true
-    },
-    "cookie-signature": {
-      "version": "1.0.6",
-      "dev": true
-    },
-    "copy-webpack-plugin": {
-      "version": "11.0.0",
-      "dev": true,
-      "requires": {
-        "fast-glob": "^3.2.11",
-        "glob-parent": "^6.0.1",
-        "globby": "^13.1.1",
-        "normalize-path": "^3.0.0",
-        "schema-utils": "^4.0.0",
-        "serialize-javascript": "^6.0.0"
-      },
-      "dependencies": {
-        "globby": {
-          "version": "13.1.4",
-          "dev": true,
-          "requires": {
-            "dir-glob": "^3.0.1",
-            "fast-glob": "^3.2.11",
-            "ignore": "^5.2.0",
-            "merge2": "^1.4.1",
-            "slash": "^4.0.0"
-          }
-        },
-        "slash": {
-          "version": "4.0.0",
-          "dev": true
-        }
-      }
-    },
-    "core-util-is": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "create-require": {
-      "version": "1.1.1",
-      "dev": true
-    },
-    "cross-spawn": {
-      "version": "7.0.3",
-      "dev": true,
-      "requires": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
-      }
-    },
-    "css-select": {
-      "version": "4.3.0",
-      "dev": true,
-      "requires": {
-        "boolbase": "^1.0.0",
-        "css-what": "^6.0.1",
-        "domhandler": "^4.3.1",
-        "domutils": "^2.8.0",
-        "nth-check": "^2.0.1"
-      }
-    },
-    "css-what": {
-      "version": "6.1.0",
-      "dev": true
-    },
-    "debug": {
-      "version": "4.3.4",
-      "dev": true,
-      "requires": {
-        "ms": "2.1.2"
-      },
-      "dependencies": {
-        "ms": {
-          "version": "2.1.2",
-          "dev": true
-        }
-      }
-    },
-    "dedent": {
-      "version": "0.7.0",
-      "dev": true
-    },
-    "deep-is": {
-      "version": "0.1.4",
-      "dev": true
-    },
-    "deepmerge": {
-      "version": "4.3.1",
-      "dev": true
-    },
-    "default-gateway": {
-      "version": "6.0.3",
-      "dev": true,
-      "requires": {
-        "execa": "^5.0.0"
-      }
-    },
-    "define-lazy-prop": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "depd": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "destroy": {
-      "version": "1.2.0",
-      "dev": true
-    },
-    "detect-newline": {
-      "version": "3.1.0",
-      "dev": true
-    },
-    "detect-node": {
-      "version": "2.1.0",
-      "dev": true
-    },
-    "diff": {
-      "version": "4.0.2",
-      "dev": true
-    },
-    "diff-sequences": {
-      "version": "29.4.3",
-      "dev": true
-    },
-    "dir-glob": {
-      "version": "3.0.1",
-      "dev": true,
-      "requires": {
-        "path-type": "^4.0.0"
-      }
-    },
-    "dns-equal": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "dns-packet": {
-      "version": "5.6.0",
-      "dev": true,
-      "requires": {
-        "@leichtgewicht/ip-codec": "^2.0.1"
-      }
-    },
-    "doctrine": {
-      "version": "3.0.0",
-      "dev": true,
-      "requires": {
-        "esutils": "^2.0.2"
-      }
-    },
-    "dom-converter": {
-      "version": "0.2.0",
-      "dev": true,
-      "requires": {
-        "utila": "~0.4"
-      }
-    },
-    "dom-serializer": {
-      "version": "1.4.1",
-      "dev": true,
-      "requires": {
-        "domelementtype": "^2.0.1",
-        "domhandler": "^4.2.0",
-        "entities": "^2.0.0"
-      }
-    },
-    "domelementtype": {
-      "version": "2.3.0",
-      "dev": true
-    },
-    "domhandler": {
-      "version": "4.3.1",
-      "dev": true,
-      "requires": {
-        "domelementtype": "^2.2.0"
-      }
-    },
-    "domutils": {
-      "version": "2.8.0",
-      "dev": true,
-      "requires": {
-        "dom-serializer": "^1.0.1",
-        "domelementtype": "^2.2.0",
-        "domhandler": "^4.2.0"
-      }
-    },
-    "dot-case": {
-      "version": "3.0.4",
-      "dev": true,
-      "requires": {
-        "no-case": "^3.0.4",
-        "tslib": "^2.0.3"
-      }
-    },
-    "ee-first": {
-      "version": "1.1.1",
-      "dev": true
-    },
-    "electron-to-chromium": {
-      "version": "1.4.356",
-      "dev": true
-    },
-    "emittery": {
-      "version": "0.13.1",
-      "dev": true
-    },
-    "emoji-regex": {
-      "version": "8.0.0",
-      "dev": true
-    },
-    "encodeurl": {
-      "version": "1.0.2",
-      "dev": true
-    },
-    "enhanced-resolve": {
-      "version": "5.14.0",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.2.4",
-        "tapable": "^2.2.0"
-      }
-    },
-    "entities": {
-      "version": "2.2.0",
-      "dev": true
-    },
-    "envinfo": {
-      "version": "7.8.1",
-      "dev": true
-    },
-    "error-ex": {
-      "version": "1.3.2",
-      "dev": true,
-      "requires": {
-        "is-arrayish": "^0.2.1"
-      }
-    },
-    "es-module-lexer": {
-      "version": "1.2.1",
-      "dev": true
-    },
-    "escalade": {
-      "version": "3.1.1",
-      "dev": true
-    },
-    "escape-html": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "escape-string-regexp": {
-      "version": "1.0.5",
-      "dev": true
-    },
-    "eslint": {
-      "version": "8.38.0",
-      "dev": true,
-      "requires": {
-        "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.4.0",
-        "@eslint/eslintrc": "^2.0.2",
-        "@eslint/js": "8.38.0",
-        "@humanwhocodes/config-array": "^0.11.8",
-        "@humanwhocodes/module-importer": "^1.0.1",
-        "@nodelib/fs.walk": "^1.2.8",
-        "ajv": "^6.10.0",
-        "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.2",
-        "debug": "^4.3.2",
-        "doctrine": "^3.0.0",
-        "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^7.1.1",
-        "eslint-visitor-keys": "^3.4.0",
-        "espree": "^9.5.1",
-        "esquery": "^1.4.2",
-        "esutils": "^2.0.2",
-        "fast-deep-equal": "^3.1.3",
-        "file-entry-cache": "^6.0.1",
-        "find-up": "^5.0.0",
-        "glob-parent": "^6.0.2",
-        "globals": "^13.19.0",
-        "grapheme-splitter": "^1.0.4",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.0.0",
-        "imurmurhash": "^0.1.4",
-        "is-glob": "^4.0.0",
-        "is-path-inside": "^3.0.3",
-        "js-sdsl": "^4.1.4",
-        "js-yaml": "^4.1.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "levn": "^0.4.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.9.1",
-        "strip-ansi": "^6.0.1",
-        "strip-json-comments": "^3.1.0",
-        "text-table": "^0.2.0"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "6.12.6",
-          "dev": true,
-          "requires": {
-            "fast-deep-equal": "^3.1.1",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.4.1",
-            "uri-js": "^4.2.2"
-          }
-        },
-        "escape-string-regexp": {
-          "version": "4.0.0",
-          "dev": true
-        },
-        "eslint-scope": {
-          "version": "7.1.1",
-          "dev": true,
-          "requires": {
-            "esrecurse": "^4.3.0",
-            "estraverse": "^5.2.0"
-          }
-        },
-        "find-up": {
-          "version": "5.0.0",
-          "dev": true,
-          "requires": {
-            "locate-path": "^6.0.0",
-            "path-exists": "^4.0.0"
-          }
-        },
-        "locate-path": {
-          "version": "6.0.0",
-          "dev": true,
-          "requires": {
-            "p-locate": "^5.0.0"
-          }
-        },
-        "p-locate": {
-          "version": "5.0.0",
-          "dev": true,
-          "requires": {
-            "p-limit": "^3.0.2"
-          }
-        }
-      }
-    },
-    "eslint-config-prettier": {
-      "version": "8.8.0",
-      "dev": true,
-      "requires": {}
-    },
-    "eslint-scope": {
-      "version": "5.1.1",
-      "dev": true,
-      "requires": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^4.1.1"
-      },
-      "dependencies": {
-        "estraverse": {
-          "version": "4.3.0",
-          "dev": true
-        }
-      }
-    },
-    "eslint-visitor-keys": {
-      "version": "3.4.0",
-      "dev": true
-    },
-    "espree": {
-      "version": "9.5.1",
-      "dev": true,
-      "requires": {
-        "acorn": "^8.8.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^3.4.0"
-      }
-    },
-    "esprima": {
-      "version": "4.0.1",
-      "dev": true
-    },
-    "esquery": {
-      "version": "1.5.0",
-      "dev": true,
-      "requires": {
-        "estraverse": "^5.1.0"
-      }
-    },
-    "esrecurse": {
-      "version": "4.3.0",
-      "dev": true,
-      "requires": {
-        "estraverse": "^5.2.0"
-      }
-    },
-    "estraverse": {
-      "version": "5.3.0",
-      "dev": true
-    },
-    "esutils": {
-      "version": "2.0.3",
-      "dev": true
-    },
-    "etag": {
-      "version": "1.8.1",
-      "dev": true
-    },
-    "eventemitter3": {
-      "version": "4.0.7",
-      "dev": true
-    },
-    "events": {
-      "version": "3.3.0",
-      "dev": true
-    },
-    "execa": {
-      "version": "5.1.1",
-      "dev": true,
-      "requires": {
-        "cross-spawn": "^7.0.3",
-        "get-stream": "^6.0.0",
-        "human-signals": "^2.1.0",
-        "is-stream": "^2.0.0",
-        "merge-stream": "^2.0.0",
-        "npm-run-path": "^4.0.1",
-        "onetime": "^5.1.2",
-        "signal-exit": "^3.0.3",
-        "strip-final-newline": "^2.0.0"
-      }
-    },
-    "exit": {
-      "version": "0.1.2",
-      "dev": true
-    },
-    "expect": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/expect-utils": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "jest-matcher-utils": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0"
-      }
-    },
-    "express": {
-      "version": "4.18.2",
-      "dev": true,
-      "requires": {
-        "accepts": "~1.3.8",
-        "array-flatten": "1.1.1",
-        "body-parser": "1.20.1",
-        "content-disposition": "0.5.4",
-        "content-type": "~1.0.4",
-        "cookie": "0.5.0",
-        "cookie-signature": "1.0.6",
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "finalhandler": "1.2.0",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
-        "merge-descriptors": "1.0.1",
-        "methods": "~1.1.2",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "path-to-regexp": "0.1.7",
-        "proxy-addr": "~2.0.7",
-        "qs": "6.11.0",
-        "range-parser": "~1.2.1",
-        "safe-buffer": "5.2.1",
-        "send": "0.18.0",
-        "serve-static": "1.15.0",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "type-is": "~1.6.18",
-        "utils-merge": "1.0.1",
-        "vary": "~1.1.2"
-      },
-      "dependencies": {
-        "array-flatten": {
-          "version": "1.1.1",
-          "dev": true
-        },
-        "debug": {
-          "version": "2.6.9",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "ms": {
-          "version": "2.0.0",
-          "dev": true
-        }
-      }
-    },
-    "fast-deep-equal": {
-      "version": "3.1.3",
-      "dev": true
-    },
-    "fast-glob": {
-      "version": "3.2.12",
-      "dev": true,
-      "requires": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.4"
-      },
-      "dependencies": {
-        "glob-parent": {
-          "version": "5.1.2",
-          "dev": true,
-          "requires": {
-            "is-glob": "^4.0.1"
-          }
-        }
-      }
-    },
-    "fast-json-stable-stringify": {
-      "version": "2.1.0",
-      "dev": true
-    },
-    "fast-levenshtein": {
-      "version": "2.0.6",
-      "dev": true
-    },
-    "fastest-levenshtein": {
-      "version": "1.0.16",
-      "dev": true
-    },
-    "fastq": {
-      "version": "1.15.0",
-      "dev": true,
-      "requires": {
-        "reusify": "^1.0.4"
-      }
-    },
-    "faye-websocket": {
-      "version": "0.11.4",
-      "dev": true,
-      "requires": {
-        "websocket-driver": ">=0.5.1"
-      }
-    },
-    "fb-watchman": {
-      "version": "2.0.2",
-      "dev": true,
-      "requires": {
-        "bser": "2.1.1"
-      }
-    },
-    "file-entry-cache": {
-      "version": "6.0.1",
-      "dev": true,
-      "requires": {
-        "flat-cache": "^3.0.4"
-      }
-    },
-    "file-uri-to-path": {
-      "version": "1.0.0"
-    },
-    "fill-range": {
-      "version": "7.0.1",
-      "dev": true,
-      "requires": {
-        "to-regex-range": "^5.0.1"
-      }
-    },
-    "finalhandler": {
-      "version": "1.2.0",
-      "dev": true,
-      "requires": {
-        "debug": "2.6.9",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "on-finished": "2.4.1",
-        "parseurl": "~1.3.3",
-        "statuses": "2.0.1",
-        "unpipe": "~1.0.0"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "2.6.9",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "ms": {
-          "version": "2.0.0",
-          "dev": true
-        }
-      }
-    },
-    "find-up": {
-      "version": "4.1.0",
-      "dev": true,
-      "requires": {
-        "locate-path": "^5.0.0",
-        "path-exists": "^4.0.0"
-      }
-    },
-    "flat-cache": {
-      "version": "3.0.4",
-      "dev": true,
-      "requires": {
-        "flatted": "^3.1.0",
-        "rimraf": "^3.0.2"
-      }
-    },
-    "flatted": {
-      "version": "3.2.7",
-      "dev": true
-    },
-    "follow-redirects": {
-      "version": "1.15.2",
-      "dev": true
-    },
-    "forwarded": {
-      "version": "0.2.0",
-      "dev": true
-    },
-    "fresh": {
-      "version": "0.5.2",
-      "dev": true
-    },
-    "fs-monkey": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "fs.realpath": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "function-bind": {
-      "version": "1.1.1",
-      "dev": true
-    },
-    "gensync": {
-      "version": "1.0.0-beta.2",
-      "dev": true
-    },
-    "get-caller-file": {
-      "version": "2.0.5",
-      "dev": true
-    },
-    "get-intrinsic": {
-      "version": "1.2.0",
-      "dev": true,
-      "requires": {
-        "function-bind": "^1.1.1",
-        "has": "^1.0.3",
-        "has-symbols": "^1.0.3"
-      }
-    },
-    "get-package-type": {
-      "version": "0.1.0",
-      "dev": true
-    },
-    "get-stream": {
-      "version": "6.0.1",
-      "dev": true
-    },
-    "glob": {
-      "version": "7.2.3",
-      "dev": true,
-      "requires": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.1.1",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      }
-    },
-    "glob-parent": {
-      "version": "6.0.2",
-      "dev": true,
-      "requires": {
-        "is-glob": "^4.0.3"
-      }
-    },
-    "glob-to-regexp": {
-      "version": "0.4.1",
-      "dev": true
-    },
-    "globals": {
-      "version": "13.20.0",
-      "dev": true,
-      "requires": {
-        "type-fest": "^0.20.2"
-      }
-    },
-    "globby": {
-      "version": "11.1.0",
-      "dev": true,
-      "requires": {
-        "array-union": "^2.1.0",
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.2.9",
-        "ignore": "^5.2.0",
-        "merge2": "^1.4.1",
-        "slash": "^3.0.0"
-      }
-    },
-    "graceful-fs": {
-      "version": "4.2.11",
-      "dev": true
-    },
-    "grapheme-splitter": {
-      "version": "1.0.4",
-      "dev": true
-    },
-    "handle-thing": {
-      "version": "2.0.1",
-      "dev": true
-    },
-    "has": {
-      "version": "1.0.3",
-      "dev": true,
-      "requires": {
-        "function-bind": "^1.1.1"
-      }
-    },
-    "has-flag": {
-      "version": "4.0.0",
-      "dev": true
-    },
-    "has-symbols": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "he": {
-      "version": "1.2.0",
-      "dev": true
-    },
-    "hpack.js": {
-      "version": "2.1.6",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "obuf": "^1.0.0",
-        "readable-stream": "^2.0.1",
-        "wbuf": "^1.1.0"
-      },
-      "dependencies": {
-        "readable-stream": {
-          "version": "2.3.8",
-          "dev": true,
-          "requires": {
-            "core-util-is": "~1.0.0",
-            "inherits": "~2.0.3",
-            "isarray": "~1.0.0",
-            "process-nextick-args": "~2.0.0",
-            "safe-buffer": "~5.1.1",
-            "string_decoder": "~1.1.1",
-            "util-deprecate": "~1.0.1"
-          }
-        },
-        "safe-buffer": {
-          "version": "5.1.2",
-          "dev": true
-        },
-        "string_decoder": {
-          "version": "1.1.1",
-          "dev": true,
-          "requires": {
-            "safe-buffer": "~5.1.0"
-          }
-        }
-      }
-    },
-    "html-entities": {
-      "version": "2.3.3",
-      "dev": true
-    },
-    "html-escaper": {
-      "version": "2.0.2",
-      "dev": true
-    },
-    "html-minifier-terser": {
-      "version": "6.1.0",
-      "dev": true,
-      "requires": {
-        "camel-case": "^4.1.2",
-        "clean-css": "^5.2.2",
-        "commander": "^8.3.0",
-        "he": "^1.2.0",
-        "param-case": "^3.0.4",
-        "relateurl": "^0.2.7",
-        "terser": "^5.10.0"
-      },
-      "dependencies": {
-        "commander": {
-          "version": "8.3.0",
-          "dev": true
-        }
-      }
-    },
-    "html-webpack-plugin": {
-      "version": "5.5.1",
-      "dev": true,
-      "requires": {
-        "@types/html-minifier-terser": "^6.0.0",
-        "html-minifier-terser": "^6.0.2",
-        "lodash": "^4.17.21",
-        "pretty-error": "^4.0.0",
-        "tapable": "^2.0.0"
-      }
-    },
-    "htmlparser2": {
-      "version": "6.1.0",
-      "dev": true,
-      "requires": {
-        "domelementtype": "^2.0.1",
-        "domhandler": "^4.0.0",
-        "domutils": "^2.5.2",
-        "entities": "^2.0.0"
-      }
-    },
-    "http-deceiver": {
-      "version": "1.2.7",
-      "dev": true
-    },
-    "http-errors": {
-      "version": "2.0.0",
-      "dev": true,
-      "requires": {
-        "depd": "2.0.0",
-        "inherits": "2.0.4",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "toidentifier": "1.0.1"
-      }
-    },
-    "http-parser-js": {
-      "version": "0.5.8",
-      "dev": true
-    },
-    "http-proxy": {
-      "version": "1.18.1",
-      "dev": true,
-      "requires": {
-        "eventemitter3": "^4.0.0",
-        "follow-redirects": "^1.0.0",
-        "requires-port": "^1.0.0"
-      }
-    },
-    "http-proxy-middleware": {
-      "version": "2.0.6",
-      "dev": true,
-      "requires": {
-        "@types/http-proxy": "^1.17.8",
-        "http-proxy": "^1.18.1",
-        "is-glob": "^4.0.1",
-        "is-plain-obj": "^3.0.0",
-        "micromatch": "^4.0.2"
-      }
-    },
-    "human-signals": {
-      "version": "2.1.0",
-      "dev": true
-    },
-    "iconv-lite": {
-      "version": "0.4.24",
-      "dev": true,
-      "requires": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      }
-    },
-    "idb-keyval": {
-      "version": "6.2.1",
-      "dev": true
-    },
-    "ieee754": {
-      "version": "1.2.1",
-      "dev": true
-    },
-    "ignore": {
-      "version": "5.2.4",
-      "dev": true
-    },
-    "import-fresh": {
-      "version": "3.3.0",
-      "dev": true,
-      "requires": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
-      },
-      "dependencies": {
-        "resolve-from": {
-          "version": "4.0.0",
-          "dev": true
-        }
-      }
-    },
-    "import-local": {
-      "version": "3.1.0",
-      "dev": true,
-      "requires": {
-        "pkg-dir": "^4.2.0",
-        "resolve-cwd": "^3.0.0"
-      }
-    },
-    "imurmurhash": {
-      "version": "0.1.4",
-      "dev": true
-    },
-    "inflight": {
-      "version": "1.0.6",
-      "dev": true,
-      "requires": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "inherits": {
-      "version": "2.0.4",
-      "dev": true
-    },
-    "interpret": {
-      "version": "3.1.1",
-      "dev": true
-    },
-    "ipaddr.js": {
-      "version": "1.9.1",
-      "dev": true
-    },
-    "is-arrayish": {
-      "version": "0.2.1",
-      "dev": true
-    },
-    "is-binary-path": {
-      "version": "2.1.0",
-      "dev": true,
-      "requires": {
-        "binary-extensions": "^2.0.0"
-      }
-    },
-    "is-core-module": {
-      "version": "2.11.0",
-      "dev": true,
-      "requires": {
-        "has": "^1.0.3"
-      }
-    },
-    "is-docker": {
-      "version": "2.2.1",
-      "dev": true
-    },
-    "is-extglob": {
-      "version": "2.1.1",
-      "dev": true
-    },
-    "is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "dev": true
-    },
-    "is-generator-fn": {
-      "version": "2.1.0",
-      "dev": true
-    },
-    "is-glob": {
-      "version": "4.0.3",
-      "dev": true,
-      "requires": {
-        "is-extglob": "^2.1.1"
-      }
-    },
-    "is-number": {
-      "version": "7.0.0",
-      "dev": true
-    },
-    "is-path-inside": {
-      "version": "3.0.3",
-      "dev": true
-    },
-    "is-plain-obj": {
-      "version": "3.0.0",
-      "dev": true
-    },
-    "is-plain-object": {
-      "version": "2.0.4",
-      "dev": true,
-      "requires": {
-        "isobject": "^3.0.1"
-      }
-    },
-    "is-stream": {
-      "version": "2.0.1",
-      "dev": true
-    },
-    "is-wsl": {
-      "version": "2.2.0",
-      "dev": true,
-      "requires": {
-        "is-docker": "^2.0.0"
-      }
-    },
-    "isarray": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "isexe": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "isobject": {
-      "version": "3.0.1",
-      "dev": true
-    },
-    "istanbul-lib-coverage": {
-      "version": "3.2.0",
-      "dev": true
-    },
-    "istanbul-lib-instrument": {
-      "version": "5.2.1",
-      "dev": true,
-      "requires": {
-        "@babel/core": "^7.12.3",
-        "@babel/parser": "^7.14.7",
-        "@istanbuljs/schema": "^0.1.2",
-        "istanbul-lib-coverage": "^3.2.0",
-        "semver": "^6.3.0"
-      },
-      "dependencies": {
-        "semver": {
-          "version": "6.3.0",
-          "dev": true
-        }
-      }
-    },
-    "istanbul-lib-report": {
-      "version": "3.0.0",
-      "dev": true,
-      "requires": {
-        "istanbul-lib-coverage": "^3.0.0",
-        "make-dir": "^3.0.0",
-        "supports-color": "^7.1.0"
-      }
-    },
-    "istanbul-lib-source-maps": {
-      "version": "4.0.1",
-      "dev": true,
-      "requires": {
-        "debug": "^4.1.1",
-        "istanbul-lib-coverage": "^3.0.0",
-        "source-map": "^0.6.1"
-      }
-    },
-    "istanbul-reports": {
-      "version": "3.1.5",
-      "dev": true,
-      "requires": {
-        "html-escaper": "^2.0.0",
-        "istanbul-lib-report": "^3.0.0"
-      }
-    },
-    "jest": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/core": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "import-local": "^3.0.2",
-        "jest-cli": "^29.5.0"
-      }
-    },
-    "jest-changed-files": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "execa": "^5.0.0",
-        "p-limit": "^3.1.0"
-      }
-    },
-    "jest-circus": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/environment": "^29.5.0",
-        "@jest/expect": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "co": "^4.6.0",
-        "dedent": "^0.7.0",
-        "is-generator-fn": "^2.0.0",
-        "jest-each": "^29.5.0",
-        "jest-matcher-utils": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-runtime": "^29.5.0",
-        "jest-snapshot": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "p-limit": "^3.1.0",
-        "pretty-format": "^29.5.0",
-        "pure-rand": "^6.0.0",
-        "slash": "^3.0.0",
-        "stack-utils": "^2.0.3"
-      }
-    },
-    "jest-cli": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/core": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "chalk": "^4.0.0",
-        "exit": "^0.1.2",
-        "graceful-fs": "^4.2.9",
-        "import-local": "^3.0.2",
-        "jest-config": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "prompts": "^2.0.1",
-        "yargs": "^17.3.1"
-      }
-    },
-    "jest-config": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@babel/core": "^7.11.6",
-        "@jest/test-sequencer": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "babel-jest": "^29.5.0",
-        "chalk": "^4.0.0",
-        "ci-info": "^3.2.0",
-        "deepmerge": "^4.2.2",
-        "glob": "^7.1.3",
-        "graceful-fs": "^4.2.9",
-        "jest-circus": "^29.5.0",
-        "jest-environment-node": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "jest-regex-util": "^29.4.3",
-        "jest-resolve": "^29.5.0",
-        "jest-runner": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "parse-json": "^5.2.0",
-        "pretty-format": "^29.5.0",
-        "slash": "^3.0.0",
-        "strip-json-comments": "^3.1.1"
-      }
-    },
-    "jest-diff": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "chalk": "^4.0.0",
-        "diff-sequences": "^29.4.3",
-        "jest-get-type": "^29.4.3",
-        "pretty-format": "^29.5.0"
-      }
-    },
-    "jest-docblock": {
-      "version": "29.4.3",
-      "dev": true,
-      "requires": {
-        "detect-newline": "^3.0.0"
-      }
-    },
-    "jest-each": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/types": "^29.5.0",
-        "chalk": "^4.0.0",
-        "jest-get-type": "^29.4.3",
-        "jest-util": "^29.5.0",
-        "pretty-format": "^29.5.0"
-      }
-    },
-    "jest-environment-node": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/environment": "^29.5.0",
-        "@jest/fake-timers": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "jest-mock": "^29.5.0",
-        "jest-util": "^29.5.0"
-      }
-    },
-    "jest-get-type": {
-      "version": "29.4.3",
-      "dev": true
-    },
-    "jest-haste-map": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/types": "^29.5.0",
-        "@types/graceful-fs": "^4.1.3",
-        "@types/node": "*",
-        "anymatch": "^3.0.3",
-        "fb-watchman": "^2.0.0",
-        "fsevents": "^2.3.2",
-        "graceful-fs": "^4.2.9",
-        "jest-regex-util": "^29.4.3",
-        "jest-util": "^29.5.0",
-        "jest-worker": "^29.5.0",
-        "micromatch": "^4.0.4",
-        "walker": "^1.0.8"
-      }
-    },
-    "jest-leak-detector": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "jest-get-type": "^29.4.3",
-        "pretty-format": "^29.5.0"
-      }
-    },
-    "jest-matcher-utils": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "chalk": "^4.0.0",
-        "jest-diff": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "pretty-format": "^29.5.0"
-      }
-    },
-    "jest-message-util": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@babel/code-frame": "^7.12.13",
-        "@jest/types": "^29.5.0",
-        "@types/stack-utils": "^2.0.0",
-        "chalk": "^4.0.0",
-        "graceful-fs": "^4.2.9",
-        "micromatch": "^4.0.4",
-        "pretty-format": "^29.5.0",
-        "slash": "^3.0.0",
-        "stack-utils": "^2.0.3"
-      }
-    },
-    "jest-mock": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "jest-util": "^29.5.0"
-      }
-    },
-    "jest-pnp-resolver": {
-      "version": "1.2.3",
-      "dev": true,
-      "requires": {}
-    },
-    "jest-regex-util": {
-      "version": "29.4.3",
-      "dev": true
-    },
-    "jest-resolve": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "chalk": "^4.0.0",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "jest-pnp-resolver": "^1.2.2",
-        "jest-util": "^29.5.0",
-        "jest-validate": "^29.5.0",
-        "resolve": "^1.20.0",
-        "resolve.exports": "^2.0.0",
-        "slash": "^3.0.0"
-      }
-    },
-    "jest-resolve-dependencies": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "jest-regex-util": "^29.4.3",
-        "jest-snapshot": "^29.5.0"
-      }
-    },
-    "jest-runner": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/console": "^29.5.0",
-        "@jest/environment": "^29.5.0",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "emittery": "^0.13.1",
-        "graceful-fs": "^4.2.9",
-        "jest-docblock": "^29.4.3",
-        "jest-environment-node": "^29.5.0",
-        "jest-haste-map": "^29.5.0",
-        "jest-leak-detector": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-resolve": "^29.5.0",
-        "jest-runtime": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "jest-watcher": "^29.5.0",
-        "jest-worker": "^29.5.0",
-        "p-limit": "^3.1.0",
-        "source-map-support": "0.5.13"
-      },
-      "dependencies": {
-        "source-map-support": {
-          "version": "0.5.13",
-          "dev": true,
-          "requires": {
-            "buffer-from": "^1.0.0",
-            "source-map": "^0.6.0"
-          }
-        }
-      }
-    },
-    "jest-runtime": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/environment": "^29.5.0",
-        "@jest/fake-timers": "^29.5.0",
-        "@jest/globals": "^29.5.0",
-        "@jest/source-map": "^29.4.3",
-        "@jest/test-result": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "cjs-module-lexer": "^1.0.0",
-        "collect-v8-coverage": "^1.0.0",
-        "glob": "^7.1.3",
-        "graceful-fs": "^4.2.9",
-        "jest-haste-map": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-mock": "^29.5.0",
-        "jest-regex-util": "^29.4.3",
-        "jest-resolve": "^29.5.0",
-        "jest-snapshot": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "slash": "^3.0.0",
-        "strip-bom": "^4.0.0"
-      }
-    },
-    "jest-snapshot": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@babel/core": "^7.11.6",
-        "@babel/generator": "^7.7.2",
-        "@babel/plugin-syntax-jsx": "^7.7.2",
-        "@babel/plugin-syntax-typescript": "^7.7.2",
-        "@babel/traverse": "^7.7.2",
-        "@babel/types": "^7.3.3",
-        "@jest/expect-utils": "^29.5.0",
-        "@jest/transform": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/babel__traverse": "^7.0.6",
-        "@types/prettier": "^2.1.5",
-        "babel-preset-current-node-syntax": "^1.0.0",
-        "chalk": "^4.0.0",
-        "expect": "^29.5.0",
-        "graceful-fs": "^4.2.9",
-        "jest-diff": "^29.5.0",
-        "jest-get-type": "^29.4.3",
-        "jest-matcher-utils": "^29.5.0",
-        "jest-message-util": "^29.5.0",
-        "jest-util": "^29.5.0",
-        "natural-compare": "^1.4.0",
-        "pretty-format": "^29.5.0",
-        "semver": "^7.3.5"
-      }
-    },
-    "jest-util": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "chalk": "^4.0.0",
-        "ci-info": "^3.2.0",
-        "graceful-fs": "^4.2.9",
-        "picomatch": "^2.2.3"
-      }
-    },
-    "jest-validate": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/types": "^29.5.0",
-        "camelcase": "^6.2.0",
-        "chalk": "^4.0.0",
-        "jest-get-type": "^29.4.3",
-        "leven": "^3.1.0",
-        "pretty-format": "^29.5.0"
-      },
-      "dependencies": {
-        "camelcase": {
-          "version": "6.3.0",
-          "dev": true
-        }
-      }
-    },
-    "jest-watcher": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/test-result": "^29.5.0",
-        "@jest/types": "^29.5.0",
-        "@types/node": "*",
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.0.0",
-        "emittery": "^0.13.1",
-        "jest-util": "^29.5.0",
-        "string-length": "^4.0.1"
-      }
-    },
-    "jest-worker": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@types/node": "*",
-        "jest-util": "^29.5.0",
-        "merge-stream": "^2.0.0",
-        "supports-color": "^8.0.0"
-      },
-      "dependencies": {
-        "supports-color": {
-          "version": "8.1.1",
-          "dev": true,
-          "requires": {
-            "has-flag": "^4.0.0"
-          }
-        }
-      }
-    },
-    "js-sdsl": {
-      "version": "4.4.0",
-      "dev": true
-    },
-    "js-tokens": {
-      "version": "4.0.0",
-      "dev": true
-    },
-    "js-yaml": {
-      "version": "4.1.0",
-      "dev": true,
-      "requires": {
-        "argparse": "^2.0.1"
-      },
-      "dependencies": {
-        "argparse": {
-          "version": "2.0.1",
-          "dev": true
-        }
-      }
-    },
-    "jsesc": {
-      "version": "2.5.2",
-      "dev": true
-    },
-    "json-parse-even-better-errors": {
-      "version": "2.3.1",
-      "dev": true
-    },
-    "json-schema-traverse": {
-      "version": "0.4.1",
-      "dev": true
-    },
-    "json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "json5": {
-      "version": "2.2.3",
-      "dev": true
-    },
-    "kind-of": {
-      "version": "6.0.3",
-      "dev": true
-    },
-    "kleur": {
-      "version": "3.0.3",
-      "dev": true
-    },
-    "launch-editor": {
-      "version": "2.6.0",
-      "dev": true,
-      "requires": {
-        "picocolors": "^1.0.0",
-        "shell-quote": "^1.7.3"
-      }
-    },
-    "leven": {
-      "version": "3.1.0",
-      "dev": true
-    },
-    "levn": {
-      "version": "0.4.1",
-      "dev": true,
-      "requires": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      }
-    },
-    "lines-and-columns": {
-      "version": "1.2.4",
-      "dev": true
-    },
-    "loader-runner": {
-      "version": "4.3.0",
-      "dev": true
-    },
-    "locate-path": {
-      "version": "5.0.0",
-      "dev": true,
-      "requires": {
-        "p-locate": "^4.1.0"
-      }
-    },
-    "lodash": {
-      "version": "4.17.21",
-      "dev": true
-    },
-    "lodash.memoize": {
-      "version": "4.1.2",
-      "dev": true
-    },
-    "lodash.merge": {
-      "version": "4.6.2",
-      "dev": true
-    },
-    "lower-case": {
-      "version": "2.0.2",
-      "dev": true,
-      "requires": {
-        "tslib": "^2.0.3"
-      }
-    },
-    "lru-cache": {
-      "version": "6.0.0",
-      "dev": true,
-      "requires": {
-        "yallist": "^4.0.0"
-      }
-    },
-    "make-dir": {
-      "version": "3.1.0",
-      "dev": true,
-      "requires": {
-        "semver": "^6.0.0"
-      },
-      "dependencies": {
-        "semver": {
-          "version": "6.3.0",
-          "dev": true
-        }
-      }
-    },
-    "make-error": {
-      "version": "1.3.6",
-      "dev": true
-    },
-    "makeerror": {
-      "version": "1.0.12",
-      "dev": true,
-      "requires": {
-        "tmpl": "1.0.5"
-      }
-    },
-    "media-typer": {
-      "version": "0.3.0",
-      "dev": true
-    },
-    "memfs": {
-      "version": "3.5.1",
-      "dev": true,
-      "requires": {
-        "fs-monkey": "^1.0.3"
-      }
-    },
-    "merge-descriptors": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "merge-stream": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "merge2": {
-      "version": "1.4.1",
-      "dev": true
-    },
-    "methods": {
-      "version": "1.1.2",
-      "dev": true
-    },
-    "micromatch": {
-      "version": "4.0.5",
-      "dev": true,
-      "requires": {
-        "braces": "^3.0.2",
-        "picomatch": "^2.3.1"
-      }
-    },
-    "mime": {
-      "version": "1.6.0",
-      "dev": true
-    },
-    "mime-db": {
-      "version": "1.52.0",
-      "dev": true
-    },
-    "mime-types": {
-      "version": "2.1.35",
-      "dev": true,
-      "requires": {
-        "mime-db": "1.52.0"
-      }
-    },
-    "mimic-fn": {
-      "version": "2.1.0",
-      "dev": true
-    },
-    "minimalistic-assert": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "minimatch": {
-      "version": "3.1.2",
-      "dev": true,
-      "requires": {
-        "brace-expansion": "^1.1.7"
-      }
-    },
-    "ms": {
-      "version": "2.1.3",
-      "dev": true
-    },
-    "multicast-dns": {
-      "version": "7.2.5",
-      "dev": true,
-      "requires": {
-        "dns-packet": "^5.2.2",
-        "thunky": "^1.0.2"
-      }
-    },
-    "natural-compare": {
-      "version": "1.4.0",
-      "dev": true
-    },
-    "natural-compare-lite": {
-      "version": "1.4.0",
-      "dev": true
-    },
-    "negotiator": {
-      "version": "0.6.3",
-      "dev": true
-    },
-    "neo-async": {
-      "version": "2.6.2",
-      "dev": true
-    },
-    "no-case": {
-      "version": "3.0.4",
-      "dev": true,
-      "requires": {
-        "lower-case": "^2.0.2",
-        "tslib": "^2.0.3"
-      }
-    },
-    "node-forge": {
-      "version": "1.3.1",
-      "dev": true
-    },
-    "node-int64": {
-      "version": "0.4.0",
-      "dev": true
-    },
-    "node-releases": {
-      "version": "2.0.10",
-      "dev": true
-    },
-    "normalize-path": {
-      "version": "3.0.0",
-      "dev": true
-    },
-    "npm-run-path": {
-      "version": "4.0.1",
-      "dev": true,
-      "requires": {
-        "path-key": "^3.0.0"
-      }
-    },
-    "nth-check": {
-      "version": "2.1.1",
-      "dev": true,
-      "requires": {
-        "boolbase": "^1.0.0"
-      }
-    },
-    "object-inspect": {
-      "version": "1.12.3",
-      "dev": true
-    },
-    "obuf": {
-      "version": "1.1.2",
-      "dev": true
-    },
-    "on-finished": {
-      "version": "2.4.1",
-      "dev": true,
-      "requires": {
-        "ee-first": "1.1.1"
-      }
-    },
-    "on-headers": {
-      "version": "1.0.2",
-      "dev": true
-    },
-    "once": {
-      "version": "1.4.0",
-      "dev": true,
-      "requires": {
-        "wrappy": "1"
-      }
-    },
-    "onetime": {
-      "version": "5.1.2",
-      "dev": true,
-      "requires": {
-        "mimic-fn": "^2.1.0"
-      }
-    },
-    "open": {
-      "version": "8.4.2",
-      "dev": true,
-      "requires": {
-        "define-lazy-prop": "^2.0.0",
-        "is-docker": "^2.1.1",
-        "is-wsl": "^2.2.0"
-      }
-    },
-    "optionator": {
-      "version": "0.9.1",
-      "dev": true,
-      "requires": {
-        "deep-is": "^0.1.3",
-        "fast-levenshtein": "^2.0.6",
-        "levn": "^0.4.1",
-        "prelude-ls": "^1.2.1",
-        "type-check": "^0.4.0",
-        "word-wrap": "^1.2.3"
-      }
-    },
-    "p-limit": {
-      "version": "3.1.0",
-      "dev": true,
-      "requires": {
-        "yocto-queue": "^0.1.0"
-      }
-    },
-    "p-locate": {
-      "version": "4.1.0",
-      "dev": true,
-      "requires": {
-        "p-limit": "^2.2.0"
-      },
-      "dependencies": {
-        "p-limit": {
-          "version": "2.3.0",
-          "dev": true,
-          "requires": {
-            "p-try": "^2.0.0"
-          }
-        }
-      }
-    },
-    "p-retry": {
-      "version": "4.6.2",
-      "dev": true,
-      "requires": {
-        "@types/retry": "0.12.0",
-        "retry": "^0.13.1"
-      },
-      "dependencies": {
-        "retry": {
-          "version": "0.13.1",
-          "dev": true
-        }
-      }
-    },
-    "p-try": {
-      "version": "2.2.0",
-      "dev": true
-    },
-    "param-case": {
-      "version": "3.0.4",
-      "dev": true,
-      "requires": {
-        "dot-case": "^3.0.4",
-        "tslib": "^2.0.3"
-      }
-    },
-    "parent-module": {
-      "version": "1.0.1",
-      "dev": true,
-      "requires": {
-        "callsites": "^3.0.0"
-      }
-    },
-    "parse-json": {
-      "version": "5.2.0",
-      "dev": true,
-      "requires": {
-        "@babel/code-frame": "^7.0.0",
-        "error-ex": "^1.3.1",
-        "json-parse-even-better-errors": "^2.3.0",
-        "lines-and-columns": "^1.1.6"
-      }
-    },
-    "parseurl": {
-      "version": "1.3.3",
-      "dev": true
-    },
-    "pascal-case": {
-      "version": "3.1.2",
-      "dev": true,
-      "requires": {
-        "no-case": "^3.0.4",
-        "tslib": "^2.0.3"
-      }
-    },
-    "path-exists": {
-      "version": "4.0.0",
-      "dev": true
-    },
-    "path-is-absolute": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "path-key": {
-      "version": "3.1.1",
-      "dev": true
-    },
-    "path-parse": {
-      "version": "1.0.7",
-      "dev": true
-    },
-    "path-to-regexp": {
-      "version": "0.1.7",
-      "dev": true
-    },
-    "path-type": {
-      "version": "4.0.0",
-      "dev": true
-    },
-    "picocolors": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "picomatch": {
-      "version": "2.3.1",
-      "dev": true
-    },
-    "pirates": {
-      "version": "4.0.5",
-      "dev": true
-    },
-    "pkg-dir": {
-      "version": "4.2.0",
-      "dev": true,
-      "requires": {
-        "find-up": "^4.0.0"
-      }
-    },
-    "prelude-ls": {
-      "version": "1.2.1",
-      "dev": true
-    },
-    "prettier": {
-      "version": "2.8.7",
-      "dev": true
-    },
-    "pretty-error": {
-      "version": "4.0.0",
-      "dev": true,
-      "requires": {
-        "lodash": "^4.17.20",
-        "renderkid": "^3.0.0"
-      }
-    },
-    "pretty-format": {
-      "version": "29.5.0",
-      "dev": true,
-      "requires": {
-        "@jest/schemas": "^29.4.3",
-        "ansi-styles": "^5.0.0",
-        "react-is": "^18.0.0"
-      },
-      "dependencies": {
-        "ansi-styles": {
-          "version": "5.2.0",
-          "dev": true
-        }
-      }
-    },
-    "process-nextick-args": {
-      "version": "2.0.1",
-      "dev": true
-    },
-    "prompts": {
-      "version": "2.4.2",
-      "dev": true,
-      "requires": {
-        "kleur": "^3.0.3",
-        "sisteransi": "^1.0.5"
-      }
-    },
-    "proxy-addr": {
-      "version": "2.0.7",
-      "dev": true,
-      "requires": {
-        "forwarded": "0.2.0",
-        "ipaddr.js": "1.9.1"
-      }
-    },
-    "punycode": {
-      "version": "2.3.0",
-      "dev": true
-    },
-    "pure-rand": {
-      "version": "6.0.1",
-      "dev": true
-    },
-    "qs": {
-      "version": "6.11.0",
-      "dev": true,
-      "requires": {
-        "side-channel": "^1.0.4"
-      }
-    },
-    "queue-microtask": {
-      "version": "1.2.3",
-      "dev": true
-    },
-    "randombytes": {
-      "version": "2.1.0",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "^5.1.0"
-      }
-    },
-    "range-parser": {
-      "version": "1.2.1",
-      "dev": true
-    },
-    "raw-body": {
-      "version": "2.5.1",
-      "dev": true,
-      "requires": {
-        "bytes": "3.1.2",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.4.24",
-        "unpipe": "1.0.0"
-      }
-    },
-    "react-is": {
-      "version": "18.2.0",
-      "dev": true
-    },
-    "readable-stream": {
-      "version": "3.6.2",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.3",
-        "string_decoder": "^1.1.1",
-        "util-deprecate": "^1.0.1"
-      }
-    },
-    "readdirp": {
-      "version": "3.6.0",
-      "dev": true,
-      "requires": {
-        "picomatch": "^2.2.1"
-      }
-    },
-    "rechoir": {
-      "version": "0.8.0",
-      "dev": true,
-      "requires": {
-        "resolve": "^1.20.0"
-      }
-    },
-    "relateurl": {
-      "version": "0.2.7",
-      "dev": true
-    },
-    "renderkid": {
-      "version": "3.0.0",
-      "dev": true,
-      "requires": {
-        "css-select": "^4.1.3",
-        "dom-converter": "^0.2.0",
-        "htmlparser2": "^6.1.0",
-        "lodash": "^4.17.21",
-        "strip-ansi": "^6.0.1"
-      }
-    },
-    "require-directory": {
-      "version": "2.1.1",
-      "dev": true
-    },
-    "require-from-string": {
-      "version": "2.0.2",
-      "dev": true
-    },
-    "requires-port": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "resolve": {
-      "version": "1.22.2",
-      "dev": true,
-      "requires": {
-        "is-core-module": "^2.11.0",
-        "path-parse": "^1.0.7",
-        "supports-preserve-symlinks-flag": "^1.0.0"
-      }
-    },
-    "resolve-cwd": {
-      "version": "3.0.0",
-      "dev": true,
-      "requires": {
-        "resolve-from": "^5.0.0"
-      }
-    },
-    "resolve-from": {
-      "version": "5.0.0",
-      "dev": true
-    },
-    "resolve-typescript-plugin": {
-      "version": "2.0.1",
-      "dev": true,
-      "requires": {
-        "tslib": "2.5.0"
-      }
-    },
-    "resolve.exports": {
-      "version": "2.0.2",
-      "dev": true
-    },
-    "reusify": {
-      "version": "1.0.4",
-      "dev": true
-    },
-    "rimraf": {
-      "version": "3.0.2",
-      "dev": true,
-      "requires": {
-        "glob": "^7.1.3"
-      }
-    },
-    "run-parallel": {
-      "version": "1.2.0",
-      "dev": true,
-      "requires": {
-        "queue-microtask": "^1.2.2"
-      }
-    },
-    "safe-buffer": {
-      "version": "5.2.1",
-      "dev": true
-    },
-    "safer-buffer": {
-      "version": "2.1.2",
-      "dev": true
-    },
-    "schema-utils": {
-      "version": "4.0.1",
-      "dev": true,
-      "requires": {
-        "@types/json-schema": "^7.0.9",
-        "ajv": "^8.9.0",
-        "ajv-formats": "^2.1.1",
-        "ajv-keywords": "^5.1.0"
-      }
-    },
-    "select-hose": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "selfsigned": {
-      "version": "2.1.1",
-      "dev": true,
-      "requires": {
-        "node-forge": "^1"
-      }
-    },
-    "semver": {
-      "version": "7.3.8",
-      "dev": true,
-      "requires": {
-        "lru-cache": "^6.0.0"
-      }
-    },
-    "send": {
-      "version": "0.18.0",
-      "dev": true,
-      "requires": {
-        "debug": "2.6.9",
-        "depd": "2.0.0",
-        "destroy": "1.2.0",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "fresh": "0.5.2",
-        "http-errors": "2.0.0",
-        "mime": "1.6.0",
-        "ms": "2.1.3",
-        "on-finished": "2.4.1",
-        "range-parser": "~1.2.1",
-        "statuses": "2.0.1"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "2.6.9",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          },
-          "dependencies": {
-            "ms": {
-              "version": "2.0.0",
-              "dev": true
-            }
-          }
-        }
-      }
-    },
-    "serialize-javascript": {
-      "version": "6.0.1",
-      "dev": true,
-      "requires": {
-        "randombytes": "^2.1.0"
-      }
-    },
-    "serve-index": {
-      "version": "1.9.1",
-      "dev": true,
-      "requires": {
-        "accepts": "~1.3.4",
-        "batch": "0.6.1",
-        "debug": "2.6.9",
-        "escape-html": "~1.0.3",
-        "http-errors": "~1.6.2",
-        "mime-types": "~2.1.17",
-        "parseurl": "~1.3.2"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "2.6.9",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "depd": {
-          "version": "1.1.2",
-          "dev": true
-        },
-        "http-errors": {
-          "version": "1.6.3",
-          "dev": true,
-          "requires": {
-            "depd": "~1.1.2",
-            "inherits": "2.0.3",
-            "setprototypeof": "1.1.0",
-            "statuses": ">= 1.4.0 < 2"
-          }
-        },
-        "inherits": {
-          "version": "2.0.3",
-          "dev": true
-        },
-        "ms": {
-          "version": "2.0.0",
-          "dev": true
-        },
-        "setprototypeof": {
-          "version": "1.1.0",
-          "dev": true
-        },
-        "statuses": {
-          "version": "1.5.0",
-          "dev": true
-        }
-      }
-    },
-    "serve-static": {
-      "version": "1.15.0",
-      "dev": true,
-      "requires": {
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "parseurl": "~1.3.3",
-        "send": "0.18.0"
-      }
-    },
-    "setprototypeof": {
-      "version": "1.2.0",
-      "dev": true
-    },
-    "shallow-clone": {
-      "version": "3.0.1",
-      "dev": true,
-      "requires": {
-        "kind-of": "^6.0.2"
-      }
-    },
-    "shebang-command": {
-      "version": "2.0.0",
-      "dev": true,
-      "requires": {
-        "shebang-regex": "^3.0.0"
-      }
-    },
-    "shebang-regex": {
-      "version": "3.0.0",
-      "dev": true
-    },
-    "shell-quote": {
-      "version": "1.8.1",
-      "dev": true
-    },
-    "side-channel": {
-      "version": "1.0.4",
-      "dev": true,
-      "requires": {
-        "call-bind": "^1.0.0",
-        "get-intrinsic": "^1.0.2",
-        "object-inspect": "^1.9.0"
-      }
-    },
-    "signal-exit": {
-      "version": "3.0.7",
-      "dev": true
-    },
-    "sisteransi": {
-      "version": "1.0.5",
-      "dev": true
-    },
-    "slash": {
-      "version": "3.0.0",
-      "dev": true
-    },
-    "sockjs": {
-      "version": "0.3.24",
-      "dev": true,
-      "requires": {
-        "faye-websocket": "^0.11.3",
-        "uuid": "^8.3.2",
-        "websocket-driver": "^0.7.4"
-      }
-    },
-    "source-map": {
-      "version": "0.6.1",
-      "dev": true
-    },
-    "source-map-support": {
-      "version": "0.5.21",
-      "dev": true,
-      "requires": {
-        "buffer-from": "^1.0.0",
-        "source-map": "^0.6.0"
-      }
-    },
-    "spdy": {
-      "version": "4.0.2",
-      "dev": true,
-      "requires": {
-        "debug": "^4.1.0",
-        "handle-thing": "^2.0.0",
-        "http-deceiver": "^1.2.7",
-        "select-hose": "^2.0.0",
-        "spdy-transport": "^3.0.0"
-      }
-    },
-    "spdy-transport": {
-      "version": "3.0.0",
-      "dev": true,
-      "requires": {
-        "debug": "^4.1.0",
-        "detect-node": "^2.0.4",
-        "hpack.js": "^2.1.6",
-        "obuf": "^1.1.2",
-        "readable-stream": "^3.0.6",
-        "wbuf": "^1.7.3"
-      }
-    },
-    "sprintf-js": {
-      "version": "1.0.3",
-      "dev": true
-    },
-    "stack-utils": {
-      "version": "2.0.6",
-      "dev": true,
-      "requires": {
-        "escape-string-regexp": "^2.0.0"
-      },
-      "dependencies": {
-        "escape-string-regexp": {
-          "version": "2.0.0",
-          "dev": true
-        }
-      }
-    },
-    "statuses": {
-      "version": "2.0.1",
-      "dev": true
-    },
-    "string_decoder": {
-      "version": "1.3.0",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "~5.2.0"
-      }
-    },
-    "string-length": {
-      "version": "4.0.2",
-      "dev": true,
-      "requires": {
-        "char-regex": "^1.0.2",
-        "strip-ansi": "^6.0.0"
-      }
-    },
-    "string-width": {
-      "version": "4.2.3",
-      "dev": true,
-      "requires": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      }
-    },
-    "strip-ansi": {
-      "version": "6.0.1",
-      "dev": true,
-      "requires": {
-        "ansi-regex": "^5.0.1"
-      }
-    },
-    "strip-bom": {
-      "version": "4.0.0",
-      "dev": true
-    },
-    "strip-final-newline": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "strip-json-comments": {
-      "version": "3.1.1",
-      "dev": true
-    },
-    "supports-color": {
-      "version": "7.2.0",
-      "dev": true,
-      "requires": {
-        "has-flag": "^4.0.0"
-      }
-    },
-    "supports-preserve-symlinks-flag": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "tapable": {
-      "version": "2.2.1",
-      "dev": true
-    },
-    "terser": {
-      "version": "5.17.3",
-      "dev": true,
-      "requires": {
-        "@jridgewell/source-map": "^0.3.2",
-        "acorn": "^8.5.0",
-        "commander": "^2.20.0",
-        "source-map-support": "~0.5.20"
-      },
-      "dependencies": {
-        "commander": {
-          "version": "2.20.3",
-          "dev": true
-        }
-      }
-    },
-    "terser-webpack-plugin": {
-      "version": "5.3.8",
-      "dev": true,
-      "requires": {
-        "@jridgewell/trace-mapping": "^0.3.17",
-        "jest-worker": "^27.4.5",
-        "schema-utils": "^3.1.1",
-        "serialize-javascript": "^6.0.1",
-        "terser": "^5.16.8"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "6.12.6",
-          "dev": true,
-          "requires": {
-            "fast-deep-equal": "^3.1.1",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.4.1",
-            "uri-js": "^4.2.2"
-          }
-        },
-        "ajv-keywords": {
-          "version": "3.5.2",
-          "dev": true,
-          "requires": {}
-        },
-        "jest-worker": {
-          "version": "27.5.1",
-          "dev": true,
-          "requires": {
-            "@types/node": "*",
-            "merge-stream": "^2.0.0",
-            "supports-color": "^8.0.0"
-          }
-        },
-        "schema-utils": {
-          "version": "3.1.2",
-          "dev": true,
-          "requires": {
-            "@types/json-schema": "^7.0.8",
-            "ajv": "^6.12.5",
-            "ajv-keywords": "^3.5.2"
-          }
-        },
-        "supports-color": {
-          "version": "8.1.1",
-          "dev": true,
-          "requires": {
-            "has-flag": "^4.0.0"
-          }
-        }
-      }
-    },
-    "test-exclude": {
-      "version": "6.0.0",
-      "dev": true,
-      "requires": {
-        "@istanbuljs/schema": "^0.1.2",
-        "glob": "^7.1.4",
-        "minimatch": "^3.0.4"
-      }
-    },
-    "text-table": {
-      "version": "0.2.0",
-      "dev": true
-    },
-    "thunky": {
-      "version": "1.1.0",
-      "dev": true
-    },
-    "tmpl": {
-      "version": "1.0.5",
-      "dev": true
-    },
-    "to-fast-properties": {
-      "version": "2.0.0",
-      "dev": true
-    },
-    "to-regex-range": {
-      "version": "5.0.1",
-      "dev": true,
-      "requires": {
-        "is-number": "^7.0.0"
-      }
-    },
-    "toidentifier": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "ts-jest": {
-      "version": "29.1.0",
-      "dev": true,
-      "requires": {
-        "bs-logger": "0.x",
-        "fast-json-stable-stringify": "2.x",
-        "jest-util": "^29.0.0",
-        "json5": "^2.2.3",
-        "lodash.memoize": "4.x",
-        "make-error": "1.x",
-        "semver": "7.x",
-        "yargs-parser": "^21.0.1"
-      }
-    },
-    "ts-loader": {
-      "version": "9.4.2",
-      "dev": true,
-      "requires": {
-        "chalk": "^4.1.0",
-        "enhanced-resolve": "^5.0.0",
-        "micromatch": "^4.0.0",
-        "semver": "^7.3.4"
-      },
-      "dependencies": {
-        "semver": {
-          "version": "7.5.0",
-          "dev": true,
-          "requires": {
-            "lru-cache": "^6.0.0"
-          }
-        }
-      }
-    },
-    "ts-node": {
-      "version": "10.9.1",
-      "dev": true,
-      "requires": {
-        "@cspotcode/source-map-support": "^0.8.0",
-        "@tsconfig/node10": "^1.0.7",
-        "@tsconfig/node12": "^1.0.7",
-        "@tsconfig/node14": "^1.0.0",
-        "@tsconfig/node16": "^1.0.2",
-        "acorn": "^8.4.1",
-        "acorn-walk": "^8.1.1",
-        "arg": "^4.1.0",
-        "create-require": "^1.1.0",
-        "diff": "^4.0.1",
-        "make-error": "^1.1.1",
-        "v8-compile-cache-lib": "^3.0.1",
-        "yn": "3.1.1"
-      }
-    },
-    "tslib": {
-      "version": "2.5.0"
-    },
-    "tsutils": {
-      "version": "3.21.0",
-      "dev": true,
-      "requires": {
-        "tslib": "^1.8.1"
-      },
-      "dependencies": {
-        "tslib": {
-          "version": "1.14.1",
-          "dev": true
-        }
-      }
-    },
-    "type-check": {
-      "version": "0.4.0",
-      "dev": true,
-      "requires": {
-        "prelude-ls": "^1.2.1"
-      }
-    },
-    "type-detect": {
-      "version": "4.0.8",
-      "dev": true
-    },
-    "type-fest": {
-      "version": "0.20.2",
-      "dev": true
-    },
-    "type-is": {
-      "version": "1.6.18",
-      "dev": true,
-      "requires": {
-        "media-typer": "0.3.0",
-        "mime-types": "~2.1.24"
-      }
-    },
-    "typescript": {
-      "version": "5.0.4",
-      "dev": true
-    },
-    "unpipe": {
-      "version": "1.0.0",
-      "dev": true
-    },
-    "update-browserslist-db": {
-      "version": "1.0.10",
-      "dev": true,
-      "requires": {
-        "escalade": "^3.1.1",
-        "picocolors": "^1.0.0"
-      }
-    },
-    "uri-js": {
-      "version": "4.4.1",
-      "dev": true,
-      "requires": {
-        "punycode": "^2.1.0"
-      }
-    },
-    "util-deprecate": {
-      "version": "1.0.2",
-      "dev": true
-    },
-    "utila": {
-      "version": "0.4.0",
-      "dev": true
-    },
-    "utils-merge": {
-      "version": "1.0.1",
-      "dev": true
-    },
-    "uuid": {
-      "version": "8.3.2",
-      "dev": true
-    },
-    "v8-compile-cache-lib": {
-      "version": "3.0.1",
-      "dev": true
-    },
-    "v8-to-istanbul": {
-      "version": "9.1.0",
-      "dev": true,
-      "requires": {
-        "@jridgewell/trace-mapping": "^0.3.12",
-        "@types/istanbul-lib-coverage": "^2.0.1",
-        "convert-source-map": "^1.6.0"
-      }
-    },
-    "vary": {
-      "version": "1.1.2",
-      "dev": true
-    },
-    "walker": {
-      "version": "1.0.8",
-      "dev": true,
-      "requires": {
-        "makeerror": "1.0.12"
-      }
-    },
-    "watchpack": {
-      "version": "2.4.0",
-      "dev": true,
-      "requires": {
-        "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.1.2"
-      }
-    },
-    "wbuf": {
-      "version": "1.7.3",
-      "dev": true,
-      "requires": {
-        "minimalistic-assert": "^1.0.0"
-      }
-    },
-    "webpack": {
-      "version": "5.82.1",
-      "dev": true,
-      "requires": {
-        "@types/eslint-scope": "^3.7.3",
-        "@types/estree": "^1.0.0",
-        "@webassemblyjs/ast": "^1.11.5",
-        "@webassemblyjs/wasm-edit": "^1.11.5",
-        "@webassemblyjs/wasm-parser": "^1.11.5",
-        "acorn": "^8.7.1",
-        "acorn-import-assertions": "^1.7.6",
-        "browserslist": "^4.14.5",
-        "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.14.0",
-        "es-module-lexer": "^1.2.1",
-        "eslint-scope": "5.1.1",
-        "events": "^3.2.0",
-        "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.2.9",
-        "json-parse-even-better-errors": "^2.3.1",
-        "loader-runner": "^4.2.0",
-        "mime-types": "^2.1.27",
-        "neo-async": "^2.6.2",
-        "schema-utils": "^3.1.2",
-        "tapable": "^2.1.1",
-        "terser-webpack-plugin": "^5.3.7",
-        "watchpack": "^2.4.0",
-        "webpack-sources": "^3.2.3"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "6.12.6",
-          "dev": true,
-          "requires": {
-            "fast-deep-equal": "^3.1.1",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.4.1",
-            "uri-js": "^4.2.2"
-          }
-        },
-        "ajv-keywords": {
-          "version": "3.5.2",
-          "dev": true,
-          "requires": {}
-        },
-        "schema-utils": {
-          "version": "3.1.2",
-          "dev": true,
-          "requires": {
-            "@types/json-schema": "^7.0.8",
-            "ajv": "^6.12.5",
-            "ajv-keywords": "^3.5.2"
-          }
-        }
-      }
-    },
-    "webpack-cli": {
-      "version": "5.1.1",
-      "dev": true,
-      "requires": {
-        "@discoveryjs/json-ext": "^0.5.0",
-        "@webpack-cli/configtest": "^2.1.0",
-        "@webpack-cli/info": "^2.0.1",
-        "@webpack-cli/serve": "^2.0.4",
-        "colorette": "^2.0.14",
-        "commander": "^10.0.1",
-        "cross-spawn": "^7.0.3",
-        "envinfo": "^7.7.3",
-        "fastest-levenshtein": "^1.0.12",
-        "import-local": "^3.0.2",
-        "interpret": "^3.1.1",
-        "rechoir": "^0.8.0",
-        "webpack-merge": "^5.7.3"
-      }
-    },
-    "webpack-dev-middleware": {
-      "version": "5.3.3",
-      "dev": true,
-      "requires": {
-        "colorette": "^2.0.10",
-        "memfs": "^3.4.3",
-        "mime-types": "^2.1.31",
-        "range-parser": "^1.2.1",
-        "schema-utils": "^4.0.0"
-      }
-    },
-    "webpack-dev-server": {
-      "version": "4.15.0",
-      "dev": true,
-      "requires": {
-        "@types/bonjour": "^3.5.9",
-        "@types/connect-history-api-fallback": "^1.3.5",
-        "@types/express": "^4.17.13",
-        "@types/serve-index": "^1.9.1",
-        "@types/serve-static": "^1.13.10",
-        "@types/sockjs": "^0.3.33",
-        "@types/ws": "^8.5.1",
-        "ansi-html-community": "^0.0.8",
-        "bonjour-service": "^1.0.11",
-        "chokidar": "^3.5.3",
-        "colorette": "^2.0.10",
-        "compression": "^1.7.4",
-        "connect-history-api-fallback": "^2.0.0",
-        "default-gateway": "^6.0.3",
-        "express": "^4.17.3",
-        "graceful-fs": "^4.2.6",
-        "html-entities": "^2.3.2",
-        "http-proxy-middleware": "^2.0.3",
-        "ipaddr.js": "^2.0.1",
-        "launch-editor": "^2.6.0",
-        "open": "^8.0.9",
-        "p-retry": "^4.5.0",
-        "rimraf": "^3.0.2",
-        "schema-utils": "^4.0.0",
-        "selfsigned": "^2.1.1",
-        "serve-index": "^1.9.1",
-        "sockjs": "^0.3.24",
-        "spdy": "^4.0.2",
-        "webpack-dev-middleware": "^5.3.1",
-        "ws": "^8.13.0"
-      },
-      "dependencies": {
-        "ipaddr.js": {
-          "version": "2.0.1",
-          "dev": true
-        }
-      }
-    },
-    "webpack-merge": {
-      "version": "5.8.0",
-      "dev": true,
-      "requires": {
-        "clone-deep": "^4.0.1",
-        "wildcard": "^2.0.0"
-      }
-    },
-    "webpack-sources": {
-      "version": "3.2.3",
-      "dev": true
-    },
-    "websocket-driver": {
-      "version": "0.7.4",
-      "dev": true,
-      "requires": {
-        "http-parser-js": ">=0.5.1",
-        "safe-buffer": ">=5.1.0",
-        "websocket-extensions": ">=0.1.1"
-      }
-    },
-    "websocket-extensions": {
-      "version": "0.1.4",
-      "dev": true
-    },
-    "which": {
-      "version": "2.0.2",
-      "dev": true,
-      "requires": {
-        "isexe": "^2.0.0"
-      }
-    },
-    "wildcard": {
-      "version": "2.0.1",
-      "dev": true
-    },
-    "word-wrap": {
-      "version": "1.2.3",
-      "dev": true
-    },
-    "wrap-ansi": {
-      "version": "7.0.0",
-      "dev": true,
-      "requires": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      }
-    },
-    "wrappy": {
-      "version": "1.0.2",
-      "dev": true
-    },
-    "write-file-atomic": {
-      "version": "4.0.2",
-      "dev": true,
-      "requires": {
-        "imurmurhash": "^0.1.4",
-        "signal-exit": "^3.0.7"
-      }
-    },
-    "ws": {
-      "version": "8.13.0",
-      "dev": true,
-      "requires": {}
-    },
-    "y18n": {
-      "version": "5.0.8",
-      "dev": true
-    },
-    "yallist": {
-      "version": "4.0.0",
-      "dev": true
-    },
-    "yargs": {
-      "version": "17.7.1",
-      "dev": true,
-      "requires": {
-        "cliui": "^8.0.1",
-        "escalade": "^3.1.1",
-        "get-caller-file": "^2.0.5",
-        "require-directory": "^2.1.1",
-        "string-width": "^4.2.3",
-        "y18n": "^5.0.5",
-        "yargs-parser": "^21.1.1"
-      }
-    },
-    "yargs-parser": {
-      "version": "21.1.1",
-      "dev": true
-    },
-    "yn": {
-      "version": "3.1.1",
-      "dev": true
-    },
-    "yocto-queue": {
-      "version": "0.1.0",
-      "dev": true
-    }
-  }
-}
diff --git a/ts/package.json b/ts/package.json
index 91c469b3c9..6bcbcd5dff 100644
--- a/ts/package.json
+++ b/ts/package.json
@@ -1,16 +1,18 @@
 {
-  "name": "@aztec/barretenberg.js",
-  "version": "0.0.0",
+  "name": "@aztec/bb.js",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "typedoc": {
     "entryPoint": "./src/index.ts",
-    "displayName": "Barretenberg.js",
+    "displayName": "bb.js",
     "tsconfig": "./tsconfig.json"
   },
-  "bin": {
-    "bb.js": "./dest/main.js",
-    "bb.js-dev": "./src/main-dev.ts"
-  },
+  "bin": "./dest/main.js",
+  "files": [
+    "src/",
+    "dest/",
+    "README.md"
+  ],
   "scripts": {
     "clean": "rm -rf ./dest .tsbuildinfo",
     "build": "yarn clean && yarn build:wasm && tsc -b && webpack && chmod +x ./dest/main.js",
@@ -40,8 +42,9 @@
     "rootDir": "./src"
   },
   "dependencies": {
-    "bigint-buffer": "^1.1.5",
+    "comlink": "^4.4.1",
     "commander": "^10.0.1",
+    "debug": "^4.3.4",
     "ts-node": "^10.9.1",
     "tslib": "^2.4.0"
   },
@@ -55,9 +58,7 @@
     "@typescript-eslint/eslint-plugin": "^5.54.1",
     "@typescript-eslint/parser": "^5.54.1",
     "buffer": "^6.0.3",
-    "comlink": "^4.4.1",
     "copy-webpack-plugin": "^11.0.0",
-    "debug": "^4.3.4",
     "eslint": "^8.35.0",
     "eslint-config-prettier": "^8.8.0",
     "html-webpack-plugin": "^5.5.1",
diff --git a/ts/src/index.ts b/ts/src/index.ts
index b6df75a32a..686cf4af06 100644
--- a/ts/src/index.ts
+++ b/ts/src/index.ts
@@ -1,3 +1,5 @@
 export * from './crs/index.js';
 export * from './barretenberg_wasm/index.js';
 export * from './barretenberg_api/index.js';
+export * from './factory/index.js';
+export { RawBuffer } from './types/index.js';
diff --git a/ts/src/main-dev.ts b/ts/src/main-dev.ts
deleted file mode 100755
index 8c090cb92d..0000000000
--- a/ts/src/main-dev.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/usr/bin/env -S node --loader ts-node/esm --no-warnings
-import './main.js';
diff --git a/ts/src/main.ts b/ts/src/main.ts
index 587117832d..dc8c5c50cd 100755
--- a/ts/src/main.ts
+++ b/ts/src/main.ts
@@ -1,16 +1,13 @@
 #!/usr/bin/env -S node --no-warnings
-import { Crs } from './crs/index.js';
+import { Crs, BarretenbergApiAsync, newBarretenbergApiAsync, RawBuffer } from './index.js';
 import createDebug from 'debug';
-import { BarretenbergApiAsync, newBarretenbergApiAsync } from './factory/index.js';
 import { readFileSync, writeFileSync } from 'fs';
 import { gunzipSync } from 'zlib';
-import { RawBuffer } from './types/index.js';
 import { numToUInt32BE } from './serialize/serialize.js';
 import { Command } from 'commander';
 
 createDebug.log = console.error.bind(console);
 const debug = createDebug('bb.js');
-// createDebug.enable('*');
 
 // Maximum we support.
 const MAX_CIRCUIT_SIZE = 2 ** 19;
@@ -247,6 +244,14 @@ export async function vkAsFields(vkPath: string, vkeyOutputPath: string) {
 
 const program = new Command();
 
+program.option('-v, --verbose', 'enable verbose logging', false);
+
+function handleGlobalOptions() {
+  if (program.opts().verbose) {
+    createDebug.enable('bb.js*');
+  }
+}
+
 program
   .command('prove_and_verify')
   .description('Generate a proof and verify it. Process exits with success or failure code.')
@@ -254,6 +259,7 @@ program
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
   .option('-r, --recursive', 'prove and verify using recursive prover and verifier', false)
   .action(async ({ jsonPath, witnessPath, recursive }) => {
+    handleGlobalOptions();
     const result = await proveAndVerify(jsonPath, witnessPath, recursive);
     process.exit(result ? 0 : 1);
   });
@@ -267,6 +273,7 @@ program
   .option('-o, --output-dir <path>', 'Specify the proof output dir', './proofs')
   .requiredOption('-n, --name <filename>', 'Output file name.')
   .action(async ({ jsonPath, witnessPath, recursive, outputDir, name }) => {
+    handleGlobalOptions();
     await prove(jsonPath, witnessPath, recursive, outputDir + '/' + name);
   });
 
@@ -284,7 +291,7 @@ program
   .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
   .option('-r, --recursive', 'prove using recursive prover', false)
-  .option('-v, --vk <path>', 'path to a verification key. avoids recomputation.')
+  .option('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
   .action(async ({ jsonPath, proofPath, recursive, vk }) => {
     await verify(jsonPath, proofPath, recursive, vk);
   });
diff --git a/ts/yarn.lock b/ts/yarn.lock
index 56f0530fc7..0b068d22d7 100644
--- a/ts/yarn.lock
+++ b/ts/yarn.lock
@@ -15,9 +15,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/barretenberg.js@workspace:.":
+"@aztec/bb.js@workspace:.":
   version: 0.0.0-use.local
-  resolution: "@aztec/barretenberg.js@workspace:."
+  resolution: "@aztec/bb.js@workspace:."
   dependencies:
     "@jest/globals": ^29.4.3
     "@types/debug": ^4.1.7
@@ -27,7 +27,6 @@ __metadata:
     "@types/source-map-support": ^0.5.6
     "@typescript-eslint/eslint-plugin": ^5.54.1
     "@typescript-eslint/parser": ^5.54.1
-    bigint-buffer: ^1.1.5
     buffer: ^6.0.3
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -50,7 +49,6 @@ __metadata:
     webpack-dev-server: ^4.15.0
   bin:
     bb.js: ./dest/main.js
-    bb.js-dev: ./src/main-dev.ts
   languageName: unknown
   linkType: soft
 
@@ -63,67 +61,67 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/compat-data@npm:^7.21.5":
-  version: 7.21.9
-  resolution: "@babel/compat-data@npm:7.21.9"
-  checksum: df97be04955c0801f5a23846f79a100660aa98f9433cfd1fad8f53ecd9f3454538e78522e86275939aa8aa7d6f9e32f23f94bc04ae843f7246b7cd4bffe3a175
+"@babel/compat-data@npm:^7.22.0":
+  version: 7.22.3
+  resolution: "@babel/compat-data@npm:7.22.3"
+  checksum: eb001646f41459f42ccb0d39ee8bb3c3c495bc297234817044c0002689c625e3159a6678c53fd31bd98cf21f31472b73506f350fc6906e3bdfa49cb706e2af8d
   languageName: node
   linkType: hard
 
 "@babel/core@npm:^7.11.6, @babel/core@npm:^7.12.3":
-  version: 7.21.8
-  resolution: "@babel/core@npm:7.21.8"
+  version: 7.22.1
+  resolution: "@babel/core@npm:7.22.1"
   dependencies:
     "@ampproject/remapping": ^2.2.0
     "@babel/code-frame": ^7.21.4
-    "@babel/generator": ^7.21.5
-    "@babel/helper-compilation-targets": ^7.21.5
-    "@babel/helper-module-transforms": ^7.21.5
-    "@babel/helpers": ^7.21.5
-    "@babel/parser": ^7.21.8
-    "@babel/template": ^7.20.7
-    "@babel/traverse": ^7.21.5
-    "@babel/types": ^7.21.5
+    "@babel/generator": ^7.22.0
+    "@babel/helper-compilation-targets": ^7.22.1
+    "@babel/helper-module-transforms": ^7.22.1
+    "@babel/helpers": ^7.22.0
+    "@babel/parser": ^7.22.0
+    "@babel/template": ^7.21.9
+    "@babel/traverse": ^7.22.1
+    "@babel/types": ^7.22.0
     convert-source-map: ^1.7.0
     debug: ^4.1.0
     gensync: ^1.0.0-beta.2
     json5: ^2.2.2
     semver: ^6.3.0
-  checksum: f28118447355af2a90bd340e2e60699f94c8020517eba9b71bf8ebff62fa9e00d63f076e033f9dfb97548053ad62ada45fafb0d96584b1a90e8aef5a3b8241b1
+  checksum: bbe45e791f223a7e692d2ea6597a73f48050abd24b119c85c48ac6504c30ce63343a2ea3f79b5847bf4b409ddd8a68b6cdc4f0272ded1d2ef6f6b1e9663432f0
   languageName: node
   linkType: hard
 
-"@babel/generator@npm:^7.21.5, @babel/generator@npm:^7.7.2":
-  version: 7.21.9
-  resolution: "@babel/generator@npm:7.21.9"
+"@babel/generator@npm:^7.22.0, @babel/generator@npm:^7.22.3, @babel/generator@npm:^7.7.2":
+  version: 7.22.3
+  resolution: "@babel/generator@npm:7.22.3"
   dependencies:
-    "@babel/types": ^7.21.5
+    "@babel/types": ^7.22.3
     "@jridgewell/gen-mapping": ^0.3.2
     "@jridgewell/trace-mapping": ^0.3.17
     jsesc: ^2.5.1
-  checksum: 5bd10334ebdf7f2a30eb4a1fd99d369a57703aa2234527784449187512c254a1174fa739c9d4c31bcbb6018732012a0664bec7c314f12b5ec2458737ddbb01c7
+  checksum: ccb6426ca5b5a38f0d47a3ac9628e223d2aaaa489cbf90ffab41468795c22afe86855f68a58667f0f2673949f1810d4d5a57b826c17984eab3e28fdb34a909e6
   languageName: node
   linkType: hard
 
-"@babel/helper-compilation-targets@npm:^7.21.5":
-  version: 7.21.5
-  resolution: "@babel/helper-compilation-targets@npm:7.21.5"
+"@babel/helper-compilation-targets@npm:^7.22.1":
+  version: 7.22.1
+  resolution: "@babel/helper-compilation-targets@npm:7.22.1"
   dependencies:
-    "@babel/compat-data": ^7.21.5
+    "@babel/compat-data": ^7.22.0
     "@babel/helper-validator-option": ^7.21.0
     browserslist: ^4.21.3
     lru-cache: ^5.1.1
     semver: ^6.3.0
   peerDependencies:
     "@babel/core": ^7.0.0
-  checksum: 0edecb9c970ddc22ebda1163e77a7f314121bef9e483e0e0d9a5802540eed90d5855b6bf9bce03419b35b2e07c323e62d0353b153fa1ca34f17dbba897a83c25
+  checksum: a686a01bd3288cf95ca26faa27958d34c04e2501c4b0858c3a6558776dec20317b5635f33d64c5a635b6fbdfe462a85c30d4bfa0ae7e7ffe3467e4d06442d7c8
   languageName: node
   linkType: hard
 
-"@babel/helper-environment-visitor@npm:^7.21.5":
-  version: 7.21.5
-  resolution: "@babel/helper-environment-visitor@npm:7.21.5"
-  checksum: e436af7b62956e919066448013a3f7e2cd0b51010c26c50f790124dcd350be81d5597b4e6ed0a4a42d098a27de1e38561cd7998a116a42e7899161192deac9a6
+"@babel/helper-environment-visitor@npm:^7.22.1":
+  version: 7.22.1
+  resolution: "@babel/helper-environment-visitor@npm:7.22.1"
+  checksum: a6b4bb5505453bff95518d361ac1de393f0029aeb8b690c70540f4317934c53c43cc4afcda8c752ffa8c272e63ed6b929a56eca28e4978424177b24238b21bf9
   languageName: node
   linkType: hard
 
@@ -155,19 +153,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-module-transforms@npm:^7.21.5":
-  version: 7.21.5
-  resolution: "@babel/helper-module-transforms@npm:7.21.5"
+"@babel/helper-module-transforms@npm:^7.22.1":
+  version: 7.22.1
+  resolution: "@babel/helper-module-transforms@npm:7.22.1"
   dependencies:
-    "@babel/helper-environment-visitor": ^7.21.5
+    "@babel/helper-environment-visitor": ^7.22.1
     "@babel/helper-module-imports": ^7.21.4
     "@babel/helper-simple-access": ^7.21.5
     "@babel/helper-split-export-declaration": ^7.18.6
     "@babel/helper-validator-identifier": ^7.19.1
-    "@babel/template": ^7.20.7
-    "@babel/traverse": ^7.21.5
-    "@babel/types": ^7.21.5
-  checksum: 1ccfc88830675a5d485d198e918498f9683cdd46f973fdd4fe1c85b99648fb70f87fca07756c7a05dc201bd9b248c74ced06ea80c9991926ac889f53c3659675
+    "@babel/template": ^7.21.9
+    "@babel/traverse": ^7.22.1
+    "@babel/types": ^7.22.0
+  checksum: dfa084211a93c9f0174ab07385fdbf7831bbf5c1ff3d4f984effc489f48670825ad8b817b9e9d2ec6492fde37ed6518c15944e9dd7a60b43a3d9874c9250f5f8
   languageName: node
   linkType: hard
 
@@ -217,14 +215,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helpers@npm:^7.21.5":
-  version: 7.21.5
-  resolution: "@babel/helpers@npm:7.21.5"
+"@babel/helpers@npm:^7.22.0":
+  version: 7.22.3
+  resolution: "@babel/helpers@npm:7.22.3"
   dependencies:
-    "@babel/template": ^7.20.7
-    "@babel/traverse": ^7.21.5
-    "@babel/types": ^7.21.5
-  checksum: a6f74b8579713988e7f5adf1a986d8b5255757632ba65b2552f0f609ead5476edb784044c7e4b18f3681ee4818ca9d08c41feb9bd4e828648c25a00deaa1f9e4
+    "@babel/template": ^7.21.9
+    "@babel/traverse": ^7.22.1
+    "@babel/types": ^7.22.3
+  checksum: 385289ee8b87cf9af448bbb9fcf747f6e67600db5f7f64eb4ad97761ee387819bf2212b6a757008286c6bfacf4f3fc0b6de88686f2e517a70fb59996bdfbd1e9
   languageName: node
   linkType: hard
 
@@ -239,12 +237,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.21.5, @babel/parser@npm:^7.21.8, @babel/parser@npm:^7.21.9":
-  version: 7.21.9
-  resolution: "@babel/parser@npm:7.21.9"
+"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.21.9, @babel/parser@npm:^7.22.0, @babel/parser@npm:^7.22.4":
+  version: 7.22.4
+  resolution: "@babel/parser@npm:7.22.4"
   bin:
     parser: ./bin/babel-parser.js
-  checksum: 985ccc311eb286a320331fd21ff54d94935df76e081abdb304cd4591ea2051a6c799c6b0d8e26d09a9dd041797d9a91ebadeb0c50699d0101bd39fc565082d5c
+  checksum: 0ca6d3a2d9aae2504ba1bc494704b64a83140884f7379f609de69bd39b60adb58a4f8ec692fe53fef8657dd82705d01b7e6efb65e18296326bdd66f71d52d9a9
   languageName: node
   linkType: hard
 
@@ -402,7 +400,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/template@npm:^7.20.7, @babel/template@npm:^7.3.3":
+"@babel/template@npm:^7.20.7, @babel/template@npm:^7.21.9, @babel/template@npm:^7.3.3":
   version: 7.21.9
   resolution: "@babel/template@npm:7.21.9"
   dependencies:
@@ -413,32 +411,32 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/traverse@npm:^7.21.5, @babel/traverse@npm:^7.7.2":
-  version: 7.21.5
-  resolution: "@babel/traverse@npm:7.21.5"
+"@babel/traverse@npm:^7.22.1, @babel/traverse@npm:^7.7.2":
+  version: 7.22.4
+  resolution: "@babel/traverse@npm:7.22.4"
   dependencies:
     "@babel/code-frame": ^7.21.4
-    "@babel/generator": ^7.21.5
-    "@babel/helper-environment-visitor": ^7.21.5
+    "@babel/generator": ^7.22.3
+    "@babel/helper-environment-visitor": ^7.22.1
     "@babel/helper-function-name": ^7.21.0
     "@babel/helper-hoist-variables": ^7.18.6
     "@babel/helper-split-export-declaration": ^7.18.6
-    "@babel/parser": ^7.21.5
-    "@babel/types": ^7.21.5
+    "@babel/parser": ^7.22.4
+    "@babel/types": ^7.22.4
     debug: ^4.1.0
     globals: ^11.1.0
-  checksum: b403733fa7d858f0c8e224f0434a6ade641bc469a4f92975363391e796629d5bf53e544761dfe85039aab92d5389ebe7721edb309d7a5bb7df2bf74f37bf9f47
+  checksum: 9560ae22092d5a7c52849145dd3e5aed2ffb73d61255e70e19e3fbd06bcbafbbdecea28df40a42ee3b60b01e85a42224ec841df93e867547e329091cc2f2bb6f
   languageName: node
   linkType: hard
 
-"@babel/types@npm:^7.0.0, @babel/types@npm:^7.18.6, @babel/types@npm:^7.20.7, @babel/types@npm:^7.21.0, @babel/types@npm:^7.21.4, @babel/types@npm:^7.21.5, @babel/types@npm:^7.3.0, @babel/types@npm:^7.3.3, @babel/types@npm:^7.8.3":
-  version: 7.21.5
-  resolution: "@babel/types@npm:7.21.5"
+"@babel/types@npm:^7.0.0, @babel/types@npm:^7.18.6, @babel/types@npm:^7.20.7, @babel/types@npm:^7.21.0, @babel/types@npm:^7.21.4, @babel/types@npm:^7.21.5, @babel/types@npm:^7.22.0, @babel/types@npm:^7.22.3, @babel/types@npm:^7.22.4, @babel/types@npm:^7.3.3, @babel/types@npm:^7.8.3":
+  version: 7.22.4
+  resolution: "@babel/types@npm:7.22.4"
   dependencies:
     "@babel/helper-string-parser": ^7.21.5
     "@babel/helper-validator-identifier": ^7.19.1
     to-fast-properties: ^2.0.0
-  checksum: 43242a99c612d13285ee4af46cc0f1066bcb6ffd38307daef7a76e8c70f36cfc3255eb9e75c8e768b40e761176c313aec4d5c0b9d97a21e494d49d5fd123a9f7
+  checksum: ffe36bb4f4a99ad13c426a98c3b508d70736036cae4e471d9c862e3a579847ed4f480686af0fce2633f6f7c0f0d3bf02da73da36e7edd3fde0b2061951dcba9a
   languageName: node
   linkType: hard
 
@@ -980,15 +978,15 @@ __metadata:
   linkType: hard
 
 "@types/babel__core@npm:^7.1.14":
-  version: 7.20.0
-  resolution: "@types/babel__core@npm:7.20.0"
+  version: 7.20.1
+  resolution: "@types/babel__core@npm:7.20.1"
   dependencies:
     "@babel/parser": ^7.20.7
     "@babel/types": ^7.20.7
     "@types/babel__generator": "*"
     "@types/babel__template": "*"
     "@types/babel__traverse": "*"
-  checksum: 49b601a0a7637f1f387442c8156bd086cfd10ff4b82b0e1994e73a6396643b5435366fb33d6b604eade8467cca594ef97adcbc412aede90bb112ebe88d0ad6df
+  checksum: 9fcd9691a33074802d9057ff70b0e3ff3778f52470475b68698a0f6714fbe2ccb36c16b43dc924eb978cd8a81c1f845e5ff4699e7a47606043b539eb8c6331a8
   languageName: node
   linkType: hard
 
@@ -1012,11 +1010,11 @@ __metadata:
   linkType: hard
 
 "@types/babel__traverse@npm:*, @types/babel__traverse@npm:^7.0.6":
-  version: 7.18.5
-  resolution: "@types/babel__traverse@npm:7.18.5"
+  version: 7.20.0
+  resolution: "@types/babel__traverse@npm:7.20.0"
   dependencies:
-    "@babel/types": ^7.3.0
-  checksum: b9e7f39eb84626cc8f83ebf75a621d47f04b53cb085a3ea738a9633d57cf65208e503b1830db91aa5e297bc2ba761681ac0b0cbfb7a3d56afcfb2296212668ef
+    "@babel/types": ^7.20.7
+  checksum: 030d647a61baa70aff5bc1193227694098191578e45e18720db3a14614f1827664d609630a668ad75cddffd7b80cd14a55455364239d1f14ea55f1f4d7d2c9ef
   languageName: node
   linkType: hard
 
@@ -1176,19 +1174,19 @@ __metadata:
   linkType: hard
 
 "@types/jest@npm:^29.4.0":
-  version: 29.5.1
-  resolution: "@types/jest@npm:29.5.1"
+  version: 29.5.2
+  resolution: "@types/jest@npm:29.5.2"
   dependencies:
     expect: ^29.0.0
     pretty-format: ^29.0.0
-  checksum: 0a22491dec86333c0e92b897be2c809c922a7b2b0aa5604ac369810d6b2360908b4a3f2c6892e8a237a54fa1f10ecefe0e823ec5fcb7915195af4dfe88d2197e
+  checksum: 7d205599ea3cccc262bad5cc173d3242d6bf8138c99458509230e4ecef07a52d6ddcde5a1dbd49ace655c0af51d2dbadef3748697292ea4d86da19d9e03e19c0
   languageName: node
   linkType: hard
 
 "@types/json-schema@npm:*, @types/json-schema@npm:^7.0.8, @types/json-schema@npm:^7.0.9":
-  version: 7.0.11
-  resolution: "@types/json-schema@npm:7.0.11"
-  checksum: 527bddfe62db9012fccd7627794bd4c71beb77601861055d87e3ee464f2217c85fca7a4b56ae677478367bbd248dbde13553312b7d4dbc702a2f2bbf60c4018d
+  version: 7.0.12
+  resolution: "@types/json-schema@npm:7.0.12"
+  checksum: 00239e97234eeb5ceefb0c1875d98ade6e922bfec39dd365ec6bd360b5c2f825e612ac4f6e5f1d13601b8b30f378f15e6faa805a3a732f4a1bbe61915163d293
   languageName: node
   linkType: hard
 
@@ -1214,23 +1212,23 @@ __metadata:
   linkType: hard
 
 "@types/node@npm:*":
-  version: 20.2.3
-  resolution: "@types/node@npm:20.2.3"
-  checksum: 576065e8fc1fa45798c8f59a6bf809169582d04abc2e25fab1a048ffc734975b9992ae31be0d960cf705a21fb37112f7fcde11aa322beddf7491e73d5a5a988c
+  version: 20.2.5
+  resolution: "@types/node@npm:20.2.5"
+  checksum: 38ce7c7e9d76880dc632f71d71e0d5914fcda9d5e9a7095d6c339abda55ca4affb0f2a882aeb29398f8e09d2c5151f0b6586c81c8ccdfe529c34b1ea3337425e
   languageName: node
   linkType: hard
 
 "@types/node@npm:^18.7.23":
-  version: 18.16.14
-  resolution: "@types/node@npm:18.16.14"
-  checksum: c11cb3c787236414efe58240ae71854971592554d82ff9d201876ce7cafd51c37aaa001c63602d002e8238614d7331bd6d48ac4c1c0caa826799980b6846fb08
+  version: 18.16.16
+  resolution: "@types/node@npm:18.16.16"
+  checksum: 0efad726dd1e0bef71c392c708fc5d78c5b39c46b0ac5186fee74de4ccb1b2e847b3fa468da67d62812f56569da721b15bf31bdc795e6c69b56c73a45079ed2d
   languageName: node
   linkType: hard
 
 "@types/prettier@npm:^2.1.5":
-  version: 2.7.2
-  resolution: "@types/prettier@npm:2.7.2"
-  checksum: b47d76a5252265f8d25dd2fe2a5a61dc43ba0e6a96ffdd00c594cb4fd74c1982c2e346497e3472805d97915407a09423804cc2110a0b8e1b22cffcab246479b7
+  version: 2.7.3
+  resolution: "@types/prettier@npm:2.7.3"
+  checksum: 705384209cea6d1433ff6c187c80dcc0b95d99d5c5ce21a46a9a58060c527973506822e428789d842761e0280d25e3359300f017fbe77b9755bc772ab3dc2f83
   languageName: node
   linkType: hard
 
@@ -1342,13 +1340,13 @@ __metadata:
   linkType: hard
 
 "@typescript-eslint/eslint-plugin@npm:^5.54.1":
-  version: 5.59.7
-  resolution: "@typescript-eslint/eslint-plugin@npm:5.59.7"
+  version: 5.59.8
+  resolution: "@typescript-eslint/eslint-plugin@npm:5.59.8"
   dependencies:
     "@eslint-community/regexpp": ^4.4.0
-    "@typescript-eslint/scope-manager": 5.59.7
-    "@typescript-eslint/type-utils": 5.59.7
-    "@typescript-eslint/utils": 5.59.7
+    "@typescript-eslint/scope-manager": 5.59.8
+    "@typescript-eslint/type-utils": 5.59.8
+    "@typescript-eslint/utils": 5.59.8
     debug: ^4.3.4
     grapheme-splitter: ^1.0.4
     ignore: ^5.2.0
@@ -1361,43 +1359,43 @@ __metadata:
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: 10d28bac7a5af9e41767be0bb9c270ee3dcdfeaa38d1b036c6822e7260b88821c460699ba943664eb1ef272d00de6a81b99d7d955332044ea87b624e7ead84a1
+  checksum: 3e05cd06149ec3741c3c2fb638e2d19a55687b4614a5c8820433db82997687650297e51c17828d320162ccf4241798cf5712c405561e7605cb17e984a6967f7b
   languageName: node
   linkType: hard
 
 "@typescript-eslint/parser@npm:^5.54.1":
-  version: 5.59.7
-  resolution: "@typescript-eslint/parser@npm:5.59.7"
+  version: 5.59.8
+  resolution: "@typescript-eslint/parser@npm:5.59.8"
   dependencies:
-    "@typescript-eslint/scope-manager": 5.59.7
-    "@typescript-eslint/types": 5.59.7
-    "@typescript-eslint/typescript-estree": 5.59.7
+    "@typescript-eslint/scope-manager": 5.59.8
+    "@typescript-eslint/types": 5.59.8
+    "@typescript-eslint/typescript-estree": 5.59.8
     debug: ^4.3.4
   peerDependencies:
     eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: bc44f37a11a44f84ae5f0156213f3e2e49aef2ecac94d9e161a0c721acd29462e288f306ad4648095ac1c0e5a5f62b78280c1735883cf39f79ee3afcba312119
+  checksum: bac9f09d8552086ceb882a7b87ce4d98dfaa41579249216c75d97e3fc07af33cddc4cbbd07a127a5823c826a258882643aaf658bec19cb2a434002b55c5f0d12
   languageName: node
   linkType: hard
 
-"@typescript-eslint/scope-manager@npm:5.59.7":
-  version: 5.59.7
-  resolution: "@typescript-eslint/scope-manager@npm:5.59.7"
+"@typescript-eslint/scope-manager@npm:5.59.8":
+  version: 5.59.8
+  resolution: "@typescript-eslint/scope-manager@npm:5.59.8"
   dependencies:
-    "@typescript-eslint/types": 5.59.7
-    "@typescript-eslint/visitor-keys": 5.59.7
-  checksum: 43f7ea93fddbe2902122a41050677fe3eff2ea468f435b981592510cfc6136e8c28ac7d3a3e05fb332c0b3078a29bd0c91c35b2b1f4e788b4eb9aaeb70e21583
+    "@typescript-eslint/types": 5.59.8
+    "@typescript-eslint/visitor-keys": 5.59.8
+  checksum: e1e810ee991cfeb433330b04ee949bb6784abe4dbdb7d9480aa7a7536671b4fec914b7803edf662516c8ecb1b31dcff126797f9923270a529c26e2b00b0ea96f
   languageName: node
   linkType: hard
 
-"@typescript-eslint/type-utils@npm:5.59.7":
-  version: 5.59.7
-  resolution: "@typescript-eslint/type-utils@npm:5.59.7"
+"@typescript-eslint/type-utils@npm:5.59.8":
+  version: 5.59.8
+  resolution: "@typescript-eslint/type-utils@npm:5.59.8"
   dependencies:
-    "@typescript-eslint/typescript-estree": 5.59.7
-    "@typescript-eslint/utils": 5.59.7
+    "@typescript-eslint/typescript-estree": 5.59.8
+    "@typescript-eslint/utils": 5.59.8
     debug: ^4.3.4
     tsutils: ^3.21.0
   peerDependencies:
@@ -1405,23 +1403,23 @@ __metadata:
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: 9cbeffad27b145b478e4cbbab2b44c5b246a9b922f01fd06d401ea4c41a4fa6dc8ba75d13a6409b3b4474ccaf2018770a4c6c599172e22ec2004110e00f4e721
+  checksum: d9fde31397da0f0e62a5568f64bad99d06bcd324b7e3aac7fd997a3d045a0fe4c084b2e85d440e0a39645acd2269ad6593f196399c2c0f880d293417fec894e3
   languageName: node
   linkType: hard
 
-"@typescript-eslint/types@npm:5.59.7":
-  version: 5.59.7
-  resolution: "@typescript-eslint/types@npm:5.59.7"
-  checksum: 52eccec9e2d631eb2808e48b5dc33a837b5e242fa9eddace89fc707c9f2283b5364f1d38b33d418a08d64f45f6c22f051800898e1881a912f8aac0c3ae300d0a
+"@typescript-eslint/types@npm:5.59.8":
+  version: 5.59.8
+  resolution: "@typescript-eslint/types@npm:5.59.8"
+  checksum: 559473d5601c849eb0da1874a2ac67c753480beed484ad6f6cda62fa6023273f2c3005c7f2864d9c2afb7c6356412d0d304b57db10c53597207f18a7f6cd4f18
   languageName: node
   linkType: hard
 
-"@typescript-eslint/typescript-estree@npm:5.59.7":
-  version: 5.59.7
-  resolution: "@typescript-eslint/typescript-estree@npm:5.59.7"
+"@typescript-eslint/typescript-estree@npm:5.59.8":
+  version: 5.59.8
+  resolution: "@typescript-eslint/typescript-estree@npm:5.59.8"
   dependencies:
-    "@typescript-eslint/types": 5.59.7
-    "@typescript-eslint/visitor-keys": 5.59.7
+    "@typescript-eslint/types": 5.59.8
+    "@typescript-eslint/visitor-keys": 5.59.8
     debug: ^4.3.4
     globby: ^11.1.0
     is-glob: ^4.0.3
@@ -1430,35 +1428,35 @@ __metadata:
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: eefe82eedf9ee2e14463c3f2b5b18df084c1328a859b245ee897a9a7075acce7cca0216a21fd7968b75aa64189daa008bfde1e2f9afbcc336f3dfe856e7f342e
+  checksum: d93371cc866f573a6a1ddc0eb10d498a8e59f36763a99ce21da0737fff2b4c942eef1587216aad273f8d896ebc0b19003677cba63a27d2646aa2c087638963eb
   languageName: node
   linkType: hard
 
-"@typescript-eslint/utils@npm:5.59.7":
-  version: 5.59.7
-  resolution: "@typescript-eslint/utils@npm:5.59.7"
+"@typescript-eslint/utils@npm:5.59.8":
+  version: 5.59.8
+  resolution: "@typescript-eslint/utils@npm:5.59.8"
   dependencies:
     "@eslint-community/eslint-utils": ^4.2.0
     "@types/json-schema": ^7.0.9
     "@types/semver": ^7.3.12
-    "@typescript-eslint/scope-manager": 5.59.7
-    "@typescript-eslint/types": 5.59.7
-    "@typescript-eslint/typescript-estree": 5.59.7
+    "@typescript-eslint/scope-manager": 5.59.8
+    "@typescript-eslint/types": 5.59.8
+    "@typescript-eslint/typescript-estree": 5.59.8
     eslint-scope: ^5.1.1
     semver: ^7.3.7
   peerDependencies:
     eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-  checksum: d8682700187ca94cc6441480cb6b87d0514a9748103c15dd93206c5b1c6fefa59063662f27a4103e16abbcfb654a61d479bc55af8f23d96f342431b87f31bb4e
+  checksum: cbaa057485c7f52c45d0dfb4f5a8e9273abccb1c52dcb4426a79f9e71d2c1062cf2525bad6d4aca5ec42db3fe723d749843bcade5a323bde7fbe4b5d5b5d5c3b
   languageName: node
   linkType: hard
 
-"@typescript-eslint/visitor-keys@npm:5.59.7":
-  version: 5.59.7
-  resolution: "@typescript-eslint/visitor-keys@npm:5.59.7"
+"@typescript-eslint/visitor-keys@npm:5.59.8":
+  version: 5.59.8
+  resolution: "@typescript-eslint/visitor-keys@npm:5.59.8"
   dependencies:
-    "@typescript-eslint/types": 5.59.7
+    "@typescript-eslint/types": 5.59.8
     eslint-visitor-keys: ^3.3.0
-  checksum: 4367f2ea68dd96a0520485434ad11e1bd26239eeeb3a2150bee7478a0f1df3c2099a39f96486722932be0456bcb7a47a483b452876d1d30bdeb9b81d354eef3d
+  checksum: 6bfa7918dbb0e08d8a7404aeeef7bcd1a85736dc8d01614d267c0c5ec10f94d2746b50a945bf5c82c54fda67926e8deaeba8565c919da17f725fc11209ef8987
   languageName: node
   linkType: hard
 
@@ -1677,7 +1675,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"acorn-import-assertions@npm:^1.7.6":
+"acorn-import-assertions@npm:^1.9.0":
   version: 1.9.0
   resolution: "acorn-import-assertions@npm:1.9.0"
   peerDependencies:
@@ -2017,16 +2015,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bigint-buffer@npm:^1.1.5":
-  version: 1.1.5
-  resolution: "bigint-buffer@npm:1.1.5"
-  dependencies:
-    bindings: ^1.3.0
-    node-gyp: latest
-  checksum: d010c9f57758bcdaccb435d88b483ffcc95fe8bbc6e7fb3a44fb5221f29c894ffaf4a3c5a4a530e0e7d6608203c2cde9b79ee4f2386cd6d4462d1070bc8c9f4e
-  languageName: node
-  linkType: hard
-
 "binary-extensions@npm:^2.0.0":
   version: 2.2.0
   resolution: "binary-extensions@npm:2.2.0"
@@ -2034,15 +2022,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bindings@npm:^1.3.0":
-  version: 1.5.0
-  resolution: "bindings@npm:1.5.0"
-  dependencies:
-    file-uri-to-path: 1.0.0
-  checksum: 65b6b48095717c2e6105a021a7da4ea435aa8d3d3cd085cb9e85bcb6e5773cf318c4745c3f7c504412855940b585bdf9b918236612a1c7a7942491de176f1ae7
-  languageName: node
-  linkType: hard
-
 "body-parser@npm:1.20.1":
   version: 1.20.1
   resolution: "body-parser@npm:1.20.1"
@@ -2111,16 +2090,16 @@ __metadata:
   linkType: hard
 
 "browserslist@npm:^4.14.5, browserslist@npm:^4.21.3":
-  version: 4.21.5
-  resolution: "browserslist@npm:4.21.5"
+  version: 4.21.7
+  resolution: "browserslist@npm:4.21.7"
   dependencies:
-    caniuse-lite: ^1.0.30001449
-    electron-to-chromium: ^1.4.284
-    node-releases: ^2.0.8
-    update-browserslist-db: ^1.0.10
+    caniuse-lite: ^1.0.30001489
+    electron-to-chromium: ^1.4.411
+    node-releases: ^2.0.12
+    update-browserslist-db: ^1.0.11
   bin:
     browserslist: cli.js
-  checksum: 9755986b22e73a6a1497fd8797aedd88e04270be33ce66ed5d85a1c8a798292a65e222b0f251bafa1c2522261e237d73b08b58689d4920a607e5a53d56dc4706
+  checksum: 3d0d025e6d381c4db5e71b538258952660ba574c060832095f182a9877ca798836fa550736269e669a2080e486f0cfdf5d3bcf2769b9f7cf123f6c6b8c005f8f
   languageName: node
   linkType: hard
 
@@ -2240,10 +2219,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"caniuse-lite@npm:^1.0.30001449":
-  version: 1.0.30001489
-  resolution: "caniuse-lite@npm:1.0.30001489"
-  checksum: 94585a351fd7661b855c83eace474db0ee5a617159b46f2eff1f6fe4b85d7a205418471fdec8cf5cd647a7f79958706d5e664c0bbf3c7c09118b35db9bb95a1b
+"caniuse-lite@npm:^1.0.30001489":
+  version: 1.0.30001492
+  resolution: "caniuse-lite@npm:1.0.30001492"
+  checksum: 261869f910ec905ab6aa5a754e4ae57da8c5c33f3b723db2fa21840da307667bff61057aef3abaca32091c1561c254dd3a807c0fdb054cdc9e7e3ba495a55e20
   languageName: node
   linkType: hard
 
@@ -2812,10 +2791,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"electron-to-chromium@npm:^1.4.284":
-  version: 1.4.405
-  resolution: "electron-to-chromium@npm:1.4.405"
-  checksum: d1cf421eaf63dbd5481bcc4296a94e5db5cf831bdc5cbdad283b4b0d53d8fd87254b64fa6cda88f1cb4789eab012f078c1eed4cbb01c5a34bd0ce657dcfe08c8
+"electron-to-chromium@npm:^1.4.411":
+  version: 1.4.416
+  resolution: "electron-to-chromium@npm:1.4.416"
+  checksum: a1804fe6f1955b3b80519bf2feb69d5e2111914e824cdacdff85545dba48da44d16f43d5fb702ff4cfc9148f7d0be7cd2669cb5e939b0ed13ee9772cae3edfd4
   languageName: node
   linkType: hard
 
@@ -2849,13 +2828,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"enhanced-resolve@npm:^5.0.0, enhanced-resolve@npm:^5.14.0":
-  version: 5.14.0
-  resolution: "enhanced-resolve@npm:5.14.0"
+"enhanced-resolve@npm:^5.0.0, enhanced-resolve@npm:^5.14.1":
+  version: 5.14.1
+  resolution: "enhanced-resolve@npm:5.14.1"
   dependencies:
     graceful-fs: ^4.2.4
     tapable: ^2.2.0
-  checksum: fff1aaebbf376371e5df4502e111967f6247c37611ad3550e4e7fca657f6dcb29ef7ffe88bf14e5010b78997f1ddd984a8db97af87ee0a5477771398fd326f5b
+  checksum: ad2a31928b6649eed40d364838449587f731baa63863e83d2629bebaa8be1eabac18b90f89c1784bc805b0818363e99b22547159edd485d7e5ccf18cdc640642
   languageName: node
   linkType: hard
 
@@ -3261,13 +3240,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"file-uri-to-path@npm:1.0.0":
-  version: 1.0.0
-  resolution: "file-uri-to-path@npm:1.0.0"
-  checksum: b648580bdd893a008c92c7ecc96c3ee57a5e7b6c4c18a9a09b44fb5d36d79146f8e442578bc0e173dc027adf3987e254ba1dfd6e3ec998b7c282873010502144
-  languageName: node
-  linkType: hard
-
 "fill-range@npm:^7.0.1":
   version: 7.0.1
   resolution: "fill-range@npm:7.0.1"
@@ -3363,9 +3335,9 @@ __metadata:
   linkType: hard
 
 "fs-monkey@npm:^1.0.3":
-  version: 1.0.3
-  resolution: "fs-monkey@npm:1.0.3"
-  checksum: cf50804833f9b88a476911ae911fe50f61a98d986df52f890bd97e7262796d023698cb2309fa9b74fdd8974f04315b648748a0a8ee059e7d5257b293bfc409c0
+  version: 1.0.4
+  resolution: "fs-monkey@npm:1.0.4"
+  checksum: 8b254c982905c0b7e028eab22b410dc35a5c0019c1c860456f5f54ae6a61666e1cb8c6b700d6c88cc873694c00953c935847b9959cc4dcf274aacb8673c1e8bf
   languageName: node
   linkType: hard
 
@@ -3944,9 +3916,9 @@ __metadata:
   linkType: hard
 
 "ipaddr.js@npm:^2.0.1":
-  version: 2.0.1
-  resolution: "ipaddr.js@npm:2.0.1"
-  checksum: dd194a394a843d470f88d17191b0948f383ed1c8e320813f850c336a0fcb5e9215d97ec26ca35ab4fbbd31392c8b3467f3e8344628029ed3710b2ff6b5d1034e
+  version: 2.1.0
+  resolution: "ipaddr.js@npm:2.1.0"
+  checksum: 807a054f2bd720c4d97ee479d6c9e865c233bea21f139fb8dabd5a35c4226d2621c42e07b4ad94ff3f82add926a607d8d9d37c625ad0319f0e08f9f2bd1968e2
   languageName: node
   linkType: hard
 
@@ -5148,7 +5120,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"node-releases@npm:^2.0.8":
+"node-releases@npm:^2.0.12":
   version: 2.0.12
   resolution: "node-releases@npm:2.0.12"
   checksum: b8c56db82c4642a0f443332b331a4396dae452a2ac5a65c8dbd93ef89ecb2fbb0da9d42ac5366d4764973febadca816cf7587dad492dce18d2a6b2af59cda260
@@ -6576,7 +6548,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"update-browserslist-db@npm:^1.0.10":
+"update-browserslist-db@npm:^1.0.11":
   version: 1.0.11
   resolution: "update-browserslist-db@npm:1.0.11"
   dependencies:
@@ -6794,8 +6766,8 @@ __metadata:
   linkType: hard
 
 "webpack@npm:^5.82.1":
-  version: 5.83.1
-  resolution: "webpack@npm:5.83.1"
+  version: 5.85.0
+  resolution: "webpack@npm:5.85.0"
   dependencies:
     "@types/eslint-scope": ^3.7.3
     "@types/estree": ^1.0.0
@@ -6803,10 +6775,10 @@ __metadata:
     "@webassemblyjs/wasm-edit": ^1.11.5
     "@webassemblyjs/wasm-parser": ^1.11.5
     acorn: ^8.7.1
-    acorn-import-assertions: ^1.7.6
+    acorn-import-assertions: ^1.9.0
     browserslist: ^4.14.5
     chrome-trace-event: ^1.0.2
-    enhanced-resolve: ^5.14.0
+    enhanced-resolve: ^5.14.1
     es-module-lexer: ^1.2.1
     eslint-scope: 5.1.1
     events: ^3.2.0
@@ -6826,7 +6798,7 @@ __metadata:
       optional: true
   bin:
     webpack: bin/webpack.js
-  checksum: 219d5ef50380bc0fd3702ed17feddf13819d8173b78f7a5b857dc74ac177e63d1f79c050792754411cc088bbc02e0971b989efddadbb8e393cf27d64c0ad9ff8
+  checksum: b013be9fbc7f6810d1f229f570c70710ddbc7290f817411acffe4214b2b6c783a041ab1f2005d9e1109f4ab21c136f0f8d8c067a5fb64f20a82dcbc1ee0d3f42
   languageName: node
   linkType: hard