diff --git a/cpp/src/aztec/common/container.hpp b/cpp/src/aztec/common/container.hpp
index 6418be1461..1c87bb1224 100644
--- a/cpp/src/aztec/common/container.hpp
+++ b/cpp/src/aztec/common/container.hpp
@@ -48,4 +48,16 @@ InnerCont flatten(Cont<InnerCont, Args...> const& in)
         result.insert(result.end(), e.begin(), e.end());
     }
     return result;
+}
+
+// Return the first index at which a given item can be found in the vector.
+// Only safe for vectors with length less than the size_t overflow size.
+template <typename T> long index_of(std::vector<T> const& vec, T const& item)
+{
+    auto const& begin = vec.begin();
+    auto const& end = vec.end();
+
+    auto const& itr = std::find(begin, end, item);
+
+    return itr == end ? -1 : std::distance(begin, itr);
 }
\ No newline at end of file
diff --git a/cpp/src/aztec/common/map.hpp b/cpp/src/aztec/common/map.hpp
index a78c81ca62..79205f2bda 100644
--- a/cpp/src/aztec/common/map.hpp
+++ b/cpp/src/aztec/common/map.hpp
@@ -10,13 +10,29 @@ template <template <typename, typename...> typename Cont,
           typename... Args,
           typename F,
           typename OutElem = typename std::invoke_result<F, InElem const&>::type>
-Cont<OutElem> map(Cont<InElem, Args...> const& in, F op)
+Cont<OutElem> map(Cont<InElem, Args...> const& in, F&& op)
 {
     Cont<OutElem> result;
     std::transform(in.begin(), in.end(), std::back_inserter(result), op);
     return result;
 }
 
+/*
+ * Generic map function for mapping a std::array's elements to another type.
+ * TODO: this has only been added because I (Mike) couldn't get the above to work
+ * with an array.
+ */
+template <std::size_t SIZE,
+          typename InElem,
+          typename F,
+          typename OutElem = typename std::invoke_result<F, InElem const&>::type>
+std::array<OutElem, SIZE> map(std::array<InElem, SIZE> const& in, F&& op)
+{
+    std::array<OutElem, SIZE> result;
+    std::transform(in.begin(), in.end(), result.begin(), op);
+    return result;
+}
+
 /*
  * Generic map function for mapping a containers element to another type.
  * This version passes the element index as a second argument to the operator function.
diff --git a/cpp/src/aztec/common/serialize.hpp b/cpp/src/aztec/common/serialize.hpp
index 72833eb1dc..3e735dc5dc 100644
--- a/cpp/src/aztec/common/serialize.hpp
+++ b/cpp/src/aztec/common/serialize.hpp
@@ -34,6 +34,7 @@
 #include <map>
 #include <iostream>
 #include <common/log.hpp>
+#include <optional>
 
 #ifndef __i386__
 __extension__ using uint128_t = unsigned __int128;
@@ -311,6 +312,33 @@ template <typename B, typename T, typename U> inline void write(B& buf, std::map
     }
 }
 
+// Read std::optional<T>.
+template <typename B, typename T> inline void read(B& it, std::optional<T>& opt_value)
+{
+    bool is_nullopt;
+    read(it, is_nullopt);
+    if (is_nullopt) {
+        opt_value = std::nullopt;
+        return;
+    }
+    T value;
+    read(it, value);
+    opt_value = T(value);
+}
+
+// Write std::optional<T>.
+// Note: It takes up a different amount of space, depending on whether it's std::nullopt or populated with an actual
+// value.
+template <typename B, typename T> inline void write(B& buf, std::optional<T> const& opt_value)
+{
+    if (opt_value) {
+        write(buf, false); // is not nullopt
+        write(buf, *opt_value);
+        return;
+    }
+    write(buf, true); // is nullopt
+}
+
 } // namespace std
 
 // Helper functions that have return values.
diff --git a/cpp/src/aztec/common/streams.hpp b/cpp/src/aztec/common/streams.hpp
index 31c4cab18f..01735bf64a 100644
--- a/cpp/src/aztec/common/streams.hpp
+++ b/cpp/src/aztec/common/streams.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include <iomanip>
 #include <ostream>
+#include <map>
 #include <vector>
 
 namespace std {
@@ -35,7 +36,7 @@ inline std::ostream& operator<<(std::ostream& os, std::vector<T> const& arr)
     for (auto element : arr) {
         os << ' ' << element << '\n';
     }
-    os << "]\n";
+    os << "]";
     return os;
 }
 
@@ -63,4 +64,25 @@ template <typename T, size_t S> inline std::ostream& operator<<(std::ostream& os
     return os;
 }
 
+template <typename T, typename U> inline std::ostream& operator<<(std::ostream& os, std::pair<T, U> const& pair)
+{
+    os << "(" << pair.first << ", " << pair.second << ")";
+    return os;
+}
+
+template <typename T> inline std::ostream& operator<<(std::ostream& os, std::optional<T> const& opt)
+{
+    return opt ? os << *opt : os << "std::nullopt";
+}
+
+template <typename T, typename U> inline std::ostream& operator<<(std::ostream& os, std::map<T, U> const& map)
+{
+    os << "[\n";
+    for (const auto& elem : map) {
+        os << " " << elem.first << ": " << elem.second << "\n";
+    }
+    os << "]";
+    return os;
+}
+
 } // namespace std
\ No newline at end of file
diff --git a/cpp/src/aztec/crypto/pedersen_commitment/pedersen.cpp b/cpp/src/aztec/crypto/pedersen_commitment/pedersen.cpp
index a2d28a5c12..a748c7c5c2 100644
--- a/cpp/src/aztec/crypto/pedersen_commitment/pedersen.cpp
+++ b/cpp/src/aztec/crypto/pedersen_commitment/pedersen.cpp
@@ -68,6 +68,27 @@ grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inpu
     return r.is_point_at_infinity() ? grumpkin::g1::affine_element(0, 0) : grumpkin::g1::affine_element(r);
 }
 
+grumpkin::g1::affine_element commit_native(const std::vector<std::pair<grumpkin::fq, generator_index_t>>& input_pairs)
+{
+    ASSERT((input_pairs.size() < (1 << 16)) && "too many inputs for 16 bit index");
+    std::vector<grumpkin::g1::element> out(input_pairs.size());
+
+#ifndef NO_MULTITHREADING
+    // Ensure generator data is initialized before threading...
+    init_generator_data();
+#pragma omp parallel for num_threads(input_pairs.size())
+#endif
+    for (size_t i = 0; i < input_pairs.size(); ++i) {
+        out[i] = commit_single(input_pairs[i].first, input_pairs[i].second);
+    }
+
+    grumpkin::g1::element r = out[0];
+    for (size_t i = 1; i < input_pairs.size(); ++i) {
+        r = out[i] + r;
+    }
+    return r.is_point_at_infinity() ? grumpkin::g1::affine_element(0, 0) : grumpkin::g1::affine_element(r);
+}
+
 /**
  * The same as commit_native, but only return the resultant x coordinate (i.e. compress).
  */
@@ -76,6 +97,11 @@ grumpkin::fq compress_native(const std::vector<grumpkin::fq>& inputs, const size
     return commit_native(inputs, hash_index).x;
 }
 
+grumpkin::fq compress_native(const std::vector<std::pair<grumpkin::fq, generator_index_t>>& input_pairs)
+{
+    return commit_native(input_pairs).x;
+}
+
 /**
  * Given an arbitrary length of bytes, convert them to fields and compress the result using the default generators.
  */
diff --git a/cpp/src/aztec/crypto/pedersen_commitment/pedersen.hpp b/cpp/src/aztec/crypto/pedersen_commitment/pedersen.hpp
index d4c1cc686d..2cb178e9e3 100644
--- a/cpp/src/aztec/crypto/pedersen_commitment/pedersen.hpp
+++ b/cpp/src/aztec/crypto/pedersen_commitment/pedersen.hpp
@@ -11,7 +11,9 @@ namespace pedersen_commitment {
 
 grumpkin::g1::element commit_single(const barretenberg::fr& in, generator_index_t const& index);
 
-grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& elements, const size_t hash_index = 0);
+grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
+
+grumpkin::g1::affine_element commit_native(const std::vector<std::pair<grumpkin::fq, generator_index_t>>& input_pairs);
 
 grumpkin::fq compress_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
 
@@ -23,5 +25,7 @@ template <size_t T> grumpkin::fq compress_native(const std::array<grumpkin::fq,
 
 grumpkin::fq compress_native(const std::vector<uint8_t>& input);
 
+grumpkin::fq compress_native(const std::vector<std::pair<grumpkin::fq, generator_index_t>>& input_pairs);
+
 } // namespace pedersen_commitment
 } // namespace crypto
diff --git a/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.cpp b/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.cpp
index d58de916e6..a334ade99d 100644
--- a/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.cpp
+++ b/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.cpp
@@ -3,6 +3,7 @@
 #include "./convert_buffer_to_field.hpp"
 
 #include <ecc/curves/grumpkin/grumpkin.hpp>
+#include <numeric/bitop/pow.hpp>
 
 using namespace crypto::pedersen_hash::lookup;
 
@@ -34,16 +35,82 @@ grumpkin::g1::element merkle_damgard_compress(const std::vector<grumpkin::fq>& i
     return (hash_single(result, false) + hash_single(grumpkin::fq(num_inputs), true));
 }
 
