diff --git a/README.md b/README.md
index 802392f5fc3..ef207aa92b8 100644
--- a/README.md
+++ b/README.md
@@ -11,10 +11,17 @@
 - libomp (if multithreading is required. Multithreading can be disabled using the compiler flag `-DMULTITHREADING 0`)
 - wasm-opt (part of the [Binaryen](https://github.com/WebAssembly/binaryen) toolkit)
 
+To install on Ubuntu, run:
+```
+sudo apt-get install cmake clang clang-format ninja-build binaryen
+```
+
 ### Installing openMP (Linux)
 
+Install from source:
+
 ```
-RUN git clone -b release/10.x --depth 1 https://github.com/llvm/llvm-project.git \
+git clone -b release/10.x --depth 1 https://github.com/llvm/llvm-project.git \
   && cd llvm-project && mkdir build-openmp && cd build-openmp \
   && cmake ../openmp -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLIBOMP_ENABLE_SHARED=OFF \
   && cmake --build . --parallel \
@@ -22,6 +29,14 @@ RUN git clone -b release/10.x --depth 1 https://github.com/llvm/llvm-project.git
   && cd ../.. && rm -rf llvm-project
 ```
 
+Or install from a package manager, on Ubuntu:
+
+```
+sudo apt-get install libomp-dev
+```
+
+> Note: on a fresh Ubuntu Kinetic installation, installing OpenMP from source yields a `Could NOT find OpenMP_C (missing: OpenMP_omp_LIBRARY) (found version "5.0")` error when trying to build Barretenberg. Installing from apt worked fine.
+
 ### Getting started
 
 Run the bootstrap script. (The bootstrap script will build both the native and wasm versions of barretenberg)
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index b978b04d53f..582d7285374 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -18,6 +18,8 @@ option(BENCHMARKS "Build benchmarks" ON)
 option(FUZZING "Build fuzzing harnesses" OFF)
 option(DISABLE_TBB "Intel Thread Building Blocks" ON)
 option(COVERAGE "Enable collecting coverage from tests" OFF)
+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)
@@ -39,6 +41,15 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "a
     set(DISABLE_TBB 0)
 endif()
 
+if(ENABLE_ASAN)
+    add_compile_options(-fsanitize=address)
+    add_link_options(-fsanitize=address)
+endif()
+
+if(SERIALIZE_CANARY)
+    add_definitions(-DENABLE_SERIALIZE_CANARY)
+endif()
+
 if(FUZZING)
     add_definitions(-DFUZZING=1)
 
diff --git a/cpp/dockerfiles/Dockerfile.wasm-linux-clang b/cpp/dockerfiles/Dockerfile.wasm-linux-clang
index f4a19bba534..d1c41f0ce7a 100644
--- a/cpp/dockerfiles/Dockerfile.wasm-linux-clang
+++ b/cpp/dockerfiles/Dockerfile.wasm-linux-clang
@@ -5,10 +5,11 @@ WORKDIR /usr/src/barretenberg/cpp/src
 RUN curl -s -L https://github.com/CraneStation/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz | tar zxfv -
 WORKDIR /usr/src/barretenberg/cpp
 COPY . .
-# Build both honk_tests barretenberg.wasm
+# Build both honk_tests barretenberg.wasm primitives.wasm
 # This ensures that we aren't using features that would be incompatible with WASM for Honk
-RUN cmake --preset wasm && cmake --build --preset wasm --target honk_tests --target barretenberg.wasm
+RUN cmake --preset wasm && cmake --build --preset wasm --target honk_tests --target barretenberg.wasm --target primitives.wasm
 
 FROM alpine:3.17
 COPY --from=builder /usr/src/barretenberg/cpp/build-wasm/bin/barretenberg.wasm /usr/src/barretenberg/cpp/build/bin/barretenberg.wasm
+COPY --from=builder /usr/src/barretenberg/cpp/build-wasm/bin/primitives.wasm /usr/src/barretenberg/cpp/build/bin/primitives.wasm
 COPY --from=builder /usr/src/barretenberg/cpp/build-wasm/bin/*_tests /usr/src/barretenberg/cpp/build/bin/
diff --git a/cpp/scripts/bb-tests b/cpp/scripts/bb-tests
index b8df6e338fb..ba012981ead 100644
--- a/cpp/scripts/bb-tests
+++ b/cpp/scripts/bb-tests
@@ -2,7 +2,7 @@ crypto_aes128_tests
 crypto_blake2s_tests
 crypto_blake3s_tests
 crypto_ecdsa_tests
-crypto_pedersen_tests
+crypto_pedersen_commitment_tests
 crypto_schnorr_tests
 crypto_sha256_tests
 ecc_tests
@@ -18,7 +18,7 @@ stdlib_blake2s_tests
 stdlib_blake3s_tests
 stdlib_ecdsa_tests
 stdlib_merkle_tree_tests
-stdlib_pedersen_tests
+stdlib_pedersen_commitment_tests
 stdlib_schnorr_tests
 stdlib_sha256_tests
 transcript_tests
diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt
index 3a40b2a908a..a90789f9c64 100644
--- a/cpp/src/CMakeLists.txt
+++ b/cpp/src/CMakeLists.txt
@@ -76,7 +76,9 @@ if(WASM)
         $<TARGET_OBJECTS:crypto_blake3s_objects>
         $<TARGET_OBJECTS:crypto_keccak_objects>
         $<TARGET_OBJECTS:crypto_schnorr_objects>
-        $<TARGET_OBJECTS:crypto_pedersen_objects>
+        $<TARGET_OBJECTS:crypto_generators_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_hash_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_commitment_objects>
         $<TARGET_OBJECTS:ecc_objects>
         $<TARGET_OBJECTS:polynomials_objects>
         $<TARGET_OBJECTS:plonk_objects>
@@ -84,7 +86,8 @@ if(WASM)
         $<TARGET_OBJECTS:proof_system_objects>
         $<TARGET_OBJECTS:stdlib_primitives_objects>
         $<TARGET_OBJECTS:stdlib_schnorr_objects>
-        $<TARGET_OBJECTS:stdlib_pedersen_objects>
+        $<TARGET_OBJECTS:stdlib_pedersen_hash_objects>
+        $<TARGET_OBJECTS:stdlib_pedersen_commitment_objects>
         $<TARGET_OBJECTS:stdlib_blake2s_objects>
         $<TARGET_OBJECTS:stdlib_blake3s_objects>
         $<TARGET_OBJECTS:stdlib_sha256_objects>
@@ -92,6 +95,9 @@ if(WASM)
         $<TARGET_OBJECTS:stdlib_merkle_tree_objects>
         $<TARGET_OBJECTS:acir_format_objects>
         $<TARGET_OBJECTS:acir_proofs_objects>
+        $<TARGET_OBJECTS:stdlib_sha256_objects>
+        $<TARGET_OBJECTS:stdlib_aes128_objects>
+        $<TARGET_OBJECTS:stdlib_merkle_tree_objects>
     )
 
     # With binaryen installed, it seems its wasm backend optimiser gets invoked automatically.
@@ -105,12 +111,35 @@ if(WASM)
         -nostartfiles -O2 -Wl,--no-entry -Wl,--export-dynamic -Wl,--import-memory -Wl,--allow-undefined -Wl,--stack-first -Wl,-z,stack-size=1048576
     )
 
+    # Repeat the above but for the smaller primitives.wasm
+    # Used in packages where we don't need the full contents of barretenberg
+    add_executable(
+        primitives.wasm
+        $<TARGET_OBJECTS:srs_objects>
+        $<TARGET_OBJECTS:numeric_objects>
+        $<TARGET_OBJECTS:crypto_sha256_objects>
+        $<TARGET_OBJECTS:crypto_aes128_objects>
+        $<TARGET_OBJECTS:crypto_blake2s_objects>
+        $<TARGET_OBJECTS:crypto_blake3s_objects>
+        $<TARGET_OBJECTS:crypto_generators_objects>
+        $<TARGET_OBJECTS:crypto_keccak_objects>
+        $<TARGET_OBJECTS:crypto_schnorr_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_hash_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_commitment_objects>
+        $<TARGET_OBJECTS:ecc_objects>
+    )
+
+    target_link_options(
+        primitives.wasm
+        PRIVATE
+        -nostartfiles -O2 -Wl,--no-entry -Wl,--export-dynamic -Wl,--import-memory -Wl,--allow-undefined -Wl,--stack-first -Wl,-z,stack-size=1048576
+    )
+
     # TODO(blaine): Figure out how to Asyncify the wasm output.
     # Binaryen's Asyncify transform produces wasm that has too many local variables to run in a WebAssembly
     # instance. This likely would be "solved" by enabling the optimizations to reduce the number of locals,
     # but using any optimization level results in a wasm file that takes an unusable amount of time to solve the
     # most simple prood.
-
     # find_program(WASM_OPT wasm-opt)
 
     # if(NOT WASM_OPT)
@@ -124,6 +153,13 @@ if(WASM)
     #     VERBATIM
     # )
 
+    add_custom_command(
+        TARGET primitives.wasm
+        POST_BUILD
+        COMMAND wasm-opt "$<TARGET_FILE:primitives.wasm>" -O2 -o "$<TARGET_FILE:primitives.wasm>"
+        VERBATIM
+    )
+
     if(INSTALL_BARRETENBERG)
         install(TARGETS barretenberg.wasm DESTINATION ${CMAKE_INSTALL_BINDIR})
     endif()
@@ -142,7 +178,9 @@ if(WASM)
         $<TARGET_OBJECTS:crypto_blake3s_objects>
         $<TARGET_OBJECTS:crypto_keccak_objects>
         $<TARGET_OBJECTS:crypto_schnorr_objects>
-        $<TARGET_OBJECTS:crypto_pedersen_objects>
+        $<TARGET_OBJECTS:crypto_generators_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_hash_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_commitment_objects>
         $<TARGET_OBJECTS:ecc_objects>
         $<TARGET_OBJECTS:polynomials_objects>
         $<TARGET_OBJECTS:plonk_objects>
@@ -150,7 +188,8 @@ if(WASM)
         $<TARGET_OBJECTS:proof_system_objects>
         $<TARGET_OBJECTS:stdlib_primitives_objects>
         $<TARGET_OBJECTS:stdlib_schnorr_objects>
-        $<TARGET_OBJECTS:stdlib_pedersen_objects>
+        $<TARGET_OBJECTS:stdlib_pedersen_hash_objects>
+        $<TARGET_OBJECTS:stdlib_pedersen_commitment_objects>
         $<TARGET_OBJECTS:stdlib_blake2s_objects>
         $<TARGET_OBJECTS:stdlib_blake3s_objects>
         $<TARGET_OBJECTS:stdlib_sha256_objects>
@@ -174,7 +213,9 @@ else()
         $<TARGET_OBJECTS:crypto_blake3s_objects>
         $<TARGET_OBJECTS:crypto_keccak_objects>
         $<TARGET_OBJECTS:crypto_schnorr_objects>
-        $<TARGET_OBJECTS:crypto_pedersen_objects>
+        $<TARGET_OBJECTS:crypto_generators_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_hash_objects>
+        $<TARGET_OBJECTS:crypto_pedersen_commitment_objects>
         $<TARGET_OBJECTS:ecc_objects>
         $<TARGET_OBJECTS:polynomials_objects>
         $<TARGET_OBJECTS:plonk_objects>
@@ -182,7 +223,8 @@ else()
         $<TARGET_OBJECTS:proof_system_objects>
         $<TARGET_OBJECTS:stdlib_primitives_objects>
         $<TARGET_OBJECTS:stdlib_schnorr_objects>
-        $<TARGET_OBJECTS:stdlib_pedersen_objects>
+        $<TARGET_OBJECTS:stdlib_pedersen_hash_objects>
+        $<TARGET_OBJECTS:stdlib_pedersen_commitment_objects>
         $<TARGET_OBJECTS:stdlib_blake2s_objects>
         $<TARGET_OBJECTS:stdlib_blake3s_objects>
         $<TARGET_OBJECTS:stdlib_sha256_objects>
diff --git a/cpp/src/barretenberg/common/container.hpp b/cpp/src/barretenberg/common/container.hpp
index 6418be1461d..1c87bb1224a 100644
--- a/cpp/src/barretenberg/common/container.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/common/map.hpp b/cpp/src/barretenberg/common/map.hpp
index a78c81ca628..79205f2bda5 100644
--- a/cpp/src/barretenberg/common/map.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/common/serialize.hpp b/cpp/src/barretenberg/common/serialize.hpp
index b196f68ab07..622dc919f73 100644
--- a/cpp/src/barretenberg/common/serialize.hpp
+++ b/cpp/src/barretenberg/common/serialize.hpp
@@ -27,6 +27,7 @@
  *  - to_buffer
  */
 #pragma once
+#include <cassert>
 #include <array>
 #include "barretenberg/common/net.hpp"
 #include <type_traits>
@@ -34,6 +35,7 @@
 #include <map>
 #include <iostream>
 #include "barretenberg/common/log.hpp"
+#include <optional>
 
 #ifndef __i386__
 __extension__ using uint128_t = unsigned __int128;
@@ -148,6 +150,24 @@ template <typename T> inline std::enable_if_t<std::is_integral_v<T>> write(std::
     write(ptr, value);
     os.write((char*)buf.data(), sizeof(T));
 }
+
+// DEBUG_CANARY_READ and DEBUG_CANARY_WRITE write strings during debug testing
+// so that we can detect serialization misalignment for more complicated types.
+// This is in an awkward location as it must see the above functions, and be seen by the below functions.
+#ifndef ENABLE_SERIALIZE_CANARY
+#define DEBUG_CANARY_WRITE(buf, x)
+#define DEBUG_CANARY_READ(it, x)
+#else
+#define DEBUG_CANARY_WRITE(buf, x) serialize::write(buf, (uint64_t) typeid(x).hash_code())
+#define DEBUG_CANARY_READ(it, x)                                                                                       \
+    {                                                                                                                  \
+        uint64_t hash_code;                                                                                            \
+        serialize::read(it, hash_code);                                                                                \
+        if (hash_code != (uint64_t) typeid(x).hash_code()) {                                                           \
+            throw std::runtime_error(std::string("Could not read magic string for ") + typeid(x).name());              \
+        }                                                                                                              \
+    }
+#endif
 } // namespace serialize
 
 namespace std {
@@ -155,17 +175,20 @@ namespace std {
 // Forwarding functions from std to serialize namespace for integers.
 template <typename B, typename T> inline std::enable_if_t<std::is_integral_v<T>> read(B& buf, T& value)
 {
+    DEBUG_CANARY_READ(buf, value);
     serialize::read(buf, value);
 }
 
 template <typename B, typename T> inline std::enable_if_t<std::is_integral_v<T>> write(B& buf, T value)
 {
+    DEBUG_CANARY_WRITE(buf, value);
     serialize::write(buf, value);
 }
 
 // Optimised specialisation for reading arrays of bytes from a raw buffer.
 template <size_t N> inline void read(uint8_t const*& it, std::array<uint8_t, N>& value)
 {
+    DEBUG_CANARY_READ(it, value);
     std::copy(it, it + N, value.data());
     it += N;
 }
@@ -173,6 +196,7 @@ template <size_t N> inline void read(uint8_t const*& it, std::array<uint8_t, N>&
 // Optimised specialisation for writing arrays of bytes to a raw buffer.
 template <size_t N> inline void write(uint8_t*& buf, std::array<uint8_t, N> const& value)
 {
+    DEBUG_CANARY_WRITE(buf, value);
     std::copy(value.begin(), value.end(), buf);
     buf += N;
 }
@@ -180,6 +204,7 @@ template <size_t N> inline void write(uint8_t*& buf, std::array<uint8_t, N> cons
 // Optimised specialisation for reading vectors of bytes from a raw buffer.
 inline void read(uint8_t const*& it, std::vector<uint8_t>& value)
 {
+    DEBUG_CANARY_READ(it, value);
     uint32_t size;
     read(it, size);
     value.resize(size);
@@ -190,6 +215,7 @@ inline void read(uint8_t const*& it, std::vector<uint8_t>& value)
 // Optimised specialisation for writing vectors of bytes to a raw buffer.
 inline void write(uint8_t*& buf, std::vector<uint8_t> const& value)
 {
+    DEBUG_CANARY_WRITE(buf, value);
     write(buf, static_cast<uint32_t>(value.size()));
     std::copy(value.begin(), value.end(), buf);
     buf += value.size();
@@ -198,6 +224,7 @@ inline void write(uint8_t*& buf, std::vector<uint8_t> const& value)
 // Optimised specialisation for reading vectors of bytes from an input stream.
 inline void read(std::istream& is, std::vector<uint8_t>& value)
 {
+    DEBUG_CANARY_READ(is, value);
     uint32_t size;
     read(is, size);
     value.resize(size);
@@ -207,6 +234,7 @@ inline void read(std::istream& is, std::vector<uint8_t>& value)
 // Optimised specialisation for writing vectors of bytes to an output stream.
 inline void write(std::ostream& os, std::vector<uint8_t> const& value)
 {
+    DEBUG_CANARY_WRITE(os, value);
     write(os, static_cast<uint32_t>(value.size()));
     os.write((char*)value.data(), (std::streamsize)value.size());
 }
@@ -214,6 +242,7 @@ inline void write(std::ostream& os, std::vector<uint8_t> const& value)
 // Optimised specialisation for writing arrays of bytes to a vector.
 template <size_t N> inline void write(std::vector<uint8_t>& buf, std::array<uint8_t, N> const& value)
 {
+    DEBUG_CANARY_WRITE(buf, value);
     buf.resize(buf.size() + N);
     auto ptr = &*buf.end() - N;
     write(ptr, value);
@@ -222,12 +251,14 @@ template <size_t N> inline void write(std::vector<uint8_t>& buf, std::array<uint
 // Optimised specialisation for writing arrays of bytes to an output stream.
 template <size_t N> inline void write(std::ostream& os, std::array<uint8_t, N> const& value)
 {
+    DEBUG_CANARY_WRITE(os, value);
     os.write((char*)value.data(), value.size());
 }
 
 // Generic read of array of types from supported buffer types.
 template <typename B, typename T, size_t N> inline void read(B& it, std::array<T, N>& value)
 {
+    DEBUG_CANARY_READ(it, value);
     for (size_t i = 0; i < N; ++i) {
         read(it, value[i]);
     }
@@ -236,6 +267,7 @@ template <typename B, typename T, size_t N> inline void read(B& it, std::array<T
 // Generic write of array of types to supported buffer types.
 template <typename B, typename T, size_t N> inline void write(B& buf, std::array<T, N> const& value)
 {
+    DEBUG_CANARY_WRITE(buf, value);
     for (size_t i = 0; i < N; ++i) {
         write(buf, value[i]);
     }
@@ -244,6 +276,7 @@ template <typename B, typename T, size_t N> inline void write(B& buf, std::array
 // Generic read of vector of types from supported buffer types.
 template <typename B, typename T> inline void read(B& it, std::vector<T>& value)
 {
+    DEBUG_CANARY_READ(it, value);
     uint32_t size;
     read(it, size);
     value.resize(size);
@@ -264,6 +297,7 @@ template <typename B, typename T> inline void write(B& buf, std::vector<T> const
 // Read string from supported buffer types.
 template <typename B> inline void read(B& it, std::string& value)
 {
+    DEBUG_CANARY_READ(it, value);
     std::vector<uint8_t> buf;
     read(it, buf);
     value = std::string(buf.begin(), buf.end());
@@ -278,6 +312,7 @@ template <typename B> inline void write(B& buf, std::string const& value)
 // Read std::pair.
 template <typename B, typename T, typename U> inline void read(B& it, std::pair<T, U>& value)
 {
+    DEBUG_CANARY_READ(it, value);
     read(it, value.first);
     read(it, value.second);
 }
@@ -285,6 +320,7 @@ template <typename B, typename T, typename U> inline void read(B& it, std::pair<
 // Write std::pair.
 template <typename B, typename T, typename U> inline void write(B& buf, std::pair<T, U> const& value)
 {
+    DEBUG_CANARY_WRITE(buf, value);
     write(buf, value.first);
     write(buf, value.second);
 }
@@ -292,6 +328,7 @@ template <typename B, typename T, typename U> inline void write(B& buf, std::pai
 // Read std::map
 template <typename B, typename T, typename U> inline void read(B& it, std::map<T, U>& value)
 {
+    DEBUG_CANARY_READ(it, value);
     value.clear();
     uint32_t size;
     read(it, size);
@@ -305,12 +342,42 @@ template <typename B, typename T, typename U> inline void read(B& it, std::map<T
 // Write std::map.
 template <typename B, typename T, typename U> inline void write(B& buf, std::map<T, U> const& value)
 {
+    DEBUG_CANARY_WRITE(buf, value);
     write(buf, static_cast<uint32_t>(value.size()));
     for (auto const& kv : value) {
         write(buf, kv);
     }
 }
 
+// Read std::optional<T>.
+template <typename B, typename T> inline void read(B& it, std::optional<T>& opt_value)
+{
+    DEBUG_CANARY_READ(it, 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)
+{
+    DEBUG_CANARY_WRITE(buf, 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/barretenberg/common/streams.hpp b/cpp/src/barretenberg/common/streams.hpp
index 31c4cab18f0..af8c9e2403b 100644
--- a/cpp/src/barretenberg/common/streams.hpp
+++ b/cpp/src/barretenberg/common/streams.hpp
@@ -1,7 +1,9 @@
 #pragma once
 #include <iomanip>
 #include <ostream>
+#include <map>
 #include <vector>
+#include <optional>
 
 namespace std {
 
@@ -35,7 +37,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 +65,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/barretenberg/crypto/CMakeLists.txt b/cpp/src/barretenberg/crypto/CMakeLists.txt
index 8f2b22453bd..a6517b16750 100644
--- a/cpp/src/barretenberg/crypto/CMakeLists.txt
+++ b/cpp/src/barretenberg/crypto/CMakeLists.txt
@@ -1,9 +1,11 @@
 add_subdirectory(hmac)
+add_subdirectory(generators)
 add_subdirectory(blake2s)
 add_subdirectory(blake3s)
 add_subdirectory(blake3s_full)
 add_subdirectory(keccak)
-add_subdirectory(pedersen)
+add_subdirectory(pedersen_commitment)
+add_subdirectory(pedersen_hash)
 add_subdirectory(schnorr)
 add_subdirectory(sha256)
 add_subdirectory(ecdsa)
diff --git a/cpp/src/barretenberg/crypto/ecdsa/ecdsa.hpp b/cpp/src/barretenberg/crypto/ecdsa/ecdsa.hpp
index fb9d7644fc6..a094701a5ce 100644
--- a/cpp/src/barretenberg/crypto/ecdsa/ecdsa.hpp
+++ b/cpp/src/barretenberg/crypto/ecdsa/ecdsa.hpp
@@ -1,6 +1,8 @@
+#pragma once
 #include "../hashers/hashers.hpp"
 #include <array>
 #include <string>
+#include "barretenberg/ecc/curves/secp256k1/secp256k1.hpp"
 
 namespace crypto {
 namespace ecdsa {
@@ -21,6 +23,42 @@ template <typename Hash, typename Fq, typename Fr, typename G1>
 bool verify_signature(const std::string& message,
                       const typename G1::affine_element& public_key,
                       const signature& signature);
+
+inline bool operator==(signature const& lhs, signature const& rhs)
+{
+    return lhs.r == rhs.r && lhs.s == rhs.s;
+}
+
+inline std::ostream& operator<<(std::ostream& os, signature const& sig)
+{
+    os << "{ " << sig.r << ", " << sig.s << " }";
+    return os;
+}
+
+template <typename B> inline void read(B& it, signature& sig)
+{
+    read(it, sig.r);
+    read(it, sig.s);
+}
+
+template <typename B> inline void write(B& buf, signature const& sig)
+{
+    write(buf, sig.r);
+    write(buf, sig.s);
+}
+
+template <typename B> inline void read(B& it, key_pair<secp256k1::fr, secp256k1::g1>& keypair)
+{
+    read(it, keypair.private_key);
+    read(it, keypair.public_key);
+}
+
+template <typename B> inline void write(B& buf, key_pair<secp256k1::fr, secp256k1::g1> const& keypair)
+{
+    write(buf, keypair.private_key);
+    write(buf, keypair.public_key);
+}
+
 } // namespace ecdsa
 } // namespace crypto
 
diff --git a/cpp/src/barretenberg/crypto/generators/CMakeLists.txt b/cpp/src/barretenberg/crypto/generators/CMakeLists.txt
new file mode 100644
index 00000000000..c57e2f53c53
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/generators/CMakeLists.txt
@@ -0,0 +1 @@
+barretenberg_module(crypto_generators ecc)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/fixed_base_scalar_mul.hpp b/cpp/src/barretenberg/crypto/generators/fixed_base_scalar_mul.hpp
similarity index 89%
rename from cpp/src/barretenberg/crypto/pedersen/fixed_base_scalar_mul.hpp
rename to cpp/src/barretenberg/crypto/generators/fixed_base_scalar_mul.hpp
index abe08371c57..2077483bda7 100644
--- a/cpp/src/barretenberg/crypto/pedersen/fixed_base_scalar_mul.hpp
+++ b/cpp/src/barretenberg/crypto/generators/fixed_base_scalar_mul.hpp
@@ -1,8 +1,9 @@
 #pragma once
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "./generator_data.hpp"
 
 namespace crypto {
-namespace pedersen {
+namespace generators {
 
 constexpr uint64_t WNAF_MASK = 0x7fffffffUL;
 
@@ -17,7 +18,7 @@ grumpkin::g1::element fixed_base_scalar_mul(const barretenberg::fr& in, const si
     constexpr size_t num_quads = ((num_quads_base << 1) + 1 < num_bits) ? num_quads_base + 1 : num_quads_base;
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
 
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
 
     uint64_t wnaf_entries[num_quads + 2] = { 0 };
     bool skew = false;
@@ -40,5 +41,5 @@ grumpkin::g1::element fixed_base_scalar_mul(const barretenberg::fr& in, const si
     return accumulator.normalize();
 }
 
-} // namespace pedersen
+} // namespace generators
 } // namespace crypto
diff --git a/cpp/src/barretenberg/crypto/pedersen/generator_data.cpp b/cpp/src/barretenberg/crypto/generators/generator_data.cpp
similarity index 90%
rename from cpp/src/barretenberg/crypto/pedersen/generator_data.cpp
rename to cpp/src/barretenberg/crypto/generators/generator_data.cpp
index c98e10c002a..7970dfe6593 100644
--- a/cpp/src/barretenberg/crypto/pedersen/generator_data.cpp
+++ b/cpp/src/barretenberg/crypto/generators/generator_data.cpp
@@ -1,19 +1,23 @@
 #include "./generator_data.hpp"
 
 namespace crypto {
-namespace pedersen {
+namespace generators {
 namespace {
 
 // The number of unique base points with default main index with precomputed ladders
 #ifdef __wasm__
-constexpr size_t num_default_generators = 32;
+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
 #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;
@@ -235,21 +239,26 @@ const fixed_base_ladder* get_g1_ladder(const size_t num_bits)
 /**
  * Generator indexing:
  *
+ * Number of default generators (index = 0): N = 2048
+ * Number of hash indices: H = 32
+ * Number of sub indices for a given hash index: h = 64.
+ * Number of types of generators needed per hash index: t = 3
+ *
  * Default generators:
- * 0: P_0  P_1  P_2  ...  P_{2047}
+ * 0: P_0  P_1  P_2  ...  P_{N'-1}
  *
- * Hash-index dependent generators:
- * 1:  P_{2048 + 0*8}   P_{2049}  ...  P_{2055}
- * 2:  P_{2048 + 1*8}   P_{2048 + 1*8 + 1}   ...  P_{2048 + 1*8 + 7}
- * 3:
+ * Hash-index dependent generators: (let N' = t * N)
+ * 1:  P_{N' + 0*h*t}   P_{N' + 0*h*t + 1*t}  ...  P_{N' + 0*h*t + (h-1)*t}
+ * 2:  P_{N' + 1*h*t}   P_{N' + 1*h*t + 1*t}  ...  P_{N' + 1*h*t + (h-1)*t}
+ * 2:  P_{N' + 2*h*t}   P_{N' + 2*h*t + 1*t}  ...  P_{N' + 2*h*t + (h-1)*t}
  * 4:
  * .
  * .
  * .
- * 31: P_{2048 + 30*8}  P_{2048 + 30*8 + 1}  ...  P_{2048 + 30*8 + 7}
- * 32: P_{2048 + 31*8}  P_{2048 + 31*8 + 1}  ...  P_{2048 + 31*8 + 7}
+ * H-1:  P_{N' + (H-2)*h*t}   P_{N' + (H-2)*h*t + 1*t}  ...  P_{N' + (H-2)*h*t + (h-1)*t}
+ * H  :  P_{N' + (H-1)*h*t}   P_{N' + (H-1)*h*t + 1*t}  ...  P_{N' + (H-1)*h*t + (h-1)*t}
  *
- * Total generators = 2048 + 32*8 = 2304
+ * Total generators = (N + H * h) * t = 2304
  */
 generator_data const& get_generator_data(generator_index_t index)
 {
@@ -276,5 +285,5 @@ const fixed_base_ladder* generator_data::get_hash_ladder(size_t num_bits) const
     return get_ladder_internal(hash_ladder, num_bits);
 }
 
-} // namespace pedersen
+} // namespace generators
 } // namespace crypto
diff --git a/cpp/src/barretenberg/crypto/pedersen/generator_data.hpp b/cpp/src/barretenberg/crypto/generators/generator_data.hpp
similarity index 97%
rename from cpp/src/barretenberg/crypto/pedersen/generator_data.hpp
rename to cpp/src/barretenberg/crypto/generators/generator_data.hpp
index 1d6c07c9ebc..e3276c6c74b 100644
--- a/cpp/src/barretenberg/crypto/pedersen/generator_data.hpp
+++ b/cpp/src/barretenberg/crypto/generators/generator_data.hpp
@@ -4,7 +4,7 @@
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
 namespace crypto {
-namespace pedersen {
+namespace generators {
 
 struct generator_index_t {
     size_t index;
@@ -58,5 +58,5 @@ std::vector<std::unique_ptr<generator_data>> const& init_generator_data();
 const fixed_base_ladder* get_g1_ladder(const size_t num_bits);
 generator_data const& get_generator_data(generator_index_t index);
 
-} // namespace pedersen
+} // namespace generators
 } // namespace crypto
diff --git a/cpp/src/barretenberg/crypto/pedersen/pedersen.test.cpp b/cpp/src/barretenberg/crypto/generators/generator_data.test.cpp
similarity index 93%
rename from cpp/src/barretenberg/crypto/pedersen/pedersen.test.cpp
rename to cpp/src/barretenberg/crypto/generators/generator_data.test.cpp
index 90e6503f7c9..ae76d124b54 100644
--- a/cpp/src/barretenberg/crypto/pedersen/pedersen.test.cpp
+++ b/cpp/src/barretenberg/crypto/generators/generator_data.test.cpp
@@ -1,10 +1,11 @@
 #include <gtest/gtest.h>
 #include "barretenberg/common/streams.hpp"
-#include "./pedersen.hpp"
+#include "./fixed_base_scalar_mul.hpp"
+#include "./generator_data.hpp"
 
-using namespace crypto::pedersen;
+using namespace crypto::generators;
 
-TEST(pedersen, hash_ladder_structure)
+TEST(generators, hash_ladder_structure)
 {
     generator_index_t index = { 2, 0 };
     generator_data gen_data = get_generator_data(index);
@@ -60,7 +61,7 @@ TEST(pedersen, hash_ladder_structure)
     EXPECT_EQ(grumpkin::g1::element(hash_ladder[0].one), mult);
 }
 
-TEST(pedersen, fixed_base_scalar_mul)
+TEST(generators, fixed_base_scalar_mul)
 {
     uint256_t scalar(123, 0, 0, 0);
 
diff --git a/cpp/src/barretenberg/crypto/pedersen/CMakeLists.txt b/cpp/src/barretenberg/crypto/pedersen/CMakeLists.txt
deleted file mode 100644
index c9e1108acdc..00000000000
--- a/cpp/src/barretenberg/crypto/pedersen/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-barretenberg_module(crypto_pedersen ecc)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/pedersen.hpp b/cpp/src/barretenberg/crypto/pedersen/pedersen.hpp
deleted file mode 100644
index 675da3d7b77..00000000000
--- a/cpp/src/barretenberg/crypto/pedersen/pedersen.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-#include <array>
-#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
-#include "./generator_data.hpp"
-#include "./fixed_base_scalar_mul.hpp"
-
-namespace crypto {
-namespace pedersen {
-
-grumpkin::g1::element hash_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::fq compress_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
-
-template <size_t T> grumpkin::fq compress_native(const std::array<grumpkin::fq, T>& inputs)
-{
-    std::vector<grumpkin::fq> converted(inputs.begin(), inputs.end());
-    return commit_native(converted).x;
-}
-
-grumpkin::fq compress_native(const std::vector<uint8_t>& input);
-
-} // namespace pedersen
-} // namespace crypto
diff --git a/cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.test.cpp b/cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.test.cpp
deleted file mode 100644
index e71c3a4150c..00000000000
--- a/cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.test.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include <gtest/gtest.h>
-#include "barretenberg/numeric/bitop/get_msb.hpp"
-#include "barretenberg/numeric/random/engine.hpp"
-
-#include "./pedersen_lookup.hpp"
-
-namespace {
-auto& engine = numeric::random::get_debug_engine();
-}
-
-auto compute_expected(const grumpkin::fq exponent, size_t generator_offset)
-{
-    uint256_t bits(exponent);
-    std::array<grumpkin::g1::element, 2> accumulators;
-    const auto lambda = grumpkin::fr::cube_root_of_unity();
-    const auto mask = crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE - 1;
-
-    for (size_t i = 0; i < 15; ++i) {
-        const auto slice_a = static_cast<size_t>(bits.data[0] & mask) + 1;
-        bits >>= crypto::pedersen::lookup::BITS_PER_TABLE;
-        const auto slice_b = static_cast<size_t>(bits.data[0] & mask) + 1;
-
-        const auto generator = crypto::pedersen::lookup::get_table_generator(generator_offset + i);
-
-        if (i == 0) {
-            accumulators[0] = generator * (lambda * slice_a);
-            accumulators[1] = generator * grumpkin::fr(slice_b);
-        } else {
-            accumulators[0] += (generator * (lambda * slice_a));
-            if (i < 14) {
-                accumulators[1] += (generator * grumpkin::fr(slice_b));
-            }
-        }
-        bits >>= crypto::pedersen::lookup::BITS_PER_TABLE;
-    }
-    return (accumulators[0] + accumulators[1]);
-}
-
-TEST(pedersen_lookup, endomorphism_test)
-{
-    typedef grumpkin::fq fq;
-    typedef grumpkin::fr fr;
-
-    typedef grumpkin::g1::affine_element affine_element;
-    typedef grumpkin::g1::element element;
-
-    fr exponent = engine.get_random_uint256();
-
-    const auto beta = fq::cube_root_of_unity();
-
-    const auto lambda = fr::cube_root_of_unity();
-
-    const element P = grumpkin::g1::one;
-
-    affine_element base(P * exponent);
-    affine_element first(P * (exponent * lambda));
-    affine_element second(P * (exponent * (lambda + 1)));
-    EXPECT_EQ(base.x * beta, first.x);
-    EXPECT_EQ(base.x * beta.sqr(), second.x);
-    EXPECT_EQ(base.y, first.y);
-    EXPECT_EQ(-base.y, second.y);
-}
-
-TEST(pedersen_lookup, hash_single)
-{
-    typedef grumpkin::fq fq;
-    typedef grumpkin::fr fr;
-    typedef grumpkin::g1::affine_element affine_element;
-    typedef grumpkin::g1::element element;
-
-    const fq exponent = engine.get_random_uint256();
-
-    const affine_element result(crypto::pedersen::lookup::hash_single(exponent, false));
-
-    const auto mask = crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE - 1;
-
-    uint256_t bits(exponent);
-
-    const fr lambda = grumpkin::fr::cube_root_of_unity();
-
-    std::array<element, 2> accumulators;
-
-    for (size_t i = 0; i < 15; ++i) {
-        const auto slice_a = static_cast<size_t>(bits.data[0] & mask) + 1;
-        bits >>= crypto::pedersen::lookup::BITS_PER_TABLE;
-        const auto slice_b = static_cast<size_t>(bits.data[0] & mask) + 1;
-
-        const element generator = crypto::pedersen::lookup::get_table_generator(i);
-
-        if (i == 0) {
-            accumulators[0] = generator * (lambda * slice_a);
-            accumulators[1] = generator * (slice_b);
-        } else {
-            accumulators[0] += (generator * (lambda * slice_a));
-            if (i < 14) {
-                accumulators[1] += (generator * (slice_b));
-            }
-        }
-        bits >>= crypto::pedersen::lookup::BITS_PER_TABLE;
-    }
-
-    const affine_element expected(accumulators[0] + accumulators[1]);
-
-    EXPECT_EQ(result, expected);
-}
-
-TEST(pedersen_lookup, hash_pair)
-{
-    typedef grumpkin::fq fq;
-    typedef grumpkin::g1::affine_element affine_element;
-
-    const fq left = engine.get_random_uint256();
-    const fq right = engine.get_random_uint256();
-
-    const fq result(crypto::pedersen::lookup::hash_pair(left, right));
-
-    const affine_element expected(compute_expected(left, 0) + compute_expected(right, 15));
-
-    EXPECT_EQ(result, expected.x);
-}
-
-TEST(pedersen_lookup, merkle_damgard_compress)
-{
-    typedef grumpkin::fq fq;
-    typedef grumpkin::fr fr;
-    typedef grumpkin::g1::affine_element affine_element;
-
-    const size_t m = 3, iv = 10;
-    std::vector<fq> inputs;
-    for (size_t i = 0; i < m; i++) {
-        inputs.push_back(engine.get_random_uint256());
-    }
-
-    const auto result = crypto::pedersen::lookup::merkle_damgard_compress(inputs, iv);
-
-    fq intermediate = (grumpkin::g1::affine_one * fr(iv + 1)).x;
-    for (size_t i = 0; i < m; i++) {
-        intermediate = affine_element(compute_expected(intermediate, 0) + compute_expected(inputs[i], 15)).x;
-    }
-
-    EXPECT_EQ(affine_element(result).x,
-              affine_element(compute_expected(intermediate, 0) + compute_expected(fq(m), 15)).x);
-}
diff --git a/cpp/src/barretenberg/crypto/pedersen_commitment/CMakeLists.txt b/cpp/src/barretenberg/crypto/pedersen_commitment/CMakeLists.txt
new file mode 100644
index 00000000000..9f6095fdf3f
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/CMakeLists.txt
@@ -0,0 +1 @@
+barretenberg_module(crypto_pedersen_commitment ecc crypto_generators crypto_pedersen_hash)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/c_bind.cpp b/cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.cpp
similarity index 64%
rename from cpp/src/barretenberg/crypto/pedersen/c_bind.cpp
rename to cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.cpp
index 320604d46b2..1b58491c3ce 100644
--- a/cpp/src/barretenberg/crypto/pedersen/c_bind.cpp
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.cpp
@@ -11,14 +11,14 @@ extern "C" {
 
 WASM_EXPORT void pedersen__init()
 {
-    crypto::pedersen::init_generator_data();
+    crypto::generators::init_generator_data();
 }
 
 WASM_EXPORT void pedersen__compress_fields(uint8_t const* left, uint8_t const* right, uint8_t* result)
 {
     auto lhs = barretenberg::fr::serialize_from_buffer(left);
     auto rhs = barretenberg::fr::serialize_from_buffer(right);
-    auto r = crypto::pedersen::compress_native({ lhs, rhs });
+    auto r = crypto::pedersen_commitment::compress_native({ lhs, rhs });
     barretenberg::fr::serialize_to_buffer(r, result);
 }
 
@@ -26,15 +26,16 @@ WASM_EXPORT void pedersen_plookup_compress_fields(uint8_t const* left, uint8_t c
 {
     auto lhs = barretenberg::fr::serialize_from_buffer(left);
     auto rhs = barretenberg::fr::serialize_from_buffer(right);
-    auto r = crypto::pedersen::lookup::compress_native({ lhs, rhs });
+    auto r = crypto::pedersen_commitment::lookup::compress_native({ lhs, rhs });
     barretenberg::fr::serialize_to_buffer(r, result);
 }
 
+
 WASM_EXPORT void pedersen__compress(uint8_t const* inputs_buffer, uint8_t* output)
 {
     std::vector<grumpkin::fq> to_compress;
     read(inputs_buffer, to_compress);
-    auto r = crypto::pedersen::compress_native(to_compress);
+    auto r = crypto::pedersen_commitment::compress_native(to_compress);
     barretenberg::fr::serialize_to_buffer(r, output);
 }
 
@@ -42,7 +43,7 @@ WASM_EXPORT void pedersen_plookup_compress(uint8_t const* inputs_buffer, uint8_t
 {
     std::vector<grumpkin::fq> to_compress;
     read(inputs_buffer, to_compress);
-    auto r = crypto::pedersen::lookup::compress_native(to_compress);
+    auto r = crypto::pedersen_commitment::lookup::compress_native(to_compress);
     barretenberg::fr::serialize_to_buffer(r, output);
 }
 
@@ -50,7 +51,7 @@ WASM_EXPORT void pedersen__compress_with_hash_index(uint8_t const* inputs_buffer
 {
     std::vector<grumpkin::fq> to_compress;
     read(inputs_buffer, to_compress);
-    auto r = crypto::pedersen::compress_native(to_compress, hash_index);
+    auto r = crypto::pedersen_commitment::compress_native(to_compress, hash_index);
     barretenberg::fr::serialize_to_buffer(r, output);
 }
 
@@ -58,7 +59,7 @@ WASM_EXPORT void pedersen__commit(uint8_t const* inputs_buffer, uint8_t* output)
 {
     std::vector<grumpkin::fq> to_compress;
     read(inputs_buffer, to_compress);
-    grumpkin::g1::affine_element pedersen_hash = crypto::pedersen::commit_native(to_compress);
+    grumpkin::g1::affine_element pedersen_hash = crypto::pedersen_commitment::commit_native(to_compress);
 
     write(output, pedersen_hash);
 }
@@ -67,7 +68,7 @@ WASM_EXPORT void pedersen_plookup_commit(uint8_t const* inputs_buffer, uint8_t*
 {
     std::vector<grumpkin::fq> to_compress;
     read(inputs_buffer, to_compress);
-    grumpkin::g1::affine_element pedersen_hash = crypto::pedersen::lookup::commit_native(to_compress);
+    grumpkin::g1::affine_element pedersen_hash = crypto::pedersen_commitment::lookup::commit_native(to_compress);
 
     write(output, pedersen_hash);
 }
@@ -75,32 +76,7 @@ WASM_EXPORT void pedersen_plookup_commit(uint8_t const* inputs_buffer, uint8_t*
 WASM_EXPORT void pedersen__buffer_to_field(uint8_t const* data, size_t length, uint8_t* r)
 {
     std::vector<uint8_t> to_compress(data, data + length);
-    auto output = crypto::pedersen::compress_native(to_compress);
+    auto output = crypto::pedersen_commitment::compress_native(to_compress);
     write(r, output);
 }
-
-/**
- * Given a buffer containing 32 byte pedersen leaves, return a new buffer containing the leaves and all pairs of
- * nodes that define a merkle tree.
- * e.g.
- * input:  [1][2][3][4]
- * output: [1][2][3][4][compress(1,2)][compress(3,4)][compress(5,6)]
- */
-WASM_EXPORT uint8_t* pedersen__hash_to_tree(uint8_t const* data)
-{
-    auto fields = from_buffer<std::vector<grumpkin::fq>>(data);
-    auto num_outputs = fields.size() * 2 - 1;
-    fields.reserve(num_outputs);
-
-    for (size_t i = 0; fields.size() < num_outputs; i += 2) {
-        fields.push_back(crypto::pedersen::compress_native({ fields[i], fields[i + 1] }));
-    }
-
-    auto buf_size = 4 + num_outputs * sizeof(grumpkin::fq);
-    auto buf = (uint8_t*)aligned_alloc(64, buf_size);
-    auto dst = &buf[0];
-    write(dst, fields);
-
-    return buf;
-}
-}
+}
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/c_bind.hpp b/cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.hpp
similarity index 76%
rename from cpp/src/barretenberg/crypto/pedersen/c_bind.hpp
rename to cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.hpp
index 9b170cdd0bd..59b4ef6c405 100644
--- a/cpp/src/barretenberg/crypto/pedersen/c_bind.hpp
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.hpp
@@ -1,3 +1,4 @@
+#pragma once
 #include "barretenberg/common/serialize.hpp"
 #include "barretenberg/common/timer.hpp"
 #include "barretenberg/common/mem.hpp"
@@ -20,13 +21,4 @@ WASM_EXPORT void pedersen__commit(uint8_t const* inputs_buffer, uint8_t* output)
 WASM_EXPORT void pedersen_plookup_commit(uint8_t const* inputs_buffer, uint8_t* output);
 
 WASM_EXPORT void pedersen__buffer_to_field(uint8_t const* data, size_t length, uint8_t* r);
-
-/**
- * Given a buffer containing 32 byte pedersen leaves, return a new buffer containing the leaves and all pairs of
- * nodes that define a merkle tree.
- * e.g.
- * input:  [1][2][3][4]
- * output: [1][2][3][4][compress(1,2)][compress(3,4)][compress(5,6)]
- */
-WASM_EXPORT uint8_t* pedersen__hash_to_tree(uint8_t const* data);
-}
+}
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/convert_buffer_to_field.hpp b/cpp/src/barretenberg/crypto/pedersen_commitment/convert_buffer_to_field.hpp
similarity index 92%
rename from cpp/src/barretenberg/crypto/pedersen/convert_buffer_to_field.hpp
rename to cpp/src/barretenberg/crypto/pedersen_commitment/convert_buffer_to_field.hpp
index cea45bd3bc9..10adacf4ce6 100644
--- a/cpp/src/barretenberg/crypto/pedersen/convert_buffer_to_field.hpp
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/convert_buffer_to_field.hpp
@@ -3,7 +3,7 @@
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
 namespace crypto {
-namespace pedersen {
+namespace pedersen_commitment {
 
 inline std::vector<grumpkin::fq> convert_buffer_to_field(const std::vector<uint8_t>& input)
 {
@@ -33,5 +33,5 @@ inline std::vector<grumpkin::fq> convert_buffer_to_field(const std::vector<uint8
     }
     return elements;
 }
-} // namespace pedersen
-} // namespace crypto
+} // namespace pedersen_commitment
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/pedersen.cpp b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.cpp
similarity index 68%
rename from cpp/src/barretenberg/crypto/pedersen/pedersen.cpp
rename to cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.cpp
index 4a2314ab351..060446ff55a 100644
--- a/cpp/src/barretenberg/crypto/pedersen/pedersen.cpp
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.cpp
@@ -6,10 +6,12 @@
 #include <omp.h>
 #endif
 
+// using namespace crypto::generators;
+
 namespace crypto {
-namespace pedersen {
+namespace pedersen_commitment {
 
-grumpkin::g1::element hash_single(const barretenberg::fr& in, generator_index_t const& index)
+grumpkin::g1::element commit_single(const barretenberg::fr& in, generator_index_t const& index)
 {
     auto gen_data = get_generator_data(index);
     barretenberg::fr scalar_multiplier = in.from_montgomery_form();
@@ -19,7 +21,7 @@ grumpkin::g1::element hash_single(const barretenberg::fr& in, generator_index_t
     constexpr size_t num_quads = ((num_quads_base << 1) + 1 < num_bits) ? num_quads_base + 1 : num_quads_base;
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
 
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_hash_ladder(num_bits);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_hash_ladder(num_bits);
 
     uint64_t wnaf_entries[num_quads + 2] = { 0 };
     bool skew = false;
@@ -56,7 +58,7 @@ grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inpu
 #endif
     for (size_t i = 0; i < inputs.size(); ++i) {
         generator_index_t index = { hash_index, i };
-        out[i] = hash_single(inputs[i], index);
+        out[i] = commit_single(inputs[i], index);
     }
 
     grumpkin::g1::element r = out[0];
@@ -66,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).
  */
@@ -74,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.
  */
@@ -89,5 +117,5 @@ grumpkin::fq compress_native(const std::vector<uint8_t>& input)
     return compress_native_buffer_to_field(input);
 }
 
-} // namespace pedersen
-} // namespace crypto
+} // namespace pedersen_commitment
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.hpp b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.hpp
new file mode 100644
index 00000000000..231ea1b25d0
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.hpp
@@ -0,0 +1,31 @@
+#pragma once
+#include <array>
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "../generators/generator_data.hpp"
+#include "../generators/fixed_base_scalar_mul.hpp"
+
+using namespace crypto::generators;
+
+namespace crypto {
+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>& 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);
+
+template <size_t T> grumpkin::fq compress_native(const std::array<grumpkin::fq, T>& inputs)
+{
+    std::vector<grumpkin::fq> converted(inputs.begin(), inputs.end());
+    return commit_native(converted).x;
+}
+
+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/barretenberg/crypto/pedersen_commitment/pedersen_lookup.cpp b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.cpp
new file mode 100644
index 00000000000..e2333acfa6e
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.cpp
@@ -0,0 +1,146 @@
+#include "./pedersen_lookup.hpp"
+#include "../pedersen_hash/pedersen_lookup.hpp"
+#include "./convert_buffer_to_field.hpp"
+
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "barretenberg/numeric/bitop/pow.hpp"
+
+using namespace crypto::pedersen_hash::lookup;
+
+namespace crypto::pedersen_hash::lookup {
+extern std::array<std::vector<grumpkin::g1::affine_element>, NUM_PEDERSEN_TABLES> pedersen_tables;
+extern std::vector<grumpkin::g1::affine_element> pedersen_iv_table;
+extern std::array<grumpkin::g1::affine_element, NUM_PEDERSEN_TABLES> generators;
+} // namespace crypto::pedersen_hash::lookup
+
+namespace crypto {
+namespace pedersen_commitment {
+namespace lookup {
+
+grumpkin::g1::element merkle_damgard_compress(const std::vector<grumpkin::fq>& inputs, const size_t iv)
+{
+    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[iv]).x;
+    for (size_t i = 0; i < num_inputs; i++) {
+        result = hash_pair(result, inputs[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);
+    grumpkin::fq result_fq = compress_native(elements);
+    return result_fq;
+}
+
+std::vector<uint8_t> compress_native(const std::vector<uint8_t>& input)
+{
+    const auto result_fq = compress_native_buffer_to_field(input);
+    uint256_t result_u256(result_fq);
+    const size_t num_bytes = input.size();
+
+    bool is_zero = true;
+    for (const auto byte : input) {
+        is_zero = is_zero && (byte == static_cast<uint8_t>(0));
+    }
+    if (is_zero) {
+        result_u256 = num_bytes;
+    }
+    std::vector<uint8_t> result_buffer;
+    result_buffer.reserve(32);
+    for (size_t i = 0; i < 32; ++i) {
+        const uint64_t shift = (31 - i) * 8;
+        uint256_t shifted = result_u256 >> uint256_t(shift);
+        result_buffer.push_back(static_cast<uint8_t>(shifted.data[0]));
+    }
+    return result_buffer;
+}
+
+} // namespace lookup
+} // namespace pedersen_commitment
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp
new file mode 100644
index 00000000000..0f99b13fbbd
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+
+namespace crypto {
+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);
+
+template <size_t T> grumpkin::fq compress_native(const std::array<grumpkin::fq, T>& inputs)
+{
+    std::vector<grumpkin::fq> in(inputs.begin(), inputs.end());
+    return compress_native(in);
+}
+
+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
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.test.cpp b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.test.cpp
new file mode 100644
index 00000000000..82d0b4f7ed0
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen_lookup.test.cpp
@@ -0,0 +1,253 @@
+#include <gtest/gtest.h>
+#include "barretenberg/numeric/bitop/get_msb.hpp"
+#include "barretenberg/numeric/random/engine.hpp"
+
+#include "./pedersen_lookup.hpp"
+#include "../pedersen_hash/pedersen_lookup.hpp"
+
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+
+auto compute_expected(const grumpkin::fq exponent, size_t generator_offset)
+{
+    uint256_t bits(exponent);
+    std::array<grumpkin::g1::element, 2> accumulators;
+    const auto lambda = grumpkin::fr::cube_root_of_unity();
+    const auto mask = crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE - 1;
+
+    /**
+     * Given an input scalar x, we split it into 9-bit slices:
+     * x = ( x_28 || x_27 || ... || x_2 || x_1 || x_0 )
+     *
+     * Note that the last slice x_28 is a 2-bit slice. Total = 2 + 9 * 28 = 254 bits.
+     *
+     * Algorithm:
+     *     hash = O;
+     *     hash += x_0 * G_0  +  x_1 * λ * G_0;
+     *     hash += x_2 * G_1  +  x_2 * λ * G_1;
+     *     ...
+     *     ...
+     *     hash += x_26 * G_13  +  x_27 * λ * G_13;
+     *     hash += x_27 * G_14;
+     *
+     * Our lookup tables stores the following:
+     *     1 -> (G_0, (λ * G_0))
+     *     2 -> (2G_0, 2(λ * G_0))
+     *     3 -> (3G_0, 3(λ * G_0))
+     *     ...
+     *   512 -> (512G_0, 512(λ * G_0))
+     */
+    for (size_t i = 0; i < (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2); ++i) {
+        const auto slice_a = static_cast<size_t>(bits.data[0] & mask) + 1;
+        bits >>= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+        const auto slice_b = static_cast<size_t>(bits.data[0] & mask) + 1;
+
+        const auto generator = crypto::pedersen_hash::lookup::get_table_generator(generator_offset + i);
+
+        if (i == 0) {
+            accumulators[0] = generator * (lambda * slice_a);
+            accumulators[1] = generator * grumpkin::fr(slice_b);
+        } else {
+            accumulators[0] += (generator * (lambda * slice_a));
+            if (i < 14) {
+                accumulators[1] += (generator * grumpkin::fr(slice_b));
+            }
+        }
+        bits >>= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    }
+    return (accumulators[0] + accumulators[1]);
+}
+
+TEST(pedersen_lookup, endomorphism_test)
+{
+    typedef grumpkin::fq fq;
+    typedef grumpkin::fr fr;
+
+    typedef grumpkin::g1::affine_element affine_element;
+    typedef grumpkin::g1::element element;
+
+    fr exponent = engine.get_random_uint256();
+
+    const auto beta = fq::cube_root_of_unity();
+
+    const auto lambda = fr::cube_root_of_unity();
+
+    const element P = grumpkin::g1::one;
+
+    affine_element base(P * exponent);
+    affine_element first(P * (exponent * lambda));
+    affine_element second(P * (exponent * (lambda + 1)));
+    EXPECT_EQ(base.x * beta, first.x);
+    EXPECT_EQ(base.x * beta.sqr(), second.x);
+    EXPECT_EQ(base.y, first.y);
+    EXPECT_EQ(-base.y, second.y);
+}
+
+TEST(pedersen_lookup, hash_single)
+{
+    typedef grumpkin::fq fq;
+    typedef grumpkin::fr fr;
+    typedef grumpkin::g1::affine_element affine_element;
+    typedef grumpkin::g1::element element;
+
+    const fq exponent = engine.get_random_uint256();
+
+    const affine_element result(crypto::pedersen_hash::lookup::hash_single(exponent, false));
+
+    const auto mask = crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE - 1;
+
+    uint256_t bits(exponent);
+
+    const fr lambda = grumpkin::fr::cube_root_of_unity();
+
+    std::array<element, 2> accumulators;
+
+    for (size_t i = 0; i < (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2); ++i) {
+        const auto slice_a = static_cast<size_t>(bits.data[0] & mask) + 1;
+        bits >>= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+        const auto slice_b = static_cast<size_t>(bits.data[0] & mask) + 1;
+
+        const element generator = crypto::pedersen_hash::lookup::get_table_generator(i);
+
+        if (i == 0) {
+            accumulators[0] = generator * (lambda * slice_a);
+            accumulators[1] = generator * (slice_b);
+        } else {
+            accumulators[0] += (generator * (lambda * slice_a));
+            if (i < 14) {
+                accumulators[1] += (generator * (slice_b));
+            }
+        }
+        bits >>= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    }
+
+    const affine_element expected(accumulators[0] + accumulators[1]);
+
+    EXPECT_EQ(result, expected);
+}
+
+TEST(pedersen_lookup, hash_pair)
+{
+    typedef grumpkin::fq fq;
+    typedef grumpkin::g1::affine_element affine_element;
+
+    const fq left = engine.get_random_uint256();
+    const fq right = engine.get_random_uint256();
+
+    const fq result(crypto::pedersen_hash::lookup::hash_pair(left, right));
+
+    const affine_element expected(compute_expected(left, 0) +
+                                  compute_expected(right, (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)));
+
+    EXPECT_EQ(result, expected.x);
+}
+
+TEST(pedersen_lookup, merkle_damgard_compress)
+{
+    typedef grumpkin::fq fq;
+    typedef grumpkin::fr fr;
+    typedef grumpkin::g1::affine_element affine_element;
+
+    const size_t m = 3, iv = 10;
+    std::vector<fq> inputs;
+    for (size_t i = 0; i < m; i++) {
+        inputs.push_back(engine.get_random_uint256());
+    }
+
+    const auto result = crypto::pedersen_commitment::lookup::merkle_damgard_compress(inputs, iv);
+
+    fq intermediate = (grumpkin::g1::affine_one * fr(iv + 1)).x;
+    for (size_t i = 0; i < m; i++) {
+        intermediate =
+            affine_element(compute_expected(intermediate, 0) +
+                           compute_expected(inputs[i], (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                .x;
+    }
+
+    EXPECT_EQ(affine_element(result).x,
+              affine_element(compute_expected(intermediate, 0) +
+                             compute_expected(fq(m), (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                  .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, (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                    .x;
+        } else {
+            intermediate = affine_element(compute_expected(intermediate, 0) +
+                                          compute_expected(inputs[i >> 1],
+                                                           (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                               .x;
+        }
+    }
+
+    EXPECT_EQ(affine_element(result).x,
+              affine_element(compute_expected(intermediate, 0) +
+                             compute_expected(fq(m), (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                  .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], (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                .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], (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                          .x;
+        }
+    }
+
+    EXPECT_EQ(affine_element(result).x,
+              affine_element(compute_expected(temp[0], 0) +
+                             compute_expected(fq(m), (crypto::pedersen_hash::lookup::NUM_PEDERSEN_TABLES / 2)))
+                  .x);
+}
diff --git a/cpp/src/barretenberg/crypto/pedersen/sidon_set/sidon_set.hpp b/cpp/src/barretenberg/crypto/pedersen_commitment/sidon_set/sidon_set.hpp
similarity index 99%
rename from cpp/src/barretenberg/crypto/pedersen/sidon_set/sidon_set.hpp
rename to cpp/src/barretenberg/crypto/pedersen_commitment/sidon_set/sidon_set.hpp
index a1a6db817d9..3eeab156615 100644
--- a/cpp/src/barretenberg/crypto/pedersen/sidon_set/sidon_set.hpp
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/sidon_set/sidon_set.hpp
@@ -223,4 +223,4 @@ template <uint64_t set_size> inline std::vector<uint64_t> compute_sidon_set()
 }
 } // namespace sidon
 } // namespace pedersen
-} // namespace crypto
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/sidon_set/sidon_set.test.cpp b/cpp/src/barretenberg/crypto/pedersen_commitment/sidon_set/sidon_set.test.cpp
similarity index 99%
rename from cpp/src/barretenberg/crypto/pedersen/sidon_set/sidon_set.test.cpp
rename to cpp/src/barretenberg/crypto/pedersen_commitment/sidon_set/sidon_set.test.cpp
index 615067414b8..69b18b22344 100644
--- a/cpp/src/barretenberg/crypto/pedersen/sidon_set/sidon_set.test.cpp
+++ b/cpp/src/barretenberg/crypto/pedersen_commitment/sidon_set/sidon_set.test.cpp
@@ -78,4 +78,4 @@ TEST(sidon, compute_sidon_set)
     for (size_t i = 1; i < sums.size(); ++i) {
         EXPECT_EQ(sums[i] != sums[i - 1], true);
     }
-}
+}
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_hash/CMakeLists.txt b/cpp/src/barretenberg/crypto/pedersen_hash/CMakeLists.txt
new file mode 100644
index 00000000000..46f39c71638
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/CMakeLists.txt
@@ -0,0 +1 @@
+barretenberg_module(crypto_pedersen_hash ecc crypto_generators)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.cpp b/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.cpp
new file mode 100644
index 00000000000..fc28d6fff0a
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.cpp
@@ -0,0 +1,67 @@
+#include "c_bind.hpp"
+#include "pedersen.hpp"
+#include "pedersen_lookup.hpp"
+#include "barretenberg/common/serialize.hpp"
+#include "barretenberg/common/timer.hpp"
+#include "barretenberg/common/mem.hpp"
+#include "barretenberg/common/streams.hpp"
+#define WASM_EXPORT __attribute__((visibility("default")))
+
+extern "C" {
+
+WASM_EXPORT void pedersen_hash__init()
+{
+    crypto::generators::init_generator_data();
+}
+
+WASM_EXPORT void pedersen__hash_pair(uint8_t const* left, uint8_t const* right, uint8_t* result)
+{
+    auto lhs = barretenberg::fr::serialize_from_buffer(left);
+    auto rhs = barretenberg::fr::serialize_from_buffer(right);
+    auto r = crypto::pedersen_hash::hash_multiple({ lhs, rhs });
+    barretenberg::fr::serialize_to_buffer(r, result);
+}
+
+WASM_EXPORT void pedersen__hash_multiple(uint8_t const* inputs_buffer, uint8_t* output)
+{
+    std::vector<grumpkin::fq> to_compress;
+    read(inputs_buffer, to_compress);
+    auto r = crypto::pedersen_hash::hash_multiple(to_compress);
+    barretenberg::fr::serialize_to_buffer(r, output);
+}
+
+WASM_EXPORT void pedersen__hash_multiple_with_hash_index(uint8_t const* inputs_buffer,
+                                                         uint8_t* output,
+                                                         uint32_t hash_index)
+{
+    std::vector<grumpkin::fq> to_compress;
+    read(inputs_buffer, to_compress);
+    auto r = crypto::pedersen_hash::hash_multiple(to_compress, hash_index);
+    barretenberg::fr::serialize_to_buffer(r, output);
+}
+
+/**
+ * Given a buffer containing 32 byte pedersen leaves, return a new buffer containing the leaves and all pairs of
+ * nodes that define a merkle tree.
+ * e.g.
+ * input:  [1][2][3][4]
+ * output: [1][2][3][4][compress(1,2)][compress(3,4)][compress(5,6)]
+ */
+WASM_EXPORT uint8_t* pedersen__hash_to_tree(uint8_t const* data)
+{
+    auto fields = from_buffer<std::vector<grumpkin::fq>>(data);
+    auto num_outputs = fields.size() * 2 - 1;
+    fields.reserve(num_outputs);
+
+    for (size_t i = 0; fields.size() < num_outputs; i += 2) {
+        fields.push_back(crypto::pedersen_hash::hash_multiple({ fields[i], fields[i + 1] }));
+    }
+
+    auto buf_size = 4 + num_outputs * sizeof(grumpkin::fq);
+    auto buf = (uint8_t*)aligned_alloc(64, buf_size);
+    auto dst = &buf[0];
+    write(dst, fields);
+
+    return buf;
+}
+}
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.hpp b/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.hpp
new file mode 100644
index 00000000000..cd2804b26cc
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.hpp
@@ -0,0 +1,28 @@
+#pragma once
+#include "barretenberg/common/serialize.hpp"
+#include "barretenberg/common/timer.hpp"
+#include "barretenberg/common/mem.hpp"
+#include "barretenberg/common/streams.hpp"
+#define WASM_EXPORT __attribute__((visibility("default")))
+
+extern "C" {
+
+WASM_EXPORT void pedersen_hash__init();
+
+WASM_EXPORT void pedersen__hash_pair(uint8_t const* left, uint8_t const* right, uint8_t* result);
+
+WASM_EXPORT void pedersen__hash_multiple(uint8_t const* inputs_buffer, uint8_t* output);
+
+WASM_EXPORT void pedersen__hash_multiple_with_hash_index(uint8_t const* inputs_buffer,
+                                                         uint8_t* output,
+                                                         uint32_t hash_index);
+
+/**
+ * Given a buffer containing 32 byte pedersen leaves, return a new buffer containing the leaves and all pairs of
+ * nodes that define a merkle tree.
+ * e.g.
+ * input:  [1][2][3][4]
+ * output: [1][2][3][4][compress(1,2)][compress(3,4)][compress(5,6)]
+ */
+WASM_EXPORT uint8_t* pedersen__hash_to_tree(uint8_t const* data);
+}
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.cpp b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.cpp
new file mode 100644
index 00000000000..06ffc6cce91
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.cpp
@@ -0,0 +1,71 @@
+#include "./pedersen.hpp"
+#include "barretenberg/common/throw_or_abort.hpp"
+#include <iostream>
+#ifndef NO_MULTITHREADING
+#include <omp.h>
+#endif
+
+namespace crypto {
+namespace pedersen_hash {
+
+grumpkin::g1::element hash_single(const barretenberg::fr& in, generator_index_t const& index)
+{
+    auto gen_data = get_generator_data(index);
+    barretenberg::fr scalar_multiplier = in.from_montgomery_form();
+
+    constexpr size_t num_bits = 254;
+    constexpr size_t num_quads_base = (num_bits - 1) >> 1;
+    constexpr size_t num_quads = ((num_quads_base << 1) + 1 < num_bits) ? num_quads_base + 1 : num_quads_base;
+    constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
+
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_hash_ladder(num_bits);
+
+    uint64_t wnaf_entries[num_quads + 2] = { 0 };
+    bool skew = false;
+    barretenberg::wnaf::fixed_wnaf<num_wnaf_bits, 1, 2>(&scalar_multiplier.data[0], &wnaf_entries[0], skew, 0);
+
+    grumpkin::g1::element accumulator;
+    accumulator = grumpkin::g1::element(ladder[0].one);
+    if (skew) {
+        accumulator -= gen_data.skew_generator;
+    }
+
+    for (size_t i = 0; i < num_quads; ++i) {
+        uint64_t entry = wnaf_entries[i + 1];
+        const grumpkin::g1::affine_element& point_to_add =
+            ((entry & WNAF_MASK) == 1) ? ladder[i + 1].three : ladder[i + 1].one;
+        uint64_t predicate = (entry >> 31U) & 1U;
+        accumulator.self_mixed_add_or_sub(point_to_add, predicate);
+    }
+    return accumulator;
+}
+
+/**
+ * Given a vector of fields, generate a pedersen hash using the indexed generators.
+ */
+grumpkin::fq hash_multiple(const std::vector<grumpkin::fq>& inputs, const size_t hash_index)
+{
+    ASSERT((inputs.size() < (1 << 16)) && "too many inputs for 16 bit index");
+    std::vector<grumpkin::g1::element> out(inputs.size());
+
+#ifndef NO_MULTITHREADING
+    // Ensure generator data is initialized before threading...
+    init_generator_data();
+#pragma omp parallel for num_threads(inputs.size())
+#endif
+    for (size_t i = 0; i < inputs.size(); ++i) {
+        generator_index_t index = { hash_index, i };
+        out[i] = hash_single(inputs[i], index);
+    }
+
+    grumpkin::g1::element r = out[0];
+    for (size_t i = 1; i < inputs.size(); ++i) {
+        r = out[i] + r;
+    }
+    grumpkin::g1::affine_element result =
+        r.is_point_at_infinity() ? grumpkin::g1::affine_element(0, 0) : grumpkin::g1::affine_element(r);
+    return result.x;
+}
+
+} // namespace pedersen_hash
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.hpp b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.hpp
new file mode 100644
index 00000000000..b6cad2ad2b7
--- /dev/null
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.hpp
@@ -0,0 +1,17 @@
+#pragma once
+#include <array>
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "../generators/generator_data.hpp"
+#include "../generators/fixed_base_scalar_mul.hpp"
+
+using namespace crypto::generators;
+
+namespace crypto {
+namespace pedersen_hash {
+
+grumpkin::g1::element hash_single(const barretenberg::fr& in, generator_index_t const& index);
+
+grumpkin::fq hash_multiple(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
+
+} // namespace pedersen_hash
+} // namespace crypto
diff --git a/cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.cpp b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.cpp
similarity index 70%
rename from cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.cpp
rename to cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.cpp
index b43bb3594b1..f455c684bee 100644
--- a/cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.cpp
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.cpp
@@ -1,16 +1,15 @@
 #include "./pedersen_lookup.hpp"
-#include "./convert_buffer_to_field.hpp"
 
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
 namespace crypto {
-namespace pedersen {
+namespace pedersen_hash {
 namespace lookup {
-namespace {
 
-static std::array<std::vector<grumpkin::g1::affine_element>, NUM_PEDERSEN_TABLES> pedersen_tables;
-static std::vector<grumpkin::g1::affine_element> pedersen_iv_table;
-static std::array<grumpkin::g1::affine_element, NUM_PEDERSEN_TABLES> generators;
+std::array<std::vector<grumpkin::g1::affine_element>, NUM_PEDERSEN_TABLES> pedersen_tables;
+std::vector<grumpkin::g1::affine_element> pedersen_iv_table;
+std::array<grumpkin::g1::affine_element, NUM_PEDERSEN_TABLES> generators;
+
 static bool inited = false;
 
 void init_single_lookup_table(const size_t index)
@@ -83,7 +82,6 @@ void init()
     init_iv_lookup_table();
     inited = true;
 }
-} // namespace
 
 grumpkin::g1::affine_element get_table_generator(const size_t table_index)
 {
@@ -149,63 +147,26 @@ grumpkin::fq hash_pair(const grumpkin::fq& left, const grumpkin::fq& right)
     return result.x;
 }
 
-grumpkin::g1::element merkle_damgard_compress(const std::vector<grumpkin::fq>& inputs, const size_t iv)
+grumpkin::fq hash_multiple(const std::vector<grumpkin::fq>& inputs, const size_t hash_index)
 {
     if (inputs.size() == 0) {
         auto result = grumpkin::g1::affine_one;
         result.self_set_infinity();
-        return result;
+        return result.x;
     }
     init();
     const size_t num_inputs = inputs.size();
 
-    grumpkin::fq result = (pedersen_iv_table[iv]).x;
+    grumpkin::fq result = (pedersen_iv_table[hash_index]).x;
     for (size_t i = 0; i < num_inputs; i++) {
         result = hash_pair(result, inputs[i]);
     }
 
-    return (hash_single(result, 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::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_buffer_to_field(const std::vector<uint8_t>& input)
-{
-    const auto elements = convert_buffer_to_field(input);
-    grumpkin::fq result_fq = compress_native(elements);
-    return result_fq;
+    auto final_result =
+        grumpkin::g1::affine_element(hash_single(result, false) + hash_single(grumpkin::fq(num_inputs), true));
+    return final_result.x;
 }
 
-std::vector<uint8_t> compress_native(const std::vector<uint8_t>& input)
-{
-    const auto result_fq = compress_native_buffer_to_field(input);
-    uint256_t result_u256(result_fq);
-    const size_t num_bytes = input.size();
-
-    bool is_zero = true;
-    for (const auto byte : input) {
-        is_zero = is_zero && (byte == static_cast<uint8_t>(0));
-    }
-    if (is_zero) {
-        result_u256 = num_bytes;
-    }
-    std::vector<uint8_t> result_buffer;
-    result_buffer.reserve(32);
-    for (size_t i = 0; i < 32; ++i) {
-        const uint64_t shift = (31 - i) * 8;
-        uint256_t shifted = result_u256 >> uint256_t(shift);
-        result_buffer.push_back(static_cast<uint8_t>(shifted.data[0]));
-    }
-    return result_buffer;
-}
 } // namespace lookup
-} // namespace pedersen
-} // namespace crypto
+} // namespace pedersen_hash
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.hpp b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.hpp
similarity index 64%
rename from cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.hpp
rename to cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.hpp
index adec0234268..9a019a8547c 100644
--- a/cpp/src/barretenberg/crypto/pedersen/pedersen_lookup.hpp
+++ b/cpp/src/barretenberg/crypto/pedersen_hash/pedersen_lookup.hpp
@@ -3,7 +3,7 @@
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
 namespace crypto {
-namespace pedersen {
+namespace pedersen_hash {
 namespace lookup {
 
 constexpr size_t BITS_PER_HASH = 512;
@@ -19,31 +19,26 @@ constexpr size_t NUM_PEDERSEN_TABLES = NUM_PEDERSEN_TABLES_RAW + (NUM_PEDERSEN_T
 constexpr size_t PEDERSEN_IV_TABLE_SIZE = (1UL) << 10;
 constexpr size_t NUM_PEDERSEN_IV_TABLES = 4;
 
-grumpkin::g1::affine_element get_table_generator(const size_t table_index);
+extern std::array<std::vector<grumpkin::g1::affine_element>, NUM_PEDERSEN_TABLES> pedersen_tables;
+extern std::vector<grumpkin::g1::affine_element> pedersen_iv_table;
+extern std::array<grumpkin::g1::affine_element, NUM_PEDERSEN_TABLES> generators;
 
-const std::array<grumpkin::fq, 2>& get_endomorphism_scalars();
+void init_single_lookup_table(const size_t index);
+void init_small_lookup_table(const size_t index);
+void init_iv_lookup_table();
+void init();
 
+grumpkin::g1::affine_element get_table_generator(const size_t table_index);
+const std::array<grumpkin::fq, 2>& get_endomorphism_scalars();
 const std::vector<grumpkin::g1::affine_element>& get_table(const size_t table_index);
 const std::vector<grumpkin::g1::affine_element>& get_iv_table();
 
 grumpkin::g1::element hash_single(const grumpkin::fq& input, const bool parity);
 
 grumpkin::fq hash_pair(const grumpkin::fq& left, const grumpkin::fq& right);
-grumpkin::g1::element merkle_damgard_compress(const std::vector<grumpkin::fq>& inputs, const size_t iv);
-
-grumpkin::fq compress_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
-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);
-
-template <size_t T> grumpkin::fq compress_native(const std::array<grumpkin::fq, T>& inputs)
-{
-    std::vector<grumpkin::fq> in(inputs.begin(), inputs.end());
-    return compress_native(in);
-}
 
-grumpkin::g1::affine_element commit_native(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
+grumpkin::fq hash_multiple(const std::vector<grumpkin::fq>& inputs, const size_t hash_index = 0);
 
 } // namespace lookup
-} // namespace pedersen
-} // namespace crypto
+} // namespace pedersen_hash
+} // namespace crypto
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/schnorr/CMakeLists.txt b/cpp/src/barretenberg/crypto/schnorr/CMakeLists.txt
index 2719d4b6b9a..e0a1c61740e 100644
--- a/cpp/src/barretenberg/crypto/schnorr/CMakeLists.txt
+++ b/cpp/src/barretenberg/crypto/schnorr/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(crypto_schnorr crypto_pedersen crypto_blake2s crypto_keccak crypto_sha256 numeric)
\ No newline at end of file
+barretenberg_module(crypto_schnorr crypto_pedersen_commitment crypto_blake2s crypto_keccak crypto_sha256 numeric)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/crypto/schnorr/schnorr.tcc b/cpp/src/barretenberg/crypto/schnorr/schnorr.tcc
index a9b04e8c51f..6984479398e 100644
--- a/cpp/src/barretenberg/crypto/schnorr/schnorr.tcc
+++ b/cpp/src/barretenberg/crypto/schnorr/schnorr.tcc
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "barretenberg/crypto/hmac/hmac.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 
 #include "schnorr.hpp"
 
@@ -42,8 +42,8 @@ static auto generate_schnorr_challenge(const std::string& message,
                                        const typename G1::affine_element& R)
 {
     using Fq = typename G1::coordinate_field;
-    // create challenge message pedersen_hash(R.x, pubkey)
-    Fq compressed_keys = crypto::pedersen::compress_native({ R.x, pubkey.x, pubkey.y });
+    // create challenge message pedersen_commitment(R.x, pubkey)
+    Fq compressed_keys = crypto::pedersen_commitment::compress_native({ R.x, pubkey.x, pubkey.y });
     std::vector<uint8_t> e_buffer;
     write(e_buffer, compressed_keys);
     std::copy(message.begin(), message.end(), std::back_inserter(e_buffer));
diff --git a/cpp/src/barretenberg/dsl/acir_format/CMakeLists.txt b/cpp/src/barretenberg/dsl/acir_format/CMakeLists.txt
index 1b0d0c22638..01788f7561e 100644
--- a/cpp/src/barretenberg/dsl/acir_format/CMakeLists.txt
+++ b/cpp/src/barretenberg/dsl/acir_format/CMakeLists.txt
@@ -4,7 +4,7 @@ barretenberg_module(
     stdlib_primitives
     stdlib_sha256
     stdlib_blake2s
-    stdlib_pedersen
+    stdlib_pedersen_commitment
     stdlib_merkle_tree
     stdlib_schnorr
     crypto_sha256
diff --git a/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp b/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp
index 03a8c4fe1f4..3ac7951ec98 100644
--- a/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp
+++ b/cpp/src/barretenberg/dsl/acir_format/pedersen.cpp
@@ -14,9 +14,10 @@ void create_pedersen_constraint(Composer& composer, const PedersenConstraint& in
         scalars.push_back(scalar_as_field);
     }
 #ifdef USE_TURBO
-    auto point = pedersen::commit(scalars);
+    auto point = pedersen_commitment::commit(scalars);
 #else
-    auto point = stdlib::pedersen_plookup<Composer>::commit(scalars);
+    // 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);
diff --git a/cpp/src/barretenberg/ecc/curves/bn254/fr.test.cpp b/cpp/src/barretenberg/ecc/curves/bn254/fr.test.cpp
index 2f7a3a5f9f0..683b4917182 100644
--- a/cpp/src/barretenberg/ecc/curves/bn254/fr.test.cpp
+++ b/cpp/src/barretenberg/ecc/curves/bn254/fr.test.cpp
@@ -86,6 +86,35 @@ TEST(fr, sub)
     EXPECT_EQ((result == expected), true);
 }
 
+TEST(fr, plus_equals)
+{
+    fr a{ 0x5def, 0x00, 0x00, 0x00 };
+    fr a_copy = a;
+    a += 2;
+    fr expected = a_copy + 2;
+    EXPECT_EQ((a == expected), true);
+
+    a += 3;
+    expected = a_copy + 5;
+    EXPECT_EQ((a == expected), true);
+}
+
+TEST(fr, prefix_increment)
+{
+    fr a{ 0x5def, 0x00, 0x00, 0x00 };
+    fr b = ++a;
+    EXPECT_EQ(b, a);
+}
+
+TEST(fr, postfix_increment)
+{
+    fr a{ 0x5def, 0x00, 0x00, 0x00 };
+    fr a_old = a;
+    fr b = a++;
+    EXPECT_EQ(b, a_old);
+    EXPECT_EQ(a, a_old + 1);
+}
+
 TEST(fr, to_montgomery_form)
 {
     fr result{ 0x01, 0x00, 0x00, 0x00 };
diff --git a/cpp/src/barretenberg/ecc/curves/bn254/g1.test.cpp b/cpp/src/barretenberg/ecc/curves/bn254/g1.test.cpp
index f7fd7fb8df8..e636e8f9554 100644
--- a/cpp/src/barretenberg/ecc/curves/bn254/g1.test.cpp
+++ b/cpp/src/barretenberg/ecc/curves/bn254/g1.test.cpp
@@ -145,6 +145,15 @@ TEST(g1, add_exception_test_infinity)
     EXPECT_EQ(rhs == result, true);
 }
 
+TEST(g1, test_infinity)
+{
+    g1::affine_element inf_affine = g1::affine_element::infinity();
+    EXPECT_EQ(inf_affine.is_point_at_infinity(), true);
+
+    g1::element inf_element = g1::element::infinity();
+    EXPECT_EQ(inf_element.is_point_at_infinity(), true);
+}
+
 TEST(g1, add_exception_test_dbl)
 {
     g1::element lhs = g1::element::random_element();
@@ -160,6 +169,19 @@ TEST(g1, add_exception_test_dbl)
     EXPECT_EQ(result == expected, true);
 }
 
+TEST(g1, add_affine_test)
+{
+    g1::element lhs = g1::element::random_element();
+    g1::affine_element lhs_affine = g1::affine_element(lhs);
+
+    g1::element rhs = g1::element::random_element();
+    g1::affine_element rhs_affine = g1::affine_element(rhs);
+
+    g1::element expected = lhs + rhs;
+    g1::affine_element result = lhs_affine + rhs_affine;
+    EXPECT_EQ(g1::element(result) == expected, true);
+}
+
 TEST(g1, add_dbl_consistency)
 {
     g1::element a = g1::element::random_element();
diff --git a/cpp/src/barretenberg/ecc/fields/field.hpp b/cpp/src/barretenberg/ecc/fields/field.hpp
index ae31b54e938..66c59ea0d2e 100644
--- a/cpp/src/barretenberg/ecc/fields/field.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/ecc/fields/field_impl.hpp b/cpp/src/barretenberg/ecc/fields/field_impl.hpp
index 24e19026da2..057a7e44636 100644
--- a/cpp/src/barretenberg/ecc/fields/field_impl.hpp
+++ b/cpp/src/barretenberg/ecc/fields/field_impl.hpp
@@ -129,6 +129,18 @@ 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
+{
+    field<T> value_before_incrementing = *this;
+    *this += 1;
+    return value_before_incrementing;
+}
+
 /**
  *
  * Subtraction
diff --git a/cpp/src/barretenberg/ecc/groups/affine_element.hpp b/cpp/src/barretenberg/ecc/groups/affine_element.hpp
index bc957a5b030..81e60990302 100644
--- a/cpp/src/barretenberg/ecc/groups/affine_element.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/ecc/groups/affine_element_impl.hpp b/cpp/src/barretenberg/ecc/groups/affine_element_impl.hpp
index d1f4828688f..691f03f9425 100644
--- a/cpp/src/barretenberg/ecc/groups/affine_element_impl.hpp
+++ b/cpp/src/barretenberg/ecc/groups/affine_element_impl.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include "barretenberg/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/barretenberg/ecc/groups/element.hpp b/cpp/src/barretenberg/ecc/groups/element.hpp
index 67f4451ba5d..1b6096f5cea 100644
--- a/cpp/src/barretenberg/ecc/groups/element.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/ecc/groups/element_impl.hpp b/cpp/src/barretenberg/ecc/groups/element_impl.hpp
index 68774464334..c3a78595300 100644
--- a/cpp/src/barretenberg/ecc/groups/element_impl.hpp
+++ b/cpp/src/barretenberg/ecc/groups/element_impl.hpp
@@ -485,6 +485,13 @@ 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();
+    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/barretenberg/honk/composer/standard_honk_composer.hpp b/cpp/src/barretenberg/honk/composer/standard_honk_composer.hpp
index ab2c344514f..d99033e67d2 100644
--- a/cpp/src/barretenberg/honk/composer/standard_honk_composer.hpp
+++ b/cpp/src/barretenberg/honk/composer/standard_honk_composer.hpp
@@ -5,6 +5,8 @@
 #include "barretenberg/srs/reference_string/file_reference_string.hpp"
 #include "barretenberg/transcript/manifest.hpp"
 #include "barretenberg/honk/flavor/flavor.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
+#include "barretenberg/proof_system/types/pedersen_commitment_type.hpp"
 
 namespace proof_system::honk {
 /**
@@ -16,6 +18,8 @@ namespace proof_system::honk {
 class StandardHonkComposer {
   public:
     static constexpr ComposerType type = ComposerType::STANDARD_HONK;
+    static constexpr merkle::HashType merkle_hash_type = merkle::HashType::LOOKUP_PEDERSEN;
+    static constexpr pedersen::CommitmentType commitment_type = pedersen::CommitmentType::FIXED_BASE_PEDERSEN;
 
     static constexpr size_t UINT_LOG2_BASE = 2;
     // An instantiation of the circuit constructor that only depends on arithmetization, not  on the proof system
diff --git a/cpp/src/barretenberg/honk/transcript/transcript.hpp b/cpp/src/barretenberg/honk/transcript/transcript.hpp
index 15d92c679be..ff859806b29 100644
--- a/cpp/src/barretenberg/honk/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/honk/transcript/transcript.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/crypto/blake3s/blake3s.hpp"
 
 #include <array>
@@ -99,7 +99,7 @@ template <typename FF> class BaseTranscript {
         // Only a collision-resistant hash-function like Pedersen is required for this step.
         // Note: this pre-hashing is an efficiency trick that may be discareded if using a SNARK-friendly or in contexts
         // (eg smart contract verification) where the cost of elliptic curve operations is high.
-        std::vector<uint8_t> compressed_buffer = to_buffer(crypto::pedersen::compress_native(full_buffer));
+        std::vector<uint8_t> compressed_buffer = to_buffer(crypto::pedersen_commitment::compress_native(full_buffer));
 
         // Use a strong hash function to derive the new challenge_buffer.
         auto base_hash = blake3::blake3s(compressed_buffer);
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/CMakeLists.txt b/cpp/src/barretenberg/join_split_example/proofs/join_split/CMakeLists.txt
index 560148e4320..2a44f93e256 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/CMakeLists.txt
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/CMakeLists.txt
@@ -5,7 +5,7 @@ barretenberg_module(
   crypto_schnorr
   stdlib_blake2s
   stdlib_sha256
-  stdlib_pedersen
+  stdlib_pedersen_commitment
   stdlib_schnorr
   stdlib_primitives
   stdlib_merkle_tree)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_signing_data.cpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_signing_data.cpp
index 0a40dd74c8c..8dd99f57ec4 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_signing_data.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_signing_data.cpp
@@ -1,12 +1,12 @@
 #include "compute_signing_data.hpp"
 #include "../notes/native/index.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 
 namespace join_split_example {
 namespace proofs {
 namespace join_split {
 
-using namespace crypto::pedersen;
+using namespace crypto::pedersen_commitment;
 using namespace notes::native;
 
 barretenberg::fr compute_signing_data(join_split_tx const& tx)
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 46a45c61507..c729f914345 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
@@ -802,13 +802,13 @@ TEST_F(join_split_tests, test_0_input_notes_and_detect_circuit_change)
 
 // The below part detects any changes in the join-split circuit
 #ifdef USE_TURBO
-    constexpr uint32_t CIRCUIT_GATE_COUNT = 64000;
+    constexpr uint32_t CIRCUIT_GATE_COUNT = 59175;
     constexpr uint32_t GATES_NEXT_POWER_OF_TWO = 65536;
-    const uint256_t VK_HASH("bb2062d006d31d3234766277711eb28577d5f6082d0f484b87e8235628f8e864");
+    const uint256_t VK_HASH("095cbe8f1b09690713d5161708b5ea77119575884e3cfab14f7364b9f1ba7faa");
 #else
-    constexpr uint32_t CIRCUIT_GATE_COUNT = 522850;
+    constexpr uint32_t CIRCUIT_GATE_COUNT = 185573;
     constexpr uint32_t GATES_NEXT_POWER_OF_TWO = 524288;
-    const uint256_t VK_HASH("012959f86e485f3a8f0b06c900082fca1c34b535cdf4f1088f03154ea655b401");
+    const uint256_t VK_HASH("21389d5392ee23ffc96984689150b63d62113678b1ba127346a0ec72df842354");
 
 #endif
     auto number_of_gates_js = result.number_of_gates;
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.cpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.cpp
index 6bf3c1bfe18..46d1e375869 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_tx.cpp
@@ -1,5 +1,5 @@
 #include "join_split_tx.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 
 namespace join_split_example {
 namespace proofs {
diff --git a/cpp/src/barretenberg/join_split_example/proofs/join_split/verify_signature.hpp b/cpp/src/barretenberg/join_split_example/proofs/join_split/verify_signature.hpp
index 87347fe7654..96f538f4f2a 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/join_split/verify_signature.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/join_split/verify_signature.hpp
@@ -1,5 +1,5 @@
 #include "barretenberg/stdlib/encryption/schnorr/schnorr.hpp"
-#include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -23,7 +23,7 @@ inline void verify_signature(field_ct const& public_value,
         public_value, public_owner,  public_asset_id, output_note1_commitment, output_note2_commitment, nullifier1,
         nullifier2,   backward_link, allow_chain,
     };
-    byte_array_ct message = pedersen::compress(to_compress);
+    byte_array_ct message = pedersen_commitment::compress(to_compress);
     verify_signature(message, owner_pub_key, signature);
 }
 
diff --git a/cpp/src/barretenberg/join_split_example/proofs/mock/CMakeLists.txt b/cpp/src/barretenberg/join_split_example/proofs/mock/CMakeLists.txt
index 7695dfdc809..2edf8f230d4 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/mock/CMakeLists.txt
+++ b/cpp/src/barretenberg/join_split_example/proofs/mock/CMakeLists.txt
@@ -2,5 +2,5 @@ barretenberg_module(
   rollup_proofs_mock
   stdlib_blake2s
   stdlib_sha256
-  stdlib_pedersen
+  stdlib_pedersen_commitment
   stdlib_primitives)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.hpp b/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.hpp
index f629a32f180..d1585909c80 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/mock/mock_circuit.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include "barretenberg/common/map.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
-#include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -15,7 +15,8 @@ template <typename Composer> void mock_circuit(Composer& composer, std::vector<f
     for (auto& p : public_inputs) {
         p.set_public();
     }
-    plonk::stdlib::pedersen<Composer>::compress(field_t(witness_t(&composer, 1)), field_t(witness_t(&composer, 1)));
+    plonk::stdlib::pedersen_commitment<Composer>::compress(field_t(witness_t(&composer, 1)),
+                                                           field_t(witness_t(&composer, 1)));
 }
 
 } // namespace mock
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/CMakeLists.txt b/cpp/src/barretenberg/join_split_example/proofs/notes/CMakeLists.txt
index 58b7fd37fd9..0efb8cfc275 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/CMakeLists.txt
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/CMakeLists.txt
@@ -3,7 +3,7 @@ barretenberg_module(
   crypto_schnorr
   stdlib_blake2s
   stdlib_sha256
-  stdlib_pedersen
+  stdlib_pedersen_commitment
   stdlib_schnorr
   stdlib_primitives
   stdlib_merkle_tree)
\ No newline at end of file
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 ca668b94f65..497644a9518 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
@@ -14,7 +14,7 @@ inline auto commit(field_ct const& account_alias_hash,
                    point_ct const& account_public_key,
                    point_ct const& signing_pub_key)
 {
-    return pedersen::compress(
+    return pedersen_commitment::compress(
         {
             account_alias_hash,
             account_public_key.x,
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 c1ea735d12d..9b1010ab585 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
@@ -14,8 +14,8 @@ inline auto complete_partial_commitment(field_ct const& partial_commitment,
                                         field_ct const& interaction_nonce,
                                         suint_ct const& fee)
 {
-    return pedersen::compress({ partial_commitment, interaction_nonce, fee.value },
-                              GeneratorIndex::CLAIM_NOTE_COMMITMENT);
+    return pedersen_commitment::compress({ partial_commitment, interaction_nonce, fee.value },
+                                         GeneratorIndex::CLAIM_NOTE_COMMITMENT);
 }
 
 } // namespace claim
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 05666cacc40..304f9f6205f 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
@@ -13,7 +13,8 @@ using namespace proof_system::plonk::stdlib::types;
 
 inline field_ct compute_nullifier(field_ct const& note_commitment)
 {
-    return pedersen::compress(std::vector<field_ct>{ note_commitment }, GeneratorIndex::CLAIM_NOTE_NULLIFIER);
+    return pedersen_commitment::compress(std::vector<field_ct>{ note_commitment },
+                                         GeneratorIndex::CLAIM_NOTE_NULLIFIER);
 
     // Note: unlike for value note nullifiers, we don't need to then Blake2-hash this result (which would provide a
     // psuedorandom-looking nullifier) because the contents of a claim note commitment are public anyway.
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 d903e5688d3..30eb7adb7a1 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
@@ -16,8 +16,9 @@ inline auto create_partial_commitment(field_ct const& deposit_value,
                                       field_ct const& value_note_partial_commitment,
                                       field_ct const& input_nullifier)
 {
-    return pedersen::compress({ deposit_value, bridge_call_data, value_note_partial_commitment, input_nullifier },
-                              GeneratorIndex::CLAIM_NOTE_PARTIAL_COMMITMENT);
+    return pedersen_commitment::compress(
+        { deposit_value, bridge_call_data, value_note_partial_commitment, input_nullifier },
+        GeneratorIndex::CLAIM_NOTE_PARTIAL_COMMITMENT);
 }
 
 } // namespace claim
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 2ec86fc763e..e5bc84b994a 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,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 "../../constants.hpp"
 
 namespace join_split_example {
@@ -16,8 +16,9 @@ inline auto complete_partial_commitment(field_ct const& value_note_partial_commi
                                         suint_ct const& asset_id,
                                         field_ct const& input_nullifier)
 {
-    return pedersen::compress({ value_note_partial_commitment, value.value, asset_id.value, input_nullifier },
-                              GeneratorIndex::VALUE_NOTE_COMMITMENT);
+    return pedersen_commitment::compress(
+        { value_note_partial_commitment, value.value, asset_id.value, input_nullifier },
+        GeneratorIndex::VALUE_NOTE_COMMITMENT);
 }
 
 } // namespace 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 08f00dbf16e..30dafca6b65 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
@@ -30,7 +30,7 @@ field_ct compute_nullifier(field_ct const& note_commitment,
 
     // We compress the hash_inputs with Pedersen, because that's cheaper (constraint-wise) than compressing
     // the data directly with Blake2s in the next step.
-    const auto compressed_inputs = pedersen::compress(hash_inputs, GeneratorIndex::JOIN_SPLIT_NULLIFIER);
+    const auto compressed_inputs = pedersen_commitment::compress(hash_inputs, GeneratorIndex::JOIN_SPLIT_NULLIFIER);
 
     // Blake2s hash the compressed result. Without this it's possible to leak info from the pedersen compression.
     /** E.g. we can extract a representation of the hashed_pk:
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 2cb12fa9d28..f01324ee349 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
@@ -16,8 +16,8 @@ inline auto create_partial_commitment(field_ct const& secret,
                                       bool_ct const& account_required,
                                       field_ct const& creator_pubkey)
 {
-    return pedersen::compress({ secret, owner.x, owner.y, account_required, creator_pubkey },
-                              GeneratorIndex::VALUE_NOTE_PARTIAL_COMMITMENT);
+    return pedersen_commitment::compress({ secret, owner.x, owner.y, account_required, creator_pubkey },
+                                         GeneratorIndex::VALUE_NOTE_PARTIAL_COMMITMENT);
 }
 
 } // namespace value
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.cpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.cpp
index 13b951ed20f..ab68a0bc722 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.cpp
@@ -1,5 +1,5 @@
 #include "account_note.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "../../constants.hpp"
 
 namespace join_split_example {
@@ -12,8 +12,8 @@ grumpkin::fq generate_account_commitment(const barretenberg::fr& alias_hash,
                                          const barretenberg::fr& owner_x,
                                          const barretenberg::fr& signing_x)
 {
-    return crypto::pedersen::compress_native({ alias_hash, owner_x, signing_x },
-                                             GeneratorIndex::ACCOUNT_NOTE_COMMITMENT);
+    return crypto::pedersen_commitment::compress_native({ alias_hash, owner_x, signing_x },
+                                                        GeneratorIndex::ACCOUNT_NOTE_COMMITMENT);
 }
 
 grumpkin::fq account_note::commit() const
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.hpp
index 3a5d3750b29..7f10d40c3a4 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/account_note.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "../../constants.hpp"
 
 namespace join_split_example {
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_alias_hash_nullifier.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_alias_hash_nullifier.hpp
index 55d98889da6..44801e10790 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_alias_hash_nullifier.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_alias_hash_nullifier.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "account_note.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "../../constants.hpp"
 
 namespace join_split_example {
@@ -13,8 +13,8 @@ using namespace barretenberg;
 
 inline fr compute_account_alias_hash_nullifier(fr const& alias_hash)
 {
-    return crypto::pedersen::compress_native(std::vector<fr>{ alias_hash },
-                                             notes::GeneratorIndex::ACCOUNT_ALIAS_HASH_NULLIFIER);
+    return crypto::pedersen_commitment::compress_native(std::vector<fr>{ alias_hash },
+                                                        notes::GeneratorIndex::ACCOUNT_ALIAS_HASH_NULLIFIER);
 }
 
 } // namespace account
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_public_key_nullifier.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_public_key_nullifier.hpp
index 68f7c6784b5..a88b18ed32e 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_public_key_nullifier.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/account/compute_account_public_key_nullifier.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "account_note.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "../../constants.hpp"
 
 namespace join_split_example {
@@ -13,8 +13,8 @@ using namespace barretenberg;
 
 inline fr compute_account_public_key_nullifier(grumpkin::g1::affine_element const& public_key)
 {
-    return crypto::pedersen::compress_native(std::vector<fr>{ public_key.x },
-                                             notes::GeneratorIndex::ACCOUNT_PUBLIC_KEY_NULLIFIER);
+    return crypto::pedersen_commitment::compress_native(std::vector<fr>{ public_key.x },
+                                                        notes::GeneratorIndex::ACCOUNT_PUBLIC_KEY_NULLIFIER);
 }
 
 } // namespace account
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/bridge_call_data.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/bridge_call_data.hpp
index 1c60a3ac4e1..22d79996add 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/bridge_call_data.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/bridge_call_data.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include "barretenberg/common/serialize.hpp"
 #include "../constants.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
 
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note.hpp
index 9c05253c6e5..a89e12bcfbd 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "create_partial_commitment.hpp"
 #include "complete_partial_commitment.hpp"
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note_tx_data.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note_tx_data.hpp
index 72a572982c0..83c2f6375c1 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note_tx_data.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/claim_note_tx_data.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "../bridge_call_data.hpp"
 
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/complete_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/complete_partial_commitment.hpp
index aa945e1145f..27407bf5676 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/complete_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/complete_partial_commitment.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "../../constants.hpp"
 
@@ -14,8 +14,8 @@ inline auto complete_partial_commitment(grumpkin::fq const& claim_note_partial_c
                                         uint32_t interaction_nonce,
                                         uint256_t fee)
 {
-    return crypto::pedersen::compress_native({ claim_note_partial_commitment, interaction_nonce, fee },
-                                             GeneratorIndex::CLAIM_NOTE_COMMITMENT);
+    return crypto::pedersen_commitment::compress_native({ claim_note_partial_commitment, interaction_nonce, fee },
+                                                        GeneratorIndex::CLAIM_NOTE_COMMITMENT);
 }
 
 } // namespace claim
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/compute_nullifier.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/compute_nullifier.hpp
index f03fa0a4d70..8503c35d2ab 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/compute_nullifier.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/compute_nullifier.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "../../constants.hpp"
 
@@ -14,7 +14,7 @@ using namespace barretenberg;
 
 inline auto compute_nullifier(grumpkin::fq const& note_commitment)
 {
-    return crypto::pedersen::compress_native({ note_commitment }, GeneratorIndex::CLAIM_NOTE_NULLIFIER);
+    return crypto::pedersen_commitment::compress_native({ note_commitment }, GeneratorIndex::CLAIM_NOTE_NULLIFIER);
 }
 
 } // namespace claim
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/create_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/create_partial_commitment.hpp
index 1743abc1e88..fd5c302007f 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/create_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/claim/create_partial_commitment.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "claim_note.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "../../constants.hpp"
 
 namespace join_split_example {
@@ -14,7 +14,7 @@ inline auto create_partial_commitment(uint256_t const& deposit_value,
                                       grumpkin::fq const& value_note_partial_commitment,
                                       grumpkin::fq const& input_nullifier)
 {
-    return crypto::pedersen::compress_native(
+    return crypto::pedersen_commitment::compress_native(
         { deposit_value, bridge_call_data, value_note_partial_commitment, input_nullifier },
         GeneratorIndex::CLAIM_NOTE_PARTIAL_COMMITMENT);
 }
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/complete_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/complete_partial_commitment.hpp
index 0744a786191..0d33dc091b4 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/complete_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/complete_partial_commitment.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "../../constants.hpp"
 
 namespace join_split_example {
@@ -13,8 +13,8 @@ inline auto complete_partial_commitment(grumpkin::fq const& partial_commitment,
                                         uint32_t asset_id,
                                         grumpkin::fq input_nullifier)
 {
-    return crypto::pedersen::compress_native({ partial_commitment, value, asset_id, input_nullifier },
-                                             GeneratorIndex::VALUE_NOTE_COMMITMENT);
+    return crypto::pedersen_commitment::compress_native({ partial_commitment, value, asset_id, input_nullifier },
+                                                        GeneratorIndex::VALUE_NOTE_COMMITMENT);
 };
 
 } // namespace value
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/compute_nullifier.cpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/compute_nullifier.cpp
index 2a7a89e92fd..d16a4bb7228 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/compute_nullifier.cpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/compute_nullifier.cpp
@@ -1,6 +1,6 @@
 #include "compute_nullifier.hpp"
 #include "../../constants.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/crypto/blake2s/blake2s.hpp"
 
 namespace join_split_example {
@@ -17,7 +17,7 @@ fr compute_nullifier(grumpkin::fq const& note_commitment,
                      grumpkin::fr const& account_private_key,
                      const bool is_note_in_use)
 {
-    auto hashed_pk = crypto::pedersen::fixed_base_scalar_mul<254>(
+    auto hashed_pk = crypto::generators::fixed_base_scalar_mul<254>(
         fr(account_private_key), GeneratorIndex::JOIN_SPLIT_NULLIFIER_ACCOUNT_PRIVATE_KEY);
 
     std::vector<barretenberg::fr> buf{
@@ -26,7 +26,7 @@ fr compute_nullifier(grumpkin::fq const& note_commitment,
         hashed_pk.y,
         is_note_in_use,
     };
-    auto compressed_inputs = crypto::pedersen::compress_native(buf, GeneratorIndex::JOIN_SPLIT_NULLIFIER);
+    auto compressed_inputs = crypto::pedersen_commitment::compress_native(buf, GeneratorIndex::JOIN_SPLIT_NULLIFIER);
     auto blake_result = blake2::blake2s(to_buffer(compressed_inputs));
 
     return from_buffer<fr>(blake_result);
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/create_partial_commitment.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/create_partial_commitment.hpp
index 1f26ffde994..5105074c023 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/create_partial_commitment.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/create_partial_commitment.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "../../constants.hpp"
 
@@ -15,8 +15,8 @@ inline auto create_partial_commitment(barretenberg::fr const& secret,
                                       bool account_required,
                                       barretenberg::fr const& creator_pubkey)
 {
-    return crypto::pedersen::compress_native({ secret, owner.x, owner.y, account_required, creator_pubkey },
-                                             GeneratorIndex::VALUE_NOTE_PARTIAL_COMMITMENT);
+    return crypto::pedersen_commitment::compress_native({ secret, owner.x, owner.y, account_required, creator_pubkey },
+                                                        GeneratorIndex::VALUE_NOTE_PARTIAL_COMMITMENT);
 }
 
 } // namespace value
diff --git a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/value_note.hpp b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/value_note.hpp
index 83e201eec03..421106004db 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/value_note.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/notes/native/value/value_note.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "barretenberg/common/serialize.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "create_partial_commitment.hpp"
 #include "complete_partial_commitment.hpp"
diff --git a/cpp/src/barretenberg/join_split_example/proofs/verify.hpp b/cpp/src/barretenberg/join_split_example/proofs/verify.hpp
index b37b5116915..e87a3e0bee3 100644
--- a/cpp/src/barretenberg/join_split_example/proofs/verify.hpp
+++ b/cpp/src/barretenberg/join_split_example/proofs/verify.hpp
@@ -3,6 +3,7 @@
 #include "barretenberg/ecc/curves/bn254/fq12.hpp"
 #include "barretenberg/ecc/curves/bn254/pairing.hpp"
 #include "barretenberg/stdlib/recursion/verifier/verifier.hpp"
+#include "barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp"
 
 namespace join_split_example {
 namespace proofs {
@@ -16,7 +17,7 @@ template <typename Composer> struct verify_result {
     bool logic_verified;
     std::string err;
     std::vector<fr> public_inputs;
-    plonk::stdlib::recursion::recursion_output<plonk::stdlib::bn254<Composer>> recursion_output;
+    plonk::stdlib::recursion::aggregation_state<plonk::stdlib::bn254<Composer>> aggregation_state;
 
     std::vector<uint8_t> proof_data;
     bool verified;
@@ -25,14 +26,14 @@ template <typename Composer> struct verify_result {
 };
 
 template <typename Composer>
-inline bool pairing_check(plonk::stdlib::recursion::recursion_output<plonk::stdlib::bn254<Composer>> recursion_output,
+inline bool pairing_check(plonk::stdlib::recursion::aggregation_state<plonk::stdlib::bn254<Composer>> aggregation_state,
                           std::shared_ptr<VerifierReferenceString> const& srs)
 {
     g1::affine_element P[2];
-    P[0].x = barretenberg::fq(recursion_output.P0.x.get_value().lo);
-    P[0].y = barretenberg::fq(recursion_output.P0.y.get_value().lo);
-    P[1].x = barretenberg::fq(recursion_output.P1.x.get_value().lo);
-    P[1].y = barretenberg::fq(recursion_output.P1.y.get_value().lo);
+    P[0].x = barretenberg::fq(aggregation_state.P0.x.get_value().lo);
+    P[0].y = barretenberg::fq(aggregation_state.P0.y.get_value().lo);
+    P[1].x = barretenberg::fq(aggregation_state.P1.x.get_value().lo);
+    P[1].y = barretenberg::fq(aggregation_state.P1.y.get_value().lo);
     barretenberg::fq12 inner_proof_result =
         barretenberg::pairing::reduced_ate_pairing_batch_precomputed(P, srs->get_precomputed_g2_lines(), 2);
     return inner_proof_result == barretenberg::fq12::one();
@@ -57,7 +58,7 @@ auto verify_logic_internal(Composer& composer, Tx& tx, CircuitData const& cd, ch
         return result;
     }
 
-    if (!pairing_check(result.recursion_output, cd.srs->get_verifier_crs())) {
+    if (!pairing_check(result.aggregation_state, cd.srs->get_verifier_crs())) {
         info(name, ": Native pairing check failed.");
         return result;
     }
diff --git a/cpp/src/barretenberg/plonk/CMakeLists.txt b/cpp/src/barretenberg/plonk/CMakeLists.txt
index 651baa2baac..0893749023f 100644
--- a/cpp/src/barretenberg/plonk/CMakeLists.txt
+++ b/cpp/src/barretenberg/plonk/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(plonk proof_system transcript crypto_pedersen polynomials crypto_sha256 ecc crypto_blake3s)
\ No newline at end of file
+barretenberg_module(plonk proof_system transcript crypto_pedersen_commitment polynomials crypto_sha256 ecc crypto_blake3s)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/plonk/composer/plookup_tables/pedersen.hpp b/cpp/src/barretenberg/plonk/composer/plookup_tables/pedersen.hpp
index b9f53725168..91107bb624f 100644
--- a/cpp/src/barretenberg/plonk/composer/plookup_tables/pedersen.hpp
+++ b/cpp/src/barretenberg/plonk/composer/plookup_tables/pedersen.hpp
@@ -2,7 +2,7 @@
 
 #include "./types.hpp"
 
-#include "barretenberg/crypto/pedersen/pedersen_lookup.hpp"
+#include "barretenberg/crypto/pedersen_hash/pedersen_lookup.hpp"
 #include "barretenberg/numeric/bitop/rotate.hpp"
 #include "barretenberg/numeric/bitop/sparse_form.hpp"
 #include "barretenberg/numeric/bitop/pow.hpp"
@@ -14,14 +14,14 @@ namespace basic {
 template <size_t generator_index>
 inline std::array<barretenberg::fr, 2> get_basic_pedersen_table_values(const std::array<uint64_t, 2> key)
 {
-    const auto& basic_table = crypto::pedersen::lookup::get_table(generator_index);
+    const auto& basic_table = crypto::pedersen_hash::lookup::get_table(generator_index);
     const size_t index = static_cast<size_t>(key[0]);
     return { basic_table[index].x, basic_table[index].y };
 }
 
 inline std::array<barretenberg::fr, 2> get_pedersen_iv_table_values(const std::array<uint64_t, 2> key)
 {
-    const auto& iv_table = crypto::pedersen::lookup::get_iv_table();
+    const auto& iv_table = crypto::pedersen_hash::lookup::get_iv_table();
     const size_t index = static_cast<size_t>(key[0]);
     return { iv_table[index].x, iv_table[index].y };
 }
@@ -32,11 +32,11 @@ inline BasicTable generate_basic_pedersen_table(BasicTableId id, const size_t ta
     BasicTable table;
     table.id = id;
     table.table_index = table_index;
-    table.size =
-        is_small ? crypto::pedersen::lookup::PEDERSEN_SMALL_TABLE_SIZE : crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE;
+    table.size = is_small ? crypto::pedersen_hash::lookup::PEDERSEN_SMALL_TABLE_SIZE
+                          : crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE;
     table.use_twin_keys = false;
 
-    const auto& basic_table = crypto::pedersen::lookup::get_table(generator_index);
+    const auto& basic_table = crypto::pedersen_hash::lookup::get_table(generator_index);
 
     for (size_t i = 0; i < table.size; ++i) {
         table.column_1.emplace_back(i);
@@ -58,10 +58,10 @@ inline BasicTable generate_pedersen_iv_table(BasicTableId id)
     BasicTable table;
     table.id = id;
     table.table_index = 0;
-    table.size = crypto::pedersen::lookup::PEDERSEN_IV_TABLE_SIZE;
+    table.size = crypto::pedersen_hash::lookup::PEDERSEN_IV_TABLE_SIZE;
     table.use_twin_keys = false;
 
-    const auto& iv_table = crypto::pedersen::lookup::get_iv_table();
+    const auto& iv_table = crypto::pedersen_hash::lookup::get_iv_table();
 
     for (size_t i = 0; i < table.size; ++i) {
         table.column_1.emplace_back(i);
@@ -80,9 +80,9 @@ inline BasicTable generate_pedersen_iv_table(BasicTableId id)
 
 inline MultiTable get_pedersen_iv_table(const MultiTableId id = PEDERSEN_IV)
 {
-    MultiTable table(crypto::pedersen::lookup::PEDERSEN_IV_TABLE_SIZE, 0, 0, 1);
+    MultiTable table(crypto::pedersen_hash::lookup::PEDERSEN_IV_TABLE_SIZE, 0, 0, 1);
     table.id = id;
-    table.slice_sizes.emplace_back(crypto::pedersen::lookup::PEDERSEN_IV_TABLE_SIZE);
+    table.slice_sizes.emplace_back(crypto::pedersen_hash::lookup::PEDERSEN_IV_TABLE_SIZE);
     table.get_table_values.emplace_back(&get_pedersen_iv_table_values);
     table.lookup_ids = { PEDERSEN_IV_BASE };
 
@@ -91,12 +91,12 @@ inline MultiTable get_pedersen_iv_table(const MultiTableId id = PEDERSEN_IV)
 
 inline MultiTable get_pedersen_left_lo_table(const MultiTableId id = PEDERSEN_LEFT_LO)
 {
-    const size_t num_entries = 126 / crypto::pedersen::lookup::BITS_PER_TABLE;
-    MultiTable table(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
+    const size_t num_entries = 126 / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    MultiTable table(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
 
     table.id = id;
     for (size_t i = 0; i < num_entries; ++i) {
-        table.slice_sizes.emplace_back(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        table.slice_sizes.emplace_back(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
 
     table.get_table_values = { &get_basic_pedersen_table_values<0>, &get_basic_pedersen_table_values<0>,
@@ -115,14 +115,14 @@ inline MultiTable get_pedersen_left_lo_table(const MultiTableId id = PEDERSEN_LE
 inline MultiTable get_pedersen_left_hi_table(const MultiTableId id = PEDERSEN_LEFT_HI)
 {
     const size_t num_entries =
-        (128 + crypto::pedersen::lookup::BITS_PER_TABLE) / crypto::pedersen::lookup::BITS_PER_TABLE;
-    MultiTable table(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
+        (128 + crypto::pedersen_hash::lookup::BITS_PER_TABLE) / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    MultiTable table(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
 
     table.id = id;
     for (size_t i = 0; i < num_entries - 1; ++i) {
-        table.slice_sizes.emplace_back(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        table.slice_sizes.emplace_back(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
-    table.slice_sizes.emplace_back(crypto::pedersen::lookup::PEDERSEN_SMALL_TABLE_SIZE);
+    table.slice_sizes.emplace_back(crypto::pedersen_hash::lookup::PEDERSEN_SMALL_TABLE_SIZE);
 
     table.get_table_values = { &get_basic_pedersen_table_values<7>,  &get_basic_pedersen_table_values<7>,
                                &get_basic_pedersen_table_values<8>,  &get_basic_pedersen_table_values<8>,
@@ -141,12 +141,12 @@ inline MultiTable get_pedersen_left_hi_table(const MultiTableId id = PEDERSEN_LE
 
 inline MultiTable get_pedersen_right_lo_table(const MultiTableId id = PEDERSEN_RIGHT_LO)
 {
-    const size_t num_entries = 126 / crypto::pedersen::lookup::BITS_PER_TABLE;
-    MultiTable table(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
+    const size_t num_entries = 126 / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    MultiTable table(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
 
     table.id = id;
     for (size_t i = 0; i < num_entries; ++i) {
-        table.slice_sizes.emplace_back(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        table.slice_sizes.emplace_back(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
 
     table.get_table_values = { &get_basic_pedersen_table_values<15>, &get_basic_pedersen_table_values<15>,
@@ -165,14 +165,14 @@ inline MultiTable get_pedersen_right_lo_table(const MultiTableId id = PEDERSEN_R
 inline MultiTable get_pedersen_right_hi_table(const MultiTableId id = PEDERSEN_RIGHT_HI)
 {
     const size_t num_entries =
-        (128 + crypto::pedersen::lookup::BITS_PER_TABLE) / crypto::pedersen::lookup::BITS_PER_TABLE;
-    MultiTable table(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
+        (128 + crypto::pedersen_hash::lookup::BITS_PER_TABLE) / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    MultiTable table(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE, 0, 0, num_entries);
 
     table.id = id;
     for (size_t i = 0; i < num_entries - 1; ++i) {
-        table.slice_sizes.emplace_back(crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        table.slice_sizes.emplace_back(crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
-    table.slice_sizes.emplace_back(crypto::pedersen::lookup::PEDERSEN_SMALL_TABLE_SIZE);
+    table.slice_sizes.emplace_back(crypto::pedersen_hash::lookup::PEDERSEN_SMALL_TABLE_SIZE);
 
     table.get_table_values = { &get_basic_pedersen_table_values<22>, &get_basic_pedersen_table_values<22>,
                                &get_basic_pedersen_table_values<23>, &get_basic_pedersen_table_values<23>,
diff --git a/cpp/src/barretenberg/plonk/composer/splitting_tmp/composer_helper/turbo_plonk_composer_helper.hpp b/cpp/src/barretenberg/plonk/composer/splitting_tmp/composer_helper/turbo_plonk_composer_helper.hpp
index 2f12901330f..c18fff8d829 100644
--- a/cpp/src/barretenberg/plonk/composer/splitting_tmp/composer_helper/turbo_plonk_composer_helper.hpp
+++ b/cpp/src/barretenberg/plonk/composer/splitting_tmp/composer_helper/turbo_plonk_composer_helper.hpp
@@ -12,9 +12,7 @@ template <typename CircuitConstructor> class TurboPlonkComposerHelper {
   public:
     static constexpr size_t NUM_RANDOMIZED_GATES = 2; // equal to the number of multilinear evaluations leaked
     static constexpr size_t program_width = CircuitConstructor::program_width;
-    static constexpr ComposerType type = ComposerType::TURBO;
-    static constexpr MerkleHashType merkle_hash_type = MerkleHashType::FIXED_BASE_PEDERSEN;
-    static constexpr size_t UINT_LOG2_BASE = 2;
+
     std::shared_ptr<plonk::proving_key> circuit_proving_key;
     std::shared_ptr<plonk::verification_key> circuit_verification_key;
 
diff --git a/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.hpp b/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.hpp
index 34e51f92de3..93524589c68 100644
--- a/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.hpp
@@ -5,6 +5,8 @@
 #include "barretenberg/srs/reference_string/file_reference_string.hpp"
 #include "barretenberg/transcript/manifest.hpp"
 #include "barretenberg/proof_system/flavor/flavor.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
+#include "barretenberg/proof_system/types/pedersen_commitment_type.hpp"
 
 namespace proof_system::plonk {
 /**
@@ -17,6 +19,8 @@ namespace proof_system::plonk {
 class StandardPlonkComposer {
   public:
     static constexpr ComposerType type = ComposerType::STANDARD;
+    static constexpr merkle::HashType merkle_hash_type = merkle::HashType::FIXED_BASE_PEDERSEN;
+    static constexpr pedersen::CommitmentType commitment_type = pedersen::CommitmentType::FIXED_BASE_PEDERSEN;
 
     static constexpr size_t UINT_LOG2_BASE = 2;
     // An instantiation of the circuit constructor that only depends on arithmetization, not  on the proof system
diff --git a/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.test.cpp
index 0ff53d40b0e..f67d6622dac 100644
--- a/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/splitting_tmp/standard_plonk_composer.test.cpp
@@ -1,7 +1,7 @@
 #include "standard_plonk_composer.hpp"
 #include <gtest/gtest.h>
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
-#include "barretenberg/crypto/pedersen/generator_data.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/generators/generator_data.hpp"
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
 
 using namespace barretenberg;
diff --git a/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.hpp b/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.hpp
index 6019662bb55..1a9abf596ff 100644
--- a/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.hpp
@@ -1,6 +1,8 @@
 #pragma once
 #include "composer_helper/turbo_plonk_composer_helper.hpp"
 #include "barretenberg/proof_system/circuit_constructors/turbo_circuit_constructor.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
+#include "barretenberg/proof_system/types/pedersen_commitment_type.hpp"
 
 namespace proof_system::plonk {
 /**
@@ -13,6 +15,8 @@ namespace proof_system::plonk {
 class TurboPlonkComposer {
   public:
     static constexpr ComposerType type = ComposerType::STANDARD;
+    static constexpr merkle::HashType merkle_hash_type = merkle::HashType::FIXED_BASE_PEDERSEN;
+    static constexpr pedersen::CommitmentType commitment_type = pedersen::CommitmentType::FIXED_BASE_PEDERSEN;
 
     static constexpr size_t UINT_LOG2_BASE = 2;
 
diff --git a/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.test.cpp
index 007afa3e19c..bdddb0f072a 100644
--- a/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/splitting_tmp/turbo_plonk_composer.test.cpp
@@ -1,11 +1,12 @@
 #include "turbo_plonk_composer.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/generators/generator_data.hpp"
+#include "barretenberg/crypto/generators/fixed_base_scalar_mul.hpp"
 #include <gtest/gtest.h>
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
 
 using namespace barretenberg;
 using namespace proof_system;
-using namespace crypto::pedersen;
+using namespace crypto::generators;
 
 namespace proof_system::plonk::test_turbo_plonk_composer {
 namespace {
@@ -213,8 +214,8 @@ TEST(turbo_plonk_composer_splitting_tmp, small_scalar_multipliers)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
     constexpr size_t initial_exponent = ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
     constexpr uint64_t bit_mask = (1ULL << num_bits) - 1UL;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
@@ -253,7 +254,7 @@ TEST(turbo_plonk_composer_splitting_tmp, small_scalar_multipliers)
     fr one = fr::one();
     fr three = ((one + one) + one);
     for (size_t i = 0; i < num_quads; ++i) {
-        uint64_t entry = wnaf_entries[i + 1] & crypto::pedersen::WNAF_MASK;
+        uint64_t entry = wnaf_entries[i + 1] & crypto::generators::WNAF_MASK;
         fr prev_accumulator = accumulator_transcript[i] + accumulator_transcript[i];
         prev_accumulator = prev_accumulator + prev_accumulator;
 
@@ -342,8 +343,8 @@ TEST(turbo_plonk_composer_splitting_tmp, large_scalar_multipliers)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
 
     constexpr size_t initial_exponent = num_bits; // ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
@@ -383,7 +384,7 @@ TEST(turbo_plonk_composer_splitting_tmp, large_scalar_multipliers)
     fr one = fr::one();
     fr three = ((one + one) + one);
     for (size_t i = 0; i < num_quads; ++i) {
-        uint64_t entry = wnaf_entries[i + 1] & crypto::pedersen::WNAF_MASK;
+        uint64_t entry = wnaf_entries[i + 1] & crypto::generators::WNAF_MASK;
         fr prev_accumulator = accumulator_transcript[i] + accumulator_transcript[i];
         prev_accumulator = prev_accumulator + prev_accumulator;
 
@@ -979,8 +980,8 @@ TEST(turbo_plonk_composer_splitting_tmp, test_check_circuit_fixed_group)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
 
     constexpr size_t initial_exponent = num_bits; // ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
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 d66c99aa1d8..ccc3ece6287 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
@@ -3,6 +3,8 @@
 #include "barretenberg/plonk/composer/plookup_tables/plookup_tables.hpp"
 #include "barretenberg/plonk/proof_system/prover/prover.hpp"
 #include "barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
+#include "barretenberg/proof_system/types/pedersen_commitment_type.hpp"
 #include "barretenberg/plonk/composer/splitting_tmp/composer_helper/ultra_plonk_composer_helper.hpp"
 #include <optional>
 
@@ -11,6 +13,10 @@ namespace proof_system::plonk {
 class UltraPlonkComposer {
 
   public:
+    static constexpr ComposerType type = ComposerType::STANDARD;
+    static constexpr merkle::HashType merkle_hash_type = merkle::HashType::LOOKUP_PEDERSEN;
+    static constexpr pedersen::CommitmentType commitment_type = pedersen::CommitmentType::FIXED_BASE_PEDERSEN;
+
     // 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:
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 d5c2128e059..cc90c8de1e5 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
@@ -1,6 +1,7 @@
 #include "barretenberg/common/log.hpp"
 #include "ultra_plonk_composer.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/generators/generator_data.hpp"
+#include "barretenberg/crypto/pedersen_hash/pedersen_lookup.hpp"
 #include "barretenberg/plonk/composer/ultra_composer.hpp" // temporary
 #include <cstddef>
 #include <gtest/gtest.h>
@@ -111,8 +112,8 @@ TEST(ultra_plonk_composer_splitting_tmp, create_gates_from_plookup_accumulators)
     std::vector<barretenberg::fr> expected_y;
 
     const size_t num_lookups_hi =
-        (128 + crypto::pedersen::lookup::BITS_PER_TABLE) / crypto::pedersen::lookup::BITS_PER_TABLE;
-    const size_t num_lookups_lo = 126 / crypto::pedersen::lookup::BITS_PER_TABLE;
+        (128 + crypto::pedersen_hash::lookup::BITS_PER_TABLE) / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    const size_t num_lookups_lo = 126 / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
     const size_t num_lookups = num_lookups_hi + num_lookups_lo;
 
     EXPECT_EQ(num_lookups_hi, lookup_witnesses_hi[ColumnIdx::C1].size());
@@ -127,10 +128,10 @@ TEST(ultra_plonk_composer_splitting_tmp, create_gates_from_plookup_accumulators)
         const size_t num_rounds = (num_lookups + 1) / 2;
         uint256_t bits(input_value);
 
-        const auto mask = crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE - 1;
+        const auto mask = crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE - 1;
 
         for (size_t i = 0; i < num_rounds; ++i) {
-            const auto& table = crypto::pedersen::lookup::get_table(i);
+            const auto& table = crypto::pedersen_hash::lookup::get_table(i);
             const size_t index = i * 2;
 
             uint64_t slice_a = ((bits >> (index * 9)) & mask).data[0];
@@ -148,7 +149,7 @@ TEST(ultra_plonk_composer_splitting_tmp, create_gates_from_plookup_accumulators)
     }
 
     for (size_t i = num_lookups - 2; i < num_lookups; --i) {
-        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
 
     size_t hi_shift = 126;
@@ -159,7 +160,7 @@ TEST(ultra_plonk_composer_splitting_tmp, create_gates_from_plookup_accumulators)
                   expected_scalars[i]);
         EXPECT_EQ(composer.get_variable(lookup_witnesses_lo[ColumnIdx::C2][i]), expected_x[i]);
         EXPECT_EQ(composer.get_variable(lookup_witnesses_lo[ColumnIdx::C3][i]), expected_y[i]);
-        hi_shift -= crypto::pedersen::lookup::BITS_PER_TABLE;
+        hi_shift -= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
     }
 
     for (size_t i = 0; i < num_lookups_hi; ++i) {
@@ -212,9 +213,9 @@ TEST(ultra_plonk_composer_splitting_tmp, test_elliptic_gate)
     typedef grumpkin::g1::element element;
     auto composer = UltraPlonkComposer();
 
-    affine_element p1 = crypto::pedersen::get_generator_data({ 0, 0 }).generator;
+    affine_element p1 = crypto::generators::get_generator_data({ 0, 0 }).generator;
 
-    affine_element p2 = crypto::pedersen::get_generator_data({ 0, 1 }).generator;
+    affine_element p2 = crypto::generators::get_generator_data({ 0, 1 }).generator;
     affine_element p3(element(p1) + element(p2));
 
     uint32_t x1 = composer.add_variable(p1.x);
diff --git a/cpp/src/barretenberg/plonk/composer/standard_composer.hpp b/cpp/src/barretenberg/plonk/composer/standard_composer.hpp
index f8ec6455339..f4c59f71a5d 100644
--- a/cpp/src/barretenberg/plonk/composer/standard_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/standard_composer.hpp
@@ -1,5 +1,7 @@
 #pragma once
 #include "composer_base.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
+#include "barretenberg/proof_system/types/pedersen_commitment_type.hpp"
 #include "barretenberg/transcript/manifest.hpp"
 #include "barretenberg/srs/reference_string/file_reference_string.hpp"
 
@@ -17,7 +19,8 @@ inline std::vector<ComposerBase::SelectorProperties> standard_selector_propertie
 class StandardComposer : public ComposerBase {
   public:
     static constexpr ComposerType type = ComposerType::STANDARD;
-    static constexpr MerkleHashType merkle_hash_type = MerkleHashType::FIXED_BASE_PEDERSEN;
+    static constexpr merkle::HashType merkle_hash_type = merkle::HashType::FIXED_BASE_PEDERSEN;
+    static constexpr pedersen::CommitmentType commitment_type = pedersen::CommitmentType::FIXED_BASE_PEDERSEN;
     static constexpr size_t UINT_LOG2_BASE = 2;
 
     StandardComposer(const size_t size_hint = 0)
diff --git a/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp
index c4413ce080c..71aec400e2c 100644
--- a/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp
@@ -1,7 +1,7 @@
 #include "standard_composer.hpp"
 #include <gtest/gtest.h>
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
-#include "barretenberg/crypto/pedersen/generator_data.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/generators/generator_data.hpp"
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
 
 using namespace barretenberg;
@@ -540,4 +540,4 @@ TEST(standard_composer, test_check_circuit_broken)
     bool result = composer.check_circuit();
     EXPECT_EQ(result, false);
 }
-} // namespace proof_system::plonk
\ No newline at end of file
+} // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp b/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp
index 5f4ffda9af1..4500b899539 100644
--- a/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp
@@ -1,11 +1,14 @@
 #pragma once
 #include "composer_base.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
+#include "barretenberg/proof_system/types/pedersen_commitment_type.hpp"
 
 namespace proof_system::plonk {
 class TurboComposer : public ComposerBase {
   public:
     static constexpr ComposerType type = ComposerType::TURBO;
-    static constexpr MerkleHashType merkle_hash_type = MerkleHashType::FIXED_BASE_PEDERSEN;
+    static constexpr merkle::HashType merkle_hash_type = merkle::HashType::FIXED_BASE_PEDERSEN;
+    static constexpr pedersen::CommitmentType commitment_type = pedersen::CommitmentType::FIXED_BASE_PEDERSEN;
     static constexpr size_t UINT_LOG2_BASE = 2;
     enum TurboSelectors { QM, QC, Q1, Q2, Q3, Q4, Q5, QARITH, QFIXED, QRANGE, QLOGIC, NUM };
 
diff --git a/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp
index 14b448db485..a329384b195 100644
--- a/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp
@@ -1,11 +1,11 @@
 #include "turbo_composer.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include <gtest/gtest.h>
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
 
 using namespace barretenberg;
 using namespace proof_system;
-using namespace crypto::pedersen;
+using namespace crypto::pedersen_commitment;
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
@@ -212,8 +212,8 @@ TEST(turbo_composer, small_scalar_multipliers)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
     constexpr size_t initial_exponent = ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
     constexpr uint64_t bit_mask = (1ULL << num_bits) - 1UL;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
@@ -252,7 +252,7 @@ TEST(turbo_composer, small_scalar_multipliers)
     fr one = fr::one();
     fr three = ((one + one) + one);
     for (size_t i = 0; i < num_quads; ++i) {
-        uint64_t entry = wnaf_entries[i + 1] & crypto::pedersen::WNAF_MASK;
+        uint64_t entry = wnaf_entries[i + 1] & crypto::generators::WNAF_MASK;
         fr prev_accumulator = accumulator_transcript[i] + accumulator_transcript[i];
         prev_accumulator = prev_accumulator + prev_accumulator;
 
@@ -341,8 +341,8 @@ TEST(turbo_composer, large_scalar_multipliers)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
 
     constexpr size_t initial_exponent = num_bits; // ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
@@ -382,7 +382,7 @@ TEST(turbo_composer, large_scalar_multipliers)
     fr one = fr::one();
     fr three = ((one + one) + one);
     for (size_t i = 0; i < num_quads; ++i) {
-        uint64_t entry = wnaf_entries[i + 1] & crypto::pedersen::WNAF_MASK;
+        uint64_t entry = wnaf_entries[i + 1] & crypto::generators::WNAF_MASK;
         fr prev_accumulator = accumulator_transcript[i] + accumulator_transcript[i];
         prev_accumulator = prev_accumulator + prev_accumulator;
 
@@ -978,8 +978,8 @@ TEST(turbo_composer, test_check_circuit_fixed_group)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
 
     constexpr size_t initial_exponent = num_bits; // ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
index 7fa42ed9397..ddb4bdf0453 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
@@ -1,5 +1,7 @@
 #pragma once
 #include "composer_base.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
+#include "barretenberg/proof_system/types/pedersen_commitment_type.hpp"
 #include "plookup_tables/plookup_tables.hpp"
 #include <optional>
 
@@ -9,7 +11,8 @@ class UltraComposer : public ComposerBase {
 
   public:
     static constexpr ComposerType type = ComposerType::PLOOKUP;
-    static constexpr MerkleHashType merkle_hash_type = MerkleHashType::LOOKUP_PEDERSEN;
+    static constexpr merkle::HashType merkle_hash_type = merkle::HashType::LOOKUP_PEDERSEN;
+    static constexpr pedersen::CommitmentType commitment_type = pedersen::CommitmentType::FIXED_BASE_PEDERSEN;
     static constexpr size_t NUM_RESERVED_GATES = 4; // This must be >= num_roots_cut_out_of_vanishing_polynomial
                                                     // See the comment in plonk/proof_system/prover/prover.cpp
                                                     // ProverBase::compute_quotient_commitments() for why 4 exactly.
diff --git a/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp b/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
index 5b0f6b6ce89..8219f9183c3 100644
--- a/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
+++ b/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
@@ -1,6 +1,6 @@
 #include "barretenberg/stdlib/primitives/plookup/plookup.hpp"
 #include "ultra_composer.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include <gtest/gtest.h>
 #include "barretenberg/numeric/bitop/get_msb.hpp"
 #include "barretenberg/numeric/uintx/uintx.hpp"
@@ -49,8 +49,8 @@ TEST(ultra_composer, create_gates_from_plookup_accumulators)
     std::vector<barretenberg::fr> expected_y;
 
     const size_t num_lookups_hi =
-        (128 + crypto::pedersen::lookup::BITS_PER_TABLE) / crypto::pedersen::lookup::BITS_PER_TABLE;
-    const size_t num_lookups_lo = 126 / crypto::pedersen::lookup::BITS_PER_TABLE;
+        (128 + crypto::pedersen_hash::lookup::BITS_PER_TABLE) / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    const size_t num_lookups_lo = 126 / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
     const size_t num_lookups = num_lookups_hi + num_lookups_lo;
 
     EXPECT_EQ(num_lookups_hi, lookup_witnesses_hi[ColumnIdx::C1].size());
@@ -65,10 +65,10 @@ TEST(ultra_composer, create_gates_from_plookup_accumulators)
         const size_t num_rounds = (num_lookups + 1) / 2;
         uint256_t bits(input_value);
 
-        const auto mask = crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE - 1;
+        const auto mask = crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE - 1;
 
         for (size_t i = 0; i < num_rounds; ++i) {
-            const auto& table = crypto::pedersen::lookup::get_table(i);
+            const auto& table = crypto::pedersen_hash::lookup::get_table(i);
             const size_t index = i * 2;
 
             uint64_t slice_a = ((bits >> (index * 9)) & mask).data[0];
@@ -86,7 +86,7 @@ TEST(ultra_composer, create_gates_from_plookup_accumulators)
     }
 
     for (size_t i = num_lookups - 2; i < num_lookups; --i) {
-        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
 
     size_t hi_shift = 126;
@@ -97,7 +97,7 @@ TEST(ultra_composer, create_gates_from_plookup_accumulators)
                   expected_scalars[i]);
         EXPECT_EQ(composer.get_variable(lookup_witnesses_lo[ColumnIdx::C2][i]), expected_x[i]);
         EXPECT_EQ(composer.get_variable(lookup_witnesses_lo[ColumnIdx::C3][i]), expected_y[i]);
-        hi_shift -= crypto::pedersen::lookup::BITS_PER_TABLE;
+        hi_shift -= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
     }
 
     for (size_t i = 0; i < num_lookups_hi; ++i) {
@@ -149,9 +149,9 @@ TEST(ultra_composer, test_elliptic_gate)
     typedef grumpkin::g1::element element;
     UltraComposer composer = UltraComposer();
 
-    affine_element p1 = crypto::pedersen::get_generator_data({ 0, 0 }).generator;
+    affine_element p1 = crypto::generators::get_generator_data({ 0, 0 }).generator;
 
-    affine_element p2 = crypto::pedersen::get_generator_data({ 0, 1 }).generator;
+    affine_element p2 = crypto::generators::get_generator_data({ 0, 1 }).generator;
     affine_element p3(element(p1) + element(p2));
 
     uint32_t x1 = composer.add_variable(p1.x);
diff --git a/cpp/src/barretenberg/plonk/proof_system/constants.hpp b/cpp/src/barretenberg/plonk/proof_system/constants.hpp
index debf064c8f7..b5de8c110ae 100644
--- a/cpp/src/barretenberg/plonk/proof_system/constants.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/constants.hpp
@@ -12,11 +12,6 @@ static constexpr uint32_t SYSTEM_COMPOSER = ComposerType::TURBO;
 static constexpr uint32_t SYSTEM_COMPOSER = ComposerType::PLOOKUP;
 #endif
 
-enum MerkleHashType {
-    FIXED_BASE_PEDERSEN,
-    LOOKUP_PEDERSEN,
-};
-
 // 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;
diff --git a/cpp/src/barretenberg/plonk/proof_system/types/proof.hpp b/cpp/src/barretenberg/plonk/proof_system/types/proof.hpp
index 9d4713ccd6b..aedf516e046 100644
--- a/cpp/src/barretenberg/plonk/proof_system/types/proof.hpp
+++ b/cpp/src/barretenberg/plonk/proof_system/types/proof.hpp
@@ -1,11 +1,44 @@
 #pragma once
 #include <cstdint>
 #include <vector>
+#include <ostream>
+#include <iomanip>
+#include "barretenberg/common/serialize.hpp"
 
 namespace proof_system::plonk {
 
 struct proof {
     std::vector<uint8_t> proof_data;
+
+    bool operator==(proof const& other) const = default;
+};
+
+inline void read(uint8_t const*& it, proof& data)
+{
+    using serialize::read;
+    read(it, data.proof_data);
 };
 
-} // namespace proof_system::plonk
\ No newline at end of file
+template <typename B> inline void write(B& buf, proof const& data)
+{
+    using serialize::write;
+    write(buf, data.proof_data);
+}
+
+inline std::ostream& operator<<(std::ostream& os, proof const& data)
+{
+    // REFACTOR: This is copied from barretenberg/common/streams.hpp,
+    // which means we could just cout proof_data directly, but that breaks the build in the CI with 
+    // a redefined operator<< error in barretenberg/stdlib/hash/keccak/keccak.test.cpp,
+    // which is something we really don't want to deal with right now.
+    std::ios_base::fmtflags f(os.flags());
+    os << "[" << std::hex << std::setfill('0');
+    for (auto byte : data.proof_data) {
+        os << ' ' << std::setw(2) << +(unsigned char)byte;
+    }
+    os << " ]";
+    os.flags(f);
+    return os;
+}
+
+} // namespace proof_system::plonk
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 ef6913f184d..f6cf92bd732 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
@@ -1,9 +1,99 @@
 #include "barretenberg/crypto/sha256/sha256.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp"
+#include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "verification_key.hpp"
 #include "barretenberg/plonk/proof_system/constants.hpp"
 
 namespace proof_system::plonk {
 
+/**
+ * @brief Hashes the evaluation domain to match the 'circuit' approach taken in
+ * stdlib/recursion/verification_key/verification_key.hpp.
+ * @note: in that reference file, the circuit-equivalent of this function is a _method_ of the `evaluation_domain'
+ * struct. But we cannot do that with the native `barretenberg::evaluation_domain` type unfortunately, because it's
+ * defined in polynomials/evaluation_domain.hpp, and `polynomial` is a bberg library which does not depend on `crypto`
+ * in its CMakeLists.txt file. (We'd need `crypto` to be able to call native pedersen functions).
+ *
+ * @param domain to compress
+ * @param composer_type to use when choosing pedersen compression function
+ * @return barretenberg::fr compression of the evaluation domain as a field
+ */
+barretenberg::fr compress_native_evaluation_domain(barretenberg::evaluation_domain const& domain,
+                                                   proof_system::ComposerType composer_type)
+{
+    barretenberg::fr out;
+    if (composer_type == proof_system::ComposerType::PLOOKUP) {
+        out = crypto::pedersen_commitment::lookup::compress_native({
+            domain.root,
+            domain.domain,
+            domain.generator,
+        });
+    } else {
+        out = crypto::pedersen_commitment::compress_native({
+            domain.root,
+            domain.domain,
+            domain.generator,
+        });
+    }
+    return out;
+}
+
+/**
+ * @brief Compress the verification key data.
+ *
+ * @details Native pedersen compression of VK data that is truly core to a VK.
+ * Omits recursion proof flag and recursion input indices as they are not really
+ * core to the VK itself.
+ *
+ * @param hash_index generator index to use during pedersen compression
+ * @returns a field containing the compression
+ */
+barretenberg::fr verification_key_data::compress_native(const size_t hash_index)
+{
+    barretenberg::evaluation_domain domain = evaluation_domain(circuit_size);
+    barretenberg::fr compressed_domain =
+        compress_native_evaluation_domain(domain, proof_system::ComposerType(composer_type));
+
+    constexpr size_t num_limb_bits = plonk::NUM_LIMB_BITS_IN_FIELD_SIMULATION;
+
+    const auto split_bigfield_limbs = [](const uint256_t& element) {
+        std::vector<barretenberg::fr> limbs;
+        limbs.push_back(element.slice(0, num_limb_bits));
+        limbs.push_back(element.slice(num_limb_bits, num_limb_bits * 2));
+        limbs.push_back(element.slice(num_limb_bits * 2, num_limb_bits * 3));
+        limbs.push_back(element.slice(num_limb_bits * 3, num_limb_bits * 4));
+        return limbs;
+    };
+
+    std::vector<barretenberg::fr> preimage_data;
+    preimage_data.emplace_back(composer_type);
+    preimage_data.emplace_back(compressed_domain);
+    preimage_data.emplace_back(num_public_inputs);
+    for (const auto& [tag, selector] : commitments) {
+        const auto x_limbs = split_bigfield_limbs(selector.x);
+        const auto y_limbs = split_bigfield_limbs(selector.y);
+
+        preimage_data.push_back(x_limbs[0]);
+        preimage_data.push_back(x_limbs[1]);
+        preimage_data.push_back(x_limbs[2]);
+        preimage_data.push_back(x_limbs[3]);
+
+        preimage_data.push_back(y_limbs[0]);
+        preimage_data.push_back(y_limbs[1]);
+        preimage_data.push_back(y_limbs[2]);
+        preimage_data.push_back(y_limbs[3]);
+    }
+
+    barretenberg::fr compressed_key;
+    if (proof_system::ComposerType(composer_type) == proof_system::ComposerType::PLOOKUP) {
+        compressed_key = crypto::pedersen_commitment::lookup::compress_native(preimage_data, hash_index);
+    } else {
+        compressed_key = crypto::pedersen_commitment::compress_native(preimage_data, hash_index);
+    }
+    return compressed_key;
+}
+
 verification_key::verification_key(const size_t num_gates,
                                    const size_t num_inputs,
                                    std::shared_ptr<VerifierReferenceString> const& crs,
@@ -74,6 +164,7 @@ verification_key& verification_key::operator=(verification_key&& other)
 sha256::hash verification_key::sha256_hash()
 {
     std::vector<uint256_t> vk_data;
+    vk_data.emplace_back(composer_type);
     vk_data.emplace_back(circuit_size);
     vk_data.emplace_back(num_public_inputs);
     for (auto& commitment_entry : commitments) {
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 3d1a31a67f9..709eea6ee78 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
@@ -1,6 +1,9 @@
 #pragma once
 #include <map>
+#include "barretenberg/common/streams.hpp"
 #include "barretenberg/srs/reference_string/reference_string.hpp"
+#include "barretenberg/srs/reference_string/env_reference_string.hpp"
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "barretenberg/crypto/sha256/sha256.hpp"
 #include "barretenberg/plonk/proof_system/types/polynomial_manifest.hpp"
@@ -14,6 +17,8 @@ struct verification_key_data {
     std::map<std::string, barretenberg::g1::affine_element> commitments;
     bool contains_recursive_proof = false;
     std::vector<uint32_t> recursive_proof_public_input_indices;
+
+    barretenberg::fr compress_native(size_t const hash_index = 0);
 };
 
 template <typename B> inline void read(B& buf, verification_key_data& key)
@@ -80,6 +85,24 @@ struct verification_key {
     size_t program_width = 3;
 };
 
+template <typename B> inline void read(B& buf, verification_key& key)
+{
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+    using serialize::read;
+    verification_key_data vk_data;
+    read(buf, vk_data);
+    key = verification_key{ std::move(vk_data), env_crs->get_verifier_crs() };
+}
+
+template <typename B> inline void read(B& buf, std::shared_ptr<verification_key>& key)
+{
+    auto env_crs = std::make_unique<proof_system::EnvReferenceStringFactory>();
+    using serialize::read;
+    verification_key_data vk_data;
+    read(buf, vk_data);
+    key = std::make_shared<verification_key>(std::move(vk_data), env_crs->get_verifier_crs());
+}
+
 template <typename B> inline void write(B& buf, verification_key const& key)
 {
     using serialize::write;
@@ -91,4 +114,14 @@ template <typename B> inline void write(B& buf, verification_key const& key)
     write(buf, key.recursive_proof_public_input_indices);
 }
 
+inline std::ostream& operator<<(std::ostream& os, verification_key const& key)
+{
+    return os << "key.composer_type: " << key.composer_type << "\n"
+              << "key.circuit_size: " << static_cast<uint32_t>(key.circuit_size) << "\n"
+              << "key.num_public_inputs: " << static_cast<uint32_t>(key.num_public_inputs) << "\n"
+              << "key.commitments: " << key.commitments << "\n"
+              << "key.contains_recursive_proof: " << key.contains_recursive_proof << "\n"
+              << "key.recursive_proof_public_input_indices: " << key.recursive_proof_public_input_indices << "\n";
+};
+
 } // 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 bb049af0111..1e2a83998e1 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
@@ -1,46 +1,156 @@
 #include "barretenberg/common/test.hpp"
 #include "barretenberg/common/streams.hpp"
+#include "barretenberg/numeric/random/engine.hpp"
 #include "verification_key.hpp"
 
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+} // namespace
+
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
 namespace proof_system::plonk::test_verification_key {
 
+/**
+ * @brief generate a random vk data for use in tests
+ *
+ * @return verification_key_data randomly generated
+ */
+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
+    vk_data.num_public_inputs = engine.get_random_uint32();
+    vk_data.commitments["test1"] = g1::element::random_element();
+    vk_data.commitments["test2"] = g1::element::random_element();
+    vk_data.commitments["foo1"] = g1::element::random_element();
+    vk_data.commitments["foo2"] = g1::element::random_element();
+    return vk_data;
+}
+
+/**
+ * @brief expect that two vk data compressions are equal for a few different hash indices
+ *
+ * @param vk0_data
+ * @param vk1_data
+ */
+void expect_compressions_eq(verification_key_data vk0_data, verification_key_data vk1_data)
+{
+    // 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));
+}
+
+/**
+ * @brief expect that two vk data compressions are not-equal for a few different hash indices
+ *
+ * @param vk0_data
+ * @param vk1_data
+ */
+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));
+    // 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));
+}
+
 TEST(verification_key, buffer_serialization)
 {
-    verification_key_data key;
-    key.composer_type = static_cast<uint32_t>(ComposerType::STANDARD);
-    key.circuit_size = 1234;
-    key.num_public_inputs = 10;
-    key.commitments["test1"] = g1::element::random_element();
-    key.commitments["test2"] = g1::element::random_element();
-    key.commitments["foo1"] = g1::element::random_element();
-    key.commitments["foo2"] = g1::element::random_element();
+    verification_key_data vk_data = rand_vk_data();
 
-    auto buf = to_buffer(key);
+    auto buf = to_buffer(vk_data);
     auto result = from_buffer<verification_key_data>(buf);
 
-    EXPECT_EQ(key, result);
+    EXPECT_EQ(vk_data, result);
 }
 
 TEST(verification_key, stream_serialization)
 {
-    verification_key_data key;
-    key.composer_type = static_cast<uint32_t>(ComposerType::STANDARD);
-    key.circuit_size = 1234;
-    key.num_public_inputs = 10;
-    key.commitments["test1"] = g1::element::random_element();
-    key.commitments["test2"] = g1::element::random_element();
-    key.commitments["foo1"] = g1::element::random_element();
-    key.commitments["foo2"] = g1::element::random_element();
+    verification_key_data vk_data = rand_vk_data();
 
     std::stringstream s;
-    write(s, key);
+    write(s, vk_data);
 
     verification_key_data result;
     read(static_cast<std::istream&>(s), result);
 
-    EXPECT_EQ(key, result);
+    EXPECT_EQ(vk_data, result);
+}
+
+TEST(verification_key, basic_compression_equality)
+{
+    verification_key_data vk0_data = rand_vk_data();
+    verification_key_data vk1_data = vk0_data; // copy
+    expect_compressions_eq(vk0_data, vk1_data);
+}
+
+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));
+}
+
+TEST(verification_key, compression_inequality_composer_type)
+{
+    verification_key_data vk0_data = rand_vk_data();
+    verification_key_data vk1_data = vk0_data; // copy
+    vk0_data.composer_type = static_cast<uint32_t>(proof_system::ComposerType::PLOOKUP);
+    expect_compressions_ne(vk0_data, vk1_data);
+}
+
+TEST(verification_key, compression_inequality_different_circuit_size) \
+{
+    verification_key_data vk0_data = rand_vk_data();
+    verification_key_data vk1_data = vk0_data;
+    vk0_data.circuit_size = 4096;
+    expect_compressions_ne(vk0_data, vk1_data);
+}
+
+TEST(verification_key, compression_inequality_different_num_public_inputs) \
+{
+    verification_key_data vk0_data = rand_vk_data();
+    verification_key_data vk1_data = vk0_data;
+    vk0_data.num_public_inputs = 42;
+    expect_compressions_ne(vk0_data, vk1_data);
+}
+
+TEST(verification_key, compression_inequality_different_commitments) \
+{
+    verification_key_data vk0_data = rand_vk_data();
+    verification_key_data vk1_data = vk0_data;
+    vk0_data.commitments["test1"] = g1::element::random_element();
+    expect_compressions_ne(vk0_data, vk1_data);
+}
+
+TEST(verification_key, compression_inequality_different_num_commitments) \
+{
+    verification_key_data vk0_data = rand_vk_data();
+    verification_key_data vk1_data = vk0_data;
+    vk0_data.commitments["new"] = g1::element::random_element();
+    expect_compressions_ne(vk0_data, vk1_data);
+}
+
+TEST(verification_key, compression_equality_different_contains_recursive_proof) \
+{
+    verification_key_data vk0_data = rand_vk_data();
+    verification_key_data vk1_data = vk0_data;
+    vk0_data.contains_recursive_proof = false;
+    vk1_data.contains_recursive_proof = true;
+    expect_compressions_eq(vk0_data, vk1_data);
+}
+
+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;
+    vk1_data.recursive_proof_public_input_indices.push_back(42);
+    expect_compressions_eq(vk0_data, vk1_data);
 }
 } // namespace proof_system::plonk::test_verification_key
\ No newline at end of file
diff --git a/cpp/src/barretenberg/proof_system/CMakeLists.txt b/cpp/src/barretenberg/proof_system/CMakeLists.txt
index 3cb26213345..3a8ed4dd8b3 100644
--- a/cpp/src/barretenberg/proof_system/CMakeLists.txt
+++ b/cpp/src/barretenberg/proof_system/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(proof_system polynomials crypto_pedersen)
\ No newline at end of file
+barretenberg_module(proof_system polynomials crypto_generators)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.test.cpp b/cpp/src/barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.test.cpp
index 3dcd8dab1a3..7023a87b58b 100644
--- a/cpp/src/barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.test.cpp
+++ b/cpp/src/barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.test.cpp
@@ -1,7 +1,7 @@
 #include "standard_circuit_constructor.hpp"
 #include <gtest/gtest.h>
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
-#include "barretenberg/crypto/pedersen/generator_data.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/generators/generator_data.hpp"
 
 using namespace barretenberg;
 using namespace proof_system;
diff --git a/cpp/src/barretenberg/proof_system/circuit_constructors/turbo_circuit_constructor.test.cpp b/cpp/src/barretenberg/proof_system/circuit_constructors/turbo_circuit_constructor.test.cpp
index 1efacb4622f..37c198c7139 100644
--- a/cpp/src/barretenberg/proof_system/circuit_constructors/turbo_circuit_constructor.test.cpp
+++ b/cpp/src/barretenberg/proof_system/circuit_constructors/turbo_circuit_constructor.test.cpp
@@ -1,9 +1,10 @@
 #include "turbo_circuit_constructor.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/generators/generator_data.hpp"
+#include "barretenberg/crypto/generators/fixed_base_scalar_mul.hpp"
 #include <gtest/gtest.h>
 
 using namespace barretenberg;
-using namespace crypto::pedersen;
+using namespace crypto::generators;
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
@@ -164,8 +165,8 @@ TEST(turbo_circuit_constructor, small_scalar_multipliers)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
     constexpr size_t initial_exponent = ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
     constexpr uint64_t bit_mask = (1ULL << num_bits) - 1UL;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
@@ -204,7 +205,7 @@ TEST(turbo_circuit_constructor, small_scalar_multipliers)
     fr one = fr::one();
     fr three = ((one + one) + one);
     for (size_t i = 0; i < num_quads; ++i) {
-        uint64_t entry = wnaf_entries[i + 1] & crypto::pedersen::WNAF_MASK;
+        uint64_t entry = wnaf_entries[i + 1] & crypto::generators::WNAF_MASK;
         fr prev_accumulator = accumulator_transcript[i] + accumulator_transcript[i];
         prev_accumulator = prev_accumulator + prev_accumulator;
 
@@ -287,8 +288,8 @@ TEST(turbo_circuit_constructor, large_scalar_multipliers)
     constexpr size_t num_wnaf_bits = (num_quads << 1) + 1;
 
     constexpr size_t initial_exponent = num_bits; // ((num_bits & 1) == 1) ? num_bits - 1 : num_bits;
-    auto gen_data = crypto::pedersen::get_generator_data(DEFAULT_GEN_1);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
+    auto gen_data = crypto::generators::get_generator_data(DEFAULT_GEN_1);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_ladder(num_bits);
     grumpkin::g1::affine_element generator = gen_data.generator;
 
     grumpkin::g1::element origin_points[2];
@@ -328,7 +329,7 @@ TEST(turbo_circuit_constructor, large_scalar_multipliers)
     fr one = fr::one();
     fr three = ((one + one) + one);
     for (size_t i = 0; i < num_quads; ++i) {
-        uint64_t entry = wnaf_entries[i + 1] & crypto::pedersen::WNAF_MASK;
+        uint64_t entry = wnaf_entries[i + 1] & crypto::generators::WNAF_MASK;
         fr prev_accumulator = accumulator_transcript[i] + accumulator_transcript[i];
         prev_accumulator = prev_accumulator + prev_accumulator;
 
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 65f73f724d5..383dccb6f00 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
@@ -4,6 +4,7 @@
 #include "circuit_constructor_base.hpp"
 #include "barretenberg/plonk/proof_system/constants.hpp"
 #include "barretenberg/proof_system/flavor/flavor.hpp"
+#include "barretenberg/proof_system/types/merkle_hash_type.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/plonk/composer/plookup_tables/types.hpp"
 #include "barretenberg/plonk/composer/plookup_tables/plookup_tables.hpp"
@@ -13,7 +14,7 @@
 namespace proof_system {
 
 static constexpr ComposerType type = ComposerType::PLOOKUP;
-static constexpr plonk::MerkleHashType merkle_hash_type = plonk::MerkleHashType::LOOKUP_PEDERSEN;
+static constexpr merkle::HashType merkle_hash_type = merkle::HashType::LOOKUP_PEDERSEN;
 static constexpr size_t NUM_RESERVED_GATES = 4; // This must be >= num_roots_cut_out_of_vanishing_polynomial
                                                 // See the comment in plonk/proof_system/prover/prover.cpp
                                                 // ProverBase::compute_quotient_commitments() for why 4 exactly.
diff --git a/cpp/src/barretenberg/proof_system/types/merkle_hash_type.hpp b/cpp/src/barretenberg/proof_system/types/merkle_hash_type.hpp
new file mode 100644
index 00000000000..a04446a185a
--- /dev/null
+++ b/cpp/src/barretenberg/proof_system/types/merkle_hash_type.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace proof_system::merkle {
+// TODO(Cody) Get rid of this?
+enum HashType { FIXED_BASE_PEDERSEN, LOOKUP_PEDERSEN };
+} // namespace proof_system::merkle
\ No newline at end of file
diff --git a/cpp/src/barretenberg/proof_system/types/pedersen_commitment_type.hpp b/cpp/src/barretenberg/proof_system/types/pedersen_commitment_type.hpp
new file mode 100644
index 00000000000..aa62edc5a67
--- /dev/null
+++ b/cpp/src/barretenberg/proof_system/types/pedersen_commitment_type.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace proof_system::pedersen {
+// TODO(Cody) Get rid of this?
+enum CommitmentType { FIXED_BASE_PEDERSEN, LOOKUP_PEDERSEN };
+} // namespace proof_system::pedersen
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/CMakeLists.txt b/cpp/src/barretenberg/stdlib/CMakeLists.txt
index 22c25b1480d..c3fa01c8518 100644
--- a/cpp/src/barretenberg/stdlib/CMakeLists.txt
+++ b/cpp/src/barretenberg/stdlib/CMakeLists.txt
@@ -1,4 +1,5 @@
 add_subdirectory(hash)
+add_subdirectory(commitment)
 add_subdirectory(encryption)
 add_subdirectory(primitives)
 add_subdirectory(recursion)
diff --git a/cpp/src/barretenberg/stdlib/commitment/CMakeLists.txt b/cpp/src/barretenberg/stdlib/commitment/CMakeLists.txt
new file mode 100644
index 00000000000..e95d22b87bd
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/commitment/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(pedersen)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/commitment/pedersen/CMakeLists.txt b/cpp/src/barretenberg/stdlib/commitment/pedersen/CMakeLists.txt
new file mode 100644
index 00000000000..2ba8c141402
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/CMakeLists.txt
@@ -0,0 +1 @@
+barretenberg_module(stdlib_pedersen_commitment stdlib_primitives stdlib_pedersen_hash crypto_pedersen_commitment crypto_generators)
diff --git a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.bench.cpp b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.bench.cpp
similarity index 92%
rename from cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.bench.cpp
rename to cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.bench.cpp
index 5fd4073deae..8726b6ecc63 100644
--- a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.bench.cpp
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.bench.cpp
@@ -1,6 +1,6 @@
 #include "pedersen.hpp"
 #include <benchmark/benchmark.h>
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/plonk/composer/turbo_composer.hpp"
@@ -10,6 +10,7 @@
 #define BARRETENBERG_SRS_PATH "../srs_db/ignition"
 
 using namespace benchmark;
+using namespace proof_system::plonk;
 
 constexpr size_t NUM_CIRCUITS = 10;
 
@@ -43,7 +44,7 @@ void generate_test_pedersen_circuit(plonk::TurboComposer& turbo_composer, size_t
         plonk::stdlib::witness_t(&turbo_composer, barretenberg::fr::random_element()));
 
     for (size_t i = 0; i < num_repetitions; ++i) {
-        out = proof_system::plonk::stdlib::pedersen<plonk::TurboComposer>::compress(left, out);
+        out = proof_system::plonk::stdlib::pedersen_commitment<plonk::TurboComposer>::compress(left, out);
     }
 }
 
@@ -56,18 +57,18 @@ grumpkin::fq pedersen_function(const size_t count)
     grumpkin::fq left = grumpkin::fq::random_element();
     grumpkin::fq out = grumpkin::fq::random_element();
     for (size_t i = 0; i < count; ++i) {
-        out = crypto::pedersen::compress_native({ left, out });
+        out = crypto::pedersen_commitment::compress_native({ left, out });
     }
     return out;
 }
-void native_pedersen_hash_bench(State& state) noexcept
+void native_pedersen_commitment_bench(State& state) noexcept
 {
     for (auto _ : state) {
         const size_t count = (static_cast<size_t>(state.range(0)));
         (pedersen_function(count));
     }
 }
-BENCHMARK(native_pedersen_hash_bench)
+BENCHMARK(native_pedersen_commitment_bench)
     ->Arg(num_hashes[0])
     ->Arg(num_hashes[1])
     ->Arg(num_hashes[2])
@@ -86,7 +87,7 @@ void native_pedersen_eight_hash_bench(State& state) noexcept
         elements[i] = grumpkin::fq::random_element();
     }
     for (auto _ : state) {
-        crypto::pedersen::compress_native(elements);
+        crypto::pedersen_commitment::compress_native(elements);
     }
 }
 BENCHMARK(native_pedersen_eight_hash_bench)->MinTime(3);
@@ -97,7 +98,7 @@ void construct_pedersen_witnesses_bench(State& state) noexcept
         plonk::TurboComposer composer =
             plonk::TurboComposer(BARRETENBERG_SRS_PATH, static_cast<size_t>(state.range(0)));
         generate_test_pedersen_circuit(composer, static_cast<size_t>(state.range(0)));
-        std::cout << "composer gates = " << composer.num_gates << std::endl;
+        std::cout << "composer gates = " << composer.get_num_gates() << std::endl;
         composer.compute_witness();
     }
 }
diff --git a/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.cpp b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.cpp
new file mode 100644
index 00000000000..57dbc02e621
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.cpp
@@ -0,0 +1,140 @@
+#include "pedersen.hpp"
+#include "pedersen_plookup.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "../../hash/pedersen/pedersen.hpp"
+
+#include "../../primitives/composers/composers.hpp"
+#include "../../primitives/packed_byte_array/packed_byte_array.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+
+using namespace barretenberg;
+using namespace crypto::pedersen_commitment;
+
+template <typename C>
+point<C> pedersen_commitment<C>::commit(const std::vector<field_t>& inputs, const size_t hash_index)
+{
+    if constexpr (C::type == ComposerType::PLOOKUP && C::commitment_type == pedersen::CommitmentType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_commitment<C>::commit(inputs, hash_index);
+    }
+
+    std::vector<point> to_accumulate;
+    for (size_t i = 0; i < inputs.size(); ++i) {
+        generator_index_t index = { hash_index, i };
+        to_accumulate.push_back(pedersen_hash<C>::commit_single(inputs[i], index));
+    }
+    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 == ComposerType::PLOOKUP && C::commitment_type == 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 == ComposerType::PLOOKUP && C::commitment_type == 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
+ */
+template <typename C>
+field_t<C> pedersen_commitment<C>::compress_unsafe(const field_t& in_left,
+                                                   const field_t& in_right,
+                                                   const size_t hash_index,
+                                                   const bool validate_input_is_in_field)
+{
+    if constexpr (C::type == ComposerType::PLOOKUP && C::commitment_type == pedersen::CommitmentType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_commitment<C>::compress({ in_left, in_right });
+    }
+
+    std::vector<point> accumulators;
+    generator_index_t index_1 = { hash_index, 0 };
+    generator_index_t index_2 = { hash_index, 1 };
+    accumulators.push_back(pedersen_hash<C>::commit_single(in_left, index_1, validate_input_is_in_field));
+    accumulators.push_back(pedersen_hash<C>::commit_single(in_right, index_2, validate_input_is_in_field));
+    return pedersen_hash<C>::accumulate(accumulators).x;
+}
+
+/**
+ * Compress a vector of scalars with a given hash index.
+ */
+template <typename C>
+field_t<C> pedersen_commitment<C>::compress(const std::vector<field_t>& inputs, const size_t hash_index)
+{
+    if constexpr (C::type == ComposerType::PLOOKUP && C::commitment_type == pedersen::CommitmentType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_commitment<C>::compress(inputs, hash_index);
+    }
+
+    return commit(inputs, hash_index).x;
+}
+
+/**
+ * Compress a byte_array.
+ *
+ * If the input values are all zero, we return the array length instead of "0\"
+ * This is because we require the inputs to regular pedersen compression function are nonzero (we use this method to
+ * hash the base layer of our merkle trees)
+ */
+template <typename C> field_t<C> pedersen_commitment<C>::compress(const byte_array& input)
+{
+    const size_t num_bytes = input.size();
+    const size_t bytes_per_element = 31;
+    size_t num_elements = (num_bytes % bytes_per_element != 0) + (num_bytes / bytes_per_element);
+
+    std::vector<field_t> elements;
+    for (size_t i = 0; i < num_elements; ++i) {
+        size_t bytes_to_slice = 0;
+        if (i == num_elements - 1) {
+            bytes_to_slice = num_bytes - (i * bytes_per_element);
+        } else {
+            bytes_to_slice = bytes_per_element;
+        }
+        field_t element = static_cast<field_t>(input.slice(i * bytes_per_element, bytes_to_slice));
+        elements.emplace_back(element);
+    }
+    field_t compressed = compress(elements, 0);
+
+    bool_t is_zero(true);
+    for (const auto& element : elements) {
+        is_zero = is_zero && element.is_zero();
+    }
+
+    field_t output = field_t::conditional_assign(is_zero, field_t(num_bytes), compressed);
+    return output;
+}
+
+INSTANTIATE_STDLIB_TYPE(pedersen_commitment);
+
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.hpp b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.hpp
new file mode 100644
index 00000000000..36ba3cab499
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.hpp
@@ -0,0 +1,59 @@
+#pragma once
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "../../primitives/composers/composers_fwd.hpp"
+#include "../../primitives/field/field.hpp"
+#include "../../primitives/point/point.hpp"
+#include "../../primitives/byte_array/byte_array.hpp"
+
+using namespace crypto::generators;
+
+namespace proof_system::plonk {
+namespace stdlib {
+
+constexpr uint64_t WNAF_MASK = crypto::generators::WNAF_MASK;
+
+template <typename ComposerContext> class pedersen_commitment {
+  private:
+    typedef stdlib::field_t<ComposerContext> field_t;
+    typedef stdlib::point<ComposerContext> point;
+    typedef stdlib::byte_array<ComposerContext> byte_array;
+    typedef 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<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,
+                                   const bool validate_input_is_in_field);
+
+    static field_t compress(const field_t& left, const field_t& right, const size_t hash_index = 0)
+    {
+        return compress_unsafe(left, right, hash_index, true);
+    }
+
+    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());
+        return compress(in);
+    }
+
+    static field_t compress(const byte_array& inputs);
+};
+
+EXTERN_STDLIB_TYPE(pedersen_commitment);
+
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.test.cpp b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp
similarity index 68%
rename from cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.test.cpp
rename to cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp
index 5450ab5b8f7..8f048015406 100644
--- a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.test.cpp
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp
@@ -1,7 +1,7 @@
 #include "pedersen.hpp"
 #include "pedersen_plookup.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
-#include "barretenberg/crypto/pedersen/pedersen_lookup.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
 #include "barretenberg/common/test.hpp"
@@ -21,7 +21,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
     typedef typename curve::fr_ct fr_ct;
     typedef typename curve::witness_ct witness_ct;
     typedef typename curve::public_witness_ct public_witness_ct;
-    typedef typename stdlib::pedersen<Composer> pedersen;
+    typedef typename stdlib::pedersen_commitment<Composer> pedersen_commitment;
 
   public:
     static grumpkin::g1::element pedersen_recover(const fr& left_in, const fr& right_in)
@@ -70,10 +70,10 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
                                           compute_split_scalar(&right_wnafs[126], 2) };
 
         grumpkin::g1::affine_element grumpkin_points[4]{
-            crypto::pedersen::get_generator_data(crypto::pedersen::DEFAULT_GEN_1).generator,
-            crypto::pedersen::get_generator_data(crypto::pedersen::DEFAULT_GEN_1).aux_generator,
-            crypto::pedersen::get_generator_data(crypto::pedersen::DEFAULT_GEN_2).generator,
-            crypto::pedersen::get_generator_data(crypto::pedersen::DEFAULT_GEN_2).aux_generator,
+            crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_1).generator,
+            crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_1).aux_generator,
+            crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_2).generator,
+            crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_2).aux_generator,
         };
 
         grumpkin::g1::element result_points[4]{
@@ -91,12 +91,12 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
 
         if (left_skew) {
             grumpkin::g1::affine_element left_skew_gen =
-                crypto::pedersen::get_generator_data(crypto::pedersen::DEFAULT_GEN_1).skew_generator;
+                crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_1).skew_generator;
             hash_output_left -= left_skew_gen;
         }
         if (right_skew) {
             grumpkin::g1::affine_element right_skew_gen =
-                crypto::pedersen::get_generator_data(crypto::pedersen::DEFAULT_GEN_2).skew_generator;
+                crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_2).skew_generator;
             hash_output_right -= right_skew_gen;
         }
 
@@ -154,7 +154,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         composer.fix_witness(left.witness_index, left.get_value());
         composer.fix_witness(right.witness_index, right.get_value());
 
-        fr_ct out = pedersen::compress(left, right);
+        fr_ct out = pedersen_commitment::compress(left, right);
 
         auto prover = composer.create_prover();
 
@@ -175,7 +175,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
 
         EXPECT_EQ(out.get_value(), hash_output.x);
 
-        fr compress_native = crypto::pedersen::compress_native({ left.get_value(), right.get_value() });
+        fr compress_native = crypto::pedersen_commitment::compress_native({ left.get_value(), right.get_value() });
         EXPECT_EQ(out.get_value(), compress_native);
     }
 
@@ -195,11 +195,11 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         fr_ct r_minus_two = witness_ct(&composer, r_minus_two_fr);
         fr_ct r = witness_ct(&composer, r_fr);
 
-        fr_ct out_1_with_zero = pedersen::compress(zero, one);
-        fr_ct out_1_with_r = pedersen::compress(r, one);
-        fr_ct out_2 = pedersen::compress(r_minus_one, r_minus_two);
-        fr_ct out_with_zero = pedersen::compress(out_1_with_zero, out_2);
-        fr_ct out_with_r = pedersen::compress(out_1_with_r, out_2);
+        fr_ct out_1_with_zero = pedersen_commitment::compress(zero, one);
+        fr_ct out_1_with_r = pedersen_commitment::compress(r, one);
+        fr_ct out_2 = pedersen_commitment::compress(r_minus_one, r_minus_two);
+        fr_ct out_with_zero = pedersen_commitment::compress(out_1_with_zero, out_2);
+        fr_ct out_with_r = pedersen_commitment::compress(out_1_with_r, out_2);
 
         auto prover = composer.create_prover();
 
@@ -232,12 +232,15 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         EXPECT_EQ(r_minus_one_fr, recovered_r_minus_one);
         EXPECT_EQ(r_minus_two_fr, recovered_r_minus_two);
 
-        fr compress_native_1_with_zero = crypto::pedersen::compress_native({ zero.get_value(), one.get_value() });
-        fr compress_native_1_with_r = crypto::pedersen::compress_native({ r.get_value(), one.get_value() });
-        fr compress_native_2 = crypto::pedersen::compress_native({ r_minus_one.get_value(), r_minus_two.get_value() });
+        fr compress_native_1_with_zero =
+            crypto::pedersen_commitment::compress_native({ zero.get_value(), one.get_value() });
+        fr compress_native_1_with_r = crypto::pedersen_commitment::compress_native({ r.get_value(), one.get_value() });
+        fr compress_native_2 =
+            crypto::pedersen_commitment::compress_native({ r_minus_one.get_value(), r_minus_two.get_value() });
         fr compress_native_with_zero =
-            crypto::pedersen::compress_native({ out_1_with_zero.get_value(), out_2.get_value() });
-        fr compress_native_with_r = crypto::pedersen::compress_native({ out_1_with_r.get_value(), out_2.get_value() });
+            crypto::pedersen_commitment::compress_native({ out_1_with_zero.get_value(), out_2.get_value() });
+        fr compress_native_with_r =
+            crypto::pedersen_commitment::compress_native({ out_1_with_r.get_value(), out_2.get_value() });
 
         EXPECT_EQ(out_1_with_zero.get_value(), compress_native_1_with_zero);
         EXPECT_EQ(out_1_with_r.get_value(), compress_native_1_with_r);
@@ -264,7 +267,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         fr_ct right = witness_ct(&composer, right_in);
 
         for (size_t i = 0; i < 256; ++i) {
-            left = pedersen::compress(left, right);
+            left = pedersen_commitment::compress(left, right);
         }
 
         composer.set_public_input(left.witness_index);
@@ -292,10 +295,10 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
             input.push_back(engine.get_random_uint8());
         }
 
-        fr expected = crypto::pedersen::compress_native(input);
+        fr expected = crypto::pedersen_commitment::compress_native(input);
 
         byte_array_ct circuit_input(&composer, input);
-        auto result = pedersen::compress(circuit_input);
+        auto result = pedersen_commitment::compress(circuit_input);
 
         EXPECT_EQ(result.get_value(), expected);
 
@@ -349,9 +352,9 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
                 witnesses.push_back(witness_ct(&composer, input));
             }
 
-            barretenberg::fr expected = crypto::pedersen::compress_native(inputs);
+            barretenberg::fr expected = crypto::pedersen_commitment::compress_native(inputs);
 
-            fr_ct result = pedersen::compress(witnesses);
+            fr_ct result = pedersen_commitment::compress(witnesses);
             EXPECT_EQ(result.get_value(), expected);
         }
 
@@ -380,8 +383,8 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         }
 
         constexpr size_t hash_idx = 10;
-        grumpkin::fq expected = crypto::pedersen::compress_native(inputs, hash_idx);
-        auto result = pedersen::compress(witness_inputs, hash_idx);
+        grumpkin::fq expected = crypto::pedersen_commitment::compress_native(inputs, hash_idx);
+        auto result = pedersen_commitment::compress(witness_inputs, hash_idx);
 
         EXPECT_EQ(result.get_value(), expected);
     }
@@ -402,8 +405,8 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
             }
         }
 
-        barretenberg::fr expected = crypto::pedersen::compress_native(inputs);
-        auto result = pedersen::compress(witness_inputs);
+        barretenberg::fr expected = crypto::pedersen_commitment::compress_native(inputs);
+        auto result = pedersen_commitment::compress(witness_inputs);
 
         EXPECT_EQ(result.get_value(), expected);
     }
@@ -448,128 +451,4 @@ TYPED_TEST(stdlib_pedersen, compress_constants)
     TestFixture::test_compress_constants();
 };
 
-// Tests of Plookup-based Pedersen hash
-namespace plookup_pedersen_tests {
-typedef stdlib::field_t<plonk::UltraComposer> field_ct;
-typedef stdlib::witness_t<plonk::UltraComposer> witness_ct;
-TEST(stdlib_pedersen, test_pedersen_plookup)
-{
-    plonk::UltraComposer composer = UltraComposer();
-
-    fr left_in = fr::random_element();
-    fr right_in = fr::random_element();
-
-    field_ct left = witness_ct(&composer, left_in);
-    field_ct right = witness_ct(&composer, right_in);
-
-    field_ct result = stdlib::pedersen_plookup<plonk::UltraComposer>::compress(left, right);
-
-    fr expected = crypto::pedersen::lookup::hash_pair(left_in, right_in);
-
-    EXPECT_EQ(result.get_value(), expected);
-
-    auto prover = composer.create_prover();
-
-    printf("composer gates = %zu\n", composer.get_num_gates());
-    auto verifier = composer.create_verifier();
-
-    plonk::proof proof = prover.construct_proof();
-
-    bool proof_result = verifier.verify_proof(proof);
-    EXPECT_EQ(proof_result, true);
-}
-
-TEST(stdlib_pedersen, test_compress_many_plookup)
-{
-    plonk::UltraComposer composer = UltraComposer();
-
-    std::vector<fr> input_values{
-        fr::random_element(), fr::random_element(), fr::random_element(),
-        fr::random_element(), fr::random_element(), fr::random_element(),
-    };
-    std::vector<field_ct> inputs;
-    for (const auto& input : input_values) {
-        inputs.emplace_back(witness_ct(&composer, input));
-    }
-
-    const size_t hash_idx = 20;
-
-    field_ct result = stdlib::pedersen_plookup<plonk::UltraComposer>::compress(inputs, hash_idx);
-
-    auto expected = crypto::pedersen::lookup::compress_native(input_values, hash_idx);
-
-    EXPECT_EQ(result.get_value(), expected);
-
-    auto prover = composer.create_prover();
-
-    printf("composer gates = %zu\n", composer.get_num_gates());
-    auto verifier = composer.create_verifier();
-
-    plonk::proof proof = prover.construct_proof();
-
-    bool proof_result = verifier.verify_proof(proof);
-    EXPECT_EQ(proof_result, true);
-}
-
-TEST(stdlib_pedersen, test_merkle_damgard_compress_plookup)
-{
-    plonk::UltraComposer composer = UltraComposer();
-
-    std::vector<fr> input_values{
-        fr::random_element(), fr::random_element(), fr::random_element(),
-        fr::random_element(), fr::random_element(), fr::random_element(),
-    };
-    std::vector<field_ct> inputs;
-    for (const auto& input : input_values) {
-        inputs.emplace_back(witness_ct(&composer, input));
-    }
-    field_ct iv = witness_ct(&composer, fr(10));
-
-    auto result = stdlib::pedersen_plookup<plonk::UltraComposer>::merkle_damgard_compress(inputs, iv);
-
-    auto expected = crypto::pedersen::lookup::merkle_damgard_compress(input_values, 10);
-
-    EXPECT_EQ(result.x.get_value(), expected.normalize().x);
-    EXPECT_EQ(result.y.get_value(), expected.normalize().y);
-
-    auto prover = composer.create_prover();
-
-    printf("composer gates = %zu\n", composer.get_num_gates());
-    auto verifier = composer.create_verifier();
-
-    plonk::proof proof = prover.construct_proof();
-
-    bool proof_result = verifier.verify_proof(proof);
-    EXPECT_EQ(proof_result, true);
-}
-
-TEST(stdlib_pedersen, test_merkle_damgard_compress_plookup_zero_one)
-{
-    plonk::UltraComposer composer = plonk::UltraComposer();
-
-    std::vector<fr> input_values{ 0, 1 };
-    std::vector<field_ct> inputs;
-    for (const auto& input : input_values) {
-        inputs.emplace_back(witness_ct(&composer, input));
-    }
-    field_ct iv = witness_ct(&composer, fr(10));
-
-    auto result = stdlib::pedersen_plookup<plonk::UltraComposer>::merkle_damgard_compress(inputs, iv);
-
-    auto expected = crypto::pedersen::lookup::merkle_damgard_compress(input_values, 10);
-
-    EXPECT_EQ(result.x.get_value(), expected.normalize().x);
-    EXPECT_EQ(result.y.get_value(), expected.normalize().y);
-
-    auto prover = composer.create_prover();
-
-    printf("composer gates = %zu\n", composer.get_num_gates());
-    auto verifier = composer.create_verifier();
-
-    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/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.cpp b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.cpp
new file mode 100644
index 00000000000..7d3bdc0950e
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.cpp
@@ -0,0 +1,145 @@
+#include "pedersen_plookup.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "../../hash/pedersen/pedersen_plookup.hpp"
+
+#include "barretenberg/plonk/composer/plookup_tables/types.hpp"
+#include "../../primitives/composers/composers.hpp"
+#include "../../primitives/plookup/plookup.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+
+using namespace barretenberg;
+
+template <typename C>
+point<C> pedersen_plookup_commitment<C>::compress_to_point(const field_t& left, const field_t& right)
+{
+    auto p2 = pedersen_plookup_hash<C>::hash_single(left, false);
+    auto p1 = pedersen_plookup_hash<C>::hash_single(right, true);
+
+    return pedersen_plookup_hash<C>::add_points(p1, p2);
+}
+
+template <typename C> field_t<C> pedersen_plookup_commitment<C>::compress(const field_t& left, const field_t& right)
+{
+    return compress_to_point(left, right).x;
+}
+
+template <typename C>
+point<C> pedersen_plookup_commitment<C>::merkle_damgard_compress(const std::vector<field_t>& inputs, const field_t& iv)
+{
+    if (inputs.size() == 0) {
+        return point{ 0, 0 };
+    }
+
+    auto result = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_IV, iv)[ColumnIdx::C2][0];
+    auto num_inputs = inputs.size();
+    for (size_t i = 0; i < num_inputs; i++) {
+        result = compress(result, inputs[i]);
+    }
+
+    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<UltraComposer>;
+
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp
new file mode 100644
index 00000000000..42cc8252d23
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp
@@ -0,0 +1,43 @@
+#pragma once
+#include "../../primitives/composers/composers_fwd.hpp"
+#include "../../primitives/field/field.hpp"
+#include "../../primitives/point/point.hpp"
+#include "../../primitives/packed_byte_array/packed_byte_array.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+
+template <typename ComposerContext> class pedersen_plookup_commitment {
+  private:
+    typedef stdlib::field_t<ComposerContext> field_t;
+    typedef stdlib::point<ComposerContext> point;
+    typedef stdlib::packed_byte_array<ComposerContext> packed_byte_array;
+    typedef 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);
+
+    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());
+        return compress(in);
+    }
+
+    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);
+};
+
+extern template class pedersen_plookup_commitment<UltraComposer>;
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.test.cpp b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
new file mode 100644
index 00000000000..fc06cd25052
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
@@ -0,0 +1,183 @@
+#include "pedersen.hpp"
+#include "pedersen_plookup.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp"
+#include "barretenberg/crypto/pedersen_hash/pedersen_lookup.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "barretenberg/common/test.hpp"
+#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
+
+namespace test_stdlib_pedersen {
+using namespace barretenberg;
+using namespace proof_system::plonk;
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+
+namespace plookup_pedersen_tests {
+typedef stdlib::field_t<UltraComposer> field_ct;
+typedef stdlib::witness_t<UltraComposer> witness_ct;
+TEST(stdlib_pedersen, test_pedersen_plookup)
+{
+    UltraComposer composer = UltraComposer();
+
+    fr left_in = fr::random_element();
+    fr right_in = fr::random_element();
+
+    field_ct left = witness_ct(&composer, left_in);
+    field_ct right = witness_ct(&composer, right_in);
+
+    field_ct result = stdlib::pedersen_plookup_commitment<UltraComposer>::compress(left, right);
+
+    fr expected = crypto::pedersen_hash::lookup::hash_pair(left_in, right_in);
+
+    EXPECT_EQ(result.get_value(), expected);
+
+    auto prover = composer.create_prover();
+
+    printf("composer gates = %zu\n", composer.get_num_gates());
+    auto verifier = composer.create_verifier();
+
+    auto proof = prover.construct_proof();
+
+    bool proof_result = verifier.verify_proof(proof);
+    EXPECT_EQ(proof_result, true);
+}
+
+TEST(stdlib_pedersen, test_compress_many_plookup)
+{
+    UltraComposer composer = UltraComposer();
+
+    std::vector<fr> input_values{
+        fr::random_element(), fr::random_element(), fr::random_element(),
+        fr::random_element(), fr::random_element(), fr::random_element(),
+    };
+    std::vector<field_ct> inputs;
+    for (const auto& input : input_values) {
+        inputs.emplace_back(witness_ct(&composer, input));
+    }
+
+    const size_t hash_idx = 20;
+
+    field_ct result = stdlib::pedersen_plookup_commitment<UltraComposer>::compress(inputs, hash_idx);
+
+    auto expected = crypto::pedersen_commitment::lookup::compress_native(input_values, hash_idx);
+
+    EXPECT_EQ(result.get_value(), expected);
+
+    auto prover = composer.create_prover();
+
+    printf("composer gates = %zu\n", composer.get_num_gates());
+    auto verifier = composer.create_verifier();
+
+    auto proof = prover.construct_proof();
+
+    bool proof_result = verifier.verify_proof(proof);
+    EXPECT_EQ(proof_result, true);
+}
+
+TEST(stdlib_pedersen, test_merkle_damgard_compress_plookup)
+{
+    UltraComposer composer = UltraComposer();
+
+    std::vector<fr> input_values{
+        fr::random_element(), fr::random_element(), fr::random_element(),
+        fr::random_element(), fr::random_element(), fr::random_element(),
+    };
+    std::vector<field_ct> inputs;
+    for (const auto& input : input_values) {
+        inputs.emplace_back(witness_ct(&composer, input));
+    }
+    field_ct iv = witness_ct(&composer, fr(10));
+
+    field_ct result = stdlib::pedersen_plookup_commitment<UltraComposer>::merkle_damgard_compress(inputs, iv).x;
+
+    auto expected = crypto::pedersen_commitment::lookup::merkle_damgard_compress(input_values, 10);
+
+    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();
+
+    auto proof = prover.construct_proof();
+
+    bool proof_result = verifier.verify_proof(proof);
+    EXPECT_EQ(proof_result, true);
+}
+
+TEST(stdlib_pedersen, test_merkle_damgard_compress_multiple_iv_plookup)
+{
+    UltraComposer composer = 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<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();
+
+    auto 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)
+{
+    UltraComposer composer = 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<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();
+
+    auto 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/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
index c6ab50fbae2..1864557af40 100644
--- a/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
+++ b/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "barretenberg/crypto/ecdsa/ecdsa.hpp"
 #include "../../primitives/byte_array/byte_array.hpp"
 #include "../../primitives/composers/composers_fwd.hpp"
 
@@ -16,6 +17,20 @@ template <typename Composer, typename Curve, typename Fq, typename Fr, typename
 bool_t<Composer> verify_signature(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)
+{
+    std::vector<uint8_t> r_vec(std::begin(input.r), std::end(input.r));
+    std::vector<uint8_t> s_vec(std::begin(input.s), std::end(input.s));
+    stdlib::byte_array<Composer> r(ctx, r_vec);
+    stdlib::byte_array<Composer> s(ctx, s_vec);
+    signature<Composer> out;
+    out.r = r;
+    out.s = s;
+    return out;
+}
+
 } // namespace ecdsa
 } // namespace stdlib
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/stdlib/encryption/schnorr/CMakeLists.txt b/cpp/src/barretenberg/stdlib/encryption/schnorr/CMakeLists.txt
index 20a100dff1b..d200b786aea 100644
--- a/cpp/src/barretenberg/stdlib/encryption/schnorr/CMakeLists.txt
+++ b/cpp/src/barretenberg/stdlib/encryption/schnorr/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(stdlib_schnorr stdlib_pedersen stdlib_blake2s stdlib_primitives)
\ No newline at end of file
+barretenberg_module(stdlib_schnorr stdlib_pedersen_commitment stdlib_blake2s stdlib_primitives)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.cpp b/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.cpp
index 86f419095c6..acf8024cc38 100644
--- a/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.cpp
+++ b/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.cpp
@@ -1,8 +1,9 @@
 #include "schnorr.hpp"
 #include <array>
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/stdlib/hash/blake2s/blake2s.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
 
 #include "../../primitives/composers/composers.hpp"
 
@@ -161,7 +162,7 @@ point<C> variable_base_mul(const point<C>& pub_key, const point<C>& current_accu
 
     // Various elliptic curve point additions that follow assume that the two points are distinct and not mutually
     // inverse. collision_offset is chosen to prevent a malicious prover from exploiting this assumption.
-    grumpkin::g1::affine_element collision_offset = crypto::pedersen::get_generator_data(DEFAULT_GEN_1).generator;
+    grumpkin::g1::affine_element collision_offset = crypto::generators::get_generator_data(DEFAULT_GEN_1).generator;
     grumpkin::g1::affine_element collision_end = collision_offset * grumpkin::fr(uint256_t(1) << 129);
 
     const bool init = current_accumulator.x.get_value() == pub_key.x.get_value();
@@ -290,7 +291,7 @@ std::array<field_t<C>, 2> verify_signature_internal(const byte_array<C>& message
 
     // build input (pedersen(([s]g + [e]pub).x | pub.x | pub.y) | message) to hash function
     // pedersen hash ([r].x | pub.x) to make sure the size of `hash_input` is <= 64 bytes for a 32 byte message
-    byte_array<C> hash_input(stdlib::pedersen<C>::compress({ x_3, pub_key.x, pub_key.y }));
+    byte_array<C> hash_input(stdlib::pedersen_commitment<C>::compress({ x_3, pub_key.x, pub_key.y }));
     hash_input.write(message);
 
     // compute  e' = hash(([s]g + [e]pub).x | message)
diff --git a/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp b/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
index 08ae0dc9831..aa4457a72ef 100644
--- a/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
+++ b/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
@@ -1,5 +1,5 @@
 #include "schnorr.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include <gtest/gtest.h>
 #include "barretenberg/stdlib/types/types.hpp"
diff --git a/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp b/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp
index 583bd87db4c..bda929ee239 100644
--- a/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp
+++ b/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp
@@ -1,6 +1,7 @@
 #include "blake3s.hpp"
 #include "blake3s_plookup.hpp"
 #include "barretenberg/crypto/blake3s/blake3s.hpp"
+#include "barretenberg/common/streams.hpp"
 #include <gtest/gtest.h>
 #include "barretenberg/plonk/composer/turbo_composer.hpp"
 #include "barretenberg/plonk/composer/ultra_composer.hpp"
@@ -14,18 +15,6 @@ 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;
 
-namespace std {
-inline std::ostream& operator<<(std::ostream& os, std::vector<uint8_t> const& t)
-{
-    os << "[ ";
-    for (auto e : t) {
-        os << std::setfill('0') << std::hex << std::setw(2) << (int)e << " ";
-    }
-    os << "]";
-    return os;
-}
-} // namespace std
-
 TEST(stdlib_blake3s, test_single_block)
 {
     Composer composer = Composer();
diff --git a/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp b/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp
index 589d14dd0e9..62f54e52835 100644
--- a/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp
+++ b/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp
@@ -18,18 +18,6 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-namespace std {
-inline std::ostream& operator<<(std::ostream& os, std::vector<uint8_t> const& t)
-{
-    os << "[ ";
-    for (auto e : t) {
-        os << std::setfill('0') << std::hex << std::setw(2) << (int)e << " ";
-    }
-    os << "]";
-    return os;
-}
-} // namespace std
-
 TEST(stdlib_keccak, keccak_format_input_table)
 {
     Composer composer = Composer();
diff --git a/cpp/src/barretenberg/stdlib/hash/pedersen/CMakeLists.txt b/cpp/src/barretenberg/stdlib/hash/pedersen/CMakeLists.txt
index 66047381bee..c4504582a27 100644
--- a/cpp/src/barretenberg/stdlib/hash/pedersen/CMakeLists.txt
+++ b/cpp/src/barretenberg/stdlib/hash/pedersen/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(stdlib_pedersen stdlib_primitives crypto_pedersen)
+barretenberg_module(stdlib_pedersen_hash stdlib_primitives crypto_pedersen_commitment crypto_generators)
diff --git a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
index d0ebf02f5a8..719e0e38885 100644
--- a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
+++ b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
@@ -1,35 +1,16 @@
 #include "pedersen.hpp"
 #include "pedersen_plookup.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
-#include "pedersen_gates.hpp"
-
 #include "../../primitives/composers/composers.hpp"
-#include "../../primitives/packed_byte_array/packed_byte_array.hpp"
+#include "pedersen_gates.hpp"
 
 namespace proof_system::plonk {
 namespace stdlib {
 
 using namespace barretenberg;
-using namespace crypto::pedersen;
+using namespace crypto::pedersen_hash;
 using namespace proof_system;
 
-namespace {
-/**
- * Adds two group elements using elliptic curve addition.
- **/
-template <typename C> point<C> add_points(const point<C>& first, const point<C>& second)
-{
-    field_t<C> lhs = second.y - first.y;
-    field_t<C> rhs = second.x - first.x;
-    // since we are adding multiples of different generators, creating a zero denum is as hard as DL
-    field_t<C> lambda = lhs.divide_no_zero_check(rhs);
-    field_t<C> x_3 = lambda * lambda - second.x - first.x;
-    field_t<C> y_3 = lambda * (first.x - x_3) - first.y;
-    return { x_3, y_3 };
-}
-} // namespace
-
 /**
  * Description of function:
  * We begin with an fr element `in`, and create a wnaf representation of it (see validate_wnaf_is_in_field for detail on
@@ -58,16 +39,15 @@ template <typename C> point<C> add_points(const point<C>& first, const point<C>&
  * Full documentation: https://hackmd.io/gRsmqUGkSDOCI9O22qWXBA?view
  **/
 template <typename C>
-point<C> pedersen<C>::hash_single(const field_t& in,
-                                  const generator_index_t hash_index,
-                                  const bool validate_input_is_in_field)
+point<C> pedersen_hash<C>::hash_single_internal(const field_t& in,
+                                                const generator_index_t hash_index,
+                                                const bool validate_input_is_in_field)
 {
     C* ctx = in.context;
-
     field_t scalar = in.normalize();
 
     if (in.is_constant()) {
-        const auto hash_native = crypto::pedersen::hash_single(in.get_value(), hash_index).normalize();
+        const auto hash_native = crypto::pedersen_hash::hash_single(in.get_value(), hash_index).normalize();
         return { field_t(ctx, hash_native.x), field_t(ctx, hash_native.y) };
     }
 
@@ -83,8 +63,8 @@ point<C> pedersen<C>::hash_single(const field_t& in,
     //   initial_exponent = ((num_bits & 1) == 1) ? num_bits - 1: num_bits;
     // this may require updating the logic around accumulator_offset
     constexpr size_t initial_exponent = num_bits;
-    const auto gen_data = crypto::pedersen::get_generator_data(hash_index);
-    const crypto::pedersen::fixed_base_ladder* ladder = gen_data.get_hash_ladder(num_bits);
+    const auto gen_data = crypto::generators::get_generator_data(hash_index);
+    const crypto::generators::fixed_base_ladder* ladder = gen_data.get_hash_ladder(num_bits);
     grumpkin::g1::affine_element skew_generator = gen_data.skew_generator;
 
     // Here n = num_quads = 127.
@@ -226,7 +206,8 @@ point<C> pedersen<C>::hash_single(const field_t& in,
             gates.create_fixed_group_add_gate(round_quad);
         } else {
             if constexpr (C::type == ComposerType::PLOOKUP &&
-                          C::merkle_hash_type == MerkleHashType::FIXED_BASE_PEDERSEN) {
+                          (C::merkle_hash_type == merkle::HashType::FIXED_BASE_PEDERSEN ||
+                           C::commitment_type == pedersen::CommitmentType::FIXED_BASE_PEDERSEN)) {
                 /* In TurboComposer, the selector q_5 is used to show that w_1 and w_2 are properly initialized to the
                  * coordinates of P_s = (-s + 4^n)[g]. In UltraPlonK, we have removed q_5 for overall efficiency (it
                  * would only be used here in this gate), but this presents us a cost in the present circuit: we must
@@ -291,6 +272,40 @@ point<C> pedersen<C>::hash_single(const field_t& in,
     return result;
 }
 
+/**
+ * Compute pedersen hash of the field element `in` using either lookup tables or its WNAF representation.
+ *
+ * Full documentation: https://hackmd.io/gRsmqUGkSDOCI9O22qWXBA?view
+ **/
+template <typename C>
+point<C> pedersen_hash<C>::hash_single(const field_t& in,
+                                       const generator_index_t hash_index,
+                                       const bool validate_input_is_in_field)
+{
+    if constexpr (C::type == ComposerType::PLOOKUP && C::merkle_hash_type == merkle::HashType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_hash<C>::hash_single(in, hash_index.index == 0);
+    }
+
+    return pedersen_hash<C>::hash_single_internal(in, hash_index, validate_input_is_in_field);
+}
+
+/**
+ * Subsidiary function used by the Pedersen commitment gadget to "hash" a field element.
+ *
+ * Full documentation: https://hackmd.io/gRsmqUGkSDOCI9O22qWXBA?view
+ **/
+template <typename C>
+point<C> pedersen_hash<C>::commit_single(const field_t& in,
+                                         const generator_index_t hash_index,
+                                         const bool validate_input_is_in_field)
+{
+    if constexpr (C::type == ComposerType::PLOOKUP && C::commitment_type == pedersen::CommitmentType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_hash<C>::hash_single(in, hash_index.index == 0);
+    }
+
+    return pedersen_hash<C>::hash_single_internal(in, hash_index, validate_input_is_in_field);
+}
+
 /**
  * Check the wnaf sum is smaller than the circuit modulus
  *
@@ -304,7 +319,7 @@ point<C> pedersen<C>::hash_single(const field_t& in,
  *
  * Total cost is ~36 gates
  **/
-template <typename C> void pedersen<C>::validate_wnaf_is_in_field(C* ctx, const std::vector<uint32_t>& accumulator)
+template <typename C> void pedersen_hash<C>::validate_wnaf_is_in_field(C* ctx, const std::vector<uint32_t>& accumulator)
 {
     /**
      * To validate that `w < r`, we use schoolbook subtraction
@@ -498,7 +513,24 @@ template <typename C> void pedersen<C>::validate_wnaf_is_in_field(C* ctx, const
     y_hi.create_range_constraint(128, "pedersen: range constraint on y_lo fails in validate_wnaf_is_in_field");
 }
 
-template <typename C> point<C> pedersen<C>::accumulate(const std::vector<point>& to_accumulate)
+/**
+ * Adds two group elements using elliptic curve addition.
+ **/
+template <typename C> point<C> pedersen_hash<C>::add_points(const point& first, const point& second)
+{
+    field_t lhs = second.y - first.y;
+    field_t rhs = second.x - first.x;
+    // since we are adding multiples of different generators, creating a zero denum is as hard as DL
+    field_t lambda = lhs.divide_no_zero_check(rhs);
+    field_t x_3 = lambda * lambda - second.x - first.x;
+    field_t y_3 = lambda * (first.x - x_3) - first.y;
+    return { x_3, y_3 };
+}
+
+/**
+ * Accumulate a set of group elements using simple elliptic curve addition.
+ */
+template <typename C> point<C> pedersen_hash<C>::accumulate(const std::vector<point>& to_accumulate)
 {
     if (to_accumulate.size() == 0) {
         return point{ 0, 0 };
@@ -511,70 +543,25 @@ template <typename C> point<C> pedersen<C>::accumulate(const std::vector<point>&
     return accumulator;
 }
 
-// called unsafe because allowing the option of not validating the input elements are unique, i.e. <r
 template <typename C>
-field_t<C> pedersen<C>::compress_unsafe(const field_t& in_left,
-                                        const field_t& in_right,
-                                        const size_t hash_index,
-                                        const bool validate_input_is_in_field)
+field_t<C> pedersen_hash<C>::hash_multiple(const std::vector<field_t>& inputs,
+                                           const size_t hash_index,
+                                           const bool validate_inputs_in_field)
 {
-    std::vector<point> accumulators;
-    generator_index_t index_1 = { hash_index, 0 };
-    generator_index_t index_2 = { hash_index, 1 };
-    accumulators.push_back(hash_single(in_left, index_1, validate_input_is_in_field));
-    accumulators.push_back(hash_single(in_right, index_2, validate_input_is_in_field));
-    return accumulate(accumulators).x;
-}
+    if constexpr (C::type == ComposerType::PLOOKUP && C::merkle_hash_type == merkle::HashType::LOOKUP_PEDERSEN) {
+        return pedersen_plookup_hash<C>::hash_multiple(inputs, hash_index);
+    }
 
-template <typename C> point<C> pedersen<C>::commit(const std::vector<field_t>& inputs, const size_t hash_index)
-{
     std::vector<point> to_accumulate;
     for (size_t i = 0; i < inputs.size(); ++i) {
         generator_index_t index = { hash_index, i };
-        to_accumulate.push_back(hash_single(inputs[i], index));
-    }
-    return accumulate(to_accumulate);
-}
-
-template <typename C> field_t<C> pedersen<C>::compress(const std::vector<field_t>& inputs, const size_t hash_index)
-{
-    return commit(inputs, hash_index).x;
-}
-
-// If the input values are all zero, we return the array length instead of `0\`
-// This is because we require the inputs to regular pedersen compression function are nonzero (we use this method to
-// hash the base layer of our merkle trees)
-template <typename C> field_t<C> pedersen<C>::compress(const byte_array& input)
-{
-    const size_t num_bytes = input.size();
-    const size_t bytes_per_element = 31;
-    size_t num_elements = (num_bytes % bytes_per_element != 0) + (num_bytes / bytes_per_element);
-
-    std::vector<field_t> elements;
-    for (size_t i = 0; i < num_elements; ++i) {
-        size_t bytes_to_slice = 0;
-        if (i == num_elements - 1) {
-            bytes_to_slice = num_bytes - (i * bytes_per_element);
-        } else {
-            bytes_to_slice = bytes_per_element;
-        }
-        field_t element = static_cast<field_t>(input.slice(i * bytes_per_element, bytes_to_slice));
-        elements.emplace_back(element);
+        to_accumulate.push_back(pedersen_hash<C>::hash_single(inputs[i], index, validate_inputs_in_field));
     }
-    field_t compressed = compress(elements, 0);
-
-    bool_t is_zero(true);
-    for (const auto& element : elements) {
-        is_zero = is_zero && element.is_zero();
-    }
-
-    field_t output = field_t::conditional_assign(is_zero, field_t(num_bytes), compressed);
-    return output;
+    point result = pedersen_hash<C>::accumulate(to_accumulate);
+    return result.x;
 }
 
-template class pedersen<plonk::StandardComposer>;
-template class pedersen<plonk::TurboComposer>;
-template class pedersen<plonk::UltraComposer>;
+INSTANTIATE_STDLIB_TYPE(pedersen_hash);
 
 } // namespace stdlib
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp
index c2cf7957ef5..9a46b85a548 100644
--- a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp
+++ b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp
@@ -1,57 +1,48 @@
 #pragma once
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_hash/pedersen.hpp"
 #include "../../primitives/composers/composers_fwd.hpp"
 #include "../../primitives/field/field.hpp"
 #include "../../primitives/point/point.hpp"
-#include "../../primitives/byte_array/byte_array.hpp"
 
 namespace proof_system::plonk {
 namespace stdlib {
 
-constexpr uint64_t WNAF_MASK = crypto::pedersen::WNAF_MASK;
+using namespace barretenberg;
+using namespace crypto::pedersen_hash;
+
+template <typename ComposerContext> class pedersen_hash {
 
-template <typename ComposerContext> class pedersen {
   private:
     typedef stdlib::field_t<ComposerContext> field_t;
     typedef stdlib::point<ComposerContext> point;
-    typedef stdlib::byte_array<ComposerContext> byte_array;
     typedef stdlib::bool_t<ComposerContext> bool_t;
 
-    static point hash_single(const field_t& in,
-                             const crypto::pedersen::generator_index_t hash_index,
-                             const bool validate_input_is_in_field = true);
-    static point accumulate(const std::vector<point>& to_accumulate);
-
-  public:
-    // called unsafe because allowing the option of not validating the input elements are unique, i.e. <r
-    static field_t compress_unsafe(const field_t& left,
-                                   const field_t& right,
-                                   const size_t hash_index,
-                                   const bool validate_input_is_in_field);
+  private:
+    static point add_points(const point& first, const point& second);
 
-    static field_t compress(const field_t& left, const field_t& right, const size_t hash_index = 0)
-    {
-        return compress_unsafe(left, right, hash_index, true);
-    }
+    static point hash_single_internal(const field_t& in,
+                                      const crypto::generators::generator_index_t hash_index,
+                                      const bool validate_input_is_in_field = true);
 
-    static field_t compress(const std::vector<field_t>& inputs, const size_t hash_index = 0);
+  public:
+    static void validate_wnaf_is_in_field(ComposerContext* ctx, const std::vector<uint32_t>& accumulator);
 
-    template <size_t T> static field_t compress(const std::array<field_t, T>& inputs)
-    {
-        std::vector<field_t> in(inputs.begin(), inputs.end());
-        return compress(in);
-    }
+    static point accumulate(const std::vector<point>& to_accumulate);
 
-    static field_t compress(const byte_array& inputs);
+    static point hash_single(const field_t& in,
+                             const crypto::generators::generator_index_t hash_index,
+                             const bool validate_input_is_in_field = true);
 
-    static void validate_wnaf_is_in_field(ComposerContext* ctx, const std::vector<uint32_t>& accumulator);
+    static point commit_single(const field_t& in,
+                               const crypto::generators::generator_index_t hash_index,
+                               const bool validate_input_is_in_field = true);
 
-    static point commit(const std::vector<field_t>& inputs, const size_t hash_index = 0);
+    static field_t hash_multiple(const std::vector<field_t>& in,
+                                 const size_t hash_index = 0,
+                                 const bool validate_inputs_in_field = true);
 };
 
-extern template class pedersen<plonk::StandardComposer>;
-extern template class pedersen<plonk::TurboComposer>;
-extern template class pedersen<plonk::UltraComposer>;
+EXTERN_STDLIB_TYPE(pedersen_hash);
 
 } // namespace stdlib
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp
index d7c062d77f2..d55161447a9 100644
--- a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp
+++ b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp
@@ -1,5 +1,5 @@
 #include "pedersen_plookup.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_hash/pedersen.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
 #include "barretenberg/plonk/composer/plookup_tables/types.hpp"
@@ -13,7 +13,14 @@ namespace stdlib {
 
 using namespace barretenberg;
 
-template <typename C> point<C> pedersen_plookup<C>::add_points(const point& p1, const point& p2, const AddType add_type)
+/**
+ * Add two curve points in one of the following ways:
+ *  one: p1 + p2
+ *  lambda: p1 + λ.p2
+ *  one_plus_lambda: p1 + (1 + λ).p2
+ */
+template <typename C>
+point<C> pedersen_plookup_hash<C>::add_points(const point& p1, const point& p2, const AddType add_type)
 {
     C* ctx = p1.x.context ? p1.x.context : (p1.y.context ? p1.y.context : (p2.x.context ? p2.x.context : p2.y.context));
     grumpkin::fq x_1_raw = p1.x.get_value();
@@ -68,11 +75,14 @@ template <typename C> point<C> pedersen_plookup<C>::add_points(const point& p1,
     return p3;
 }
 
-template <typename C> point<C> pedersen_plookup<C>::hash_single(const field_t& scalar, const bool parity)
+/**
+ * Hash a single field element using lookup tables.
+ */
+template <typename C> point<C> pedersen_plookup_hash<C>::hash_single(const field_t& scalar, const bool parity)
 {
     if (scalar.is_constant()) {
         C* ctx = scalar.get_context();
-        const auto hash_native = crypto::pedersen::lookup::hash_single(scalar.get_value(), parity).normalize();
+        const auto hash_native = crypto::pedersen_hash::lookup::hash_single(scalar.get_value(), parity).normalize();
         return { field_t(ctx, hash_native.x), field_t(ctx, hash_native.y) };
     }
 
@@ -125,47 +135,30 @@ template <typename C> point<C> pedersen_plookup<C>::hash_single(const field_t& s
     return res;
 }
 
-template <typename C> point<C> pedersen_plookup<C>::compress_to_point(const field_t& left, const field_t& right)
-{
-    auto p2 = hash_single(left, false);
-    auto p1 = hash_single(right, true);
-
-    return add_points(p1, p2);
-}
-
-template <typename C> field_t<C> pedersen_plookup<C>::compress(const field_t& left, const field_t& right)
-{
-    return compress_to_point(left, right).x;
-}
-
+/**
+ * Hash a bunch of field element using merkle damagard construction.
+ */
 template <typename C>
-point<C> pedersen_plookup<C>::merkle_damgard_compress(const std::vector<field_t>& inputs, const field_t& iv)
+field_t<C> pedersen_plookup_hash<C>::hash_multiple(const std::vector<field_t>& inputs, const size_t hash_index)
 {
     if (inputs.size() == 0) {
-        return point{ 0, 0 };
+        return point{ 0, 0 }.x;
     }
 
-    auto result = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_IV, iv)[ColumnIdx::C2][0];
+    auto result = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_IV, hash_index)[ColumnIdx::C2][0];
     auto num_inputs = inputs.size();
     for (size_t i = 0; i < num_inputs; i++) {
-        result = compress(result, inputs[i]);
+        auto p2 = pedersen_plookup_hash<C>::hash_single(result, false);
+        auto p1 = pedersen_plookup_hash<C>::hash_single(inputs[i], true);
+        result = add_points(p1, p2).x;
     }
 
-    return compress_to_point(result, field_t(num_inputs));
-}
-
-template <typename C> point<C> pedersen_plookup<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>
-field_t<C> pedersen_plookup<C>::compress(const std::vector<field_t>& inputs, const size_t hash_index)
-{
-    return commit(inputs, hash_index).x;
+    auto p2 = hash_single(result, false);
+    auto p1 = hash_single(field_t(num_inputs), true);
+    return add_points(p1, p2).x;
 }
 
-template class pedersen_plookup<plonk::UltraComposer>;
+template class pedersen_plookup_hash<plonk::UltraComposer>;
 
 } // namespace stdlib
 } // namespace proof_system::plonk
diff --git a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp
index 2d14bf73cb0..5d099c5c3fa 100644
--- a/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp
+++ b/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp
@@ -7,7 +7,7 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext> class pedersen_plookup {
+template <typename ComposerContext> class pedersen_plookup_hash {
   private:
     typedef stdlib::field_t<ComposerContext> field_t;
     typedef stdlib::point<ComposerContext> point;
@@ -20,27 +20,14 @@ template <typename ComposerContext> class pedersen_plookup {
         ONE_PLUS_LAMBDA,
     };
 
-    static point hash_single(const field_t& in, const bool parity);
-    static point add_points(const point& p1, const point& p2, const AddType add_type = ONE);
-
   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()); }
-
-    template <size_t T> static field_t compress(const std::array<field_t, T>& inputs)
-    {
-        std::vector<field_t> in(inputs.begin(), inputs.end());
-        return compress(in);
-    }
-
-    static point merkle_damgard_compress(const std::vector<field_t>& inputs, const field_t& iv);
+    static point add_points(const point& p1, const point& p2, const AddType add_type = ONE);
 
-    static point commit(const std::vector<field_t>& inputs, const size_t hash_index = 0);
+    static point hash_single(const field_t& in, const bool parity);
 
-    static point compress_to_point(const field_t& left, const field_t& right);
+    static field_t hash_multiple(const std::vector<field_t>& in, const size_t hash_index = 0);
 };
 
-extern template class pedersen_plookup<plonk::UltraComposer>;
+extern template class pedersen_plookup_hash<plonk::UltraComposer>;
 } // namespace stdlib
 } // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/CMakeLists.txt b/cpp/src/barretenberg/stdlib/merkle_tree/CMakeLists.txt
index 2457820baf2..f0378375a7a 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/CMakeLists.txt
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/CMakeLists.txt
@@ -1 +1,43 @@
-barretenberg_module(stdlib_merkle_tree stdlib_primitives stdlib_blake3s stdlib_pedersen)
+barretenberg_module(stdlib_merkle_tree stdlib_primitives stdlib_blake3s stdlib_pedersen_hash)
+
+if(NOT WASM)
+    include(FetchContent)
+    FetchContent_Declare(
+        leveldb
+        GIT_REPOSITORY https://github.com/google/leveldb.git
+        GIT_TAG 1.22
+        FIND_PACKAGE_ARGS
+    )
+
+    # Disable some leveldb targets before we call FetchContent_MakeAvailable
+    # so they are configured correctly if it needs to fetch
+    set(LEVELDB_BUILD_TESTS OFF CACHE BOOL "LevelDB tests off")
+    set(LEVELDB_BUILD_BENCHMARKS OFF CACHE BOOL "LevelDB benchmarks off")
+
+    FetchContent_MakeAvailable(leveldb)
+
+    if (leveldb_FOUND)
+        # Globally installed leveldb needs Threads available as Threads::Threads as discovered by `find_package`
+        find_package(Threads REQUIRED)
+
+        foreach(target IN LISTS stdlib_merkle_tree_lib_targets stdlib_merkle_tree_exe_targets)
+            target_link_libraries(${target} PRIVATE leveldb::leveldb)
+        endforeach()
+    else()
+        # FetchContent_MakeAvailable calls FetchContent_Populate if `find_package` is unsuccessful
+        # so these variables will be available if we reach this case
+        set_property(DIRECTORY ${leveldb_SOURCE_DIR} PROPERTY EXCLUDE_FROM_ALL)
+        set_property(DIRECTORY ${leveldb_BINARY_DIR} PROPERTY EXCLUDE_FROM_ALL)
+
+        # Silence all compiler warnings from LevelDB
+        target_compile_options(
+            leveldb
+            PRIVATE
+            -w
+        )
+
+        foreach(target IN LISTS stdlib_merkle_tree_lib_targets stdlib_merkle_tree_exe_targets)
+            target_link_libraries(${target} PRIVATE leveldb)
+        endforeach()
+    endif()
+endif()
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp
index c24ccf60599..32e6fb2d8df 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/hash.hpp
@@ -1,7 +1,9 @@
 #pragma once
 #include "barretenberg/common/net.hpp"
 #include "barretenberg/crypto/blake2s/blake2s.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_hash/pedersen_lookup.hpp"
+#include "barretenberg/crypto/pedersen_commitment/convert_buffer_to_field.hpp"
 #include "barretenberg/stdlib/hash/blake2s/blake2s.hpp"
 #include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
@@ -11,19 +13,73 @@ namespace proof_system::plonk {
 namespace stdlib {
 namespace merkle_tree {
 
-template <typename ComposerContext> inline field_t<ComposerContext> hash_value(byte_array<ComposerContext> const& input)
+inline barretenberg::fr hash_pair_native(barretenberg::fr const& lhs, barretenberg::fr const& rhs)
 {
-    return plonk::stdlib::pedersen<ComposerContext>::compress(input);
+    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
+    }
 }
 
-inline barretenberg::fr hash_value_native(std::vector<uint8_t> const& input)
+inline barretenberg::fr hash_multiple_native(std::vector<barretenberg::fr> const& inputs)
 {
-    return crypto::pedersen::compress_native(input);
+    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
+    }
 }
 
-inline barretenberg::fr compress_native(barretenberg::fr const& lhs, barretenberg::fr const& rhs)
+/**
+ * Computes the root of a tree with leaves given as the vector `input`.
+ *
+ * @param input: vector of leaf values.
+ * @returns root as field
+ */
+inline barretenberg::fr compute_tree_root_native(std::vector<barretenberg::fr> const& input)
 {
-    return crypto::pedersen::compress_native({ lhs, rhs });
+    // Check if the input vector size is a power of 2.
+    ASSERT(input.size() > 0);
+    ASSERT(numeric::is_power_of_two(input.size()));
+    auto layer = input;
+    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] });
+            }
+        }
+        layer = std::move(next_layer);
+    }
+
+    return layer[0];
+}
+
+// TODO write test
+inline std::vector<barretenberg::fr> compute_tree_native(std::vector<barretenberg::fr> const& input)
+{
+    // Check if the input vector size is a power of 2.
+    ASSERT(input.size() > 0);
+    ASSERT(numeric::is_power_of_two(input.size()));
+    auto layer = input;
+    std::vector<barretenberg::fr> tree(input);
+    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] });
+            }
+            tree.push_back(next_layer[i]);
+        }
+        layer = std::move(next_layer);
+    }
+
+    return tree;
 }
 
 } // namespace merkle_tree
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
index dbe178c3aef..da60dfa7998 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
@@ -1,6 +1,8 @@
 #include "hash.hpp"
+#include "memory_tree.hpp"
 #include <gtest/gtest.h>
 #include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/merkle_tree/membership.hpp"
 #include "barretenberg/stdlib/types/types.hpp"
 
 using namespace barretenberg;
@@ -11,17 +13,47 @@ 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 = proof_system::plonk::stdlib::pedersen<Composer>::compress(y, y);
-    auto zz = crypto::pedersen::compress_native({ x, x });
+    field_ct z = plonk::stdlib::pedersen_hash<Composer>::hash_multiple({ y, y });
+    auto zz = stdlib::merkle_tree::hash_pair_native(x, x);
+
     EXPECT_EQ(z.get_value(), zz);
 }
 
-TEST(stdlib_merkle_tree_hash, hash_value_native_vs_circuit)
+TEST(stdlib_merkle_tree_hash, compute_tree_root_native_vs_circuit)
 {
-    std::vector<uint8_t> x = std::vector<uint8_t>(64, '\1');
     Composer composer = Composer();
-    byte_array_ct y(&composer, x);
-    field_ct z = merkle_tree::hash_value(y);
-    fr zz = merkle_tree::hash_value_native(x);
+    std::vector<fr> inputs;
+    std::vector<field_ct> inputs_ct;
+    for (size_t i = 0; i < 16; i++) {
+        auto input = fr::random_element();
+        auto input_ct = witness_ct(&composer, input);
+        inputs.push_back(input);
+        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);
+
     EXPECT_EQ(z.get_value(), zz);
 }
+
+TEST(stdlib_merkle_tree_hash, compute_tree_native)
+{
+    constexpr size_t depth = 2;
+    stdlib::merkle_tree::MemoryTree mem_tree(depth);
+
+    std::vector<fr> leaves;
+    for (size_t i = 0; i < (size_t(1) << depth); i++) {
+        auto input = fr::random_element();
+        leaves.push_back(input);
+        mem_tree.update_element(i, input);
+    }
+
+    std::vector<fr> tree_vector = plonk::stdlib::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++) {
+        EXPECT_EQ(tree_vector[i], mem_tree.hashes_[i]);
+    }
+    EXPECT_EQ(tree_vector.back(), mem_tree.root());
+}
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/hash_path.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/hash_path.hpp
index dbe62f26116..e6e5bfcdf6d 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/hash_path.hpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/hash_path.hpp
@@ -11,6 +11,7 @@ namespace merkle_tree {
 using namespace barretenberg;
 
 typedef std::vector<std::pair<fr, fr>> fr_hash_path;
+typedef std::vector<fr> fr_sibling_path;
 template <typename Ctx> using hash_path = std::vector<std::pair<field_t<Ctx>, field_t<Ctx>>>;
 
 inline fr_hash_path get_new_hash_path(fr_hash_path const& old_path, uint128_t index, fr const& value)
@@ -24,7 +25,7 @@ inline fr_hash_path get_new_hash_path(fr_hash_path const& old_path, uint128_t in
         } else {
             path[i].first = current;
         }
-        current = compress_native(path[i].first, path[i].second);
+        current = hash_pair_native(path[i].first, path[i].second);
         index /= 2;
     }
     return path;
@@ -50,14 +51,14 @@ template <typename Ctx> inline hash_path<Ctx> create_witness_hash_path(Ctx& ctx,
 
 inline fr get_hash_path_root(fr_hash_path const& input)
 {
-    return compress_native(input[input.size() - 1].first, input[input.size() - 1].second);
+    return hash_pair_native(input[input.size() - 1].first, input[input.size() - 1].second);
 }
 
 inline fr zero_hash_at_height(size_t height)
 {
     auto current = fr(0);
     for (size_t i = 0; i < height; ++i) {
-        current = compress_native(current, current);
+        current = hash_pair_native(current, current);
     }
     return current;
 }
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp
index 8b62921fbe4..861d83091ba 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp
@@ -43,7 +43,7 @@ bool_t<Composer> check_subtree_membership(field_t<Composer> const& root,
         // current iff path_bit If either of these does not hold, then the final computed merkle root will not match
         field_t<Composer> left = field_t<Composer>::conditional_assign(path_bit, hashes[i].first, current);
         field_t<Composer> right = field_t<Composer>::conditional_assign(path_bit, current, hashes[i].second);
-        current = pedersen<Composer>::compress_unsafe(left, right, 0, is_updating_tree);
+        current = pedersen_hash<Composer>::hash_multiple({ left, right }, 0, is_updating_tree);
     }
 
     return (current == root);
@@ -149,6 +149,35 @@ void update_membership(field_t<Composer> const& new_root,
     assert_check_membership(new_root, old_hashes, new_value, index, true, msg + "_new_value");
 }
 
+/**
+ * Asserts if the state transitions on updating multiple existing leaves with new values.
+ *
+ * @param old_root: The root of the merkle tree before it was updated,
+ * @param new_roots: New roots after each existing leaf was updated,
+ * @param new_values: The new values that are inserted in the existing leaves,
+ * @param old_values: The values of the existing leaves that were updated,
+ * @param old_paths: The hash path from the given index right before a given existing leaf is updated,
+ * @param old_indicies: Indices of the existing leaves that need to be updated,
+ * @tparam Composer: type of composer.
+ */
+template <typename Composer>
+field_t<Composer> update_memberships(field_t<Composer> old_root,
+                                     std::vector<field_t<Composer>> const& new_roots,
+                                     std::vector<field_t<Composer>> const& new_values,
+                                     std::vector<field_t<Composer>> const& old_values,
+                                     std::vector<hash_path<Composer>> const& old_paths,
+                                     std::vector<bit_vector<Composer>> const& old_indicies)
+{
+    for (size_t i = 0; i < old_indicies.size(); i++) {
+        update_membership(
+            new_roots[i], new_values[i], old_root, old_paths[i], old_values[i], old_indicies[i], "update_memberships");
+
+        old_root = new_roots[i];
+    }
+
+    return old_root;
+}
+
 /**
  * Asserts if old and new state of the tree is correct after a subtree-update.
  *
@@ -199,7 +228,7 @@ template <typename Composer> field_t<Composer> compute_tree_root(std::vector<fie
     while (layer.size() > 1) {
         std::vector<field_t<Composer>> next_layer(layer.size() / 2);
         for (size_t i = 0; i < next_layer.size(); ++i) {
-            next_layer[i] = pedersen<Composer>::compress(layer[i * 2], layer[i * 2 + 1]);
+            next_layer[i] = pedersen_hash<Composer>::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
         }
         layer = std::move(next_layer);
     }
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
index 53e43ff816a..1fb8f216f63 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
@@ -9,6 +9,10 @@ using namespace barretenberg;
 using namespace proof_system::plonk::stdlib::types;
 using namespace proof_system::plonk::stdlib::merkle_tree;
 
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+
 TEST(stdlib_merkle_tree, test_check_membership)
 {
     MemoryStore store;
@@ -203,3 +207,69 @@ TEST(stdlib_merkle_tree, test_tree)
     bool result = verifier.verify_proof(proof);
     EXPECT_EQ(result, true);
 }
+
+TEST(stdlib_merkle_tree, test_update_memberships)
+{
+    constexpr size_t depth = 4;
+    MemoryStore store;
+    MerkleTree tree(store, depth);
+
+    Composer composer = Composer();
+
+    constexpr size_t filled = (1UL << depth) / 2;
+    std::vector<fr> filled_values;
+    for (size_t i = 0; i < filled; i++) {
+        uint256_t val = fr::random_element();
+        tree.update_element(i, val);
+        filled_values.push_back(val);
+    }
+
+    // old state
+    fr old_root = tree.root();
+    std::vector<size_t> old_indices = { 0, 2, 5, 7 };
+
+    std::vector<fr> old_values;
+    std::vector<fr_hash_path> old_hash_paths;
+    for (size_t i = 0; i < old_indices.size(); i++) {
+        old_values.push_back(filled_values[old_indices[i]]);
+    }
+
+    // new state
+    std::vector<fr> new_values;
+    std::vector<fr> new_roots;
+    for (size_t i = 0; i < old_indices.size(); i++) {
+        uint256_t val = fr::random_element();
+        new_values.push_back(val);
+        old_hash_paths.push_back(tree.get_hash_path(old_indices[i]));
+        new_roots.push_back(tree.update_element(old_indices[i], new_values[i]));
+    }
+
+    // old state circuit types
+    field_ct old_root_ct = witness_ct(&composer, old_root);
+    std::vector<bit_vector<Composer>> old_indices_ct;
+    std::vector<field_ct> old_values_ct;
+    std::vector<hash_path<Composer>> old_hash_paths_ct;
+
+    // new state circuit types
+    std::vector<field_ct> new_values_ct;
+    std::vector<field_ct> new_roots_ct;
+
+    for (size_t i = 0; i < old_indices.size(); i++) {
+        auto idx_vec = field_ct(witness_ct(&composer, uint256_t(old_indices[i]))).decompose_into_bits(depth);
+        old_indices_ct.push_back(idx_vec);
+        old_values_ct.push_back(witness_ct(&composer, old_values[i]));
+        old_hash_paths_ct.push_back(create_witness_hash_path(composer, old_hash_paths[i]));
+
+        new_values_ct.push_back(witness_ct(&composer, new_values[i]));
+        new_roots_ct.push_back(witness_ct(&composer, new_roots[i]));
+    }
+
+    update_memberships(old_root_ct, new_roots_ct, new_values_ct, old_values_ct, old_hash_paths_ct, old_indices_ct);
+
+    auto prover = composer.create_prover();
+    printf("composer gates = %zu\n", composer.get_num_gates());
+    auto verifier = composer.create_verifier();
+    plonk::proof proof = prover.construct_proof();
+    bool result = verifier.verify_proof(proof);
+    EXPECT_EQ(result, true);
+}
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.cpp
index cdfacca7ff5..a1d38e7092d 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.cpp
@@ -19,7 +19,7 @@ MemoryTree::MemoryTree(size_t depth)
         for (size_t i = 0; i < layer_size; ++i) {
             hashes_[offset + i] = current;
         }
-        current = compress_native(current, current);
+        current = hash_pair_native(current, current);
     }
 
     root_ = current;
@@ -40,6 +40,24 @@ fr_hash_path MemoryTree::get_hash_path(size_t index)
     return path;
 }
 
+fr_sibling_path MemoryTree::get_sibling_path(size_t index)
+{
+    fr_sibling_path path(depth_);
+    size_t offset = 0;
+    size_t layer_size = total_size_;
+    for (size_t i = 0; i < depth_; i++) {
+        if (index % 2 == 0) {
+            path[i] = hashes_[offset + index + 1];
+        } else {
+            path[i] = hashes_[offset + index - 1];
+        }
+        offset += layer_size;
+        layer_size >>= 1;
+        index >>= 1;
+    }
+    return path;
+}
+
 fr MemoryTree::update_element(size_t index, fr const& value)
 {
     size_t offset = 0;
@@ -48,7 +66,7 @@ fr MemoryTree::update_element(size_t index, fr const& value)
     for (size_t i = 0; i < depth_; ++i) {
         hashes_[offset + index] = current;
         index &= (~0ULL) - 1;
-        current = compress_native(hashes_[offset + index], hashes_[offset + index + 1]);
+        current = hash_pair_native(hashes_[offset + index], hashes_[offset + index + 1]);
         offset += layer_size;
         layer_size >>= 1;
         index >>= 1;
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.hpp
index b0e2504c77b..ac1b6bd0bf0 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.hpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.hpp
@@ -30,11 +30,13 @@ class MemoryTree {
 
     fr_hash_path get_hash_path(size_t index);
 
+    fr_sibling_path get_sibling_path(size_t index);
+
     fr update_element(size_t index, fr const& value);
 
     fr root() const { return root_; }
 
-  private:
+  public:
     size_t depth_;
     size_t total_size_;
     barretenberg::fr root_;
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.test.cpp
index 08dfd185955..2b91a36b597 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.test.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/memory_tree.test.cpp
@@ -1,6 +1,5 @@
 #include "memory_tree.hpp"
 #include <gtest/gtest.h>
-#include "barretenberg/stdlib/types/types.hpp"
 
 using namespace barretenberg;
 using namespace proof_system::plonk::stdlib::merkle_tree;
@@ -19,9 +18,9 @@ TEST(stdlib_merkle_tree, test_memory_store)
     fr e01 = VALUES[1];
     fr e02 = VALUES[2];
     fr e03 = VALUES[3];
-    fr e10 = compress_native(e00, e01);
-    fr e11 = compress_native(e02, e03);
-    fr root = compress_native(e10, e11);
+    fr e10 = hash_pair_native(e00, e01);
+    fr e11 = hash_pair_native(e02, e03);
+    fr root = hash_pair_native(e10, e11);
 
     MemoryTree db(2);
     for (size_t i = 0; i < 4; ++i) {
@@ -43,3 +42,39 @@ TEST(stdlib_merkle_tree, test_memory_store)
     EXPECT_EQ(db.get_hash_path(3), expected);
     EXPECT_EQ(db.root(), root);
 }
+
+TEST(stdlib_merkle_tree, test_memory_store_sibling_path)
+{
+    fr e00 = 0;
+    fr e01 = VALUES[1];
+    fr e02 = VALUES[2];
+    fr e03 = VALUES[3];
+    fr e10 = hash_pair_native(e00, e01);
+    fr e11 = hash_pair_native(e02, e03);
+    fr root = hash_pair_native(e10, e11);
+
+    MemoryTree db(2);
+    for (size_t i = 0; i < 4; ++i) {
+        db.update_element(i, VALUES[i]);
+    }
+
+    // Check correct paths are generated for each layer 0 element
+    fr_sibling_path expected00 = {
+        e01,
+        e11,
+    };
+    fr_sibling_path expected01 = { e00, e11 };
+    fr_sibling_path expected02 = {
+        e03,
+        e10,
+    };
+    fr_sibling_path expected03 = {
+        e02,
+        e10,
+    };
+    EXPECT_EQ(db.get_sibling_path(0), expected00);
+    EXPECT_EQ(db.get_sibling_path(1), expected01);
+    EXPECT_EQ(db.get_sibling_path(2), expected02);
+    EXPECT_EQ(db.get_sibling_path(3), expected03);
+    EXPECT_EQ(db.root(), root);
+}
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.bench.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.bench.cpp
index 01d51b68c03..86fa9ef38a7 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.bench.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.bench.cpp
@@ -25,7 +25,7 @@ static std::vector<fr> VALUES = []() {
 void hash(State& state) noexcept
 {
     for (auto _ : state) {
-        compress_native({ 0, 0, 0, 0 }, { 1, 1, 1, 1 });
+        hash_pair_native({ 0, 0, 0, 0 }, { 1, 1, 1, 1 });
     }
 }
 BENCHMARK(hash)->MinTime(5);
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.cpp
index 23765f24acb..ec78b9cd175 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.cpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.cpp
@@ -32,7 +32,7 @@ MerkleTree<Store>::MerkleTree(Store& store, size_t depth, uint8_t tree_id)
     auto current = fr(0);
     for (size_t i = 0; i < depth; ++i) {
         zero_hashes_[i] = current;
-        current = compress_native(current, current);
+        current = hash_pair_native(current, current);
     }
 }
 
@@ -51,7 +51,7 @@ template <typename Store> fr MerkleTree<Store>::root() const
     std::vector<uint8_t> root;
     std::vector<uint8_t> key = { tree_id_ };
     bool status = store_.get(key, root);
-    return status ? from_buffer<fr>(root) : compress_native(zero_hashes_.back(), zero_hashes_.back());
+    return status ? from_buffer<fr>(root) : hash_pair_native(zero_hashes_.back(), zero_hashes_.back());
 }
 
 template <typename Store> typename MerkleTree<Store>::index_t MerkleTree<Store>::size() const
@@ -103,7 +103,7 @@ template <typename Store> fr_hash_path MerkleTree<Store>::get_hash_path(index_t
                     } else {
                         path[j] = std::make_pair(current, zero_hashes_[j]);
                     }
-                    current = compress_native(path[j].first, path[j].second);
+                    current = hash_pair_native(path[j].first, path[j].second);
                 }
             } else {
                 // Requesting path to a different, indepenent element.
@@ -123,7 +123,7 @@ template <typename Store> fr_hash_path MerkleTree<Store>::get_hash_path(index_t
                     } else {
                         path[j] = std::make_pair(current, zero_hashes_[j]);
                     }
-                    current = compress_native(path[j].first, path[j].second);
+                    current = hash_pair_native(path[j].first, path[j].second);
                 }
             }
             break;
@@ -158,7 +158,7 @@ template <typename Store> fr MerkleTree<Store>::binary_put(index_t a_index, fr c
     bool a_is_right = bit_set(a_index, height - 1);
     auto left = a_is_right ? b : a;
     auto right = a_is_right ? a : b;
-    auto key = compress_native(left, right);
+    auto key = hash_pair_native(left, right);
     put(key, left, right);
     return key;
 }
@@ -236,7 +236,7 @@ fr MerkleTree<Store>::update_element(fr const& root, fr const& value, index_t in
         } else {
             left = subtree_root;
         }
-        auto new_root = compress_native(left, right);
+        auto new_root = hash_pair_native(left, right);
         put(new_root, left, right);
 
         // Remove the old node only while rolling back in recursion.
@@ -260,7 +260,7 @@ template <typename Store> fr MerkleTree<Store>::compute_zero_path_hash(size_t he
             right = zero_hashes_[i];
             left = current;
         }
-        current = compress_native(is_right ? zero_hashes_[i] : current, is_right ? current : zero_hashes_[i]);
+        current = hash_pair_native(left, right);
     }
     return current;
 }
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.hpp
index a5c10135819..7e9ca411b80 100644
--- a/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.hpp
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.hpp
@@ -29,7 +29,7 @@ template <typename Store> class MerkleTree {
 
     index_t size() const;
 
-  private:
+  protected:
     void load_metadata();
 
     /**
@@ -88,7 +88,7 @@ template <typename Store> class MerkleTree {
 
     void remove(fr const& key);
 
-  private:
+  protected:
     Store& store_;
     std::vector<fr> zero_hashes_;
     size_t depth_;
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_leaf.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_leaf.hpp
new file mode 100644
index 00000000000..bac3478e6a8
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_leaf.hpp
@@ -0,0 +1,66 @@
+#pragma once
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+namespace merkle_tree {
+
+using namespace barretenberg;
+typedef uint256_t index_t;
+
+struct nullifier_leaf {
+    fr value;
+    index_t nextIndex;
+    fr nextValue;
+
+    bool operator==(nullifier_leaf const&) const = default;
+
+    std::ostream& operator<<(std::ostream& os)
+    {
+        os << "value = " << value << "\nnextIdx = " << nextIndex << "\nnextVal = " << nextValue;
+        return os;
+    }
+
+    void read(uint8_t const*& it)
+    {
+        using serialize::read;
+        read(it, value);
+        read(it, nextIndex);
+        read(it, nextValue);
+    }
+
+    inline void write(std::vector<uint8_t>& buf)
+    {
+        using serialize::write;
+        write(buf, value);
+        write(buf, nextIndex);
+        write(buf, nextValue);
+    }
+
+    barretenberg::fr hash() const { return stdlib::merkle_tree::hash_multiple_native({ value, nextIndex, nextValue }); }
+};
+
+inline std::pair<size_t, bool> find_closest_leaf(std::vector<nullifier_leaf> const& leaves_, fr const& new_value)
+{
+    std::vector<uint256_t> diff;
+    bool repeated = false;
+    auto new_value_ = uint256_t(new_value);
+
+    for (size_t i = 0; i < leaves_.size(); i++) {
+        auto leaf_value_ = uint256_t(leaves_[i].value);
+        if (leaf_value_ > new_value_) {
+            diff.push_back(leaf_value_);
+        } else if (leaf_value_ == new_value_) {
+            repeated = true;
+            return std::make_pair(i, repeated);
+        } else {
+            diff.push_back(new_value_ - leaf_value_);
+        }
+    }
+    auto it = std::min_element(diff.begin(), diff.end());
+    return std::make_pair(static_cast<size_t>(it - diff.begin()), repeated);
+}
+
+} // namespace merkle_tree
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.cpp
new file mode 100644
index 00000000000..09398f5a5a9
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.cpp
@@ -0,0 +1,65 @@
+#include "nullifier_memory_tree.hpp"
+#include "../hash.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+namespace merkle_tree {
+
+NullifierMemoryTree::NullifierMemoryTree(size_t depth)
+    : MemoryTree(depth)
+{
+    ASSERT(depth_ >= 1 && depth <= 32);
+    total_size_ = 1UL << depth_;
+    hashes_.resize(total_size_ * 2 - 2);
+
+    // Build the entire tree.
+    nullifier_leaf zero_leaf = { 0, 0, 0 };
+    leaves_.push_back(zero_leaf);
+    auto current = zero_leaf.hash();
+    update_element(0, current);
+    size_t layer_size = total_size_;
+    for (size_t offset = 0; offset < hashes_.size(); offset += layer_size, layer_size /= 2) {
+        for (size_t i = 0; i < layer_size; ++i) {
+            hashes_[offset + i] = current;
+        }
+        current = hash_pair_native(current, current);
+    }
+
+    root_ = current;
+}
+
+fr NullifierMemoryTree::update_element(fr const& value)
+{
+    // Find the leaf with the value closest and less than `value`
+    size_t current;
+    bool is_already_present;
+    std::tie(current, is_already_present) = find_closest_leaf(leaves_, value);
+
+    nullifier_leaf new_leaf = { .value = value,
+                                .nextIndex = leaves_[current].nextIndex,
+                                .nextValue = leaves_[current].nextValue };
+    if (!is_already_present) {
+        // Update the current leaf to point it to the new leaf
+        leaves_[current].nextIndex = leaves_.size();
+        leaves_[current].nextValue = value;
+
+        // Insert the new leaf with (nextIndex, nextValue) of the current leaf
+        leaves_.push_back(new_leaf);
+    }
+
+    // Update the old leaf in the tree
+    auto old_leaf_hash = leaves_[current].hash();
+    size_t old_leaf_index = current;
+    auto root = update_element(old_leaf_index, old_leaf_hash);
+
+    // Insert the new leaf in the tree
+    auto new_leaf_hash = new_leaf.hash();
+    size_t new_leaf_index = is_already_present ? old_leaf_index : leaves_.size() - 1;
+    root = update_element(new_leaf_index, new_leaf_hash);
+
+    return root;
+}
+
+} // namespace merkle_tree
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.hpp
new file mode 100644
index 00000000000..3a41d691944
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.hpp
@@ -0,0 +1,94 @@
+#pragma once
+#include "../hash.hpp"
+#include "../memory_tree.hpp"
+#include "nullifier_leaf.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+namespace merkle_tree {
+
+using namespace barretenberg;
+
+/**
+ * An NullifierMemoryTree is structured just like a usual merkle tree:
+ *
+ *                                       hashes_
+ *    +------------------------------------------------------------------------------+
+ *    |  0 -> h_{0,0}  h_{0,1}  h_{0,2}  h_{0,3}  h_{0,4}  h_{0,5}  h_{0,6}  h_{0,7} |
+ *  i |                                                                              |
+ *  n |  8 -> h_{1,0}  h_{1,1}  h_{1,2}  h_{1,3}                                     |
+ *  d |                                                                              |
+ *  e | 12 -> h_{2,0}  h_{2,1}                                                       |
+ *  x |                                                                              |
+ *    | 14 -> h_{3,0}                                                                |
+ *    +------------------------------------------------------------------------------+
+ *
+ * Here, depth_ = 3 and {h_{0,j}}_{i=0..7} are leaf values.
+ * Also, root_ = h_{3,0} and total_size_ = (2 * 8 - 2) = 14.
+ * Lastly, h_{i,j} = hash( h_{i-1,2j}, h_{i-1,2j+1} ) where i > 1.
+ *
+ * 1. Initial state:
+ *
+ *                                        #
+ *
+ *                        #                               #
+ *
+ *                #               #               #               #
+ *
+ *            #       #       #       #        #       #       #       #
+ *
+ *  index     0       1       2       3        4       5       6       7
+ *
+ *  val       0       0       0       0        0       0       0       0
+ *  nextIdx   0       0       0       0        0       0       0       0
+ *  nextVal   0       0       0       0        0       0       0       0
+ *
+ * 2. Add new leaf with value 30
+ *
+ *  val       0       30      0       0        0       0       0       0
+ *  nextIdx   1       0       0       0        0       0       0       0
+ *  nextVal   30      0       0       0        0       0       0       0
+ *
+ * 3. Add new leaf with value 10
+ *
+ *  val       0       30      10      0        0       0       0       0
+ *  nextIdx   2       0       1       0        0       0       0       0
+ *  nextVal   10      0       30      0        0       0       0       0
+ *
+ * 4. Add new leaf with value 20
+ *
+ *  val       0       30      10      20       0       0       0       0
+ *  nextIdx   2       0       3       1        0       0       0       0
+ *  nextVal   10      0       20      30       0       0       0       0
+ *
+ * 5. Add new leaf with value 50
+ *
+ *  val       0       30      10      20       50      0       0       0
+ *  nextIdx   2       4       3       1        0       0       0       0
+ *  nextVal   10      50      20      30       0       0       0       0
+ */
+class NullifierMemoryTree : public MemoryTree {
+  public:
+    NullifierMemoryTree(size_t depth);
+
+    using MemoryTree::get_hash_path;
+    using MemoryTree::root;
+    using MemoryTree::update_element;
+
+    fr update_element(fr const& value);
+
+    const std::vector<barretenberg::fr>& get_hashes() { return hashes_; }
+    const std::vector<nullifier_leaf>& get_leaves() { return leaves_; }
+    const nullifier_leaf& get_leaf(size_t index) { return leaves_[index]; }
+
+  protected:
+    using MemoryTree::depth_;
+    using MemoryTree::hashes_;
+    using MemoryTree::root_;
+    using MemoryTree::total_size_;
+    std::vector<nullifier_leaf> leaves_;
+};
+
+} // namespace merkle_tree
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.test.cpp
new file mode 100644
index 00000000000..b404519fd4d
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_memory_tree.test.cpp
@@ -0,0 +1,203 @@
+#include "nullifier_memory_tree.hpp"
+#include <gtest/gtest.h>
+
+using namespace barretenberg;
+using namespace proof_system::plonk::stdlib::merkle_tree;
+
+void print_tree(const size_t depth, std::vector<fr> hashes, std::string const& msg)
+{
+    info("\n", msg);
+    size_t offset = 0;
+    for (size_t i = 0; i < depth; i++) {
+        info("i = ", i);
+        size_t layer_size = (1UL << (depth - i));
+        for (size_t j = 0; j < layer_size; j++) {
+            info("j = ", j, ": ", hashes[offset + j]);
+        }
+        offset += layer_size;
+    }
+}
+
+bool check_hash_path(const fr& root, const fr_hash_path& path, const nullifier_leaf& leaf_value, const size_t idx)
+{
+    auto current = leaf_value.hash();
+    size_t depth_ = path.size();
+    size_t index = idx;
+    for (size_t i = 0; i < depth_; ++i) {
+        fr left = (index & 1) ? path[i].first : current;
+        fr right = (index & 1) ? current : path[i].second;
+        current = hash_pair_native(left, right);
+        index >>= 1;
+    }
+    return current == root;
+}
+
+TEST(crypto_nullifier_tree, test_nullifier_memory)
+{
+    // Create a depth-3 indexed merkle tree
+    constexpr size_t depth = 3;
+    NullifierMemoryTree tree(depth);
+
+    /**
+     * Intial state:
+     *
+     *  index     0       1       2       3        4       5       6       7
+     *  ---------------------------------------------------------------------
+     *  val       0       0       0       0        0       0       0       0
+     *  nextIdx   0       0       0       0        0       0       0       0
+     *  nextVal   0       0       0       0        0       0       0       0
+     */
+    nullifier_leaf zero_leaf = { 0, 0, 0 };
+    EXPECT_EQ(tree.get_leaves().size(), 1);
+    EXPECT_EQ(tree.get_leaves()[0], zero_leaf);
+
+    /**
+     * Add new value 30:
+     *
+     *  index     0       1       2       3        4       5       6       7
+     *  ---------------------------------------------------------------------
+     *  val       0       30      0       0        0       0       0       0
+     *  nextIdx   1       0       0       0        0       0       0       0
+     *  nextVal   30      0       0       0        0       0       0       0
+     */
+    tree.update_element(30);
+    EXPECT_EQ(tree.get_leaves().size(), 2);
+    EXPECT_EQ(tree.get_leaves()[0].hash(), nullifier_leaf({ 0, 1, 30 }).hash());
+    EXPECT_EQ(tree.get_leaves()[1].hash(), nullifier_leaf({ 30, 0, 0 }).hash());
+
+    /**
+     * Add new value 10:
+     *
+     *  index     0       1       2       3        4       5       6       7
+     *  ---------------------------------------------------------------------
+     *  val       0       30      10      0        0       0       0       0
+     *  nextIdx   2       0       1       0        0       0       0       0
+     *  nextVal   10      0       30      0        0       0       0       0
+     */
+    tree.update_element(10);
+    EXPECT_EQ(tree.get_leaves().size(), 3);
+    EXPECT_EQ(tree.get_leaves()[0].hash(), nullifier_leaf({ 0, 2, 10 }).hash());
+    EXPECT_EQ(tree.get_leaves()[1].hash(), nullifier_leaf({ 30, 0, 0 }).hash());
+    EXPECT_EQ(tree.get_leaves()[2].hash(), nullifier_leaf({ 10, 1, 30 }).hash());
+
+    /**
+     * Add new value 20:
+     *
+     *  index     0       1       2       3        4       5       6       7
+     *  ---------------------------------------------------------------------
+     *  val       0       30      10      20       0       0       0       0
+     *  nextIdx   2       0       3       1        0       0       0       0
+     *  nextVal   10      0       20      30       0       0       0       0
+     */
+    tree.update_element(20);
+    EXPECT_EQ(tree.get_leaves().size(), 4);
+    EXPECT_EQ(tree.get_leaves()[0].hash(), nullifier_leaf({ 0, 2, 10 }).hash());
+    EXPECT_EQ(tree.get_leaves()[1].hash(), nullifier_leaf({ 30, 0, 0 }).hash());
+    EXPECT_EQ(tree.get_leaves()[2].hash(), nullifier_leaf({ 10, 3, 20 }).hash());
+    EXPECT_EQ(tree.get_leaves()[3].hash(), nullifier_leaf({ 20, 1, 30 }).hash());
+
+    // Adding the same value must not affect anything
+    tree.update_element(20);
+    EXPECT_EQ(tree.get_leaves().size(), 4);
+    EXPECT_EQ(tree.get_leaves()[0].hash(), nullifier_leaf({ 0, 2, 10 }).hash());
+    EXPECT_EQ(tree.get_leaves()[1].hash(), nullifier_leaf({ 30, 0, 0 }).hash());
+    EXPECT_EQ(tree.get_leaves()[2].hash(), nullifier_leaf({ 10, 3, 20 }).hash());
+    EXPECT_EQ(tree.get_leaves()[3].hash(), nullifier_leaf({ 20, 1, 30 }).hash());
+
+    /**
+     * Add new value 50:
+     *
+     *  index     0       1       2       3        4       5       6       7
+     *  ---------------------------------------------------------------------
+     *  val       0       30      10      20       50      0       0       0
+     *  nextIdx   2       4       3       1        0       0       0       0
+     *  nextVal   10      50      20      30       0       0       0       0
+     */
+    tree.update_element(50);
+    EXPECT_EQ(tree.get_leaves().size(), 5);
+    EXPECT_EQ(tree.get_leaves()[0].hash(), nullifier_leaf({ 0, 2, 10 }).hash());
+    EXPECT_EQ(tree.get_leaves()[1].hash(), nullifier_leaf({ 30, 4, 50 }).hash());
+    EXPECT_EQ(tree.get_leaves()[2].hash(), nullifier_leaf({ 10, 3, 20 }).hash());
+    EXPECT_EQ(tree.get_leaves()[3].hash(), nullifier_leaf({ 20, 1, 30 }).hash());
+    EXPECT_EQ(tree.get_leaves()[4].hash(), nullifier_leaf({ 50, 0, 0 }).hash());
+
+    // Manually compute the node values
+    auto e000 = tree.get_leaves()[0].hash();
+    auto e001 = tree.get_leaves()[1].hash();
+    auto e010 = tree.get_leaves()[2].hash();
+    auto e011 = tree.get_leaves()[3].hash();
+    auto e100 = tree.get_leaves()[4].hash();
+    auto e101 = nullifier_leaf({ 0, 0, 0 }).hash();
+    auto e110 = nullifier_leaf({ 0, 0, 0 }).hash();
+    auto e111 = nullifier_leaf({ 0, 0, 0 }).hash();
+
+    auto e00 = hash_pair_native(e000, e001);
+    auto e01 = hash_pair_native(e010, e011);
+    auto e10 = hash_pair_native(e100, e101);
+    auto e11 = hash_pair_native(e110, e111);
+
+    auto e0 = hash_pair_native(e00, e01);
+    auto e1 = hash_pair_native(e10, e11);
+    auto root = hash_pair_native(e0, e1);
+
+    // Check the hash path at index 2 and 3
+    // Note: This merkle proof would also serve as a non-membership proof of values in (10, 20) and (20, 30)
+    fr_hash_path expected = {
+        std::make_pair(e010, e011),
+        std::make_pair(e00, e01),
+        std::make_pair(e0, e1),
+    };
+    EXPECT_EQ(tree.get_hash_path(2), expected);
+    EXPECT_EQ(tree.get_hash_path(3), expected);
+    EXPECT_EQ(tree.root(), root);
+
+    // Check the hash path at index 6 and 7
+    expected = {
+        std::make_pair(e110, e111),
+        std::make_pair(e10, e11),
+        std::make_pair(e0, e1),
+    };
+    EXPECT_EQ(tree.get_hash_path(6), expected);
+    EXPECT_EQ(tree.get_hash_path(7), expected);
+}
+
+TEST(crypto_nullifier_tree, test_nullifier_tree)
+{
+    // Create a depth-8 indexed merkle tree
+    constexpr size_t depth = 8;
+    NullifierMemoryTree tree(depth);
+
+    nullifier_leaf zero_leaf = { 0, 0, 0 };
+    EXPECT_EQ(tree.get_leaves().size(), 1);
+    EXPECT_EQ(tree.get_leaves()[0].hash(), zero_leaf.hash());
+
+    // Add 20 random values to the tree
+    for (size_t i = 0; i < 20; i++) {
+        auto value = fr::random_element();
+        tree.update_element(value);
+    }
+
+    auto abs_diff = [](uint256_t a, uint256_t b) {
+        if (a > b) {
+            return (a - b);
+        } else {
+            return (b - a);
+        }
+    };
+
+    // Check if a new random value is not a member of this tree.
+    fr new_member = fr::random_element();
+    const auto& leaves = tree.get_leaves();
+    std::vector<uint256_t> differences;
+    for (size_t i = 0; i < leaves.size(); i++) {
+        uint256_t diff_hi = abs_diff(uint256_t(new_member), uint256_t(leaves[i].value));
+        uint256_t diff_lo = abs_diff(uint256_t(new_member), uint256_t(leaves[i].nextValue));
+        differences.push_back(diff_hi + diff_lo);
+    }
+    auto it = std::min_element(differences.begin(), differences.end());
+    auto index = static_cast<size_t>(it - differences.begin());
+
+    // Merkle proof at `index` proves non-membership of `new_member`
+    auto hash_path = tree.get_hash_path(index);
+    EXPECT_TRUE(check_hash_path(tree.root(), hash_path, leaves[index], index));
+}
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.cpp
new file mode 100644
index 00000000000..0a36b8020cf
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.cpp
@@ -0,0 +1,85 @@
+#include "nullifier_tree.hpp"
+#include "../merkle_tree.hpp"
+#include "../hash.hpp"
+#include "../memory_store.hpp"
+#include <iostream>
+#include <sstream>
+#include "barretenberg/common/net.hpp"
+#include "barretenberg/numeric/bitop/count_leading_zeros.hpp"
+#include "barretenberg/numeric/bitop/keep_n_lsb.hpp"
+#include "barretenberg/numeric/uint128/uint128.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+namespace merkle_tree {
+
+using namespace barretenberg;
+
+template <typename T> inline bool bit_set(T const& index, size_t i)
+{
+    return bool((index >> i) & 0x1);
+}
+
+template <typename Store>
+NullifierTree<Store>::NullifierTree(Store& store, size_t depth, uint8_t tree_id)
+    : MerkleTree<Store>(store, depth, tree_id)
+{
+    ASSERT(depth_ >= 1 && depth <= 256);
+    zero_hashes_.resize(depth);
+
+    // Compute the zero values at each layer.
+    // Insert the zero leaf to the `leaves` and also to the tree at index 0.
+    auto zero_leaf = nullifier_leaf{ .value = 0, .nextIndex = 0, .nextValue = 0 };
+    leaves.push_back(zero_leaf);
+    auto current = zero_leaf.hash();
+    update_element(0, current);
+    for (size_t i = 0; i < depth; ++i) {
+        zero_hashes_[i] = current;
+        current = hash_pair_native(current, current);
+    }
+}
+
+template <typename Store>
+NullifierTree<Store>::NullifierTree(NullifierTree&& other)
+    : MerkleTree<Store>(std::move(other))
+{}
+
+template <typename Store> NullifierTree<Store>::~NullifierTree() {}
+
+template <typename Store> fr NullifierTree<Store>::update_element(fr const& value)
+{
+    // Find the leaf with the value closest and less than `value`
+    size_t current;
+    bool is_already_present;
+    std::tie(current, is_already_present) = find_closest_leaf(leaves, value);
+
+    nullifier_leaf new_leaf = { .value = value,
+                                .nextIndex = leaves[current].nextIndex,
+                                .nextValue = leaves[current].nextValue };
+    if (!is_already_present) {
+        // Update the current leaf to point it to the new leaf
+        leaves[current].nextIndex = leaves.size();
+        leaves[current].nextValue = value;
+
+        // Insert the new leaf with (nextIndex, nextValue) of the current leaf
+        leaves.push_back(new_leaf);
+    }
+
+    // Update the old leaf in the tree
+    auto old_leaf_hash = leaves[current].hash();
+    index_t old_leaf_index = current;
+    auto r = update_element(old_leaf_index, old_leaf_hash);
+
+    // Insert the new leaf in the tree
+    auto new_leaf_hash = new_leaf.hash();
+    index_t new_leaf_index = is_already_present ? old_leaf_index : leaves.size() - 1;
+    r = update_element(new_leaf_index, new_leaf_hash);
+
+    return r;
+}
+
+template class NullifierTree<MemoryStore>;
+
+} // namespace merkle_tree
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.hpp b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.hpp
new file mode 100644
index 00000000000..aa5af2771a6
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.hpp
@@ -0,0 +1,45 @@
+#pragma once
+#include "../hash.hpp"
+#include "../merkle_tree.hpp"
+#include "nullifier_leaf.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+namespace merkle_tree {
+
+using namespace barretenberg;
+
+template <typename Store> class NullifierTree : public MerkleTree<Store> {
+  public:
+    typedef uint256_t index_t;
+
+    NullifierTree(Store& store, size_t depth, uint8_t tree_id = 0);
+    NullifierTree(NullifierTree const& other) = delete;
+    NullifierTree(NullifierTree&& other);
+    ~NullifierTree();
+
+    using MerkleTree<Store>::get_hash_path;
+    using MerkleTree<Store>::root;
+    using MerkleTree<Store>::size;
+    using MerkleTree<Store>::depth;
+
+    fr update_element(fr const& value);
+
+  private:
+    using MerkleTree<Store>::update_element;
+    using MerkleTree<Store>::get_element;
+    using MerkleTree<Store>::compute_zero_path_hash;
+
+  private:
+    using MerkleTree<Store>::store_;
+    using MerkleTree<Store>::zero_hashes_;
+    using MerkleTree<Store>::depth_;
+    using MerkleTree<Store>::tree_id_;
+    std::vector<nullifier_leaf> leaves;
+};
+
+extern template class NullifierTree<MemoryStore>;
+
+} // namespace merkle_tree
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.test.cpp b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.test.cpp
new file mode 100644
index 00000000000..f7deed21dac
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/merkle_tree/nullifier_tree/nullifier_tree.test.cpp
@@ -0,0 +1,140 @@
+#include "../memory_store.hpp"
+#include "nullifier_memory_tree.hpp"
+#include "nullifier_tree.hpp"
+#include "barretenberg/common/streams.hpp"
+#include "barretenberg/common/test.hpp"
+#include "barretenberg/numeric/random/engine.hpp"
+
+using namespace barretenberg;
+using namespace proof_system::plonk::stdlib::merkle_tree;
+
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+auto& random_engine = numeric::random::get_engine();
+} // namespace
+
+static std::vector<fr> VALUES = []() {
+    std::vector<fr> values(1024);
+    for (size_t i = 0; i < 1024; ++i) {
+        values[i] = fr(random_engine.get_random_uint64());
+    }
+    return values;
+}();
+
+inline void print_tree(const size_t depth, std::vector<fr> hashes, std::string const& msg)
+{
+    info("\n", msg);
+    size_t offset = 0;
+    for (size_t i = 0; i < depth; i++) {
+        info("i = ", i);
+        size_t layer_size = (1UL << (depth - i));
+        for (size_t j = 0; j < layer_size; j++) {
+            info("j = ", j, ": ", hashes[offset + j]);
+        }
+        offset += layer_size;
+    }
+}
+
+TEST(stdlib_nullifier_tree, test_kv_memory_vs_memory_consistency)
+{
+    constexpr size_t depth = 2;
+    NullifierMemoryTree memdb(depth);
+
+    MemoryStore store;
+    NullifierTree db(store, depth);
+
+    std::vector<size_t> indicies(1 << depth);
+    std::iota(indicies.begin(), indicies.end(), 0);
+    std::random_device rd;
+    std::mt19937 g(rd());
+    std::shuffle(indicies.begin(), indicies.end(), g);
+
+    for (size_t i = 0; i < indicies.size() - 1; ++i) {
+        size_t idx = indicies[i];
+        memdb.update_element(VALUES[idx]);
+        db.update_element(VALUES[idx]);
+    }
+
+    for (size_t i = 0; i < indicies.size() - 1; ++i) {
+        size_t idx = indicies[i];
+        EXPECT_EQ(db.get_hash_path(idx), memdb.get_hash_path(idx));
+    }
+
+    EXPECT_EQ(db.root(), memdb.root());
+}
+
+TEST(stdlib_nullifier_tree, test_size)
+{
+    MemoryStore store;
+    auto db = NullifierTree(store, 256);
+
+    // We assume that the first leaf is already filled with (0, 0, 0).
+    EXPECT_EQ(db.size(), 1ULL);
+
+    // Add a new non-zero leaf at index 1.
+    db.update_element(30);
+    EXPECT_EQ(db.size(), 2ULL);
+
+    // Add third.
+    db.update_element(10);
+    EXPECT_EQ(db.size(), 3ULL);
+
+    // Add forth.
+    db.update_element(20);
+    EXPECT_EQ(db.size(), 4ULL);
+
+    // Add forth but with same value.
+    db.update_element(20);
+    EXPECT_EQ(db.size(), 4ULL);
+}
+
+TEST(stdlib_nullifier_tree, test_get_hash_path)
+{
+    NullifierMemoryTree memdb(10);
+
+    MemoryStore store;
+    auto db = NullifierTree(store, 10);
+
+    EXPECT_EQ(memdb.get_hash_path(512), db.get_hash_path(512));
+
+    memdb.update_element(VALUES[512]);
+    db.update_element(VALUES[512]);
+
+    EXPECT_EQ(db.get_hash_path(512), memdb.get_hash_path(512));
+
+    for (size_t i = 0; i < 512; ++i) {
+        memdb.update_element(VALUES[i]);
+        db.update_element(VALUES[i]);
+    }
+
+    EXPECT_EQ(db.get_hash_path(512), memdb.get_hash_path(512));
+}
+
+TEST(stdlib_nullifier_tree, test_get_hash_path_layers)
+{
+    {
+        MemoryStore store;
+        auto db = NullifierTree(store, 3);
+
+        auto before = db.get_hash_path(1);
+        db.update_element(VALUES[1]);
+        auto after = db.get_hash_path(1);
+
+        EXPECT_NE(before[0], after[0]);
+        EXPECT_NE(before[1], after[1]);
+        EXPECT_NE(before[2], after[2]);
+    }
+
+    {
+        MemoryStore store;
+        auto db = NullifierTree(store, 3);
+
+        auto before = db.get_hash_path(7);
+        db.update_element(VALUES[1]);
+        auto after = db.get_hash_path(7);
+
+        EXPECT_EQ(before[0], after[0]);
+        EXPECT_EQ(before[1], after[1]);
+        EXPECT_NE(before[2], after[2]);
+    }
+}
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/primitives/address/address.hpp b/cpp/src/barretenberg/stdlib/primitives/address/address.hpp
new file mode 100644
index 00000000000..0b27a443c65
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/primitives/address/address.hpp
@@ -0,0 +1,142 @@
+#pragma once
+#include "barretenberg/numeric/uint256/uint256.hpp"
+#include "barretenberg/stdlib/commitment/pedersen/pedersen.hpp"
+#include "barretenberg/stdlib/primitives/field/field.hpp"
+#include "barretenberg/stdlib/primitives/bool/bool.hpp"
+#include "barretenberg/stdlib/primitives/group/group.hpp"
+#include "barretenberg/stdlib/primitives/point/point.hpp"
+#include "barretenberg/stdlib/primitives/witness/witness.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+
+using barretenberg::fr;
+using numeric::uint256_t;
+using stdlib::bool_t;
+using stdlib::field_t;
+using stdlib::group;
+using stdlib::pedersen_commitment;
+using stdlib::point;
+using 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(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(); }
+
+    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 proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.hpp b/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.hpp
index 1552eb845a7..002fce1df12 100644
--- a/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp b/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
index 218576684e7..b32ec8d77e1 100644
--- a/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
+++ b/cpp/src/barretenberg/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 == ComposerType::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 };
@@ -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/barretenberg/stdlib/primitives/bool/bool.cpp b/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
index 204b20790e9..6d3e1e8d1a2 100644
--- a/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
@@ -420,18 +420,97 @@ 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
+{
+    // Extract the composer
+    const bool_t this_bool = *this;
+    ComposerContext* ctx = this_bool.get_context();
+    bool composer_found = (ctx != nullptr);
+    for (size_t i = 0; i < conds.size(); i++) {
+        if (!composer_found) {
+            ctx = conds[i].first.get_context();
+            composer_found = (ctx != nullptr);
+        }
+    }
+
+    // If no composer is found, all of the bool_t's must be constants.
+    // In that case, we enforce a static assertion to check must_imply condition holds.
+    // If all of your inputs do this function are constants and they don't obey a condition,
+    // this function will panic at those static assertions.
+    if (!composer_found) {
+        bool is_const = this_bool.is_constant();
+        bool result = !this_bool.get_value();
+        bool acc = true;
+        for (size_t i = 0; i < conds.size(); i++) {
+            is_const &= conds[i].first.is_constant();
+            acc &= conds[i].first.get_value();
+        }
+        result |= acc;
+        ASSERT(is_const == true);
+        ASSERT(result == true);
+    }
+
+    bool_t acc = witness_t(ctx, true); // will accumulate the conjunctions of each condition (i.e. `&&` of each)
+    const bool this_val = this->get_value();
+    bool error_found = false;
+    std::string error_msg;
+
+    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) && !error_found) {
+            error_found = true;
+            error_msg = msg;
+        }
+
+        acc &= cond;
+    }
+
+    (this->implies(acc)).assert_equal(true, format("multi implication fail: ", error_msg));
+}
+
 // A "double-implication" (<=>),
 // a.k.a "iff", a.k.a. "biconditional"
 template <typename ComposerContext>
diff --git a/cpp/src/barretenberg/stdlib/primitives/bool/bool.hpp b/cpp/src/barretenberg/stdlib/primitives/bool/bool.hpp
index 86ddee1e4a6..40889aefece 100644
--- a/cpp/src/barretenberg/stdlib/primitives/bool/bool.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/stdlib/primitives/bool/bool.test.cpp b/cpp/src/barretenberg/stdlib/primitives/bool/bool.test.cpp
index d080f06f108..3d32e63cd22 100644
--- a/cpp/src/barretenberg/stdlib/primitives/bool/bool.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/bool/bool.test.cpp
@@ -1,13 +1,17 @@
 #include "bool.hpp"
 #include "barretenberg/plonk/proof_system/constants.hpp"
 #include <gtest/gtest.h>
-// #include <plonk/composer/standard_composer.hpp>
+#include "barretenberg/plonk/composer/standard_composer.hpp"
 #include "barretenberg/honk/composer/standard_honk_composer.hpp"
 
 namespace test_stdlib_bool {
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+
 typedef stdlib::bool_t<honk::StandardHonkComposer> bool_t;
 typedef stdlib::witness_t<honk::StandardHonkComposer> witness_t;
 
@@ -359,6 +363,163 @@ TEST(stdlib_bool, implies_both_ways)
     EXPECT_EQ(result, true);
 }
 
+TEST(stdlib_bool, must_imply)
+{
+    honk::StandardHonkComposer composer = honk::StandardHonkComposer();
+    for (size_t j = 0; j < 4; ++j) {
+        bool lhs_constant = (bool)(j % 2);
+        bool rhs_constant = (bool)(j > 1 ? true : false);
+
+        for (size_t i = 4; i < 14; i += 2) {
+            // If a number is divisible by 2 and 3, it is divisible by 6
+            bool two = (bool)(i % 2);
+            bool three = (bool)(i % 3);
+            bool six = (bool)(i % 6);
+            bool a_val = (two && three);
+            bool b_val = six;
+            bool_t a = lhs_constant ? bool_t(a_val) : (witness_t(&composer, a_val));
+            bool_t b = rhs_constant ? bool_t(b_val) : (witness_t(&composer, b_val));
+            a.must_imply(b);
+        }
+    }
+    auto prover = composer.create_prover();
+    auto verifier = composer.create_verifier();
+
+    plonk::proof proof = prover.construct_proof();
+
+    bool result = verifier.verify_proof(proof);
+    EXPECT_EQ(result, true);
+}
+
+TEST(stdlib_bool, must_imply_fails)
+{
+    honk::StandardHonkComposer composer = honk::StandardHonkComposer();
+    for (size_t j = 0; j < 3; ++j) { // ignore the case when both lhs and rhs are constants
+        bool lhs_constant = (bool)(j % 2);
+        bool rhs_constant = (bool)(j > 1 ? true : false);
+
+        // If a number is divisible by 2 and 3, it is divisible by 6
+        // => 8 is not divisible by 3, so it must not be divisible by 6
+        const size_t i = 8;
+        bool a_val = (bool)(i % 2 == 0);
+        bool b_val = (bool)(i % 6 == 0);
+        bool_t a = lhs_constant ? bool_t(a_val) : (witness_t(&composer, a_val));
+        bool_t b = rhs_constant ? bool_t(b_val) : (witness_t(&composer, b_val));
+        a.must_imply(b, "div by 2 does not imply div by 8");
+
+        EXPECT_EQ(composer.failed(), true);
+        EXPECT_EQ(composer.err(), "div by 2 does not imply div by 8");
+    }
+}
+
+TEST(stdlib_bool, must_imply_multiple)
+{
+    honk::StandardHonkComposer composer = honk::StandardHonkComposer();
+
+    /**
+     * Define g(x) = 2x + 12
+     * if x is divisible by both 4 and 6:
+     *     => g(x) > 0
+     *     => g(x) is even
+     *     => g(x) >= 12
+     *     => g(x) is a multiple of 6
+     */
+    auto g = [](size_t x) { return 2 * x + 12; };
+
+    for (size_t j = 0; j < 3; ++j) { // ignore when both lhs and rhs are constants
+        bool lhs_constant = (bool)(j % 2);
+        bool rhs_constant = (bool)(j > 1 ? true : false);
+
+        for (size_t x = 10; x < 18; x += 2) {
+            std::vector<std::pair<bool_t, std::string>> conditions;
+            bool four = (bool)(x % 4 == 0);
+            bool six = (bool)(x % 6 == 0);
+
+            bool_t a = lhs_constant ? bool_t(four) : (witness_t(&composer, four));
+            bool_t b = rhs_constant ? bool_t(six) : (witness_t(&composer, six));
+
+            auto g_x = g(x);
+            conditions.push_back(std::make_pair(g_x > 0, "g(x) > 0"));
+            conditions.push_back(std::make_pair(g_x % 2 == 0, "g(x) is even"));
+            conditions.push_back(std::make_pair(g_x >= 12, "g(x) >= 12"));
+            conditions.push_back(std::make_pair(g_x % 6 == 0, "g(x) is a multiple of 6"));
+
+            (a && b).must_imply(conditions);
+
+            if (composer.failed()) {
+                EXPECT_EQ(composer.err(), "multi implication fail: g(x) is a multiple of 6");
+            } else {
+                auto prover = composer.create_prover();
+                auto verifier = composer.create_verifier();
+
+                plonk::proof proof = prover.construct_proof();
+                bool result = verifier.verify_proof(proof);
+                EXPECT_EQ(result, true);
+            }
+        }
+    }
+}
+
+TEST(stdlib_bool, must_imply_multiple_fails)
+{
+    honk::StandardHonkComposer composer = honk::StandardHonkComposer();
+
+    /**
+     * Given x = 15:
+     * (x > 10)
+     *  => (x > 8)
+     *  => (x > 5)
+     *  ≠> (x > 18)
+     */
+    for (size_t j = 0; j < 2; ++j) { // ignore when both lhs and rhs are constants
+        bool is_constant = (bool)(j % 2);
+
+        size_t x = 15;
+        bool main = (bool)(x > 10);
+        bool_t main_ct = is_constant ? bool_t(main) : (witness_t(&composer, main));
+
+        std::vector<std::pair<bool_t, std::string>> conditions;
+        conditions.push_back(std::make_pair(witness_t(&composer, x > 8), "x > 8"));
+        conditions.push_back(std::make_pair(witness_t(&composer, x > 5), "x > 5"));
+        conditions.push_back(std::make_pair(witness_t(&composer, x > 18), "x > 18"));
+
+        main_ct.must_imply(conditions);
+
+        EXPECT_EQ(composer.failed(), true);
+        EXPECT_EQ(composer.err(), "multi implication fail: x > 18");
+    }
+}
+
+TEST(stdlib_bool, conditional_assign)
+{
+    honk::StandardHonkComposer composer = honk::StandardHonkComposer();
+    for (size_t j = 0; j < 4; ++j) {
+        bool lhs_constant = (bool)(j % 2);
+        bool rhs_constant = (bool)(j > 1 ? true : false);
+
+        const uint256_t x = (uint256_t(1) << 128) - 1;
+        const uint256_t val = engine.get_random_uint256();
+
+        bool condition = (val % 2 == 0);
+        bool right = x < val;
+        bool left = x > val;
+        bool_t l_ct = lhs_constant ? bool_t(left) : (witness_t(&composer, left));
+        bool_t r_ct = rhs_constant ? bool_t(right) : (witness_t(&composer, right));
+        bool_t cond = (witness_t(&composer, condition));
+
+        auto result = bool_t::conditional_assign(cond, l_ct, r_ct);
+
+        EXPECT_EQ(result.get_value(), condition ? left : right);
+    }
+    auto prover = composer.create_prover();
+    auto verifier = composer.create_verifier();
+
+    plonk::proof proof = prover.construct_proof();
+    info("composer gates = ", composer.get_num_gates());
+    bool result = verifier.verify_proof(proof);
+    EXPECT_EQ(result, true);
+}
+
 TEST(stdlib_bool, test_simple_proof)
 {
     honk::StandardHonkComposer composer = proof_system::honk::StandardHonkComposer();
diff --git a/cpp/src/barretenberg/stdlib/primitives/field/array.hpp b/cpp/src/barretenberg/stdlib/primitives/field/array.hpp
new file mode 100644
index 00000000000..b7d11788337
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/primitives/field/array.hpp
@@ -0,0 +1,179 @@
+#pragma once
+#include "field.hpp"
+#include "../safe_uint/safe_uint.hpp"
+#include "../bool/bool.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+
+/**
+ * Gets the number of contiguous nonzero values of an array from the start.
+ * Note: This assumes `0` always means 'not used', so be careful. As soon as we locate 0, we stop the counting.
+ * If you actually want `0` to be counted, you'll need something else.
+ */
+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) {
+        bool_t<Composer> is_zero = e.is_zero();
+        hit_zero.must_imply(is_zero, "Once we've hit the first zero, there must only be zeros thereafter!");
+        hit_zero |= is_zero;
+        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 = 0;
+    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, "array_pop 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, "array_push 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>
+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("array_push 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 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("array_push 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, typename T, size_t SIZE> inline void array_push(std::array<T, SIZE>& arr, T const& value)
+{
+    bool_t<Composer> already_pushed = false;
+    for (size_t i = 0; i < arr.size(); ++i) {
+        bool_t<Composer> is_zero = arr[i].is_empty();
+        arr[i].conditional_select(!already_pushed && is_zero, value);
+
+        already_pushed |= is_zero;
+    }
+    already_pushed.assert_equal(true, "array_push 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)
+{
+    field_t<Composer> target_length = array_length<Composer>(target);
+    const field_t<Composer> overflow_capacity = target.max_size() + 1;
+
+    field_t<Composer> j_ct = 0; // circuit-type index for the inner loop
+    // Find the first empty slot in the target:
+    field_t<Composer> next_target_index = target_length;
+
+    bool_t<Composer> hit_s_zero = false;
+    bool_t<Composer> not_hit_s_zero = true;
+
+    for (size_t i = 0; i < source.max_size(); ++i) {
+        // Loop over each source value we want to push:
+        auto& s = source[i];
+        {
+            auto is_s_zero = s.is_zero();
+            hit_s_zero.must_imply(is_s_zero,
+                                  "Once we've hit the first source zero, there must only be zeros thereafter!");
+            hit_s_zero |= is_s_zero;
+            not_hit_s_zero = !hit_s_zero;
+        }
+
+        // Triangular loop:
+        for (size_t j = i; j < target.max_size(); ++j) {
+            auto& t = target[j];
+
+            // Check whether we've reached the next target index at which we can push `s`:
+            bool_t<Composer> at_next_target_index = j_ct == next_target_index;
+
+            t = field_t<Composer>::conditional_assign(at_next_target_index && not_hit_s_zero, s, t);
+
+            j_ct++;
+        }
+
+        next_target_index += not_hit_s_zero;
+
+        next_target_index.assert_not_equal(overflow_capacity, "push_array_to_array target array capacity exceeded");
+
+        j_ct = i + 1;
+    }
+}
+
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/primitives/field/array.test.cpp b/cpp/src/barretenberg/stdlib/primitives/field/array.test.cpp
new file mode 100644
index 00000000000..a4af3b899d0
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/primitives/field/array.test.cpp
@@ -0,0 +1,727 @@
+#include "../bool/bool.hpp"
+#include "field.hpp"
+#include "array.hpp"
+#include <gtest/gtest.h>
+#include <utility>
+#include "barretenberg/honk/composer/standard_honk_composer.hpp"
+#include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/numeric/random/engine.hpp"
+
+namespace test_stdlib_array {
+
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+
+template <class T> void ignore_unused(T&) {} // use to ignore unused variables in lambdas
+
+using namespace barretenberg;
+using namespace proof_system::plonk;
+
+template <typename Composer> class stdlib_array : 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:
+    static void test_array_length()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t ARRAY_LEN = 10;
+        std::array<fr, ARRAY_LEN> values;
+        std::array<field_ct, ARRAY_LEN> values_ct;
+
+        constexpr size_t filled = 6;
+        for (size_t i = 0; i < filled; i++) {
+            values[i] = fr::random_element();
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+        auto filled_len = array_length<Composer>(values_ct);
+        EXPECT_EQ(filled_len.get_value(), filled);
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    }
+
+    static void test_array_length_null()
+    {
+        Composer composer = Composer();
+
+        std::array<field_ct, 0> values_ct;
+        auto filled_len = array_length<Composer>(values_ct);
+        EXPECT_EQ(filled_len.get_value(), 0);
+        EXPECT_TRUE(filled_len.is_constant());
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    }
+
+    static void test_array_length_fails()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t ARRAY_LEN = 10;
+        std::array<fr, ARRAY_LEN> values;
+        std::array<field_ct, ARRAY_LEN> values_ct;
+
+        constexpr size_t filled = 6;
+        for (size_t i = 0; i < filled; i++) {
+            values[i] = fr::random_element();
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+
+        // Put a zero in the middle of the array, so that the array_length function complains that all zeros thereafter
+        // should be zero.
+        values_ct[4] = 0;
+
+        array_length<Composer>(values_ct);
+
+        EXPECT_EQ(composer.failed(), true);
+        EXPECT_EQ(composer.err(), "Once we've hit the first zero, there must only be zeros thereafter!");
+    }
+
+    static void test_array_pop()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t ARRAY_LEN = 10;
+        std::array<fr, ARRAY_LEN> values;
+        std::array<field_ct, ARRAY_LEN> values_ct;
+
+        constexpr size_t filled = 6;
+        for (size_t i = 0; i < filled; i++) {
+            values[i] = fr::random_element();
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+        auto popped = array_pop<Composer>(values_ct);
+        EXPECT_EQ(popped.get_value(), values[filled - 1]);
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    };
+
+    static void test_array_pop_from_empty()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t ARRAY_LEN = 10;
+        std::array<fr, ARRAY_LEN> values;
+        std::array<field_ct, ARRAY_LEN> values_ct;
+
+        constexpr size_t filled = 0;
+        for (size_t i = 0; i < filled; i++) {
+            values[i] = fr::random_element();
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+        for (size_t i = filled; i < ARRAY_LEN; i++) {
+            values[i] = 0;
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+
+        auto popped = array_pop<Composer>(values_ct);
+        EXPECT_EQ(popped.get_value(), 0);
+
+        EXPECT_EQ(composer.failed(), true);
+        EXPECT_EQ(composer.err(), "array_pop cannot pop from an empty array");
+    };
+
+    static void test_array_push()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t ARRAY_LEN = 10;
+        std::array<fr, ARRAY_LEN> values;
+        std::array<field_ct, ARRAY_LEN> values_ct;
+
+        constexpr size_t filled = 6;
+        for (size_t i = 0; i < filled; i++) {
+            values[i] = fr::random_element();
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+        for (size_t i = filled; i < ARRAY_LEN; i++) {
+            values[i] = 0;
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+
+        auto value_ct = field_ct(&composer, fr::random_element());
+        array_push<Composer>(values_ct, value_ct);
+        EXPECT_EQ(value_ct.get_value(), values_ct[filled].get_value());
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    }
+
+    static void test_array_push_optional()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t ARRAY_LEN = 10;
+        std::array<std::optional<fr>, ARRAY_LEN> values;
+        std::array<std::optional<field_ct>, ARRAY_LEN> values_ct;
+
+        // Fill the array with some values
+        for (size_t i = 0; i < ARRAY_LEN; i++) {
+            values[i] = std::nullopt;
+            values_ct[i] = std::nullopt;
+        }
+
+        // Push some values into the array
+        size_t num_pushes = 0;
+        for (size_t i = 0; i < ARRAY_LEN; i++) {
+            auto value = field_ct(&composer, fr::random_element());
+            size_t idx = array_push<Composer>(values_ct, value);
+            EXPECT_TRUE(values_ct[idx].has_value());
+            EXPECT_EQ(values_ct[idx].value().get_value(), value.get_value());
+            num_pushes++;
+        }
+
+        // Make sure the array is full now
+        try {
+            auto value = field_ct(&composer, fr::random_element());
+            array_push<Composer>(values_ct, value);
+            FAIL() << "array_push should have thrown an exception when trying to push to a full array";
+        } catch (std::runtime_error& e) {
+            EXPECT_EQ(e.what(), std::string("array_push cannot push to a full array"));
+        }
+
+        EXPECT_EQ(num_pushes, ARRAY_LEN);
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    }
+
+    static void test_array_push_shared_ptr()
+    {
+        constexpr size_t ARRAY_LEN = 5;
+        std::array<std::shared_ptr<int>, ARRAY_LEN> arr;
+        for (size_t i = 0; i < arr.size(); ++i) {
+            arr[i] = nullptr;
+        }
+
+        // Fill the array up to capacity
+        for (size_t i = 0; i < arr.size(); ++i) {
+            arr[i] = std::make_shared<int>(i);
+        }
+
+        // Attempt to push a value to the array
+        std::shared_ptr<int> new_value = std::make_shared<int>(42);
+        EXPECT_THROW(array_push<Composer>(arr, new_value), std::runtime_error);
+
+        // Ensure that the array was not modified
+        for (size_t i = 0; i < arr.size(); ++i) {
+            EXPECT_NE(arr[i], new_value);
+        }
+    }
+
+    static void test_is_array_empty()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t ARRAY_LEN = 10;
+        std::array<fr, ARRAY_LEN> values;
+        std::array<field_ct, ARRAY_LEN> values_ct;
+
+        // Test non-empty array
+        constexpr size_t filled = 3;
+        for (size_t i = 0; i < filled; i++) {
+            values[i] = fr::random_element();
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+        for (size_t i = filled; i < ARRAY_LEN; i++) {
+            values[i] = 0;
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+        auto is_empty = is_array_empty<Composer>(values_ct);
+        EXPECT_EQ(is_empty.get_value(), false);
+
+        // Test empty array
+        for (size_t i = 0; i < ARRAY_LEN; i++) {
+            values[i] = 0;
+            values_ct[i] = witness_ct(&composer, values[i]);
+        }
+        is_empty = is_array_empty<Composer>(values_ct);
+        EXPECT_EQ(is_empty.get_value(), true);
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    };
+
+    template <size_t size_1, size_t size_2>
+    static auto test_push_array_to_array_helper(Composer& composer,
+                                                std::array<fr, size_1> const& source,
+                                                std::array<fr, size_2> const& target,
+                                                std::array<fr, size_2> const& expected_target,
+                                                bool const expect_fail = false)
+    {
+        std::array<field_ct, size_1> source_ct;
+        std::array<field_ct, size_2> target_ct;
+        for (size_t i = 0; i < source.size(); i++) {
+            source_ct[i] = witness_ct(&composer, source[i]);
+        }
+        for (size_t i = 0; i < target.size(); i++) {
+            target_ct[i] = witness_ct(&composer, target[i]);
+        }
+
+        push_array_to_array<Composer>(source_ct, target_ct);
+
+        // Check that the source array has been inserted into the first available index of the target array.
+        if (!expect_fail) {
+            for (size_t i = 0; i < target.size(); i++) {
+                EXPECT_EQ(target_ct[i].get_value(), expected_target[i]);
+            }
+        }
+
+        bool proof_result = false;
+        if (!composer.failed()) {
+            auto prover = composer.create_prover();
+            auto verifier = composer.create_verifier();
+            auto proof = prover.construct_proof();
+            info("composer gates = ", composer.get_num_gates());
+            proof_result = verifier.verify_proof(proof);
+        }
+
+        return std::make_pair(proof_result, composer.err());
+    }
+
+    static void test_pata_large_bench()
+    {
+        // Benchmark
+        Composer composer = Composer();
+
+        std::array<fr, 64> source;
+        std::array<fr, 128> target = { 0 };
+        std::array<fr, 128> expected_target;
+        for (size_t i = 0; i < source.max_size(); ++i) {
+            source[i] = i + 1;
+            target[i] = i + 1;
+            expected_target[i] = i + 1;
+            expected_target[i + source.max_size()] = i + 1;
+        };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_same_size_not_full_to_not_full()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 4> source = { 1, 0, 0, 0 };
+        std::array<fr, 4> target = { 3, 0, 0, 0 };
+        std::array<fr, 4> expected_target = { 3, 1, 0, 0 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_same_size_not_full_to_not_full_2()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 4> source = { 3, 4, 0, 0 };
+        std::array<fr, 4> target = { 1, 2, 0, 0 };
+        std::array<fr, 4> expected_target = { 1, 2, 3, 4 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_same_size_not_full_to_empty()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 4> source = { 1, 2, 3, 0 };
+        std::array<fr, 4> target = { 0, 0, 0, 0 };
+        std::array<fr, 4> expected_target = { 1, 2, 3, 0 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_smaller_source_full_to_not_full()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 3> source = { 1, 2, 3 };
+        std::array<fr, 6> target = { 4, 5, 6, 0, 0, 0 };
+        std::array<fr, 6> expected_target = { 4, 5, 6, 1, 2, 3 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_null_source()
+    {
+        // null means array size is 0
+        Composer composer = Composer();
+
+        std::array<fr, 0> source;
+        std::array<fr, 4> target = { 1, 2, 0, 0 };
+        std::array<fr, 4> expected_target = { 1, 2, 0, 0 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_null_target_fails()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 4> source = { 1, 2, 0, 0 };
+        std::array<fr, 0> target;
+        std::array<fr, 0> expected_target;
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_FALSE(proof_result);
+        EXPECT_EQ(error, "push_array_to_array target array capacity exceeded");
+    }
+
+    static void test_pata_singletons_full_to_not_full()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 1> source = { 1 };
+        std::array<fr, 1> target = { 0 };
+        std::array<fr, 1> expected_target = { 1 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_singletons_not_full_to_full()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 1> source = { 0 };
+        std::array<fr, 1> target = { 1 };
+        std::array<fr, 1> expected_target = { 1 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_TRUE(proof_result);
+    }
+
+    static void test_pata_singletons_full_to_full()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 1> source = { 2 };
+        std::array<fr, 1> target = { 1 };
+        std::array<fr, 1> expected_target = { 1 };
+        bool proof_result;
+        std::string error;
+        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+
+        EXPECT_FALSE(proof_result);
+        EXPECT_EQ(error, "push_array_to_array target array capacity exceeded");
+    }
+
+    static void test_pata_same_size_full_to_full_fails()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 5> source = { 1, 2, 3, 4, 5 };
+        std::array<fr, 5> target = { 5, 6, 7, 8, 9 };
+        std::array<fr, 5> expected_target = { 5, 6, 7, 8, 9 };
+        bool proof_result;
+        std::string error;
+        bool expect_fail = true;
+        std::tie(proof_result, error) =
+            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+
+        EXPECT_FALSE(proof_result);
+        EXPECT_EQ(error, "push_array_to_array target array capacity exceeded");
+    }
+
+    static void test_pata_nonzero_after_zero_source_fails()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 4> source = { 1, 0, 2, 3 };
+        std::array<fr, 6> target = { 4, 5, 6, 7, 8, 0 };
+        std::array<fr, 6> expected_target = { 4, 5, 6, 7, 8, 0 };
+        bool proof_result;
+        std::string error;
+        bool expect_fail = true;
+        std::tie(proof_result, error) =
+            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+
+        EXPECT_FALSE(proof_result);
+        EXPECT_EQ(error, "Once we've hit the first source zero, there must only be zeros thereafter!");
+    }
+
+    static void test_pata_nonzero_after_zero_source_fails_2()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 3> source = { 1, 0, 3 };
+        std::array<fr, 6> target = { 4, 5, 2, 0, 0, 0 };
+        std::array<fr, 6> expected_target = { 4, 5, 2, 1, 0, 3 };
+        bool proof_result;
+        std::string error;
+        bool expect_fail = true;
+        std::tie(proof_result, error) =
+            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+
+        EXPECT_FALSE(proof_result);
+        EXPECT_EQ(error, "Once we've hit the first source zero, there must only be zeros thereafter!");
+    }
+
+    static void test_pata_nonzero_after_zero_target_fails()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 3> source = { 1, 2, 3 };
+        std::array<fr, 6> target = { 4, 5, 0, 6, 7, 8 };
+        std::array<fr, 6> expected_target = { 4, 5, 0, 6, 7, 8 };
+        bool proof_result;
+        std::string error;
+        bool expect_fail = true;
+        std::tie(proof_result, error) =
+            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+
+        EXPECT_FALSE(proof_result);
+        EXPECT_EQ(error, "Once we've hit the first zero, there must only be zeros thereafter!");
+    }
+
+    static void test_pata_nonzero_after_zero_target_fails_2()
+    {
+        Composer composer = Composer();
+
+        std::array<fr, 3> source = { 1, 0, 3 };
+        std::array<fr, 6> target = { 4, 5, 0, 6, 7, 8 };
+        std::array<fr, 6> expected_target = { 4, 5, 0, 6, 7, 8 };
+        bool proof_result;
+        std::string error;
+        bool expect_fail = true;
+        std::tie(proof_result, error) =
+            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+
+        EXPECT_FALSE(proof_result);
+        EXPECT_EQ(error, "Once we've hit the first zero, there must only be zeros thereafter!");
+    }
+
+    class MockClass {
+      public:
+        MockClass()
+            : m_a(field_ct(0))
+            , m_b(field_ct(0))
+        {}
+        MockClass(field_ct a, field_ct b)
+            : m_a(a)
+            , m_b(b)
+        {}
+
+        bool_ct is_empty() const { return m_a == 0 && m_b == 0; }
+
+        std::pair<field_ct, field_ct> get_values() { return std::make_pair(m_a, m_b); }
+
+        void conditional_select(bool_ct const& condition, MockClass const& other)
+        {
+            m_a = field_ct::conditional_assign(condition, other.m_a, m_a);
+            m_b = field_ct::conditional_assign(condition, other.m_b, m_b);
+        }
+
+      private:
+        field_ct m_a;
+        field_ct m_b;
+    };
+
+    void test_array_push_generic()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t SIZE = 5;
+        std::array<MockClass, SIZE> arr{};
+
+        // Push values into the array
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 1), witness_ct(&composer, 10)));
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 2), witness_ct(&composer, 20)));
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 3), witness_ct(&composer, 30)));
+
+        // Check the values in the array
+        EXPECT_EQ(arr[0].get_values().first.get_value(), 1);
+        EXPECT_EQ(arr[0].get_values().second.get_value(), 10);
+        EXPECT_EQ(arr[1].get_values().first.get_value(), 2);
+        EXPECT_EQ(arr[1].get_values().second.get_value(), 20);
+        EXPECT_EQ(arr[2].get_values().first.get_value(), 3);
+        EXPECT_EQ(arr[2].get_values().second.get_value(), 30);
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    }
+
+    void test_array_push_generic_full()
+    {
+        Composer composer = Composer();
+
+        constexpr size_t SIZE = 5;
+        std::array<MockClass, SIZE> arr{};
+
+        // Push values into the array
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 1), witness_ct(&composer, 10)));
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 2), witness_ct(&composer, 20)));
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 3), witness_ct(&composer, 30)));
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 4), witness_ct(&composer, 40)));
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 5), witness_ct(&composer, 50)));
+
+        // Try to push into a full array
+        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 6), witness_ct(&composer, 60)));
+
+        EXPECT_EQ(composer.failed(), true);
+        EXPECT_EQ(composer.err(), "array_push cannot push to a full array");
+    }
+};
+
+typedef testing::Types<plonk::UltraComposer, plonk::TurboComposer, plonk::StandardComposer, honk::StandardHonkComposer>
+    ComposerTypes;
+
+TYPED_TEST_SUITE(stdlib_array, ComposerTypes);
+
+TYPED_TEST(stdlib_array, test_array_length)
+{
+    TestFixture::test_array_length();
+}
+TYPED_TEST(stdlib_array, test_array_length_null)
+{
+    TestFixture::test_array_length_null();
+}
+TYPED_TEST(stdlib_array, test_array_length_fails)
+{
+    TestFixture::test_array_length_fails();
+}
+TYPED_TEST(stdlib_array, test_array_pop)
+{
+    TestFixture::test_array_pop();
+}
+TYPED_TEST(stdlib_array, test_array_pop_from_empty)
+{
+    TestFixture::test_array_pop_from_empty();
+}
+TYPED_TEST(stdlib_array, test_array_push)
+{
+    TestFixture::test_array_push();
+}
+TYPED_TEST(stdlib_array, test_array_push_optional)
+{
+    TestFixture::test_array_push_optional();
+}
+TYPED_TEST(stdlib_array, test_array_push_generic)
+{
+    TestFixture::test_array_push_generic();
+}
+TYPED_TEST(stdlib_array, test_array_push_generic_full)
+{
+    TestFixture::test_array_push_generic_full();
+}
+// push array to array (pata) tests
+TYPED_TEST(stdlib_array, test_pata_large_bench)
+{
+    TestFixture::test_pata_large_bench();
+}
+TYPED_TEST(stdlib_array, test_pata_same_size_not_full_to_not_full)
+{
+    TestFixture::test_pata_same_size_not_full_to_not_full();
+}
+TYPED_TEST(stdlib_array, test_pata_same_size_not_full_to_not_full_2)
+{
+    TestFixture::test_pata_same_size_not_full_to_not_full_2();
+}
+TYPED_TEST(stdlib_array, test_pata_same_size_not_full_to_empty)
+{
+    TestFixture::test_pata_same_size_not_full_to_empty();
+}
+TYPED_TEST(stdlib_array, test_pata_smaller_source_full_to_not_full)
+{
+    TestFixture::test_pata_smaller_source_full_to_not_full();
+}
+TYPED_TEST(stdlib_array, test_pata_null_source)
+{
+    TestFixture::test_pata_null_source();
+}
+TYPED_TEST(stdlib_array, test_pata_null_target_fails)
+{
+    TestFixture::test_pata_null_target_fails();
+}
+TYPED_TEST(stdlib_array, test_pata_singletons_full_to_not_full)
+{
+    TestFixture::test_pata_singletons_full_to_not_full();
+}
+TYPED_TEST(stdlib_array, test_pata_singletons_not_full_to_full)
+{
+    TestFixture::test_pata_singletons_not_full_to_full();
+}
+TYPED_TEST(stdlib_array, test_pata_singletons_full_to_full)
+{
+    TestFixture::test_pata_singletons_full_to_full();
+}
+TYPED_TEST(stdlib_array, test_pata_same_size_full_to_full_fails)
+{
+    TestFixture::test_pata_same_size_full_to_full_fails();
+}
+TYPED_TEST(stdlib_array, test_pata_nonzero_after_zero_source_fails)
+{
+    TestFixture::test_pata_nonzero_after_zero_source_fails();
+}
+TYPED_TEST(stdlib_array, test_pata_nonzero_after_zero_source_fails_2)
+{
+    TestFixture::test_pata_nonzero_after_zero_source_fails_2();
+}
+TYPED_TEST(stdlib_array, test_pata_nonzero_after_zero_target_fails)
+{
+    TestFixture::test_pata_nonzero_after_zero_target_fails();
+}
+TYPED_TEST(stdlib_array, test_pata_nonzero_after_zero_target_fails_2)
+{
+    TestFixture::test_pata_nonzero_after_zero_target_fails_2();
+}
+} // namespace test_stdlib_array
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/primitives/field/field.hpp b/cpp/src/barretenberg/stdlib/primitives/field/field.hpp
index bbe7268727d..401af793b04 100644
--- a/cpp/src/barretenberg/stdlib/primitives/field/field.hpp
+++ b/cpp/src/barretenberg/stdlib/primitives/field/field.hpp
@@ -104,6 +104,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;
@@ -136,6 +143,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)
@@ -239,9 +261,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/barretenberg/stdlib/primitives/field/field.test.cpp b/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
index b78f492e3e0..7d3fa5e5761 100644
--- a/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
@@ -1,12 +1,15 @@
 #include "../bool/bool.hpp"
 #include "field.hpp"
+#include "array.hpp"
 #include "barretenberg/plonk/proof_system/constants.hpp"
 #include <gtest/gtest.h>
+#include <utility>
 #include "barretenberg/honk/composer/standard_honk_composer.hpp"
 #include "barretenberg/plonk/composer/standard_composer.hpp"
 #include "barretenberg/plonk/composer/ultra_composer.hpp"
 #include "barretenberg/plonk/composer/turbo_composer.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
+#include "barretenberg/common/streams.hpp"
 
 using namespace proof_system;
 
@@ -241,6 +244,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();
+        auto 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();
+        auto proof = prover.construct_proof();
+        bool result = verifier.verify_proof(proof);
+        EXPECT_EQ(result, true);
+    }
+
     static void test_field_fibbonaci()
     {
         Composer composer = Composer();
@@ -579,7 +620,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));
@@ -908,6 +950,30 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(composer.failed(), true);
         EXPECT_EQ(composer.err(), "field_t::pow exponent accumulator incorrect");
     };
+
+    static void test_copy_as_new_witness()
+    {
+        Composer composer = Composer();
+
+        barretenberg::fr value(engine.get_random_uint256());
+        field_ct value_ct = witness_ct(&composer, value);
+
+        field_ct first_copy = witness_ct(&composer, value_ct.get_value());
+        field_ct second_copy = field_ct::copy_as_new_witness(composer, value_ct);
+
+        EXPECT_EQ(value_ct.get_value(), value);
+        EXPECT_EQ(first_copy.get_value(), value);
+        EXPECT_EQ(second_copy.get_value(), value);
+        EXPECT_EQ(value_ct.get_witness_index() + 1, first_copy.get_witness_index());
+        EXPECT_EQ(value_ct.get_witness_index() + 2, second_copy.get_witness_index());
+
+        auto prover = composer.create_prover();
+        auto verifier = composer.create_verifier();
+        auto proof = prover.construct_proof();
+        info("composer gates = ", composer.get_num_gates());
+        bool proof_result = verifier.verify_proof(proof);
+        EXPECT_EQ(proof_result, true);
+    }
 };
 
 typedef testing::Types<plonk::UltraComposer, plonk::TurboComposer, plonk::StandardComposer, honk::StandardHonkComposer>
@@ -931,6 +997,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();
@@ -1023,4 +1097,8 @@ TYPED_TEST(stdlib_field, test_pow_exponent_out_of_range)
 {
     TestFixture::test_pow_exponent_out_of_range();
 }
+TYPED_TEST(stdlib_field, test_copy_as_new_witness)
+{
+    TestFixture::test_copy_as_new_witness();
+}
 } // namespace test_stdlib_field
diff --git a/cpp/src/barretenberg/stdlib/primitives/group/group.hpp b/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
index f3cf23e1d53..071056d16e2 100644
--- a/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
+++ b/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
@@ -3,7 +3,7 @@
 #include "../field/field.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/plonk/composer/composer_base.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 
 #include "../../hash/pedersen/pedersen.hpp"
 #include "../../hash/pedersen/pedersen_gates.hpp"
@@ -14,7 +14,7 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 using namespace barretenberg;
-using namespace crypto::pedersen;
+using namespace crypto::pedersen_hash;
 
 template <typename ComposerContext> class group {
   public:
@@ -137,7 +137,7 @@ auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<Compos
     fr three = ((one + one) + one);
 
     for (size_t i = 0; i < num_quads; ++i) {
-        uint64_t entry = wnaf_entries[i + 1] & stdlib::WNAF_MASK;
+        uint64_t entry = wnaf_entries[i + 1] & crypto::generators::WNAF_MASK;
 
         fr prev_accumulator = accumulator_transcript[i] + accumulator_transcript[i];
         prev_accumulator = prev_accumulator + prev_accumulator;
@@ -209,7 +209,7 @@ auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<Compos
     accumulator_witnesses.push_back(add_quad.d);
 
     if (num_bits >= 254) {
-        plonk::stdlib::pedersen<ComposerContext>::validate_wnaf_is_in_field(ctx, accumulator_witnesses);
+        plonk::stdlib::pedersen_hash<ComposerContext>::validate_wnaf_is_in_field(ctx, accumulator_witnesses);
     }
     aligned_free(multiplication_transcript);
     aligned_free(accumulator_transcript);
diff --git a/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp b/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
index f59f8b8888d..7bb79fc0d64 100644
--- a/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
@@ -20,7 +20,7 @@ TEST(stdlib_group, test_fixed_base_scalar_mul)
 {
     auto scalar = uint256_t(123, 0, 0, 0);
     auto priv_key = grumpkin::fr(scalar);
-    auto pub_key = crypto::pedersen::get_generator_data(crypto::pedersen::DEFAULT_GEN_1).generator * priv_key;
+    auto pub_key = crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_1).generator * priv_key;
 
     Composer composer;
     auto priv_key_witness = field_ct(witness_ct(&composer, fr(scalar)));
@@ -30,7 +30,7 @@ TEST(stdlib_group, test_fixed_base_scalar_mul)
     EXPECT_EQ(result.x.get_value(), pub_key.x);
     EXPECT_EQ(result.y.get_value(), pub_key.y);
 
-    auto native_result = crypto::pedersen::fixed_base_scalar_mul<128>(barretenberg::fr(scalar), 0);
+    auto native_result = crypto::generators::fixed_base_scalar_mul<128>(barretenberg::fr(scalar), 0);
     EXPECT_EQ(native_result.x, pub_key.x);
     EXPECT_EQ(native_result.y, pub_key.y);
 
diff --git a/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp b/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp
index 235e966a677..f9fd3d89849 100644
--- a/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp
+++ b/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp
@@ -4,7 +4,7 @@
 #include "barretenberg/plonk/composer/ultra_composer.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
 #include "barretenberg/numeric/bitop/rotate.hpp"
-#include "barretenberg/crypto/pedersen/pedersen_lookup.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp"
 #include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
 #include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
 #include "barretenberg/stdlib/primitives/uint/uint.hpp"
@@ -41,8 +41,8 @@ TEST(stdlib_plookup, pedersen_lookup_left)
     std::vector<barretenberg::fr> expected_y;
 
     const size_t num_lookups_hi =
-        (128 + crypto::pedersen::lookup::BITS_PER_TABLE) / crypto::pedersen::lookup::BITS_PER_TABLE;
-    const size_t num_lookups_lo = 126 / crypto::pedersen::lookup::BITS_PER_TABLE;
+        (128 + crypto::pedersen_hash::lookup::BITS_PER_TABLE) / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    const size_t num_lookups_lo = 126 / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
 
     EXPECT_EQ(num_lookups_hi, lookup_hi[ColumnIdx::C1].size());
     EXPECT_EQ(num_lookups_lo, lookup_lo[ColumnIdx::C1].size());
@@ -57,21 +57,21 @@ TEST(stdlib_plookup, pedersen_lookup_left)
         const size_t num_rounds = (num_lookups + 1) / 2;
         uint256_t bits(input_value);
 
-        const auto mask = crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE - 1;
+        const auto mask = crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE - 1;
 
         for (size_t i = 0; i < num_rounds; ++i) {
-            const auto& table = crypto::pedersen::lookup::get_table(i);
+            const auto& table = crypto::pedersen_hash::lookup::get_table(i);
             const size_t index = i * 2;
 
             size_t slice_a =
-                static_cast<size_t>(((bits >> (index * crypto::pedersen::lookup::BITS_PER_TABLE)) & mask).data[0]);
+                static_cast<size_t>(((bits >> (index * crypto::pedersen_hash::lookup::BITS_PER_TABLE)) & mask).data[0]);
             expected_x[index] = (table[slice_a].x);
             expected_y[index] = (table[slice_a].y);
             expected_scalars[index] = slice_a;
 
             if (i < 14) {
                 size_t slice_b = static_cast<size_t>(
-                    ((bits >> ((index + 1) * crypto::pedersen::lookup::BITS_PER_TABLE)) & mask).data[0]);
+                    ((bits >> ((index + 1) * crypto::pedersen_hash::lookup::BITS_PER_TABLE)) & mask).data[0]);
                 expected_x[index + 1] = (table[slice_b].x);
                 expected_y[index + 1] = (table[slice_b].y);
                 expected_scalars[index + 1] = slice_b;
@@ -80,7 +80,7 @@ TEST(stdlib_plookup, pedersen_lookup_left)
     }
 
     for (size_t i = num_lookups - 2; i < num_lookups; --i) {
-        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
     size_t hi_shift = 126;
     const fr hi_cumulative = lookup_hi[ColumnIdx::C1][0].get_value();
@@ -89,7 +89,7 @@ TEST(stdlib_plookup, pedersen_lookup_left)
         EXPECT_EQ(lookup_lo[ColumnIdx::C1][i].get_value() + (hi_cumulative * hi_mult), expected_scalars[i]);
         EXPECT_EQ(lookup_lo[ColumnIdx::C2][i].get_value(), expected_x[i]);
         EXPECT_EQ(lookup_lo[ColumnIdx::C3][i].get_value(), expected_y[i]);
-        hi_shift -= crypto::pedersen::lookup::BITS_PER_TABLE;
+        hi_shift -= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
     }
     for (size_t i = 0; i < num_lookups_hi; ++i) {
         EXPECT_EQ(lookup_hi[ColumnIdx::C1][i].get_value(), expected_scalars[i + num_lookups_lo]);
@@ -121,8 +121,8 @@ TEST(stdlib_plookup, pedersen_lookup_right)
     std::vector<barretenberg::fr> expected_y;
 
     const size_t num_lookups_hi =
-        (128 + crypto::pedersen::lookup::BITS_PER_TABLE) / crypto::pedersen::lookup::BITS_PER_TABLE;
-    const size_t num_lookups_lo = 126 / crypto::pedersen::lookup::BITS_PER_TABLE;
+        (128 + crypto::pedersen_hash::lookup::BITS_PER_TABLE) / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
+    const size_t num_lookups_lo = 126 / crypto::pedersen_hash::lookup::BITS_PER_TABLE;
 
     EXPECT_EQ(num_lookups_hi, lookup_hi[ColumnIdx::C1].size());
     EXPECT_EQ(num_lookups_lo, lookup_lo[ColumnIdx::C1].size());
@@ -137,21 +137,21 @@ TEST(stdlib_plookup, pedersen_lookup_right)
         const size_t num_rounds = (num_lookups + 1) / 2;
         uint256_t bits(input_value);
 
-        const auto mask = crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE - 1;
+        const auto mask = crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE - 1;
 
         for (size_t i = 0; i < num_rounds; ++i) {
-            const auto& table = crypto::pedersen::lookup::get_table(i + num_rounds);
+            const auto& table = crypto::pedersen_hash::lookup::get_table(i + num_rounds);
             const size_t index = i * 2;
 
             size_t slice_a =
-                static_cast<size_t>(((bits >> (index * crypto::pedersen::lookup::BITS_PER_TABLE)) & mask).data[0]);
+                static_cast<size_t>(((bits >> (index * crypto::pedersen_hash::lookup::BITS_PER_TABLE)) & mask).data[0]);
             expected_x[index] = (table[slice_a].x);
             expected_y[index] = (table[slice_a].y);
             expected_scalars[index] = slice_a;
 
             if (i < 14) {
                 size_t slice_b = static_cast<size_t>(
-                    ((bits >> ((index + 1) * crypto::pedersen::lookup::BITS_PER_TABLE)) & mask).data[0]);
+                    ((bits >> ((index + 1) * crypto::pedersen_hash::lookup::BITS_PER_TABLE)) & mask).data[0]);
                 expected_x[index + 1] = (table[slice_b].x);
                 expected_y[index + 1] = (table[slice_b].y);
                 expected_scalars[index + 1] = slice_b;
@@ -160,7 +160,7 @@ TEST(stdlib_plookup, pedersen_lookup_right)
     }
 
     for (size_t i = num_lookups - 2; i < num_lookups; --i) {
-        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen::lookup::PEDERSEN_TABLE_SIZE);
+        expected_scalars[i] += (expected_scalars[i + 1] * crypto::pedersen_hash::lookup::PEDERSEN_TABLE_SIZE);
     }
     size_t hi_shift = 126;
     const fr hi_cumulative = lookup_hi[ColumnIdx::C1][0].get_value();
@@ -169,7 +169,7 @@ TEST(stdlib_plookup, pedersen_lookup_right)
         EXPECT_EQ(lookup_lo[ColumnIdx::C1][i].get_value() + (hi_cumulative * hi_mult), expected_scalars[i]);
         EXPECT_EQ(lookup_lo[ColumnIdx::C2][i].get_value(), expected_x[i]);
         EXPECT_EQ(lookup_lo[ColumnIdx::C3][i].get_value(), expected_y[i]);
-        hi_shift -= crypto::pedersen::lookup::BITS_PER_TABLE;
+        hi_shift -= crypto::pedersen_hash::lookup::BITS_PER_TABLE;
     }
     for (size_t i = 0; i < num_lookups_hi; ++i) {
         EXPECT_EQ(lookup_hi[ColumnIdx::C1][i].get_value(), expected_scalars[i + num_lookups_lo]);
diff --git a/cpp/src/barretenberg/stdlib/primitives/point/point.hpp b/cpp/src/barretenberg/stdlib/primitives/point/point.hpp
index 3c1f1143208..c61756ac89c 100644
--- a/cpp/src/barretenberg/stdlib/primitives/point/point.hpp
+++ b/cpp/src/barretenberg/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/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp b/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp
index 622e896fee2..401b44a95ef 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
@@ -472,7 +472,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/barretenberg/stdlib/recursion/CMakeLists.txt b/cpp/src/barretenberg/stdlib/recursion/CMakeLists.txt
index 0790762551c..325069d4465 100644
--- a/cpp/src/barretenberg/stdlib/recursion/CMakeLists.txt
+++ b/cpp/src/barretenberg/stdlib/recursion/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(stdlib_recursion ecc plonk stdlib_primitives stdlib_pedersen stdlib_blake3s) 
\ No newline at end of file
+barretenberg_module(stdlib_recursion ecc proof_system stdlib_primitives stdlib_pedersen_commitment stdlib_blake3s)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp b/cpp/src/barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp
new file mode 100644
index 00000000000..64d7e69fc8f
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp
@@ -0,0 +1,74 @@
+#pragma once
+#include "../../primitives/field/field.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+namespace recursion {
+
+/**
+ * Aggregation state contains the following:
+ *   (P0, P1): the aggregated elements storing the verification results of proofs in the past
+ *   proof_witness_indices: witness indices that point to (P0, P1)
+ *   public_inputs: the public inputs of the inner proof, these become the private inputs to the recursive circuit
+ *   has_data: indicates if this aggregation state contain past (P0, P1)
+ */
+template <typename Curve> struct aggregation_state {
+    typename Curve::g1_ct P0;
+    typename Curve::g1_ct P1;
+
+    // The public inputs of the inner ciruit are now private inputs of the outer circuit!
+    std::vector<typename Curve::fr_ct> public_inputs;
+    std::vector<uint32_t> proof_witness_indices;
+    bool has_data = false;
+
+    typename Curve::bool_ct operator==(aggregation_state const& other) const
+    {
+        return P0 == other.P0 && P1 == other.P1 && public_inputs == other.public_inputs &&
+               proof_witness_indices == other.proof_witness_indices;
+        //    has_data == other.has_data; can't compare as native
+    };
+
+    void add_proof_outputs_as_public_inputs()
+    {
+        ASSERT(proof_witness_indices.size() > 0);
+
+        auto* context = P0.get_context();
+
+        context->add_recursive_proof(proof_witness_indices);
+    }
+};
+
+template <typename Curve> void read(uint8_t const*& it, aggregation_state<Curve>& as)
+{
+    using serialize::read;
+
+    read(it, as.P0);
+    read(it, as.P1);
+    read(it, as.public_inputs);
+    read(it, as.proof_witness_indices);
+    read(it, as.has_data);
+};
+
+template <typename Curve> void write(std::vector<uint8_t>& buf, aggregation_state<Curve> const& as)
+{
+    using serialize::write;
+
+    write(buf, as.P0);
+    write(buf, as.P1);
+    write(buf, as.public_inputs);
+    write(buf, as.proof_witness_indices);
+    write(buf, as.has_data);
+};
+
+template <typename NCT> std::ostream& operator<<(std::ostream& os, aggregation_state<NCT> const& as)
+{
+    return os << "P0: " << as.P0 << "\n"
+              << "P1: " << as.P1 << "\n"
+              << "public_inputs: " << as.public_inputs << "\n"
+              << "proof_witness_indices: " << as.proof_witness_indices << "\n"
+              << "has_data: " << as.has_data << "\n";
+}
+
+} // namespace recursion
+} // namespace stdlib
+} // namespace proof_system::plonk
\ No newline at end of file
diff --git a/cpp/src/barretenberg/stdlib/recursion/aggregation_state/native_aggregation_state.hpp b/cpp/src/barretenberg/stdlib/recursion/aggregation_state/native_aggregation_state.hpp
new file mode 100644
index 00000000000..47b82b3f574
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/recursion/aggregation_state/native_aggregation_state.hpp
@@ -0,0 +1,63 @@
+#pragma once
+#include "barretenberg/ecc/groups/affine_element.hpp"
+#include "barretenberg/ecc/curves/bn254/g1.hpp"
+#include "barretenberg/common/streams.hpp"
+
+namespace proof_system::plonk {
+namespace stdlib {
+namespace recursion {
+
+/**
+ * Native aggregation state contains the following:
+ *   (P0, P1): the aggregated elements storing the verification results of proofs in the past
+ *   proof_witness_indices: witness indices that point to (P0, P1)
+ *   public_inputs: the public inputs of the inner proof, these become the private inputs to the recursive circuit
+ *   has_data: indicates if this aggregation state contain past (P0, P1)
+ */
+struct native_aggregation_state {
+    typename barretenberg::g1::affine_element P0 = barretenberg::g1::affine_one;
+    typename barretenberg::g1::affine_element P1 = barretenberg::g1::affine_one;
+    std::vector<barretenberg::fr> public_inputs;
+    std::vector<uint32_t> proof_witness_indices;
+    bool has_data = false;
+
+    bool operator==(native_aggregation_state const& other) const
+    {
+        return P0 == other.P0 && P1 == other.P1 && public_inputs == other.public_inputs &&
+               proof_witness_indices == other.proof_witness_indices && has_data == other.has_data;
+    };
+};
+
+inline void read(uint8_t const*& it, native_aggregation_state& state)
+{
+    using serialize::read;
+
+    read(it, state.P0);
+    read(it, state.P1);
+    read(it, state.public_inputs);
+    read(it, state.proof_witness_indices);
+    read(it, state.has_data);
+};
+
+template <typename B> inline void write(B& buf, native_aggregation_state const& state)
+{
+    using serialize::write;
+    write(buf, state.P0);
+    write(buf, state.P1);
+    write(buf, state.public_inputs);
+    write(buf, state.proof_witness_indices);
+    write(buf, state.has_data);
+}
+
+inline std::ostream& operator<<(std::ostream& os, native_aggregation_state const& obj)
+{
+    return os << "P0: " << obj.P0 << "\n"
+              << "P1: " << obj.P1 << "\n"
+              << "public_inputs: " << obj.public_inputs << "\n"
+              << "proof_witness_indices: " << obj.proof_witness_indices << "\n"
+              << "has_data: " << obj.has_data << "\n";
+};
+
+} // namespace recursion
+} // namespace stdlib
+} // namespace proof_system::plonk
\ 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 def7ead90a7..73055fb3762 100644
--- a/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
@@ -8,8 +8,8 @@
 #include "../../primitives/curves/bn254.hpp"
 #include "../verification_key/verification_key.hpp"
 #include "../../hash/blake3s/blake3s.hpp"
-#include "../../hash/pedersen/pedersen.hpp"
-#include "../../hash/pedersen/pedersen_plookup.hpp"
+#include "../../commitment/pedersen/pedersen.hpp"
+#include "../../commitment/pedersen/pedersen_plookup.hpp"
 #include "../../primitives/bigfield/bigfield.hpp"
 #include "../../primitives/biggroup/biggroup.hpp"
 #include "../../primitives/bool/bool.hpp"
@@ -247,9 +247,9 @@ template <typename Composer> class Transcript {
 
         field_pt T0;
         if constexpr (Composer::type == ComposerType::PLOOKUP) {
-            T0 = stdlib::pedersen_plookup<Composer>::compress(compression_buffer);
+            T0 = stdlib::pedersen_plookup_commitment<Composer>::compress(compression_buffer);
         } else {
-            T0 = stdlib::pedersen<Composer>::compress(compression_buffer);
+            T0 = stdlib::pedersen_commitment<Composer>::compress(compression_buffer);
         }
         byte_array<Composer> compressed_buffer(T0);
 
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 4d6dc477c4f..57b8a39207c 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -5,20 +5,19 @@
 
 #include "barretenberg/plonk/proof_system/types/polynomial_manifest.hpp"
 
-#include "barretenberg/plonk/proof_system/utils/kate_verification.hpp"
 #include "barretenberg/plonk/proof_system/public_inputs/public_inputs.hpp"
 
 #include "barretenberg/polynomials/polynomial_arithmetic.hpp"
 
 #include "barretenberg/ecc/curves/bn254/fq12.hpp"
 #include "barretenberg/ecc/curves/bn254/pairing.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
-#include "barretenberg/crypto/pedersen/pedersen_lookup.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp"
 
 #include "../../primitives/uint/uint.hpp"
 #include "../../primitives/memory/rom_table.hpp"
-#include "../../hash/pedersen/pedersen.hpp"
-#include "../../hash/pedersen/pedersen_plookup.hpp"
+#include "../../commitment/pedersen/pedersen.hpp"
+#include "../../commitment/pedersen/pedersen_plookup.hpp"
 #include "../../primitives/curves/bn254.hpp"
 
 namespace proof_system::plonk {
@@ -55,14 +54,14 @@ template <typename Composer> struct evaluation_domain {
     field_t<Composer> compress() const
     {
         if constexpr (Composer::type == ComposerType::PLOOKUP) {
-            field_t<Composer> out = pedersen_plookup<Composer>::compress({
+            field_t<Composer> out = pedersen_plookup_commitment<Composer>::compress({
                 root,
                 domain,
                 generator,
             });
             return out;
         } else {
-            field_t<Composer> out = pedersen<Composer>::compress({
+            field_t<Composer> out = pedersen_commitment<Composer>::compress({
                 root,
                 domain,
                 generator,
@@ -75,13 +74,13 @@ template <typename Composer> struct evaluation_domain {
     {
         barretenberg::fr out;
         if constexpr (Composer::type == ComposerType::PLOOKUP) {
-            out = crypto::pedersen::lookup::compress_native({
+            out = crypto::pedersen_commitment::lookup::compress_native({
                 input.root,
                 input.domain,
                 input.generator,
             });
         } else {
-            out = crypto::pedersen::compress_native({
+            out = crypto::pedersen_commitment::compress_native({
                 input.root,
                 input.domain,
                 input.generator,
@@ -120,6 +119,7 @@ template <typename Curve> struct verification_key {
         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);
 
         for (const auto& [tag, value] : input_key->commitments) {
             key->commitments.insert({ tag, Curve::g1_ct::from_witness(ctx, value) });
@@ -136,6 +136,7 @@ template <typename Curve> struct verification_key {
         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->domain = evaluation_domain<Composer>::from_constants(ctx, input_key->domain);
 
@@ -185,35 +186,37 @@ template <typename Curve> struct verification_key {
         }
     }
 
-  private:
-    field_t<Composer> compress()
+  public:
+    field_t<Composer> compress(size_t const hash_index = 0)
     {
         field_t<Composer> compressed_domain = domain.compress();
 
-        std::vector<field_t<Composer>> key_witnesses;
-        key_witnesses.push_back(compressed_domain);
-        key_witnesses.push_back(num_public_inputs);
+        std::vector<field_t<Composer>> preimage_data;
+        preimage_data.push_back(Composer::type);
+        preimage_data.push_back(compressed_domain);
+        preimage_data.push_back(num_public_inputs);
         for (const auto& [tag, selector] : commitments) {
-            key_witnesses.push_back(selector.x.binary_basis_limbs[0].element);
-            key_witnesses.push_back(selector.x.binary_basis_limbs[1].element);
-            key_witnesses.push_back(selector.x.binary_basis_limbs[2].element);
-            key_witnesses.push_back(selector.x.binary_basis_limbs[3].element);
-            key_witnesses.push_back(selector.y.binary_basis_limbs[0].element);
-            key_witnesses.push_back(selector.y.binary_basis_limbs[1].element);
-            key_witnesses.push_back(selector.y.binary_basis_limbs[2].element);
-            key_witnesses.push_back(selector.y.binary_basis_limbs[3].element);
+            preimage_data.push_back(selector.x.binary_basis_limbs[0].element);
+            preimage_data.push_back(selector.x.binary_basis_limbs[1].element);
+            preimage_data.push_back(selector.x.binary_basis_limbs[2].element);
+            preimage_data.push_back(selector.x.binary_basis_limbs[3].element);
+            preimage_data.push_back(selector.y.binary_basis_limbs[0].element);
+            preimage_data.push_back(selector.y.binary_basis_limbs[1].element);
+            preimage_data.push_back(selector.y.binary_basis_limbs[2].element);
+            preimage_data.push_back(selector.y.binary_basis_limbs[3].element);
         }
 
         field_t<Composer> compressed_key;
         if constexpr (Composer::type == ComposerType::PLOOKUP) {
-            compressed_key = pedersen_plookup<Composer>::compress(key_witnesses);
+            compressed_key = pedersen_plookup_commitment<Composer>::compress(preimage_data, hash_index);
         } else {
-            compressed_key = pedersen<Composer>::compress(key_witnesses);
+            compressed_key = pedersen_commitment<Composer>::compress(preimage_data, hash_index);
         }
         return compressed_key;
     }
 
-    barretenberg::fr compress_native(const std::shared_ptr<plonk::verification_key>& key)
+    static barretenberg::fr compress_native(const std::shared_ptr<plonk::verification_key>& key,
+                                            const size_t hash_index = 0)
     {
         barretenberg::fr compressed_domain = evaluation_domain<Composer>::compress_native(key->domain);
 
@@ -227,28 +230,30 @@ template <typename Curve> struct verification_key {
             return limbs;
         };
 
-        std::vector<barretenberg::fr> key_witnesses;
-        key_witnesses.push_back(compressed_domain);
-        key_witnesses.push_back(key->num_public_inputs);
+        std::vector<barretenberg::fr> preimage_data;
+        preimage_data.push_back(Composer::type);
+        preimage_data.push_back(compressed_domain);
+        preimage_data.push_back(key->num_public_inputs);
         for (const auto& [tag, selector] : key->commitments) {
             const auto x_limbs = split_bigfield_limbs(selector.x);
             const auto y_limbs = split_bigfield_limbs(selector.y);
 
-            key_witnesses.push_back(x_limbs[0]);
-            key_witnesses.push_back(x_limbs[1]);
-            key_witnesses.push_back(x_limbs[2]);
-            key_witnesses.push_back(x_limbs[3]);
+            preimage_data.push_back(x_limbs[0]);
+            preimage_data.push_back(x_limbs[1]);
+            preimage_data.push_back(x_limbs[2]);
+            preimage_data.push_back(x_limbs[3]);
 
-            key_witnesses.push_back(y_limbs[0]);
-            key_witnesses.push_back(y_limbs[1]);
-            key_witnesses.push_back(y_limbs[2]);
-            key_witnesses.push_back(y_limbs[3]);
+            preimage_data.push_back(y_limbs[0]);
+            preimage_data.push_back(y_limbs[1]);
+            preimage_data.push_back(y_limbs[2]);
+            preimage_data.push_back(y_limbs[3]);
         }
+
         barretenberg::fr compressed_key;
         if constexpr (Composer::type == ComposerType::PLOOKUP) {
-            compressed_key = crypto::pedersen::lookup::compress_native(key_witnesses);
+            compressed_key = crypto::pedersen_commitment::lookup::compress_native(preimage_data, hash_index);
         } else {
-            compressed_key = crypto::pedersen::compress_native(key_witnesses);
+            compressed_key = crypto::pedersen_commitment::compress_native(preimage_data, hash_index);
         }
         return compressed_key;
     }
@@ -259,6 +264,10 @@ 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;
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
new file mode 100644
index 00000000000..5be5ce87c92
--- /dev/null
+++ b/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
@@ -0,0 +1,90 @@
+#include "barretenberg/common/test.hpp"
+#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+#include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
+#include "verification_key.hpp"
+
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+} // namespace
+
+using namespace proof_system::plonk;
+
+/**
+ * @brief A test fixture that will let us generate VK data and run tests
+ * for all composer types
+ *
+ * @tparam Composer
+ */
+template <typename Composer> class VerificationKeyFixture : public testing::Test {
+  public:
+    using Curve = stdlib::bn254<Composer>;
+    using RecursVk = plonk::stdlib::recursion::verification_key<Curve>;
+
+    static Composer init_composer() { return Composer("../srs_db/ignition"); }
+
+    /**
+     * @brief generate a random vk data for use in tests
+     *
+     * @return verification_key_data randomly generated
+     */
+    static verification_key_data rand_vk_data()
+    {
+        verification_key_data vk_data;
+        vk_data.composer_type = static_cast<uint32_t>(Composer::type);
+        vk_data.circuit_size = 1024; // not random - must be power of 2
+        vk_data.num_public_inputs = engine.get_random_uint32();
+        vk_data.commitments["test1"] = g1::element::random_element();
+        vk_data.commitments["test2"] = g1::element::random_element();
+        vk_data.commitments["foo1"] = g1::element::random_element();
+        vk_data.commitments["foo2"] = g1::element::random_element();
+        return vk_data;
+    }
+};
+
+// Each test will run for all composer types
+using ComposerTypes =
+    testing::Types<plonk::StandardComposer, plonk::TurboComposer, plonk::UltraComposer, honk::StandardHonkComposer>;
+TYPED_TEST_SUITE(VerificationKeyFixture, ComposerTypes);
+
+TYPED_TEST(VerificationKeyFixture, vk_data_vs_recursion_compress_native)
+{
+    using RecursVk = typename TestFixture::RecursVk;
+    auto composer = TestFixture::init_composer();
+
+    verification_key_data vk_data = TestFixture::rand_vk_data();
+    verification_key_data vk_data_copy = vk_data;
+
+    auto file_crs = std::make_unique<proof_system::FileReferenceStringFactory>("../srs_db/ignition");
+    auto file_verifier = file_crs->get_verifier_crs();
+
+    auto native_vk = std::make_shared<verification_key>(std::move(vk_data_copy), file_verifier);
+    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));
+    // 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));
+}
+
+TYPED_TEST(VerificationKeyFixture, compress_vs_compress_native)
+{
+    using RecursVk = typename TestFixture::RecursVk;
+    auto composer = TestFixture::init_composer();
+
+    verification_key_data vk_data = TestFixture::rand_vk_data();
+
+    auto file_crs = std::make_unique<proof_system::FileReferenceStringFactory>("../srs_db/ignition");
+    auto file_verifier = file_crs->get_verifier_crs();
+
+    auto native_vk = std::make_shared<verification_key>(std::move(vk_data), file_verifier);
+    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));
+    // 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));
+}
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
index 83800640ee8..aa185e34d7c 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.hpp
@@ -6,6 +6,7 @@
 #include "../../primitives/field/field.hpp"
 
 #include "../transcript/transcript.hpp"
+#include "../aggregation_state/aggregation_state.hpp"
 
 #include "barretenberg/plonk/proof_system/utils/kate_verification.hpp"
 #include "barretenberg/plonk/proof_system/public_inputs/public_inputs.hpp"
@@ -19,24 +20,6 @@ namespace proof_system::plonk {
 namespace stdlib {
 namespace recursion {
 
-template <typename Curve> struct recursion_output {
-    typename Curve::g1_ct P0;
-    typename Curve::g1_ct P1;
-    // the public inputs of the inner ciruit are now private inputs of the outer circuit!
-    std::vector<typename Curve::fr_ct> public_inputs;
-    std::vector<uint32_t> proof_witness_indices;
-    bool has_data = false;
-
-    void add_proof_outputs_as_public_inputs()
-    {
-        ASSERT(proof_witness_indices.size() > 0);
-
-        auto* context = P0.get_context();
-
-        context->add_recursive_proof(proof_witness_indices);
-    }
-};
-
 template <typename Composer> struct lagrange_evaluations {
     field_t<Composer> l_start;
     field_t<Composer> l_end;
@@ -194,11 +177,11 @@ lagrange_evaluations<typename Curve::Composer> get_lagrange_evaluations(
  * which includes detailed comments.
  */
 template <typename Curve, typename program_settings>
-recursion_output<Curve> verify_proof(typename Curve::Composer* context,
-                                     std::shared_ptr<verification_key<Curve>> key,
-                                     const transcript::Manifest& manifest,
-                                     const plonk::proof& proof,
-                                     const recursion_output<Curve> previous_output = recursion_output<Curve>())
+aggregation_state<Curve> verify_proof(typename Curve::Composer* context,
+                                      std::shared_ptr<verification_key<Curve>> key,
+                                      const transcript::Manifest& manifest,
+                                      const plonk::proof& proof,
+                                      const aggregation_state<Curve> previous_output = aggregation_state<Curve>())
 {
     using fr_ct = typename Curve::fr_ct;
     using fq_ct = typename Curve::fq_ct;
@@ -342,6 +325,10 @@ recursion_output<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
@@ -418,7 +405,7 @@ recursion_output<Curve> verify_proof(typename Curve::Composer* context,
         rhs.y.binary_basis_limbs[3].element.normalize().witness_index,
     };
 
-    return recursion_output<Curve>{
+    return aggregation_state<Curve>{
         opening_result, rhs, transcript.get_field_element_vector("public_inputs"), proof_witness_indices, true,
     };
 }
diff --git a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
index 25364b23580..82e8042b02f 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp
@@ -25,7 +25,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
     typedef inner_curve::witness_ct witness_ct;
 
     struct circuit_outputs {
-        stdlib::recursion::recursion_output<outer_curve> recursion_output;
+        stdlib::recursion::aggregation_state<outer_curve> aggregation_state;
         std::shared_ptr<verification_key_pt> verification_key;
     };
 
@@ -39,7 +39,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             a = (a * b) + b + a;
             a = a.madd(b, c);
         }
-        plonk::stdlib::pedersen<InnerComposer>::compress(a, b);
+        plonk::stdlib::pedersen_commitment<InnerComposer>::compress(a, b);
         typename inner_curve::byte_array_ct to_hash(&composer, "nonsense test data");
         stdlib::blake3s(to_hash);
 
@@ -86,7 +86,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             a = (a * b) + b + a;
             a = c.madd(b, a);
         }
-        plonk::stdlib::pedersen<InnerComposer>::compress(a, a);
+        plonk::stdlib::pedersen_commitment<InnerComposer>::compress(a, a);
         inner_curve::byte_array_ct to_hash(&composer, "different nonsense test data");
         stdlib::blake3s(to_hash);
 
@@ -158,7 +158,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         transcript::Manifest recursive_manifest = InnerComposer::create_manifest(prover.key->num_public_inputs);
 
         info("Verifying the ultra (inner) proof with CIRCUIT TYPES (i.e. within a standard plonk arithmetic circuit):");
-        stdlib::recursion::recursion_output<outer_curve> output =
+        stdlib::recursion::aggregation_state<outer_curve> output =
             stdlib::recursion::verify_proof<outer_curve, RecursiveSettings>(
                 &outer_composer, verification_key, recursive_manifest, recursive_proof);
 
@@ -192,7 +192,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
         transcript::Manifest recursive_manifest = InnerComposer::create_manifest(prover.key->num_public_inputs);
 
-        stdlib::recursion::recursion_output<outer_curve> previous_output =
+        stdlib::recursion::aggregation_state<outer_curve> previous_output =
             stdlib::recursion::verify_proof<outer_curve, RecursiveSettings>(
                 &outer_composer, verification_key, recursive_manifest, recursive_proof_a);
 
@@ -208,7 +208,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
         plonk::proof recursive_proof_b = prover.construct_proof();
 
-        stdlib::recursion::recursion_output<outer_curve> output =
+        stdlib::recursion::aggregation_state<outer_curve> output =
             stdlib::recursion::verify_proof<outer_curve, RecursiveSettings>(
                 &outer_composer, verification_key_b, recursive_manifest, recursive_proof_b, previous_output);
 
@@ -267,7 +267,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
         transcript::Manifest recursive_manifest = InnerComposer::create_manifest(prover_a.key->num_public_inputs);
 
-        stdlib::recursion::recursion_output<outer_curve> output =
+        stdlib::recursion::aggregation_state<outer_curve> output =
             stdlib::recursion::verify_proof<outer_curve, RecursiveSettings>(
                 &outer_composer, verification_key, recursive_manifest, recursive_proof);
 
@@ -288,20 +288,20 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         auto circuit_output = create_outer_circuit(inner_composer, outer_composer);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs[1]);
+        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]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
-        circuit_output.recursion_output.add_proof_outputs_as_public_inputs();
+        circuit_output.aggregation_state.add_proof_outputs_as_public_inputs();
 
         EXPECT_EQ(outer_composer.failed(), false);
 
@@ -336,17 +336,17 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         auto circuit_output = create_outer_circuit(inner_composer, outer_composer);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
-        circuit_output.recursion_output.add_proof_outputs_as_public_inputs();
+        circuit_output.aggregation_state.add_proof_outputs_as_public_inputs();
 
         EXPECT_EQ(outer_composer.failed(), false);
 
@@ -391,15 +391,15 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         auto circuit_output = create_double_outer_circuit(inner_composer_a, inner_composer_b, outer_composer);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs[1]);
+        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]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -442,16 +442,16 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             create_outer_circuit_with_variable_inner_circuit(inner_composer_a, inner_composer_b, outer_composer, true);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_a[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_a[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_a[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_a[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -488,17 +488,17 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             create_outer_circuit_with_variable_inner_circuit(inner_composer_a, inner_composer_b, outer_composer, false);
         g1::affine_element P[2];
 
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_b[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_b[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_b[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_b[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -534,16 +534,16 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             inner_composer_a, inner_composer_b, outer_composer, true, true);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_a[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_a[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_a[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_a[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -579,16 +579,16 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             inner_composer_a, inner_composer_b, outer_composer, true, false, true);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_a[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_a[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_a[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_a[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
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 3766296af7b..1f4410148b4 100644
--- a/cpp/src/barretenberg/stdlib/recursion/verifier/verifier_turbo.test.cpp
+++ b/cpp/src/barretenberg/stdlib/recursion/verifier/verifier_turbo.test.cpp
@@ -23,7 +23,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
     typedef inner_curve::witness_ct witness_ct;
 
     struct circuit_outputs {
-        stdlib::recursion::recursion_output<outer_curve> recursion_output;
+        stdlib::recursion::aggregation_state<outer_curve> aggregation_state;
         std::shared_ptr<verification_key_pt> verification_key;
     };
 
@@ -37,7 +37,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             a = (a * b) + b + a;
             a = a.madd(b, c);
         }
-        plonk::stdlib::pedersen<InnerComposer>::compress(a, b);
+        plonk::stdlib::pedersen_commitment<InnerComposer>::compress(a, b);
         typename inner_curve::byte_array_ct to_hash(&composer, "nonsense test data");
         stdlib::blake3s(to_hash);
 
@@ -60,7 +60,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             verification_key_pt::from_witness(&outer_composer, verification_key_raw);
         plonk::proof recursive_proof = prover.construct_proof();
         transcript::Manifest recursive_manifest = InnerComposer::create_manifest(prover.key->num_public_inputs);
-        stdlib::recursion::recursion_output<outer_curve> output =
+        stdlib::recursion::aggregation_state<outer_curve> output =
             stdlib::recursion::verify_proof<outer_curve, recursive_settings>(
                 &outer_composer, verification_key, recursive_manifest, recursive_proof);
         return { output, verification_key };
@@ -80,7 +80,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
 
         transcript::Manifest recursive_manifest = InnerComposer::create_manifest(prover.key->num_public_inputs);
 
-        stdlib::recursion::recursion_output<outer_curve> previous_output =
+        stdlib::recursion::aggregation_state<outer_curve> previous_output =
             stdlib::recursion::verify_proof<outer_curve, recursive_settings>(
                 &outer_composer, verification_key, recursive_manifest, recursive_proof_a);
 
@@ -91,7 +91,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             verification_key_pt::from_witness(&outer_composer, verification_key_b_raw);
         plonk::proof recursive_proof_b = prover_b.construct_proof();
 
-        stdlib::recursion::recursion_output<outer_curve> output =
+        stdlib::recursion::aggregation_state<outer_curve> output =
             stdlib::recursion::verify_proof<outer_curve, recursive_settings>(
                 &outer_composer, verification_key_b, recursive_manifest, recursive_proof_b, previous_output);
 
@@ -109,7 +109,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             a = (a * b) + b + a;
             a = c.madd(b, a);
         }
-        plonk::stdlib::pedersen<InnerComposer>::compress(a, a);
+        plonk::stdlib::pedersen_commitment<InnerComposer>::compress(a, a);
         inner_curve::byte_array_ct to_hash(&composer, "different nonsense test data");
         stdlib::blake3s(to_hash);
 
@@ -156,7 +156,7 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         }
         plonk::proof recursive_proof = proof_type ? prover_a.construct_proof() : prover_b.construct_proof();
         transcript::Manifest recursive_manifest = InnerComposer::create_manifest(prover_a.key->num_public_inputs);
-        stdlib::recursion::recursion_output<outer_curve> output =
+        stdlib::recursion::aggregation_state<outer_curve> output =
             stdlib::recursion::verify_proof<outer_curve, recursive_settings>(
                 &outer_composer, verification_key, recursive_manifest, recursive_proof);
         return { output, verification_key };
@@ -176,19 +176,19 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         auto circuit_output = create_outer_circuit(inner_composer, outer_composer);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs[1]);
+        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]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
-        circuit_output.recursion_output.add_proof_outputs_as_public_inputs();
+        circuit_output.aggregation_state.add_proof_outputs_as_public_inputs();
 
         EXPECT_EQ(outer_composer.failed(), false);
         std::cout << "creating prover" << std::endl;
@@ -229,15 +229,15 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
         auto circuit_output = create_double_outer_circuit(inner_composer_a, inner_composer_b, outer_composer);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs[1]);
+        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]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -280,16 +280,16 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             create_outer_circuit_with_variable_inner_circuit(inner_composer_a, inner_composer_b, outer_composer, true);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_a[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_a[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_a[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_a[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -326,17 +326,17 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             create_outer_circuit_with_variable_inner_circuit(inner_composer_a, inner_composer_b, outer_composer, false);
         g1::affine_element P[2];
 
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
 
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_b[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_b[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_b[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_b[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -372,16 +372,16 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             inner_composer_a, inner_composer_b, outer_composer, true, true);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_a[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_a[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_a[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_a[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
@@ -417,16 +417,16 @@ template <typename OuterComposer> class stdlib_verifier_turbo : public testing::
             inner_composer_a, inner_composer_b, outer_composer, true, false, true);
 
         g1::affine_element P[2];
-        P[0].x = barretenberg::fq(circuit_output.recursion_output.P0.x.get_value().lo);
-        P[0].y = barretenberg::fq(circuit_output.recursion_output.P0.y.get_value().lo);
-        P[1].x = barretenberg::fq(circuit_output.recursion_output.P1.x.get_value().lo);
-        P[1].y = barretenberg::fq(circuit_output.recursion_output.P1.y.get_value().lo);
+        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);
         barretenberg::fq12 inner_proof_result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
             P, circuit_output.verification_key->reference_string->get_precomputed_g2_lines(), 2);
 
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[0].get_value(), inner_inputs_a[0]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[1].get_value(), inner_inputs_a[1]);
-        EXPECT_EQ(circuit_output.recursion_output.public_inputs[2].get_value(), inner_inputs_a[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]);
+        EXPECT_EQ(circuit_output.aggregation_state.public_inputs[2].get_value(), inner_inputs_a[2]);
 
         EXPECT_EQ(inner_proof_result, barretenberg::fq12::one());
 
diff --git a/cpp/src/barretenberg/stdlib/types/types.hpp b/cpp/src/barretenberg/stdlib/types/types.hpp
index 15f524d8ed3..706b160800b 100644
--- a/cpp/src/barretenberg/stdlib/types/types.hpp
+++ b/cpp/src/barretenberg/stdlib/types/types.hpp
@@ -13,8 +13,8 @@
 #include "barretenberg/stdlib/primitives/witness/witness.hpp"
 #include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
 #include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
-#include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
-#include "barretenberg/stdlib/hash/pedersen/pedersen_plookup.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"
@@ -75,7 +75,7 @@ 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<Composer> pedersen;
+typedef stdlib::pedersen_commitment<Composer> pedersen_commitment;
 typedef stdlib::group<Composer> group_ct;
 typedef stdlib::bn254<Composer> bn254;
 typedef stdlib::secp256k1<Composer> secp256k1_ct;
diff --git a/cpp/src/barretenberg/transcript/CMakeLists.txt b/cpp/src/barretenberg/transcript/CMakeLists.txt
index 2142c04ef77..6a00821c3c3 100644
--- a/cpp/src/barretenberg/transcript/CMakeLists.txt
+++ b/cpp/src/barretenberg/transcript/CMakeLists.txt
@@ -1 +1 @@
-barretenberg_module(transcript crypto_pedersen crypto_blake3s)
\ No newline at end of file
+barretenberg_module(transcript crypto_pedersen_commitment crypto_blake3s)
\ No newline at end of file
diff --git a/cpp/src/barretenberg/transcript/transcript.cpp b/cpp/src/barretenberg/transcript/transcript.cpp
index 57b9cfa4100..91349628b92 100644
--- a/cpp/src/barretenberg/transcript/transcript.cpp
+++ b/cpp/src/barretenberg/transcript/transcript.cpp
@@ -6,8 +6,8 @@
 #include "barretenberg/common/net.hpp"
 #include "barretenberg/crypto/blake3s/blake3s.hpp"
 #include "barretenberg/crypto/keccak/keccak.hpp"
-#include "barretenberg/crypto/pedersen/pedersen.hpp"
-#include "barretenberg/crypto/pedersen/pedersen_lookup.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
+#include "barretenberg/crypto/pedersen_commitment/pedersen_lookup.hpp"
 #include <cstddef>
 #include <iomanip>
 #include <iostream>
@@ -213,12 +213,12 @@ void Transcript::apply_fiat_shamir(const std::string& challenge_name /*, const b
         break;
     }
     case HashType::PedersenBlake3s: {
-        std::vector<uint8_t> compressed_buffer = to_buffer(crypto::pedersen::compress_native(buffer));
+        std::vector<uint8_t> compressed_buffer = to_buffer(crypto::pedersen_commitment::compress_native(buffer));
         base_hash = Blake3sHasher::hash(compressed_buffer);
         break;
     }
     case HashType::PlookupPedersenBlake3s: {
-        std::vector<uint8_t> compressed_buffer = crypto::pedersen::lookup::compress_native(buffer);
+        std::vector<uint8_t> compressed_buffer = crypto::pedersen_commitment::lookup::compress_native(buffer);
         base_hash = Blake3sHasher::hash(compressed_buffer);
         break;
     }
diff --git a/ts/src/crypto/index.ts b/ts/src/crypto/index.ts
deleted file mode 100644
index bd41f781c3c..00000000000
--- a/ts/src/crypto/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './pedersen/index.js';
diff --git a/ts/src/crypto/pedersen/index.ts b/ts/src/crypto/pedersen/index.ts
deleted file mode 100644
index 41d557571b3..00000000000
--- a/ts/src/crypto/pedersen/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './pedersen.js';
diff --git a/ts/src/crypto/pedersen/pedersen.test.ts b/ts/src/crypto/pedersen/pedersen.test.ts
deleted file mode 100644
index 9ae59815c3a..00000000000
--- a/ts/src/crypto/pedersen/pedersen.test.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { BarretenbergWasm } from '../../wasm/barretenberg_wasm.js';
-import { pedersenGetHashTree } from './pedersen.js';
-
-describe('pedersen', () => {
-  let barretenbergWasm!: BarretenbergWasm;
-  const values: Buffer[] = [];
-
-  beforeAll(async () => {
-    barretenbergWasm = await BarretenbergWasm.new();
-
-    // TODO was originally 2 ** 12
-    for (let i = 0; i < 2 ** 2; ++i) {
-      const v = Buffer.alloc(32, 0);
-      v.writeUInt32LE(i, 0);
-      values[i] = v;
-    }
-  });
-
-  it('hasher_consistency_and_benchmark', () => {
-    const start1 = new Date().getTime();
-    const result = pedersenGetHashTree(barretenbergWasm, values);
-    const end1 = new Date().getTime() - start1;
-
-    console.log(`Single hasher: ~${end1 / values.length}ms / value`);
-    // TODO more than smoke-test this
-    expect(result.length).toBe(values.length * 2 - 1);
-    // TODO
-    // console.log(`Pooled hasher: ~${end2 / values.length}ms / value`);
-    // console.log(`Pooled improvement: ${(end1 / end2).toFixed(2)}x`);
-    // expect(poolResults).toEqual(singleResults);
-    // await pool.destroy();
-  });
-});
diff --git a/ts/src/crypto/pedersen/pedersen.ts b/ts/src/crypto/pedersen/pedersen.ts
deleted file mode 100644
index 5ab0533a77d..00000000000
--- a/ts/src/crypto/pedersen/pedersen.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { BarretenbergWasm } from '../../wasm/index.js';
-import { deserializeArrayFromVector, deserializeField, serializeBufferArrayToVector } from '../../wasm/serialize.js';
-import { Buffer } from 'buffer';
-
-/**
- * Combines two 32-byte hashes.
- * @param wasm - The barretenberg module.
- * @param lhs - The first hash.
- * @param rhs - The second hash.
- * @returns The new 32-byte hash.
- */
-export function pedersenCompress(wasm: BarretenbergWasm, lhs: Uint8Array, rhs: Uint8Array): Buffer {
-  // If not done already, precompute constants.
-  wasm.call('pedersen__init');
-  // TODO check if lhs and rhs are <= 32 bytes?
-  wasm.writeMemory(0, lhs);
-  wasm.writeMemory(32, rhs);
-  wasm.call('pedersen__compress_fields', 0, 32, 64);
-  return Buffer.from(wasm.getMemorySlice(64, 96));
-}
-
-/**
- * Combine an array of hashes.
- * @param wasm - The barretenberg module.
- * @param lhs - The first hash.
- * @param rhs - The second hash.
- * @returns The new 32-byte hash.
- */
-export function pedersenCompressInputs(wasm: BarretenbergWasm, inputs: Buffer[]): Buffer {
-  // If not done already, precompute constants.
-  wasm.call('pedersen__init');
-  const inputVectors = serializeBufferArrayToVector(inputs);
-  wasm.writeMemory(0, inputVectors);
-  wasm.call('pedersen__compress', 0, 0);
-  return Buffer.from(wasm.getMemorySlice(0, 32));
-}
-
-/**
- * Combine an array of hashes.
- * @param wasm - The barretenberg module.
- * @param lhs - The first hash.
- * @param rhs - The second hash.
- * @returns The new 32-byte hash.
- */
-export function pedersenCompressWithHashIndex(wasm: BarretenbergWasm, inputs: Buffer[], hashIndex: number): Buffer {
-  // If not done already, precompute constants.
-  wasm.call('pedersen__init');
-  const inputVectors = serializeBufferArrayToVector(inputs);
-  wasm.writeMemory(0, inputVectors);
-  wasm.call('pedersen__compress_with_hash_index', 0, 0, hashIndex);
-  return Buffer.from(wasm.getMemorySlice(0, 32));
-}
-
-/**
- * Get a 32-byte pedersen hash from a buffer.
- * @param wasm - The barretenberg module.
- * @param data - The data buffer.
- * @returns The hash buffer.
- */
-export function pedersenGetHash(wasm: BarretenbergWasm, data: Buffer): Buffer {
-  // If not done already, precompute constants.
-  wasm.call('pedersen__init');
-  const mem = wasm.call('bbmalloc', data.length);
-  wasm.writeMemory(mem, data);
-  wasm.call('pedersen__buffer_to_field', mem, data.length, 0);
-  wasm.call('bbfree', mem);
-  return Buffer.from(wasm.getMemorySlice(0, 32));
-}
-
-/**
- * Given a buffer containing 32 byte pedersen leaves, return a new buffer containing the leaves and all pairs of nodes that define a merkle tree.
- * E.g.
- * Input:  [1][2][3][4]
- * Output: [1][2][3][4][compress(1,2)][compress(3,4)][compress(5,6)].
- * @param wasm - The barretenberg module.
- * @param values - The 32 byte pedersen leaves.
- * @returns A tree represented by an array.
- */
-export function pedersenGetHashTree(wasm: BarretenbergWasm, values: Buffer[]) {
-  // If not done already, precompute constants.
-  wasm.call('pedersen__init');
-  const data = serializeBufferArrayToVector(values);
-  const inputPtr = wasm.call('bbmalloc', data.length);
-  wasm.writeMemory(inputPtr, data);
-
-  const resultPtr = wasm.call('pedersen__hash_to_tree', inputPtr);
-  const resultNumFields = Buffer.from(wasm.getMemorySlice(resultPtr, resultPtr + 4)).readUInt32BE(0);
-  const resultData = Buffer.from(wasm.getMemorySlice(resultPtr, resultPtr + 4 + resultNumFields * 32));
-  wasm.call('bbfree', inputPtr);
-  wasm.call('bbfree', resultPtr);
-
-  return deserializeArrayFromVector(deserializeField, resultData).elem;
-}
diff --git a/ts/src/wasm/barretenberg.wasm b/ts/src/wasm/barretenberg.wasm
deleted file mode 120000
index f6e5fe2c735..00000000000
--- a/ts/src/wasm/barretenberg.wasm
+++ /dev/null
@@ -1 +0,0 @@
-../../../cpp/build-wasm/bin/barretenberg.wasm
\ No newline at end of file
diff --git a/ts/src/wasm/barretenberg_wasm.test.ts b/ts/src/wasm/barretenberg_wasm.test.ts
deleted file mode 100644
index 03560c40024..00000000000
--- a/ts/src/wasm/barretenberg_wasm.test.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { FileCrs, SRS_DEV_PATH } from '../crs/index.js';
-import { BarretenbergWasm } from './barretenberg_wasm.js';
-
-describe('basic barretenberg smoke test', () => {
-  const wasm: BarretenbergWasm = new BarretenbergWasm();
-
-  beforeAll(async () => {
-    await wasm.init();
-  });
-
-  it('should new malloc, transfer and slice mem', () => {
-    const length = 1024;
-    const ptr = wasm.call('bbmalloc', length);
-    const buf = Buffer.alloc(length, 128);
-    wasm.writeMemory(ptr, buf);
-    wasm.call('bbfree', ptr);
-    const result = Buffer.from(wasm.getMemorySlice(ptr, ptr + length));
-    expect(result).toStrictEqual(buf);
-  });
-
-  it('should use asyncify to do an async callback into js', async () => {
-    const addr1 = await wasm.asyncCall('test_async_func', 1024 * 1024, 1);
-    const addr2 = await wasm.asyncCall('test_async_func', 1024 * 1024 * 2, 2);
-    expect(wasm.getMemorySlice(addr1, addr1 + 1024 * 1024).every(v => v === 1)).toBe(true);
-    expect(wasm.getMemorySlice(addr2, addr2 + 1024 * 1024 * 2).every(v => v === 2)).toBe(true);
-  });
-
-  it('should correctly pass CRS data through env_load_verifier_crs', async () => {
-    const crs = new FileCrs(0, SRS_DEV_PATH);
-    await crs.init();
-    const g2DataPtr = await wasm.asyncCall('test_env_load_verifier_crs');
-    const g2Data = wasm.getMemorySlice(g2DataPtr, g2DataPtr + 128);
-    expect(Buffer.from(g2Data)).toStrictEqual(crs.getG2Data());
-    wasm.call('bbfree', g2DataPtr);
-  });
-
-  it('should correctly pass CRS data through env_load_prover_crs', async () => {
-    const numPoints = 1024;
-    const crs = new FileCrs(numPoints, SRS_DEV_PATH);
-    await crs.init();
-    const g1DataPtr = await wasm.asyncCall('test_env_load_prover_crs', numPoints);
-    const g1Data = wasm.getMemorySlice(g1DataPtr, g1DataPtr + numPoints * 64);
-    expect(Buffer.from(g1Data)).toStrictEqual(crs.getG1Data());
-    wasm.call('bbfree', g1DataPtr);
-  });
-});
diff --git a/ts/src/wasm/index.ts b/ts/src/wasm/index.ts
deleted file mode 100644
index de04d5bf878..00000000000
--- a/ts/src/wasm/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { BarretenbergWasm } from './barretenberg_wasm.js';
diff --git a/ts/src/wasm/serialize.ts b/ts/src/wasm/serialize.ts
deleted file mode 100644
index fce96899531..00000000000
--- a/ts/src/wasm/serialize.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * For serializing an array of fixed length buffers.
- * TODO move to foundation pkg.
- * @param arr - Array of bufffers.
- * @returns The serialized buffers.
- */
-export function serializeBufferArrayToVector(arr: Buffer[]) {
-  const lengthBuf = Buffer.alloc(4);
-  lengthBuf.writeUInt32BE(arr.length, 0);
-  return Buffer.concat([lengthBuf, ...arr]);
-}
-
-/**
- * Helper function for deserializeArrayFromVector.
- */
-type DeserializeFn<T> = (
-  buf: Buffer,
-  offset: number,
-) => {
-  /**
-   * The deserialized type.
-   */
-  elem: T;
-  /**
-   * How many bytes to advance by.
-   */
-  adv: number;
-};
-
-/**
- * For deserializing numbers to 32-bit little-endian form.
- * TODO move to foundation pkg.
- * @param n - The number.
- * @returns The endian-corrected number.
- */
-export function deserializeArrayFromVector<T>(deserialize: DeserializeFn<T>, vector: Buffer, offset = 0) {
-  let pos = offset;
-  const size = vector.readUInt32BE(pos);
-  pos += 4;
-  const arr = new Array<T>(size);
-  for (let i = 0; i < size; ++i) {
-    const { elem, adv } = deserialize(vector, pos);
-    pos += adv;
-    arr[i] = elem;
-  }
-  return { elem: arr, adv: pos - offset };
-}
-
-/**
- * For serializing numbers to 32 bit little-endian form.
- * TODO move to foundation pkg.
- * @param n - The number.
- * @returns The endian-corrected number.
- */
-export function numToUInt32LE(n: number, bufferSize = 4) {
-  const buf = Buffer.alloc(bufferSize);
-  buf.writeUInt32LE(n, bufferSize - 4);
-  return buf;
-}
-
-/**
- * Deserialize the 256-bit number at address `offset`.
- * @param buf - The buffer.
- * @param offset - The address.
- * @returns The derserialized 256-bit field.
- */
-export function deserializeField(buf: Buffer, offset = 0) {
-  const adv = 32;
-  return { elem: buf.slice(offset, offset + adv), adv };
-}