+grumpkin::g1::element merkle_damgard_compress(const std::vector<grumpkin::fq>& inputs, const std::vector<size_t>& ivs)
+{
+    if (inputs.size() == 0) {
+        auto result = grumpkin::g1::affine_one;
+        result.self_set_infinity();
+        return result;
+    }
+    init();
+    const size_t num_inputs = inputs.size();
+
+    grumpkin::fq result = (pedersen_iv_table[0]).x;
+    for (size_t i = 0; i < 2 * num_inputs; i++) {
+        if ((i & 1) == 0) {
+            grumpkin::fq iv_result = (pedersen_iv_table[ivs[i >> 1]]).x;
+            result = hash_pair(result, iv_result);
+        } else {
+            result = hash_pair(result, inputs[i >> 1]);
+        }
+    }
+
+    return (hash_single(result, false) + hash_single(grumpkin::fq(num_inputs), true));
+}
+
+grumpkin::g1::element merkle_damgard_tree_compress(const std::vector<grumpkin::fq>& inputs,
+                                                   const std::vector<size_t>& ivs)
+{
+    const size_t num_inputs = inputs.size();
+    ASSERT(num_inputs == ivs.size());
+    ASSERT(numeric::is_power_of_two(num_inputs));
+    if (inputs.size() == 0) {
+        auto result = grumpkin::g1::affine_one;
+        result.self_set_infinity();
+        return result;
+    }
+    init();
+
+    // Process height 0 of the tree.
+    std::vector<grumpkin::fq> temp_storage;
+    for (size_t i = 0; i < num_inputs; i++) {
+        grumpkin::fq iv_result = (pedersen_iv_table[ivs[i]]).x;
+        temp_storage.push_back(hash_pair(iv_result, inputs[i]));
+    }
+
+    // Process heights 1, 2, ..., log2(m) of the tree.
+    const size_t total_height = numeric::get_msb(num_inputs);
+    for (size_t height = 1; height <= total_height; height++) {
+        const size_t leaf_count = 1UL << (total_height - height);
+        for (size_t i = 0; i < leaf_count; i++) {
+            temp_storage[i] = hash_pair(temp_storage[2 * i], temp_storage[2 * i + 1]);
+        }
+    }
+
+    return (hash_single(temp_storage[0], false) + hash_single(grumpkin::fq(num_inputs), true));
+}
+
 grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index)
 {
     return grumpkin::g1::affine_element(merkle_damgard_compress(inputs, hash_index));
 }
 
+grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inputs,
+                                           const std::vector<size_t>& hash_indices)
+{
+    return grumpkin::g1::affine_element(merkle_damgard_compress(inputs, hash_indices));
+}
+
 grumpkin::fq compress_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index)
 {
     return commit_native(inputs, hash_index).x;
 }
 
+grumpkin::fq compress_native(const std::vector<grumpkin::fq>& inputs, const std::vector<size_t>& hash_indices)
+{
+    return commit_native(inputs, hash_indices).x;
+}
+
 grumpkin::fq compress_native_buffer_to_field(const std::vector<uint8_t>& input)
 {
     const auto elements = convert_buffer_to_field(input);
diff --git a/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.hpp b/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.hpp
index b2408075e5..9be4f8eafb 100644
--- a/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.hpp
+++ b/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.hpp
@@ -7,8 +7,12 @@ namespace pedersen_commitment {
 namespace lookup {
 
 grumpkin::g1::element merkle_damgard_compress(const std::vector<grumpkin::fq>& inputs, const size_t iv);
+grumpkin::g1::element merkle_damgard_compress(const std::vector<grumpkin::fq>& inputs, const std::vector<size_t>& ivs);
+grumpkin::g1::element merkle_damgard_tree_compress(const std::vector<grumpkin::fq>& inputs,
+                                                   const std::vector<size_t>& ivs);
 
 grumpkin::fq compress_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
+grumpkin::fq compress_native(const std::vector<grumpkin::fq>& inputs, const std::vector<size_t>& hash_indices);
 std::vector<uint8_t> compress_native(const std::vector<uint8_t>& input);
 
 grumpkin::fq compress_native_buffer_to_field(const std::vector<uint8_t>& input);
@@ -20,6 +24,8 @@ template <size_t T> grumpkin::fq compress_native(const std::array<grumpkin::fq,
 }
 
 grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
+grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inputs,
+                                           const std::vector<size_t>& hash_indices);
 
 } // namespace lookup
 } // namespace pedersen_commitment
diff --git a/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.test.cpp b/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.test.cpp
index eeed7a27df..7354deb58f 100644
--- a/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.test.cpp
+++ b/cpp/src/aztec/crypto/pedersen_commitment/pedersen_lookup.test.cpp
@@ -142,3 +142,67 @@ TEST(pedersen_lookup, merkle_damgard_compress)
     EXPECT_EQ(affine_element(result).x,
               affine_element(compute_expected(intermediate, 0) + compute_expected(fq(m), 15)).x);
 }
+
+TEST(pedersen_lookup, merkle_damgard_compress_multiple_iv)
+{
+    typedef grumpkin::fq fq;
+    typedef grumpkin::fr fr;
+    typedef grumpkin::g1::affine_element affine_element;
+
+    const size_t m = 10;
+    std::vector<size_t> ivs;
+    std::vector<fq> inputs;
+    for (size_t i = 0; i < m; i++) {
+        inputs.push_back(engine.get_random_uint256());
+        ivs.push_back(engine.get_random_uint8());
+    }
+
+    const auto result = crypto::pedersen_commitment::lookup::merkle_damgard_compress(inputs, ivs);
+
+    const size_t initial_iv = 0;
+    fq intermediate = (grumpkin::g1::affine_one * fr(initial_iv + 1)).x;
+    for (size_t i = 0; i < 2 * m; i++) {
+        if ((i & 1) == 0) {
+            const auto iv = (grumpkin::g1::affine_one * fr(ivs[i >> 1] + 1)).x;
+            intermediate = affine_element(compute_expected(intermediate, 0) + compute_expected(iv, 15)).x;
+        } else {
+            intermediate = affine_element(compute_expected(intermediate, 0) + compute_expected(inputs[i >> 1], 15)).x;
+        }
+    }
+
+    EXPECT_EQ(affine_element(result).x,
+              affine_element(compute_expected(intermediate, 0) + compute_expected(fq(m), 15)).x);
+}
+
+TEST(pedersen_lookup, merkle_damgard_tree_compress)
+{
+    typedef grumpkin::fq fq;
+    typedef grumpkin::fr fr;
+    typedef grumpkin::g1::affine_element affine_element;
+
+    const size_t m = 8;
+    std::vector<size_t> ivs;
+    std::vector<fq> inputs;
+    for (size_t i = 0; i < m; i++) {
+        inputs.push_back(engine.get_random_uint256());
+        ivs.push_back(engine.get_random_uint8());
+    }
+
+    const auto result = crypto::pedersen_commitment::lookup::merkle_damgard_tree_compress(inputs, ivs);
+
+    std::vector<fq> temp;
+    for (size_t i = 0; i < m; i++) {
+        const fq iv_term = (grumpkin::g1::affine_one * fr(ivs[i] + 1)).x;
+        temp.push_back(affine_element(compute_expected(iv_term, 0) + compute_expected(inputs[i], 15)).x);
+    }
+
+    const size_t logm = numeric::get_msb(m);
+    for (size_t j = 1; j <= logm; j++) {
+        const size_t nodes = (1UL << (logm - j));
+        for (size_t i = 0; i < nodes; i++) {
+            temp[i] = affine_element(compute_expected(temp[2 * i], 0) + compute_expected(temp[2 * i + 1], 15)).x;
+        }
+    }
+
+    EXPECT_EQ(affine_element(result).x, affine_element(compute_expected(temp[0], 0) + compute_expected(fq(m), 15)).x);
+}
diff --git a/cpp/src/aztec/ecc/fields/field.hpp b/cpp/src/aztec/ecc/fields/field.hpp
index 42da28cef0..ba846ec53f 100644
--- a/cpp/src/aztec/ecc/fields/field.hpp
+++ b/cpp/src/aztec/ecc/fields/field.hpp
@@ -173,6 +173,11 @@ template <class Params> struct alignas(32) field {
     BBERG_INLINE constexpr field operator-() const noexcept;
     constexpr field operator/(const field& other) const noexcept;
 
+    // prefix increment (++x)
+    BBERG_INLINE constexpr field operator++() noexcept;
+    // postfix increment (x++)
+    BBERG_INLINE constexpr field operator++(int) noexcept;
+
     BBERG_INLINE constexpr field operator*=(const field& other) noexcept;
     BBERG_INLINE constexpr field operator+=(const field& other) noexcept;
     BBERG_INLINE constexpr field operator-=(const field& other) noexcept;
diff --git a/cpp/src/aztec/ecc/fields/field_impl.hpp b/cpp/src/aztec/ecc/fields/field_impl.hpp
index 482418da33..67dfe0e5b3 100644
--- a/cpp/src/aztec/ecc/fields/field_impl.hpp
+++ b/cpp/src/aztec/ecc/fields/field_impl.hpp
@@ -129,6 +129,17 @@ template <class T> constexpr field<T> field<T>::operator+=(const field& other) n
     return *this;
 }
 
+template <class T> constexpr field<T> field<T>::operator++() noexcept
+{
+    return *this += 1;
+}
+
+template <class T> constexpr field<T> field<T>::operator++(int) noexcept
+{
+    // TODO check if this is correct.
+    return *this += 1;
+}
+
 /**
  *
  * Subtraction
diff --git a/cpp/src/aztec/ecc/groups/affine_element.hpp b/cpp/src/aztec/ecc/groups/affine_element.hpp
index 2b597ab23e..59560bcfe3 100644
--- a/cpp/src/aztec/ecc/groups/affine_element.hpp
+++ b/cpp/src/aztec/ecc/groups/affine_element.hpp
@@ -35,10 +35,13 @@ template <typename Fq, typename Fr, typename Params> class alignas(64) affine_el
 
     constexpr affine_element& operator=(affine_element&& other) noexcept;
 
+    constexpr affine_element operator+(const affine_element& other) const noexcept;
+
     template <typename BaseField = Fq,
               typename CompileTimeEnabled = std::enable_if_t<(BaseField::modulus >> 255) == uint256_t(0), void>>
     constexpr uint256_t compress() const noexcept;
 
+    static affine_element infinity();
     constexpr affine_element set_infinity() const noexcept;
     constexpr void self_set_infinity() noexcept;
 
diff --git a/cpp/src/aztec/ecc/groups/affine_element_impl.hpp b/cpp/src/aztec/ecc/groups/affine_element_impl.hpp
index bfde853c22..bf07a572fa 100644
--- a/cpp/src/aztec/ecc/groups/affine_element_impl.hpp
+++ b/cpp/src/aztec/ecc/groups/affine_element_impl.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <crypto/keccak/keccak.hpp>
+#include "./element.hpp"
 
 namespace barretenberg {
 namespace group_elements {
@@ -45,6 +46,13 @@ constexpr affine_element<Fq, Fr, T> affine_element<Fq, Fr, T>::from_compressed(c
     return affine_element<Fq, Fr, T>(x, y);
 }
 
+template <class Fq, class Fr, class T>
+constexpr affine_element<Fq, Fr, T> affine_element<Fq, Fr, T>::operator+(
+    const affine_element<Fq, Fr, T>& other) const noexcept
+{
+    return affine_element(element<Fq, Fr, T>(*this) + element<Fq, Fr, T>(other));
+}
+
 template <class Fq, class Fr, class T>
 constexpr affine_element<Fq, Fr, T>& affine_element<Fq, Fr, T>::operator=(const affine_element& other) noexcept
 {
@@ -73,6 +81,13 @@ constexpr uint256_t affine_element<Fq, Fr, T>::compress() const noexcept
     return out;
 }
 
+template <class Fq, class Fr, class T> affine_element<Fq, Fr, T> affine_element<Fq, Fr, T>::infinity()
+{
+    affine_element e;
+    e.self_set_infinity();
+    return e;
+}
+
 template <class Fq, class Fr, class T>
 constexpr affine_element<Fq, Fr, T> affine_element<Fq, Fr, T>::set_infinity() const noexcept
 {
diff --git a/cpp/src/aztec/ecc/groups/element.hpp b/cpp/src/aztec/ecc/groups/element.hpp
index 5898b11bab..50890bbef1 100644
--- a/cpp/src/aztec/ecc/groups/element.hpp
+++ b/cpp/src/aztec/ecc/groups/element.hpp
@@ -77,7 +77,6 @@ template <class Fq, class Fr, class Params> class alignas(32) element {
     }
 
     element operator*(const Fr& other) const noexcept;
-
     element operator*=(const Fr& other) noexcept;
 
     // If you end up implementing this, congrats, you've solved the DL problem!
@@ -85,6 +84,7 @@ template <class Fq, class Fr, class Params> class alignas(32) element {
     // constexpr Fr operator/(const element& other) noexcept {}
 
     constexpr element normalize() const noexcept;
+    static element infinity();
     BBERG_INLINE constexpr element set_infinity() const noexcept;
     BBERG_INLINE constexpr void self_set_infinity() noexcept;
     BBERG_INLINE constexpr bool is_point_at_infinity() const noexcept;
diff --git a/cpp/src/aztec/ecc/groups/element_impl.hpp b/cpp/src/aztec/ecc/groups/element_impl.hpp
index 6877446433..baaaa36ec5 100644
--- a/cpp/src/aztec/ecc/groups/element_impl.hpp
+++ b/cpp/src/aztec/ecc/groups/element_impl.hpp
@@ -485,6 +485,16 @@ template <class Fq, class Fr, class T> constexpr element<Fq, Fr, T> element<Fq,
     return element(converted);
 }
 
+template <class Fq, class Fr, class T> element<Fq, Fr, T> element<Fq, Fr, T>::infinity()
+{
+    element<Fq, Fr, T> e;
+    e.self_set_infinity();
+    if (!e.is_point_at_infinity()) {
+        info("yup, it's infinity");
+    };
+    return e;
+}
+
 template <class Fq, class Fr, class T> constexpr element<Fq, Fr, T> element<Fq, Fr, T>::set_infinity() const noexcept
 {
     element result(*this);
diff --git a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.cpp b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.cpp
index 18ecb40808..7f2c9210f8 100644
--- a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.cpp
+++ b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.cpp
@@ -29,6 +29,45 @@ point<C> pedersen_commitment<C>::commit(const std::vector<field_t>& inputs, cons
     return pedersen_hash<C>::accumulate(to_accumulate);
 }
 
+template <typename C>
+point<C> pedersen_commitment<C>::commit(const std::vector<field_t>& inputs,
+                                        const std::vector<generator_index_t>& hash_generator_indices)
+{
+    if (inputs.size() != hash_generator_indices.size()) {
+        throw_or_abort("Vector size mismatch.");
+    }
+
+    if constexpr (C::type == waffle::ComposerType::PLOOKUP &&
+                  C::commitment_type == waffle::pedersen::CommitmentType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_commitment<C>::commit(inputs, hash_generator_indices);
+    }
+
+    std::vector<point> to_accumulate;
+    for (size_t i = 0; i < inputs.size(); ++i) {
+        to_accumulate.push_back(pedersen_hash<C>::commit_single(inputs[i], hash_generator_indices[i]));
+    }
+
+    return pedersen_hash<C>::accumulate(to_accumulate);
+}
+
+template <typename C>
+point<C> pedersen_commitment<C>::commit(const std::vector<std::pair<field_t, generator_index_t>>& input_pairs)
+{
+    if constexpr (C::type == waffle::ComposerType::PLOOKUP &&
+                  C::commitment_type == waffle::pedersen::CommitmentType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_commitment<C>::commit(input_pairs);
+    }
+
+    std::vector<point> to_accumulate;
+    std::vector<field_t> inputs;
+    for (size_t i = 0; i < input_pairs.size(); ++i) {
+        to_accumulate.push_back(pedersen_hash<C>::commit_single(input_pairs[i].first, input_pairs[i].second));
+        inputs.push_back(input_pairs[i].first);
+    }
+
+    return pedersen_hash<C>::accumulate(to_accumulate);
+}
+
 /**
  * Compress the pair (in_left, in_right) with a given hash index.
  * Called unsafe because this allows the option of not validating the input elements are unique, i.e. <r
diff --git a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.hpp b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.hpp
index d7b44296f4..ec2dda8d1d 100644
--- a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.hpp
+++ b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen.hpp
@@ -5,6 +5,8 @@
 #include "../../primitives/point/point.hpp"
 #include "../../primitives/byte_array/byte_array.hpp"
 
+using namespace crypto::generators;
+
 namespace plonk {
 namespace stdlib {
 
@@ -17,9 +19,14 @@ template <typename ComposerContext> class pedersen_commitment {
     typedef plonk::stdlib::byte_array<ComposerContext> byte_array;
     typedef plonk::stdlib::bool_t<ComposerContext> bool_t;
 
+  public:
     static point commit(const std::vector<field_t>& inputs, const size_t hash_index = 0);
 
-  public:
+    static point commit(const std::vector<field_t>& inputs,
+                        const std::vector<generator_index_t>& hash_generator_indices);
+
+    static point commit(const std::vector<std::pair<field_t, generator_index_t>>& input_pairs);
+
     static field_t compress_unsafe(const field_t& left,
                                    const field_t& right,
                                    const size_t hash_index,
@@ -32,6 +39,11 @@ template <typename ComposerContext> class pedersen_commitment {
 
     static field_t compress(const std::vector<field_t>& inputs, const size_t hash_index = 0);
 
+    static field_t compress(const std::vector<field_t>& inputs,
+                            const std::vector<generator_index_t>& hash_generator_indices);
+
+    static field_t compress(const std::vector<std::pair<field_t, generator_index_t>>& input_pairs);
+
     template <size_t T> static field_t compress(const std::array<field_t, T>& inputs)
     {
         std::vector<field_t> in(inputs.begin(), inputs.end());
diff --git a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.cpp b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.cpp
index 014a5dc6d6..6ecf62bee1 100644
--- a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.cpp
+++ b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.cpp
@@ -42,18 +42,103 @@ point<C> pedersen_plookup_commitment<C>::merkle_damgard_compress(const std::vect
     return compress_to_point(result, field_t(num_inputs));
 }
 
+template <typename C>
+point<C> pedersen_plookup_commitment<C>::merkle_damgard_compress(const std::vector<field_t>& inputs,
+                                                                 const std::vector<field_t>& ivs)
+{
+    const size_t num_inputs = inputs.size();
+    if (num_inputs == 0) {
+        return point{ 0, 0 };
+    }
+
+    auto result = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_IV, 0)[ColumnIdx::C2][0];
+    for (size_t i = 0; i < 2 * num_inputs; i++) {
+        if ((i & 1) == 0) {
+            auto iv_result =
+                plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_IV, ivs[i >> 1])[ColumnIdx::C2][0];
+            result = compress(result, iv_result);
+        } else {
+            result = compress(result, inputs[i >> 1]);
+        }
+    }
+
+    return compress_to_point(result, field_t(num_inputs));
+}
+
+template <typename C>
+point<C> pedersen_plookup_commitment<C>::merkle_damgard_tree_compress(const std::vector<field_t>& inputs,
+                                                                      const std::vector<field_t>& ivs)
+{
+    const size_t num_inputs = inputs.size();
+    ASSERT(num_inputs == ivs.size());
+    ASSERT(numeric::is_power_of_two(num_inputs));
+    if (num_inputs == 0) {
+        return point{ 0, 0 };
+    }
+
+    // Process height 0 of the tree.
+    std::vector<field_t> temp_storage;
+    for (size_t i = 0; i < num_inputs; i++) {
+        auto iv_result = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_IV, ivs[i])[ColumnIdx::C2][0];
+        temp_storage.push_back(compress(iv_result, inputs[i]));
+    }
+
+    // Process heights 1, 2, ..., log2(m) of the tree.
+    const size_t total_height = numeric::get_msb(num_inputs);
+    for (size_t height = 1; height <= total_height; height++) {
+        const size_t leaf_count = 1UL << (total_height - height);
+        for (size_t i = 0; i < leaf_count; i++) {
+            temp_storage[i] = compress(temp_storage[2 * i], temp_storage[2 * i + 1]);
+        }
+    }
+
+    return compress_to_point(temp_storage[0], field_t(num_inputs));
+}
+
 template <typename C>
 point<C> pedersen_plookup_commitment<C>::commit(const std::vector<field_t>& inputs, const size_t hash_index)
 {
     return merkle_damgard_compress(inputs, field_t(hash_index));
 }
 
+template <typename C>
+point<C> pedersen_plookup_commitment<C>::commit(const std::vector<field_t>& inputs,
+                                                const std::vector<size_t>& hash_indices)
+{
+    std::vector<field_t> hash_indices_;
+    for (size_t i = 0; i < hash_indices.size(); i++) {
+        hash_indices_.push_back(field_t(hash_indices[i]));
+    }
+
+    return merkle_damgard_compress(inputs, hash_indices_);
+}
+
 template <typename C>
 field_t<C> pedersen_plookup_commitment<C>::compress(const std::vector<field_t>& inputs, const size_t hash_index)
 {
     return commit(inputs, hash_index).x;
 }
 
+template <typename C>
+field_t<C> pedersen_plookup_commitment<C>::compress(const std::vector<field_t>& inputs,
+                                                    const std::vector<size_t>& hash_indices)
+{
+    return commit(inputs, hash_indices).x;
+}
+
+template <typename C>
+field_t<C> pedersen_plookup_commitment<C>::compress(const std::vector<std::pair<field_t, size_t>>& input_pairs)
+{
+    std::vector<field_t> inputs;
+    std::vector<size_t> hash_indices;
+    for (size_t i = 0; i < input_pairs.size(); i++) {
+        inputs.push_back(input_pairs[0].first);
+        hash_indices.push_back(input_pairs[0].second);
+    }
+
+    return commit(inputs, hash_indices).x;
+}
+
 template class pedersen_plookup_commitment<waffle::UltraComposer>;
 
 } // namespace stdlib
diff --git a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.hpp b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.hpp
index acd662307c..49ff11a778 100644
--- a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.hpp
+++ b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.hpp
@@ -14,13 +14,17 @@ template <typename ComposerContext> class pedersen_plookup_commitment {
     typedef plonk::stdlib::packed_byte_array<ComposerContext> packed_byte_array;
     typedef plonk::stdlib::bool_t<ComposerContext> bool_t;
 
+  public:
     static point commit(const std::vector<field_t>& inputs, const size_t hash_index = 0);
+    static point commit(const std::vector<field_t>& inputs, const std::vector<size_t>& hash_indices);
 
-  public:
     static field_t compress(const field_t& left, const field_t& right);
     static field_t compress(const std::vector<field_t>& inputs, const size_t hash_index = 0);
     static field_t compress(const packed_byte_array& input) { return compress(input.get_limbs()); }
 
+    static field_t compress(const std::vector<field_t>& inputs, const std::vector<size_t>& hash_indices);
+    static field_t compress(const std::vector<std::pair<field_t, size_t>>& input_pairs);
+
     template <size_t T> static field_t compress(const std::array<field_t, T>& inputs)
     {
         std::vector<field_t> in(inputs.begin(), inputs.end());
@@ -28,6 +32,8 @@ template <typename ComposerContext> class pedersen_plookup_commitment {
     }
 
     static point merkle_damgard_compress(const std::vector<field_t>& inputs, const field_t& iv);
+    static point merkle_damgard_compress(const std::vector<field_t>& inputs, const std::vector<field_t>& ivs);
+    static point merkle_damgard_tree_compress(const std::vector<field_t>& inputs, const std::vector<field_t>& ivs);
 
     static point compress_to_point(const field_t& left, const field_t& right);
 };
diff --git a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.test.cpp b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
index 8863de207e..135d923f79 100644
--- a/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
+++ b/cpp/src/aztec/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
@@ -107,5 +107,80 @@ TEST(stdlib_pedersen, test_merkle_damgard_compress_plookup)
     bool proof_result = verifier.verify_proof(proof);
     EXPECT_EQ(proof_result, true);
 }
+
+TEST(stdlib_pedersen, test_merkle_damgard_compress_multiple_iv_plookup)
+{
+    waffle::UltraComposer composer = waffle::UltraComposer();
+
+    const size_t m = 10;
+    std::vector<fr> input_values;
+    std::vector<size_t> iv_values;
+    for (size_t i = 0; i < m; i++) {
+        input_values.push_back(fr::random_element());
+        iv_values.push_back(engine.get_random_uint8());
+    }
+
+    std::vector<field_ct> inputs;
+    std::vector<field_ct> ivs;
+    for (size_t i = 0; i < m; i++) {
+        inputs.emplace_back(witness_ct(&composer, input_values[i]));
+        ivs.emplace_back(witness_ct(&composer, fr(iv_values[i])));
+    }
+
+    field_ct result =
+        stdlib::pedersen_plookup_commitment<waffle::UltraComposer>::merkle_damgard_compress(inputs, ivs).x;
+
+    auto expected = crypto::pedersen_commitment::lookup::merkle_damgard_compress(input_values, iv_values);
+
+    EXPECT_EQ(result.get_value(), expected.normalize().x);
+
+    auto prover = composer.create_prover();
+
+    printf("composer gates = %zu\n", composer.get_num_gates());
+    auto verifier = composer.create_verifier();
+
+    waffle::plonk_proof proof = prover.construct_proof();
+
+    bool proof_result = verifier.verify_proof(proof);
+    EXPECT_EQ(proof_result, true);
+}
+
+TEST(stdlib_pedersen, test_merkle_damgard_tree_compress_plookup)
+{
+    waffle::UltraComposer composer = waffle::UltraComposer();
+
+    const size_t m = 16;
+    std::vector<fr> input_values;
+    std::vector<size_t> iv_values;
+    for (size_t i = 0; i < m; i++) {
+        input_values.push_back(fr::random_element());
+        iv_values.push_back(engine.get_random_uint8());
+    }
+
+    std::vector<field_ct> inputs;
+    std::vector<field_ct> ivs;
+    for (size_t i = 0; i < m; i++) {
+        inputs.emplace_back(witness_ct(&composer, input_values[i]));
+        ivs.emplace_back(witness_ct(&composer, fr(iv_values[i])));
+    }
+
+    field_ct result =
+        stdlib::pedersen_plookup_commitment<waffle::UltraComposer>::merkle_damgard_tree_compress(inputs, ivs).x;
+
+    auto expected = crypto::pedersen_commitment::lookup::merkle_damgard_tree_compress(input_values, iv_values);
+
+    EXPECT_EQ(result.get_value(), expected.normalize().x);
+
+    auto prover = composer.create_prover();
+
+    printf("composer gates = %zu\n", composer.get_num_gates());
+    auto verifier = composer.create_verifier();
+
+    waffle::plonk_proof proof = prover.construct_proof();
+
+    bool proof_result = verifier.verify_proof(proof);
+    EXPECT_EQ(proof_result, true);
+}
+
 } // namespace plookup_pedersen_tests
 } // namespace test_stdlib_pedersen
diff --git a/cpp/src/aztec/stdlib/primitives/address/address.hpp b/cpp/src/aztec/stdlib/primitives/address/address.hpp
new file mode 100644
index 0000000000..af2d43ff88
--- /dev/null
+++ b/cpp/src/aztec/stdlib/primitives/address/address.hpp
@@ -0,0 +1,140 @@
+#pragma once
+#include <numeric/uint256/uint256.hpp>
+#include <stdlib/commitment/pedersen/pedersen.hpp>
+#include <stdlib/primitives/field/field.hpp>
+#include <stdlib/primitives/bool/bool.hpp>
+#include <stdlib/primitives/group/group.hpp>
+#include <stdlib/primitives/point/point.hpp>
+#include <stdlib/primitives/witness/witness.hpp>
+
+namespace plonk {
+namespace stdlib {
+
+using barretenberg::fr;
+using numeric::uint256_t;
+using plonk::stdlib::bool_t;
+using plonk::stdlib::field_t;
+using plonk::stdlib::group;
+using plonk::stdlib::pedersen_commitment;
+using plonk::stdlib::point;
+using plonk::stdlib::witness_t;
+
+// Native type
+class address {
+  public:
+    fr address_;
+
+    address() noexcept { address_ = fr(); }
+
+    address(address const& other)
+        : address_(other.address_){};
+
+    address(fr const& address)
+        : address_(address){};
+
+    address(uint256_t const& address)
+        : address_(address){};
+
+    address(int const& address)
+        : address_(fr(address)){};
+
+    operator fr() { return address_; }
+
+    operator fr() const { return address_; }
+
+    constexpr bool operator==(address const& other) const { return this->address_ == other.address_; }
+
+    friend std::ostream& operator<<(std::ostream& os, address const& v) { return os << v.address_; }
+
+    fr to_field() const { return address_; }
+};
+
+template <typename B> void read(B& it, address& addr)
+{
+    using serialize::read;
+    fr address_field;
+    read(it, address_field);
+    addr = address_field;
+}
+
+template <typename B> void write(B& buf, address const& addr)
+{
+    using serialize::write;
+    write(buf, addr.address_);
+}
+
+// Circuit type
+template <typename Composer> class address_t {
+  public:
+    field_t<Composer> address_;
+    Composer* context_;
+
+    address_t() = default;
+
+    address_t(address_t<Composer> const& other)
+        : address_(other.address_)
+        , context_(other.context_){};
+
+    address_t(field_t<Composer> const& address)
+        : address_(address)
+        , context_(address.context){};
+
+    address_t(uint256_t const& address)
+        : address_(address)
+        , context_(nullptr){};
+
+    address_t(int const& address)
+        : address_(address)
+        , context_(nullptr){};
+
+    address_t(witness_t<Composer> const& witness)
+    {
+        address_ = field_t(witness);
+        context_ = witness.context;
+    }
+
+    address_t<Composer>& operator=(const address_t<Composer>& other)
+    {
+        address_ = other.address_;
+        context_ = other.context_;
+        return *this;
+    }
+
+    bool_t<Composer> operator==(const address_t& other) const { return this->to_field() == other.to_field(); }
+
+    field_t<Composer> to_field() const { return address_; }
+
+    fr get_value() const { return address_.get_value(); };
+
+    void assert_equal(const address_t& rhs, std::string const& msg = "address_t::assert_equal") const
+    {
+        address_.assert_equal(rhs.address_, msg);
+    };
+
+    void assert_is_in_set(const std::vector<address_t>& set,
+                          std::string const& msg = "address_t::assert_is_in_set") const
+    {
+        std::vector<field_t<Composer>> field_set;
+        for (const auto& e : set) {
+            field_set.push_back(e.address_);
+        }
+        address_.assert_is_in_set(field_set, msg);
+    }
+
+    static address_t conditional_assign(const bool_t<Composer>& predicate, const address_t& lhs, const address_t& rhs)
+    {
+        return field_t<Composer>::conditional_assign(predicate, lhs.address_, rhs.address_);
+    };
+
+    static address_t<Composer> derive_from_private_key(field_t<Composer> const& private_key)
+    {
+        // TODO: Dummy logic, for now. Proper derivation undecided.
+        point<Composer> public_key = group<Composer>::template fixed_base_scalar_mul_g1<254>(private_key);
+        return address_t<Composer>(public_key.x);
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, address_t<Composer> const& v) { return os << v.address_; }
+};
+
+} // namespace stdlib
+} // namespace plonk
\ No newline at end of file
diff --git a/cpp/src/aztec/stdlib/primitives/bigfield/bigfield.hpp b/cpp/src/aztec/stdlib/primitives/bigfield/bigfield.hpp
index 1e03582c34..30e884664c 100644
--- a/cpp/src/aztec/stdlib/primitives/bigfield/bigfield.hpp
+++ b/cpp/src/aztec/stdlib/primitives/bigfield/bigfield.hpp
@@ -292,13 +292,13 @@ template <typename Composer, typename T> class bigfield {
     /**
      * Create a witness form a constant. This way the value of the witness is fixed and public.
      **/
-    void convert_constant_to_witness(Composer* composer)
+    void convert_constant_to_fixed_witness(Composer* composer)
     {
         context = composer;
         for (auto& limb : binary_basis_limbs) {
-            limb.element.convert_constant_to_witness(context);
+            limb.element.convert_constant_to_fixed_witness(context);
         }
-        prime_basis_limb.convert_constant_to_witness(context);
+        prime_basis_limb.convert_constant_to_fixed_witness(context);
     }
 
     /**
diff --git a/cpp/src/aztec/stdlib/primitives/bigfield/bigfield_impl.hpp b/cpp/src/aztec/stdlib/primitives/bigfield/bigfield_impl.hpp
index 0165d31316..62140a8d0a 100644
--- a/cpp/src/aztec/stdlib/primitives/bigfield/bigfield_impl.hpp
+++ b/cpp/src/aztec/stdlib/primitives/bigfield/bigfield_impl.hpp
@@ -1309,7 +1309,7 @@ bigfield<C, T> bigfield<C, T>::mult_madd(const std::vector<bigfield>& mul_left,
         remainder = zero();
         // remainder needs to be defined as wire value and not selector values to satisfy
         // UltraPlonk's bigfield custom gates
-        remainder.convert_constant_to_witness(ctx);
+        remainder.convert_constant_to_fixed_witness(ctx);
     } else {
         remainder = create_from_u512_as_witness(ctx, remainder_value);
     }
@@ -1883,7 +1883,7 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
     if constexpr (C::type == waffle::PLOOKUP) {
         // The plookup custom bigfield gate requires inputs are witnesses.
         // If we're using constant values, instantiate them as circuit variables
-        const auto convert_constant_to_witness = [ctx](const bigfield& input) {
+        const auto convert_constant_to_fixed_witness = [ctx](const bigfield& input) {
             bigfield output(input);
             output.prime_basis_limb =
                 field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(input.prime_basis_limb.get_value()));
@@ -1899,16 +1899,16 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
             return output;
         };
         if (left.is_constant()) {
-            left = convert_constant_to_witness(left);
+            left = convert_constant_to_fixed_witness(left);
         }
         if (to_mul.is_constant()) {
-            to_mul = convert_constant_to_witness(to_mul);
+            to_mul = convert_constant_to_fixed_witness(to_mul);
         }
         if (quotient.is_constant()) {
-            quotient = convert_constant_to_witness(quotient);
+            quotient = convert_constant_to_fixed_witness(quotient);
         }
         if (remainders[0].is_constant()) {
-            remainders[0] = convert_constant_to_witness(remainders[0]);
+            remainders[0] = convert_constant_to_fixed_witness(remainders[0]);
         }
 
         std::vector<field_t<C>> limb_0_accumulator{ remainders[0].binary_basis_limbs[0].element };
@@ -2104,11 +2104,11 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
                 carry_lo = carry_lo.normalize();
                 carry_hi = carry_hi.normalize();
                 ctx->decompose_into_base4_accumulators(carry_lo.witness_index,
-                                                    static_cast<size_t>(carry_lo_msb),
-                                                    "bigfield: carry_lo too large in unsafe_evaluate_multiply_add.");
+                                                       static_cast<size_t>(carry_lo_msb),
+                                                       "bigfield: carry_lo too large in unsafe_evaluate_multiply_add.");
                 ctx->decompose_into_base4_accumulators(carry_hi.witness_index,
-                                                    static_cast<size_t>(carry_hi_msb),
-                                                    "bigfield: carry_hi too large in unsafe_evaluate_multiply_add.");
+                                                       static_cast<size_t>(carry_hi_msb),
+                                                       "bigfield: carry_hi too large in unsafe_evaluate_multiply_add.");
             }
         }
     }
@@ -2242,7 +2242,7 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
         // The plookup custom bigfield gate requires inputs are witnesses.
         // If we're using constant values, instantiate them as circuit variables
 
-        const auto convert_constant_to_witness = [ctx](const bigfield& input) {
+        const auto convert_constant_to_fixed_witness = [ctx](const bigfield& input) {
             bigfield output(input);
             output.prime_basis_limb =
                 field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(input.prime_basis_limb.get_value()));
@@ -2274,16 +2274,16 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
 
         for (size_t i = 0; i < num_multiplications; ++i) {
             if (i == 0 && left[0].is_constant()) {
-                left[0] = convert_constant_to_witness(left[0]);
+                left[0] = convert_constant_to_fixed_witness(left[0]);
             }
             if (i == 0 && right[0].is_constant()) {
-                right[0] = convert_constant_to_witness(right[0]);
+                right[0] = convert_constant_to_fixed_witness(right[0]);
             }
             if (i > 0 && left[i].is_constant()) {
-                left[i] = convert_constant_to_witness(left[i]);
+                left[i] = convert_constant_to_fixed_witness(left[i]);
             }
             if (i > 0 && right[i].is_constant()) {
-                right[i] = convert_constant_to_witness(right[i]);
+                right[i] = convert_constant_to_fixed_witness(right[i]);
             }
 
             if (i > 0) {
@@ -2331,7 +2331,7 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
             }
         }
         if (quotient.is_constant()) {
-            quotient = convert_constant_to_witness(quotient);
+            quotient = convert_constant_to_fixed_witness(quotient);
         }
 
         bool no_remainders = remainders.size() == 0;
diff --git a/cpp/src/aztec/stdlib/primitives/bool/bool.cpp b/cpp/src/aztec/stdlib/primitives/bool/bool.cpp
index 3564195918..3c4f0340cc 100644
--- a/cpp/src/aztec/stdlib/primitives/bool/bool.cpp
+++ b/cpp/src/aztec/stdlib/primitives/bool/bool.cpp
@@ -420,18 +420,68 @@ void bool_t<ComposerContext>::assert_equal(const bool_t& rhs, std::string const&
     }
 }
 
+// if predicate == true then return lhs, else return rhs
+template <typename ComposerContext>
+bool_t<ComposerContext> bool_t<ComposerContext>::conditional_assign(const bool_t<ComposerContext>& predicate,
+                                                                    const bool_t& lhs,
+                                                                    const bool_t& rhs)
+{
+    return (predicate && lhs) || (!predicate && rhs);
+}
+
 template <typename ComposerContext>
 bool_t<ComposerContext> bool_t<ComposerContext>::implies(const bool_t<ComposerContext>& other) const
 {
     return (!(*this) || other); // P => Q is equiv. to !P || Q (not(P) or Q).
 }
 
+/**
+ *      (P => Q) && (P => R)
+ * <=>  (!P || Q) && (!P || R)
+ * <=>  !P || (Q && R)           [by distributivity of propositional logic]
+ * <=>  P => (Q && R)            [a.k.a. distribution of implication over conjunction]
+ */
 template <typename ComposerContext>
 void bool_t<ComposerContext>::must_imply(const bool_t& other, std::string const& msg) const
 {
     (this->implies(other)).assert_equal(true, msg);
 }
 
+/**
+ * Process many implications all at once, for readablity, and as an optimisation.
+ * @param conds - each pair is a boolean condition that we want to constrain to be "implied", and an error message if it
+ * is not implied.
+ *
+ * Why this works:
+ *      (P => Q) && (P => R)
+ * <=>  (!P || Q) && (!P || R)
+ * <=>  !P || (Q && R)           [by distributivity of propositional logic]
+ * <=>  P => (Q && R)            [a.k.a. distribution of implication over conjunction]
+ */
+template <typename ComposerContext>
+void bool_t<ComposerContext>::must_imply(const std::vector<std::pair<bool_t, std::string>>& conds) const
+{
+    bool_t acc = true; // will accumulate the conjunctions of each condition (i.e. `&&` of each)
+    const bool this_val = this->get_value();
+
+    for (size_t i = 0; i < conds.size(); ++i) {
+        const bool_t& cond = conds[i].first;
+        const std::string& msg = conds[i].second;
+        const bool cond_val = cond.get_value();
+
+        // If this does NOT imply that, throw the error msg of that condition.
+        if (!(!this_val || cond_val)) {
+            // TODO: make it so the first failure message given to the composer persists, and cannot be overwritten by
+            // subsequent failure msgs.
+            context->failure(msg);
+        }
+
+        acc &= cond;
+    }
+
+    (this->implies(acc)).assert_equal(true, "multi implication fail");
+}
+
 // A "double-implication" (<=>),
 // a.k.a "iff", a.k.a. "biconditional"
 template <typename ComposerContext>
diff --git a/cpp/src/aztec/stdlib/primitives/bool/bool.hpp b/cpp/src/aztec/stdlib/primitives/bool/bool.hpp
index 03c9f757ca..60b01ffa70 100644
--- a/cpp/src/aztec/stdlib/primitives/bool/bool.hpp
+++ b/cpp/src/aztec/stdlib/primitives/bool/bool.hpp
@@ -52,8 +52,12 @@ template <typename ComposerContext> class bool_t {
     // assertions
     void assert_equal(const bool_t& rhs, std::string const& msg = "bool_t::assert_equal") const;
 
+    static bool_t conditional_assign(const bool_t<ComposerContext>& predicate, const bool_t& lhs, const bool_t& rhs);
+
     void must_imply(const bool_t& other, std::string const& msg = "bool_t::must_imply") const;
 
+    void must_imply(const std::vector<std::pair<bool_t, std::string>>& conds) const;
+
     bool get_value() const { return witness_bool ^ witness_inverted; }
 
     bool is_constant() const { return witness_index == IS_CONSTANT; }
diff --git a/cpp/src/aztec/stdlib/primitives/field/array.hpp b/cpp/src/aztec/stdlib/primitives/field/array.hpp
new file mode 100644
index 0000000000..59f6710f39
--- /dev/null
+++ b/cpp/src/aztec/stdlib/primitives/field/array.hpp
@@ -0,0 +1,153 @@
+#pragma once
+#include "field.hpp"
+#include "../bool/bool.hpp"
+
+namespace plonk {
+namespace stdlib {
+
+/**
+ * Gets the number of contiguous nonzero values of an array.
+ * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
+ * something else.
+ */
+// TODO: move to own file of helper functions.
+template <typename Composer, size_t SIZE> field_t<Composer> array_length(std::array<field_t<Composer>, SIZE> const& arr)
+{
+    field_t<Composer> length = 0;
+    bool_t<Composer> hit_zero = false;
+    for (const auto& e : arr) {
+        hit_zero |= e == 0;
+        const field_t<Composer> increment = !hit_zero;
+        length += increment;
+    }
+    return length;
+};
+
+/**
+ * Note: doesn't remove the last element from the array; only returns it!
+ * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
+ * something else.
+ * If it returns `0`, the array is considered 'empty'.
+ */
+template <typename Composer, size_t SIZE> field_t<Composer> array_pop(std::array<field_t<Composer>, SIZE> const& arr)
+{
+    field_t<Composer> popped_value;
+    bool_t<Composer> already_popped = false;
+    for (size_t i = arr.size() - 1; i != (size_t)-1; i--) {
+        bool_t<Composer> is_non_zero = arr[i] != 0;
+        popped_value = field_t<Composer>::conditional_assign(!already_popped && is_non_zero, arr[i], popped_value);
+
+        already_popped |= is_non_zero;
+    }
+    already_popped.assert_equal(true, "Cannot pop from an empty array");
+
+    return popped_value;
+};
+
+/**
+ * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
+ * something else.
+ */
+template <typename Composer, size_t SIZE>
+void array_push(std::array<field_t<Composer>, SIZE>& arr, field_t<Composer> const& value)
+{
+    bool_t<Composer> already_pushed = false;
+    for (size_t i = 0; i < arr.size(); ++i) {
+        bool_t<Composer> is_zero = arr[i] == 0;
+        arr[i] = field_t<Composer>::conditional_assign(!already_pushed && is_zero, value, arr[i]);
+
+        already_pushed |= is_zero;
+    }
+    already_pushed.assert_equal(true, "Cannot push to a full array");
+};
+
+template <typename Composer, size_t SIZE>
+inline size_t array_push(std::array<std::optional<field_t<Composer>>, SIZE>& arr, field_t<Composer> const& value)
+{
+    for (size_t i = 0; i < arr.size(); ++i) {
+        if (arr[i] == std::nullopt) {
+            arr[i] = value;
+            return i;
+        }
+    }
+    throw_or_abort("Cannot push to a full array");
+};
+
+template <typename T, size_t SIZE>
+inline size_t array_push(std::array<std::shared_ptr<T>, SIZE>& arr, std::shared_ptr<T> const& value)
+{
+    for (size_t i = 0; i < arr.size(); ++i) {
+        if (arr[i] == nullptr) {
+            arr[i] = value;
+            return i;
+        }
+    }
+    throw_or_abort("Cannot push to a full array");
+};
+
+/**
+ * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
+ * something else.
+ */
+template <typename Composer, size_t SIZE>
+typename plonk::stdlib::bool_t<Composer> is_array_empty(std::array<field_t<Composer>, SIZE> const& arr)
+{
+    bool_t<Composer> nonzero_found = false;
+    for (size_t i = arr.size() - 1; i != (size_t)-1; i--) {
+        bool_t<Composer> is_non_zero = arr[i] != 0;
+        nonzero_found |= is_non_zero;
+    }
+    return !nonzero_found;
+};
+
+/**
+ * Inserts the `source` array at the first zero-valued index of the `target` array.
+ * Fails if the `source` array is too large vs the remaining capacity of the `target` array.
+ */
+template <typename Composer, size_t size_1, size_t size_2>
+void push_array_to_array(std::array<field_t<Composer>, size_1> const& source,
+                         std::array<field_t<Composer>, size_2>& target)
+{
+    // TODO: inefficient to get length this way within this function. Probably best to inline the checks that we need
+    // into the below loops directly.
+    field_t<Composer> target_length = array_length<Composer>(target);
+    field_t<Composer> source_length = array_length<Composer>(source);
+    field_t<Composer> target_capacity = field_t<Composer>(target.size());
+    const field_t<Composer> overflow_capacity = target_capacity + 1;
+
+    // TODO: using safe_uint for an underflow check, do:
+    // remaining_target_capacity = target_capacity.subtract(target_length + source_length);
+
+    ASSERT(target_capacity.get_value() + 1 > target_length.get_value() + source_length.get_value());
+
+    info("source: ", source);
+    info("target before: ", target);
+
+    field_t<Composer> j_ct = 0; // circuit-type index for the inner loop
+    field_t<Composer> next_target_index = target_length;
+    for (size_t i = 0; i < source.size(); ++i) {
+        auto& s = source[i];
+
+        // Triangular loop:
+        for (size_t j = i; j < target.size() - source.size() + i + 1; ++j) {
+            auto& t = target[j];
+
+            bool_t<Composer> at_next_index = j_ct == next_target_index;
+
+            t = field_t<Composer>::conditional_assign(at_next_index, s, t);
+
+            j_ct++;
+        }
+
+        next_target_index++;
+
+        next_target_index.assert_not_equal(overflow_capacity, "Target array capacity exceeded");
+
+        j_ct = i + 1;
+    }
+
+    info("target after: ", target);
+}
+
+} // namespace stdlib
+} // namespace plonk
\ No newline at end of file
diff --git a/cpp/src/aztec/stdlib/primitives/field/field.hpp b/cpp/src/aztec/stdlib/primitives/field/field.hpp
index d082d87c58..2d8c8cce26 100644
--- a/cpp/src/aztec/stdlib/primitives/field/field.hpp
+++ b/cpp/src/aztec/stdlib/primitives/field/field.hpp
@@ -103,6 +103,13 @@ template <typename ComposerContext> class field_t {
         return *this;
     }
 
+    static field_t copy_as_new_witness(ComposerContext& context, field_t const& other)
+    {
+        auto result = field_t<ComposerContext>(witness_t<ComposerContext>(&context, other.get_value()));
+        result.assert_equal(other, "field_t::copy_as_new_witness, assert_equal");
+        return result;
+    }
+
     field_t operator+(const field_t& other) const;
     field_t operator-(const field_t& other) const;
     field_t operator*(const field_t& other) const;
@@ -135,6 +142,21 @@ template <typename ComposerContext> class field_t {
         return *this;
     }
 
+    // Prefix increment (++x)
+    field_t& operator++()
+    {
+        *this = *this + 1;
+        return *this;
+    };
+
+    // Postfix increment (x++)
+    field_t operator++(int)
+    {
+        field_t this_before_operation = field_t(*this);
+        *this = *this + 1;
+        return this_before_operation;
+    };
+
     field_t invert() const { return (field_t(1) / field_t(*this)).normalize(); }
 
     static field_t coset_generator(const size_t generator_idx)
@@ -238,9 +260,10 @@ template <typename ComposerContext> class field_t {
     void set_public() const { context->set_public_input(normalize().witness_index); }
 
     /**
-     * Create a witness form a constant. This way the value of the witness is fixed and public.
-     **/
-    void convert_constant_to_witness(ComposerContext* ctx)
+     * Create a witness form a constant. This way the value of the witness is fixed and public (public, because the
+     * value becomes hard-coded as an element of the q_c selector vector).
+     */
+    void convert_constant_to_fixed_witness(ComposerContext* ctx)
     {
         ASSERT(witness_index == IS_CONSTANT);
         context = ctx;
diff --git a/cpp/src/aztec/stdlib/primitives/field/field.test.cpp b/cpp/src/aztec/stdlib/primitives/field/field.test.cpp
index ea15fe4fe6..aa7f20f876 100644
--- a/cpp/src/aztec/stdlib/primitives/field/field.test.cpp
+++ b/cpp/src/aztec/stdlib/primitives/field/field.test.cpp
@@ -241,6 +241,44 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(result, true);
     }
 
+    static void test_postfix_increment()
+    {
+        Composer composer = Composer();
+
+        field_ct a = witness_ct(&composer, 10);
+
+        field_ct b = a++;
+
+        EXPECT_EQ(b.get_value(), 10);
+        EXPECT_EQ(a.get_value(), 11);
+
+        auto prover = composer.create_prover();
+
+        auto verifier = composer.create_verifier();
+        waffle::plonk_proof proof = prover.construct_proof();
+        bool result = verifier.verify_proof(proof);
+        EXPECT_EQ(result, true);
+    }
+
+    static void test_prefix_increment()
+    {
+        Composer composer = Composer();
+
+        field_ct a = witness_ct(&composer, 10);
+
+        field_ct b = ++a;
+
+        EXPECT_EQ(b.get_value(), 11);
+        EXPECT_EQ(a.get_value(), 11);
+
+        auto prover = composer.create_prover();
+
+        auto verifier = composer.create_verifier();
+        waffle::plonk_proof proof = prover.construct_proof();
+        bool result = verifier.verify_proof(proof);
+        EXPECT_EQ(result, true);
+    }
+
     static void test_field_fibbonaci()
     {
         Composer composer = Composer();
@@ -579,7 +617,8 @@ template <typename Composer> class stdlib_field : public testing::Test {
 
         const uint256_t expected0 = uint256_t(a_) & ((uint256_t(1) << uint64_t(lsb)) - 1);
         const uint256_t expected1 = (uint256_t(a_) >> lsb) & ((uint256_t(1) << (uint64_t(msb - lsb) + 1)) - 1);
-        const uint256_t expected2 = (uint256_t(a_) >> (msb + 1)) & ((uint256_t(1) << (uint64_t(252 - msb) - 1)) - 1);
+        const uint256_t expected2 =
+            (uint256_t(a_) >> uint64_t(msb + 1)) & ((uint256_t(1) << (uint64_t(252 - msb) - 1)) - 1);
 
         EXPECT_EQ(slice[0].get_value(), fr(expected0));
         EXPECT_EQ(slice[1].get_value(), fr(expected1));
@@ -932,6 +971,14 @@ TYPED_TEST(stdlib_field, test_div)
 {
     TestFixture::test_div();
 }
+TYPED_TEST(stdlib_field, test_postfix_increment)
+{
+    TestFixture::test_postfix_increment();
+}
+TYPED_TEST(stdlib_field, test_prefix_increment)
+{
+    TestFixture::test_prefix_increment();
+}
 TYPED_TEST(stdlib_field, test_field_fibbonaci)
 {
     TestFixture::test_field_fibbonaci();
diff --git a/cpp/src/aztec/stdlib/primitives/point/point.hpp b/cpp/src/aztec/stdlib/primitives/point/point.hpp
index 27aa9f88ef..88422813c1 100644
--- a/cpp/src/aztec/stdlib/primitives/point/point.hpp
+++ b/cpp/src/aztec/stdlib/primitives/point/point.hpp
@@ -46,6 +46,21 @@ template <typename Composer> struct point {
     };
 
     bool_t<Composer> operator==(const point& other) const { return (this->x == other.x) && (this->y == other.y); }
+
+    point<Composer> operator+(const point& other) const
+    {
+        const field_t<Composer>& x1 = this->x;
+        const field_t<Composer>& y1 = this->y;
+
+        const field_t<Composer>& x2 = other.x;
+        const field_t<Composer>& y2 = other.y;
+
+        const field_t<Composer> lambda = (y2 - y1) / (x2 - x1);
+        const field_t<Composer> x3 = lambda * lambda - x2 - x1;
+        const field_t<Composer> y3 = lambda * (x1 - x3) - y1;
+
+        return { x3, y3 };
+    }
 };
 
 template <typename Composer, typename E>
diff --git a/cpp/src/aztec/stdlib/primitives/safe_uint/safe_uint.test.cpp b/cpp/src/aztec/stdlib/primitives/safe_uint/safe_uint.test.cpp
index 701716b454..620c01cc03 100644
--- a/cpp/src/aztec/stdlib/primitives/safe_uint/safe_uint.test.cpp
+++ b/cpp/src/aztec/stdlib/primitives/safe_uint/safe_uint.test.cpp
@@ -475,7 +475,8 @@ TEST(stdlib_safeuint, test_slice_random)
 
     const uint256_t expected0 = uint256_t(a_) & ((uint256_t(1) << uint64_t(lsb)) - 1);
     const uint256_t expected1 = (uint256_t(a_) >> lsb) & ((uint256_t(1) << (uint64_t(msb - lsb) + 1)) - 1);
-    const uint256_t expected2 = (uint256_t(a_) >> (msb + 1)) & ((uint256_t(1) << (uint64_t(252 - msb) - 1)) - 1);
+    const uint256_t expected2 =
+        (uint256_t(a_) >> uint64_t(msb + 1)) & ((uint256_t(1) << (uint64_t(252 - msb) - 1)) - 1);
 
     EXPECT_EQ(slice[0].get_value(), fr(expected0));
     EXPECT_EQ(slice[1].get_value(), fr(expected1));
diff --git a/cpp/src/aztec/stdlib/recursion/verifier/verifier.hpp b/cpp/src/aztec/stdlib/recursion/verifier/verifier.hpp
index d8121e5f30..e9da4c6899 100644
--- a/cpp/src/aztec/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/aztec/stdlib/recursion/verifier/verifier.hpp
@@ -39,6 +39,17 @@ template <typename Curve> struct recursion_output {
     }
 };
 
+// Native version of the recursion_output of the stdlib, for passing into/between circuits.
+// TODO: this isn't really in the right place, but wasn't sure where to put it?
+struct native_recursion_output {
+    typename barretenberg::g1::affine_element P0 = barretenberg::g1::affine_one;
+    typename barretenberg::g1::affine_element P1 = barretenberg::g1::affine_one;
+    // the public inputs of the inner ciruit are now private inputs of the outer circuit!
+    std::vector<barretenberg::fr> public_inputs;
+    std::vector<uint32_t> proof_witness_indices;
+    bool has_data = false;
+};
+
 template <typename Composer> struct lagrange_evaluations {
     field_t<Composer> l_start;
     field_t<Composer> l_end;
diff --git a/cpp/src/aztec/stdlib/types/circuit_types.hpp b/cpp/src/aztec/stdlib/types/circuit_types.hpp
new file mode 100644
index 0000000000..ac224c0f35
--- /dev/null
+++ b/cpp/src/aztec/stdlib/types/circuit_types.hpp
@@ -0,0 +1,95 @@
+#pragma once
+#include <stdlib/primitives/address/address.hpp>
+#include <stdlib/encryption/schnorr/schnorr.hpp>
+#include <stdlib/primitives/bigfield/bigfield.hpp>
+#include <stdlib/primitives/biggroup/biggroup.hpp>
+#include <stdlib/primitives/bit_array/bit_array.hpp>
+#include <stdlib/primitives/bool/bool.hpp>
+#include <stdlib/primitives/byte_array/byte_array.hpp>
+#include <stdlib/primitives/packed_byte_array/packed_byte_array.hpp>
+#include <stdlib/primitives/uint/uint.hpp>
+#include <stdlib/primitives/point/point.hpp>
+#include <stdlib/primitives/group/group.hpp>
+#include <stdlib/primitives/curves/bn254.hpp>
+#include <stdlib/recursion/verifier/verifier.hpp>
+#include <stdlib/recursion/verification_key/verification_key.hpp>
+#include <stdlib/commitment/pedersen/pedersen.hpp>
+#include <stdlib/hash/blake2s/blake2s.hpp>
+#include "native_types.hpp"
+
+namespace plonk::stdlib::types {
+
+using plonk::stdlib::address_t;
+// using NT = plonk::stdlib::types::NativeTypes;
+// using plonk::stdlib::pedersen;
+
+template <typename Composer> struct CircuitTypes {
+    typedef bool_t<Composer> boolean;
+
+    // typedef uint8<Composer> uint8;
+    // typedef uint16<Composer> uint16;
+    typedef stdlib::uint32<Composer> uint32;
+    // typedef uint64<Composer> uint64;
+
+    typedef field_t<Composer> fr; // of altbn
+    typedef safe_uint_t<Composer> safe_fr;
+    // TODO: make address_ct be the same as all other types. (And define it in the stdlib, instead of aztec3 dir).
+    typedef address_t<Composer> address;
+
+    typedef stdlib::bigfield<Composer, barretenberg::Bn254FqParams> fq; // of altbn
+
+    // typedef fq grumpkin_fr;
+    // typedef fr grumpkin_fq;
+    typedef point<Composer> grumpkin_point; // affine
+    typedef group<Composer> grumpkin_group;
+
+    typedef stdlib::bn254<Composer> bn254;
+    // typedef bn254::g1_ct bn254_point;
+    typedef element<Composer, fq, fr, barretenberg::g1>
+        bn254_point; // looks affine (despite the confusing name 'element').
+
+    // typedef bit_array<Composer> bit_array;
+    typedef stdlib::byte_array<Composer> byte_array;
+    // typedef packed_byte_array<Composer> packed_byte_array;
+
+    // typedef stdlib::schnorr::signature_bits<Composer> signature;
+
+    typedef stdlib::recursion::recursion_output<bn254> AggregationObject;
+    typedef stdlib::recursion::verification_key<bn254> VK;
+    // Notice: no CircuitType for a Proof: we only ever handle native; the verify_proof() function swallows the
+    // 'circuit-type-ness' of the proof.
+
+    /// TODO: lots of these compress / commit functions aren't actually used: remove them.
+
+    // Define the 'circuit' version of the function `compress`, with the name `compress`:
+    static fr compress(std::vector<fr> const& inputs, const size_t hash_index = 0)
+    {
+        return plonk::stdlib::pedersen_commitment<Composer>::compress(inputs, hash_index);
+    }
+
+    static fr compress(std::vector<fr> const& inputs,
+                       std::vector<size_t> const& hash_sub_indices,
+                       const size_t hash_index = 0)
+    {
+        return plonk::stdlib::pedersen_commitment<Composer>::compress(inputs, hash_sub_indices, hash_index);
+    }
+
+    static fr compress(const std::vector<std::pair<fr, crypto::generators::generator_index_t>>& input_pairs)
+    {
+        return plonk::stdlib::pedersen_commitment<Composer>::compress(input_pairs);
+    };
+
+    static grumpkin_point commit(const std::vector<fr>& inputs, const size_t hash_index = 0)
+    {
+        return plonk::stdlib::pedersen_commitment<Composer>::commit(inputs, hash_index);
+    };
+
+    static grumpkin_point commit(const std::vector<std::pair<fr, crypto::generators::generator_index_t>>& input_pairs)
+    {
+        return plonk::stdlib::pedersen_commitment<Composer>::commit(input_pairs);
+    };
+
+    static byte_array blake2s(const byte_array& input) { return plonk::stdlib::blake2s(input); }
+};
+
+} // namespace plonk::stdlib::types
\ No newline at end of file
diff --git a/cpp/src/aztec/stdlib/types/convert.hpp b/cpp/src/aztec/stdlib/types/convert.hpp
new file mode 100644
index 0000000000..61ee0fd25c
--- /dev/null
+++ b/cpp/src/aztec/stdlib/types/convert.hpp
@@ -0,0 +1,215 @@
+#pragma once
+
+#include <common/map.hpp>
+#include <stdlib/primitives/witness/witness.hpp>
+#include <stdlib/primitives/point/point.hpp>
+#include "native_types.hpp"
+#include "circuit_types.hpp"
+
+namespace plonk::stdlib::types {
+
+using plonk::stdlib::witness_t;
+
+namespace {
+
+template <typename Composer> using CT = plonk::stdlib::types::CircuitTypes<Composer>;
+using NT = plonk::stdlib::types::NativeTypes;
+
+} // namespace
+
+/// TODO: Lots of identical functions here (but for their in/out types). Can we use templates? I couldn't figure out how
+/// to keep the NT:: or CT:: prefixes with templates.
+template <typename Composer> typename CT<Composer>::boolean to_ct(Composer& composer, typename NT::boolean const& e)
+{
+    return typename CT<Composer>::boolean(witness_t<Composer>(&composer, e));
+};
+
+template <typename Composer> typename CT<Composer>::fr to_ct(Composer& composer, typename NT::fr const& e)
+{
+    return typename CT<Composer>::fr(witness_t<Composer>(&composer, e));
+};
+
+template <typename Composer> typename CT<Composer>::fq to_ct(Composer& composer, typename NT::fq const& e)
+{
+    return typename CT<Composer>::fq(witness_t<Composer>(&composer, e));
+};
+
+template <typename Composer> typename CT<Composer>::address to_ct(Composer& composer, typename NT::address const& e)
+{
+    return typename CT<Composer>::address(witness_t<Composer>(&composer, e));
+};
+
+template <typename Composer> typename CT<Composer>::uint32 to_ct(Composer& composer, typename NT::uint32 const& e)
+{
+    return typename CT<Composer>::uint32(witness_t<Composer>(&composer, e));
+};
+
+template <typename Composer>
+typename CT<Composer>::grumpkin_point to_ct(Composer& composer, typename NT::grumpkin_point const& e)
+{
+    return plonk::stdlib::create_point_witness<Composer, typename NT::grumpkin_point>(composer, e, true);
+};
+
+template <typename Composer>
+typename CT<Composer>::bn254_point to_ct(Composer& composer, typename NT::bn254_point const& e)
+{
+    return CT<Composer>::bn254_point::from_witness(&composer, e);
+};
+
+template <typename Composer>
+std::optional<typename CT<Composer>::boolean> to_ct(Composer& composer, std::optional<typename NT::boolean> const& e)
+{
+    return e ? std::make_optional<typename CT<Composer>::boolean>(to_ct(composer, *e)) : std::nullopt;
+};
+
+template <typename Composer>
+std::optional<typename CT<Composer>::fr> to_ct(Composer& composer, std::optional<typename NT::fr> const& e)
+{
+    return e ? std::make_optional<typename CT<Composer>::fr>(to_ct(composer, *e)) : std::nullopt;
+};
+
+template <typename Composer>
+std::optional<typename CT<Composer>::address> to_ct(Composer& composer, std::optional<typename NT::address> const& e)
+{
+    return e ? std::make_optional<typename CT<Composer>::address>(to_ct(composer, *e)) : std::nullopt;
+};
+
+template <typename Composer>
+std::optional<typename CT<Composer>::grumpkin_point> to_ct(Composer& composer,
+                                                           std::optional<typename NT::grumpkin_point> const& e)
+{
+    return e ? std::make_optional<typename CT<Composer>::grumpkin_point>(to_ct(composer, *e)) : std::nullopt;
+};
+
+template <typename Composer>
+std::vector<typename CT<Composer>::fr> to_ct(Composer& composer, std::vector<typename NT::fr> const& vec)
+{
+    auto ref_to_ct = [&](typename NT::fr const& e) { return to_ct(composer, e); };
+
+    return map(vec, ref_to_ct);
+};
+
+template <typename Composer>
+std::optional<std::vector<typename CT<Composer>::fr>> to_ct(Composer& composer,
+                                                            std::optional<std::vector<typename NT::fr>> const& vec)
+{
+    auto ref_to_ct = [&](typename NT::fr const& e) { return to_ct(composer, e); };
+
+    return vec ? std::make_optional<std::vector<typename CT<Composer>::fr>>(map(*vec, ref_to_ct)) : std::nullopt;
+};
+
+template <typename Composer, std::size_t SIZE>
+std::array<typename CT<Composer>::fr, SIZE> to_ct(Composer& composer, std::array<typename NT::fr, SIZE> const& arr)
+{
+    auto ref_to_ct = [&](typename NT::fr const& e) { return to_ct(composer, e); };
+
+    return map(arr, ref_to_ct);
+};
+
+template <typename Composer, std::size_t SIZE>
+std::array<std::optional<typename CT<Composer>::fr>, SIZE> to_ct(
+    Composer& composer, std::array<std::optional<typename NT::fr>, SIZE> const& arr)
+{
+    auto ref_to_ct = [&](std::optional<typename NT::fr> const& e) { return to_ct(composer, e); };
+
+    return map(arr, ref_to_ct);
+};
+
+// to_nt() below ********************************
+
+template <typename Composer> typename NT::boolean to_nt(typename CT<Composer>::boolean const& e)
+{
+    return e.get_value();
+};
+
+template <typename Composer> typename NT::fr to_nt(typename CT<Composer>::fr const& e)
+{
+    return e.get_value();
+};
+
+template <typename Composer> typename NT::fq to_nt(typename CT<Composer>::fq const& e)
+{
+    return e.get_value();
+};
+
+template <typename Composer> typename NT::address to_nt(typename CT<Composer>::address const& e)
+{
+    return NT::address(e.address_.get_value()); // TODO: add get_value() method to address types.
+};
+
+template <typename Composer> typename NT::uint32 to_nt(typename CT<Composer>::uint32 const& e)
+{
+    NT::uint256 e_256 = e.get_value();
+    NT::uint64 e_64 = e_256.data[0]; // TODO: check that this endianness is correct!
+    NT::uint32 e_32 = static_cast<NT::uint32>(e_64);
+    return e_32;
+};
+
+template <typename Composer> typename NT::grumpkin_point to_nt(typename CT<Composer>::grumpkin_point const& e)
+{
+    return NT::grumpkin_point{ e.x.get_value(), e.y.get_value() };
+};
+
+template <typename Composer> typename NT::bn254_point to_nt(typename CT<Composer>::bn254_point const& e)
+{
+    return NT::bn254_point{ e.x.get_value(), e.y.get_value() };
+};
+
+template <typename Composer>
+std::optional<typename NT::boolean> to_nt(std::optional<typename CT<Composer>::boolean> const& e)
+{
+    return e ? std::make_optional<typename NT::boolean>(to_nt<Composer>(*e)) : std::nullopt;
+};
+
+template <typename Composer> std::optional<typename NT::fr> to_nt(std::optional<typename CT<Composer>::fr> const& e)
+{
+    return e ? std::make_optional<typename NT::fr>(to_nt<Composer>(*e)) : std::nullopt;
+};
+
+template <typename Composer>
+std::optional<typename NT::address> to_nt(std::optional<typename CT<Composer>::address> const& e)
+{
+    return e ? std::make_optional<typename NT::address>(to_nt<Composer>(*e)) : std::nullopt;
+};
+
+template <typename Composer>
+std::optional<typename NT::grumpkin_point> to_nt(std::optional<typename CT<Composer>::grumpkin_point> const& e)
+{
+    return e ? std::make_optional<typename NT::grumpkin_point>(to_nt<Composer>(*e)) : std::nullopt;
+};
+
+template <typename Composer>
+std::optional<std::vector<typename NT::fr>> to_nt(std::optional<std::vector<typename CT<Composer>::fr>> const& vec)
+{
+    auto ref_to_nt = [&](typename CT<Composer>::fr const& e) { return to_nt<Composer>(e); };
+
+    return vec ? std::make_optional<std::vector<typename NT::fr>>(map(*vec, ref_to_nt)) : std::nullopt;
+};
+
+template <typename Composer, std::size_t SIZE>
+std::array<typename NT::fr, SIZE> to_nt(std::array<typename CT<Composer>::fr, SIZE> const& arr)
+{
+    auto ref_to_nt = [&](typename CT<Composer>::fr const& e) { return to_nt<Composer>(e); };
+
+    return map(arr, ref_to_nt);
+};
+
+// template <typename Composer, std::size_t SIZE>
+// std::optional<std::array<typename NT::fr, SIZE>> to_nt(
+//     std::optional<std::array<typename CT<Composer>::fr, SIZE>> const& arr)
+// {
+//     auto ref_to_nt = [&](typename CT<Composer>::fr const& e) { return to_nt(e); };
+
+//     return arr ? std::make_optional<std::array<typename NT::fr, SIZE>>(map(arr, ref_to_nt)) : std::nullopt;
+// };
+
+template <typename Composer, std::size_t SIZE>
+std::array<std::optional<typename NT::fr>, SIZE> to_nt(
+    std::array<std::optional<typename CT<Composer>::fr>, SIZE> const& arr)
+{
+    auto ref_to_nt = [&](std::optional<typename CT<Composer>::fr> const& e) { return to_nt<Composer>(e); };
+
+    return map(arr, ref_to_nt);
+};
+
+} // namespace plonk::stdlib::types
\ No newline at end of file
diff --git a/cpp/src/aztec/stdlib/types/native_types.hpp b/cpp/src/aztec/stdlib/types/native_types.hpp
new file mode 100644
index 0000000000..e9955daf1a
--- /dev/null
+++ b/cpp/src/aztec/stdlib/types/native_types.hpp
@@ -0,0 +1,87 @@
+#pragma once
+#include <stdlib/primitives/address/address.hpp>
+#include <crypto/pedersen_commitment/pedersen.hpp>
+#include <crypto/generators/generator_data.hpp>
+#include <crypto/schnorr/schnorr.hpp>
+#include <ecc/curves/bn254/fq.hpp>
+#include <ecc/curves/bn254/fr.hpp>
+#include <ecc/curves/bn254/g1.hpp>
+#include <ecc/curves/grumpkin/grumpkin.hpp>
+#include <numeric/uint256/uint256.hpp>
+#include <proof_system/verification_key/verification_key.hpp>
+#include <plonk/proof_system/types/plonk_proof.hpp>
+#include <stdlib/recursion/verifier/verifier.hpp>
+
+// #include <stdlib/primitives/bit_array/bit_array.hpp>
+// #include <stdlib/primitives/bool/bool.hpp>
+// #include <stdlib/primitives/byte_array/byte_array.hpp>
+// #include <stdlib/primitives/packed_byte_array/packed_byte_array.hpp>
+// #include <stdlib/primitives/uint/uint.hpp>
+// #include <stdlib/primitives/point/point.hpp>
+// #include <stdlib/primitives/group/group.hpp>
+
+namespace plonk::stdlib::types {
+
+using plonk::stdlib::address;
+
+struct NativeTypes {
+    typedef bool boolean;
+
+    // typedef uint8_t uint8;
+    // typedef uint16_t uint16;
+    typedef uint32_t uint32;
+    typedef uint64_t uint64;
+    typedef uint256_t uint256;
+
+    typedef barretenberg::fr fr;
+    typedef barretenberg::fr safe_fr;
+    typedef types::address address;
+
+    typedef barretenberg::fq fq;
+
+    // typedef fq grumpkin_fr;
+    // typedef fr grumpkin_fq;
+    typedef grumpkin::g1::affine_element grumpkin_point;
+    // typedef grumpkin::g1::element grumpkin_jac_point;
+    typedef grumpkin::g1 grumpkin_group;
+
+    typedef barretenberg::g1::affine_element bn254_point;
+    // typedef barretenberg::g1::element bn254_jac_point;
+    // typedef barretenberg::g1 bn254_group;
+
+    // typedef bit_array bit_array;
+    // typedef byte_array byte_array;
+    // typedef packed_byte_array packed_byte_array;
+
+    // typedef crypto::schnorr::signature signature;
+
+    typedef stdlib::recursion::native_recursion_output AggregationObject;
+    typedef waffle::verification_key_data VKData;
+    typedef waffle::verification_key VK;
+    typedef waffle::plonk_proof Proof;
+
+    /// TODO: lots of these compress / commit functions aren't actually used: remove them.
+
+    // Define the 'native' version of the function `compress`, with the name `compress`:
+    static fr compress(const std::vector<fr>& inputs, const size_t hash_index = 0)
+    {
+        return crypto::pedersen_commitment::compress_native(inputs, hash_index);
+    }
+
+    static fr compress(const std::vector<std::pair<fr, crypto::generators::generator_index_t>>& input_pairs)
+    {
+        return crypto::pedersen_commitment::compress_native(input_pairs);
+    }
+
+    static grumpkin_point commit(const std::vector<fr>& inputs, const size_t hash_index = 0)
+    {
+        return crypto::pedersen_commitment::commit_native(inputs, hash_index);
+    }
+
+    static grumpkin_point commit(const std::vector<std::pair<fr, crypto::generators::generator_index_t>>& input_pairs)
+    {
+        return crypto::pedersen_commitment::commit_native(input_pairs);
+    }
+};
+
+} // namespace plonk::stdlib::types
\ No newline at end of file