diff --git a/Cargo.lock b/Cargo.lock
index d9743ce70f2..c0ea0dac252 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2940,6 +2940,7 @@ dependencies = [
  "noirc_errors",
  "noirc_evaluator",
  "noirc_frontend",
+ "noirc_macros",
  "rust-embed",
  "serde",
  "tracing",
@@ -3002,6 +3003,14 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "noirc_macros"
+version = "0.23.0"
+dependencies = [
+ "iter-extended",
+ "noirc_frontend",
+]
+
 [[package]]
 name = "noirc_printable_type"
 version = "0.23.0"
diff --git a/Cargo.toml b/Cargo.toml
index 5dfff3dbb5d..2ba97e906b1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,10 @@
 [workspace]
 
 members = [
+    # Macros crates for metaprogramming
     "aztec_macros",
+    "noirc_macros",
+    # Compiler crates
     "compiler/noirc_evaluator",
     "compiler/noirc_frontend",
     "compiler/noirc_errors",
diff --git a/acvm-repo/acir/acir_docs.md b/acvm-repo/acir/README.md
similarity index 100%
rename from acvm-repo/acir/acir_docs.md
rename to acvm-repo/acir/README.md
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 9b74a8ea631..0f94e91ab10 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -157,16 +157,6 @@ namespace Circuit {
             static EmbeddedCurveAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct EmbeddedCurveDouble {
-            Circuit::FunctionInput input_x;
-            Circuit::FunctionInput input_y;
-            std::array<Circuit::Witness, 2> outputs;
-
-            friend bool operator==(const EmbeddedCurveDouble&, const EmbeddedCurveDouble&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static EmbeddedCurveDouble bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct Keccak256 {
             std::vector<Circuit::FunctionInput> inputs;
             std::vector<Circuit::Witness> outputs;
@@ -206,7 +196,86 @@ namespace Circuit {
             static RecursiveAggregation bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, EmbeddedCurveDouble, Keccak256, Keccak256VariableLength, Keccakf1600, RecursiveAggregation> value;
+        struct BigIntAdd {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntAdd&, const BigIntAdd&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntNeg {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntNeg&, const BigIntNeg&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntNeg bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntMul {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntMul&, const BigIntMul&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntMul bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntDiv {
+            uint32_t lhs;
+            uint32_t rhs;
+            uint32_t output;
+
+            friend bool operator==(const BigIntDiv&, const BigIntDiv&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntDiv bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntFromLeBytes {
+            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<uint8_t> modulus;
+            uint32_t output;
+
+            friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntFromLeBytes bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntToLeBytes {
+            uint32_t input;
+            std::vector<Circuit::Witness> outputs;
+
+            friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntToLeBytes bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Poseidon2Permutation {
+            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Circuit::Witness> outputs;
+            uint32_t len;
+
+            friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Poseidon2Permutation bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Sha256Compression {
+            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Circuit::FunctionInput> hash_values;
+            std::vector<Circuit::Witness> outputs;
+
+            friend bool operator==(const Sha256Compression&, const Sha256Compression&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccak256VariableLength, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntNeg, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -533,17 +602,86 @@ namespace Circuit {
             static EmbeddedCurveAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct EmbeddedCurveDouble {
-            Circuit::RegisterIndex input1_x;
-            Circuit::RegisterIndex input1_y;
-            Circuit::HeapArray result;
+        struct BigIntAdd {
+            Circuit::RegisterIndex lhs;
+            Circuit::RegisterIndex rhs;
+            Circuit::RegisterIndex output;
+
+            friend bool operator==(const BigIntAdd&, const BigIntAdd&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntNeg {
+            Circuit::RegisterIndex lhs;
+            Circuit::RegisterIndex rhs;
+            Circuit::RegisterIndex output;
+
+            friend bool operator==(const BigIntNeg&, const BigIntNeg&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntNeg bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntMul {
+            Circuit::RegisterIndex lhs;
+            Circuit::RegisterIndex rhs;
+            Circuit::RegisterIndex output;
+
+            friend bool operator==(const BigIntMul&, const BigIntMul&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntMul bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntDiv {
+            Circuit::RegisterIndex lhs;
+            Circuit::RegisterIndex rhs;
+            Circuit::RegisterIndex output;
+
+            friend bool operator==(const BigIntDiv&, const BigIntDiv&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntDiv bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntFromLeBytes {
+            Circuit::HeapVector inputs;
+            Circuit::HeapVector modulus;
+            Circuit::RegisterIndex output;
+
+            friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static BigIntFromLeBytes bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct BigIntToLeBytes {
+            Circuit::RegisterIndex input;
+            Circuit::HeapVector output;
 
-            friend bool operator==(const EmbeddedCurveDouble&, const EmbeddedCurveDouble&);
+            friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static EmbeddedCurveDouble bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntToLeBytes bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul, EmbeddedCurveAdd, EmbeddedCurveDouble> value;
+        struct Poseidon2Permutation {
+            Circuit::HeapVector message;
+            Circuit::HeapArray output;
+            Circuit::RegisterIndex len;
+
+            friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Poseidon2Permutation bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Sha256Compression {
+            Circuit::HeapVector input;
+            Circuit::HeapVector hash_values;
+            Circuit::HeapArray output;
+
+            friend bool operator==(const Sha256Compression&, const Sha256Compression&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntNeg, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -2252,50 +2390,6 @@ Circuit::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Circuit::Black
     return obj;
 }
 
-namespace Circuit {
-
-    inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveDouble &lhs, const BlackBoxFuncCall::EmbeddedCurveDouble &rhs) {
-        if (!(lhs.input_x == rhs.input_x)) { return false; }
-        if (!(lhs.input_y == rhs.input_y)) { return false; }
-        if (!(lhs.outputs == rhs.outputs)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxFuncCall::EmbeddedCurveDouble::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::EmbeddedCurveDouble>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxFuncCall::EmbeddedCurveDouble BlackBoxFuncCall::EmbeddedCurveDouble::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::EmbeddedCurveDouble>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Circuit
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::EmbeddedCurveDouble>::serialize(const Circuit::BlackBoxFuncCall::EmbeddedCurveDouble &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.input_x)>::serialize(obj.input_x, serializer);
-    serde::Serializable<decltype(obj.input_y)>::serialize(obj.input_y, serializer);
-    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Circuit::BlackBoxFuncCall::EmbeddedCurveDouble serde::Deserializable<Circuit::BlackBoxFuncCall::EmbeddedCurveDouble>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::EmbeddedCurveDouble obj;
-    obj.input_x = serde::Deserializable<decltype(obj.input_x)>::deserialize(deserializer);
-    obj.input_y = serde::Deserializable<decltype(obj.input_y)>::deserialize(deserializer);
-    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Circuit {
 
     inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, const BlackBoxFuncCall::Keccak256 &rhs) {
@@ -2471,20 +2565,22 @@ Circuit::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Circuit::B
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::BigIntAdd &lhs, const BlackBoxFuncCall::BigIntAdd &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntAdd::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::BigIntAdd>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp BlackBoxOp::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::BigIntAdd BlackBoxFuncCall::BigIntAdd::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntAdd>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2495,39 +2591,40 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp>::serialize(const Circuit::BlackBoxOp &obj, Serializer &serializer) {
-    serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-    serializer.decrease_container_depth();
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntAdd>::serialize(const Circuit::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp serde::Deserializable<Circuit::BlackBoxOp>::deserialize(Deserializer &deserializer) {
-    deserializer.increase_container_depth();
-    Circuit::BlackBoxOp obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    deserializer.decrease_container_depth();
+Circuit::BlackBoxFuncCall::BigIntAdd serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntAdd>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::BigIntAdd obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) {
-        if (!(lhs.message == rhs.message)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::BigIntNeg &lhs, const BlackBoxFuncCall::BigIntNeg &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::Sha256::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntNeg::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::Sha256>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::BigIntNeg>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::Sha256 BlackBoxOp::Sha256::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::BigIntNeg BlackBoxFuncCall::BigIntNeg::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::Sha256>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntNeg>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2538,37 +2635,40 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Sha256>::serialize(const Circuit::BlackBoxOp::Sha256 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntNeg>::serialize(const Circuit::BlackBoxFuncCall::BigIntNeg &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Sha256 serde::Deserializable<Circuit::BlackBoxOp::Sha256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Sha256 obj;
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+Circuit::BlackBoxFuncCall::BigIntNeg serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntNeg>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::BigIntNeg obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::Blake2s &lhs, const BlackBoxOp::Blake2s &rhs) {
-        if (!(lhs.message == rhs.message)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, const BlackBoxFuncCall::BigIntMul &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::Blake2s::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntMul::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::Blake2s>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::BigIntMul>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::Blake2s BlackBoxOp::Blake2s::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::BigIntMul BlackBoxFuncCall::BigIntMul::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::Blake2s>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntMul>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2579,37 +2679,40 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Blake2s>::serialize(const Circuit::BlackBoxOp::Blake2s &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntMul>::serialize(const Circuit::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Blake2s serde::Deserializable<Circuit::BlackBoxOp::Blake2s>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Blake2s obj;
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+Circuit::BlackBoxFuncCall::BigIntMul serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntMul>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::BigIntMul obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::Blake3 &lhs, const BlackBoxOp::Blake3 &rhs) {
-        if (!(lhs.message == rhs.message)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, const BlackBoxFuncCall::BigIntDiv &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::Blake3::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntDiv::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::Blake3>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::BigIntDiv>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::Blake3 BlackBoxOp::Blake3::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::BigIntDiv BlackBoxFuncCall::BigIntDiv::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::Blake3>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntDiv>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2620,37 +2723,40 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Blake3>::serialize(const Circuit::BlackBoxOp::Blake3 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntDiv>::serialize(const Circuit::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Blake3 serde::Deserializable<Circuit::BlackBoxOp::Blake3>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Blake3 obj;
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+Circuit::BlackBoxFuncCall::BigIntDiv serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntDiv>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::BigIntDiv obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::Keccak256 &lhs, const BlackBoxOp::Keccak256 &rhs) {
-        if (!(lhs.message == rhs.message)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, const BlackBoxFuncCall::BigIntFromLeBytes &rhs) {
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.modulus == rhs.modulus)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::Keccak256::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntFromLeBytes::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::Keccak256>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::BigIntFromLeBytes>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::Keccak256 BlackBoxOp::Keccak256::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::BigIntFromLeBytes BlackBoxFuncCall::BigIntFromLeBytes::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::Keccak256>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntFromLeBytes>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2661,37 +2767,39 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Keccak256>::serialize(const Circuit::BlackBoxOp::Keccak256 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::serialize(const Circuit::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.modulus)>::serialize(obj.modulus, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Keccak256 serde::Deserializable<Circuit::BlackBoxOp::Keccak256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Keccak256 obj;
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+Circuit::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::BigIntFromLeBytes obj;
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.modulus = serde::Deserializable<decltype(obj.modulus)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) {
-        if (!(lhs.message == rhs.message)) { return false; }
-        if (!(lhs.output == rhs.output)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, const BlackBoxFuncCall::BigIntToLeBytes &rhs) {
+        if (!(lhs.input == rhs.input)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::Keccakf1600::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntToLeBytes::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::Keccakf1600>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::BigIntToLeBytes>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::Keccakf1600 BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::BigIntToLeBytes BlackBoxFuncCall::BigIntToLeBytes::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::Keccakf1600>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntToLeBytes>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2702,40 +2810,38 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Keccakf1600>::serialize(const Circuit::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
-    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntToLeBytes>::serialize(const Circuit::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Keccakf1600 serde::Deserializable<Circuit::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Keccakf1600 obj;
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
-    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+Circuit::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::BigIntToLeBytes obj;
+    obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) {
-        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
-        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
-        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
-        if (!(lhs.signature == rhs.signature)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
+    inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, const BlackBoxFuncCall::Poseidon2Permutation &rhs) {
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
+        if (!(lhs.len == rhs.len)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::Poseidon2Permutation::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::EcdsaSecp256k1>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::Poseidon2Permutation>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::EcdsaSecp256k1 BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::Poseidon2Permutation BlackBoxFuncCall::Poseidon2Permutation::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256k1>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::Poseidon2Permutation>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2746,46 +2852,615 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
-    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
-    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
-    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+void serde::Serializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::serialize(const Circuit::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+    serde::Serializable<decltype(obj.len)>::serialize(obj.len, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EcdsaSecp256k1 obj;
-    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
-    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
-    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
-    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
+Circuit::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::Poseidon2Permutation obj;
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    obj.len = serde::Deserializable<decltype(obj.len)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, const BlackBoxFuncCall::Sha256Compression &rhs) {
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.hash_values == rhs.hash_values)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxFuncCall::Sha256Compression::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxFuncCall::Sha256Compression>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxFuncCall::Sha256Compression BlackBoxFuncCall::Sha256Compression::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxFuncCall::Sha256Compression>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxFuncCall::Sha256Compression>::serialize(const Circuit::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.hash_values)>::serialize(obj.hash_values, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxFuncCall::Sha256Compression serde::Deserializable<Circuit::BlackBoxFuncCall::Sha256Compression>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::Sha256Compression obj;
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.hash_values = serde::Deserializable<decltype(obj.hash_values)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp BlackBoxOp::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp>::serialize(const Circuit::BlackBoxOp &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp serde::Deserializable<Circuit::BlackBoxOp>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Circuit::BlackBoxOp obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) {
+        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::Sha256::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::Sha256>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::Sha256 BlackBoxOp::Sha256::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::Sha256>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::Sha256>::serialize(const Circuit::BlackBoxOp::Sha256 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::Sha256 serde::Deserializable<Circuit::BlackBoxOp::Sha256>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::Sha256 obj;
+    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::Blake2s &lhs, const BlackBoxOp::Blake2s &rhs) {
+        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::Blake2s::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::Blake2s>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::Blake2s BlackBoxOp::Blake2s::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::Blake2s>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::Blake2s>::serialize(const Circuit::BlackBoxOp::Blake2s &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::Blake2s serde::Deserializable<Circuit::BlackBoxOp::Blake2s>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::Blake2s obj;
+    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::Blake3 &lhs, const BlackBoxOp::Blake3 &rhs) {
+        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::Blake3::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::Blake3>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::Blake3 BlackBoxOp::Blake3::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::Blake3>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::Blake3>::serialize(const Circuit::BlackBoxOp::Blake3 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::Blake3 serde::Deserializable<Circuit::BlackBoxOp::Blake3>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::Blake3 obj;
+    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::Keccak256 &lhs, const BlackBoxOp::Keccak256 &rhs) {
+        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::Keccak256::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::Keccak256>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::Keccak256 BlackBoxOp::Keccak256::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::Keccak256>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::Keccak256>::serialize(const Circuit::BlackBoxOp::Keccak256 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::Keccak256 serde::Deserializable<Circuit::BlackBoxOp::Keccak256>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::Keccak256 obj;
+    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) {
+        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::Keccakf1600::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::Keccakf1600>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::Keccakf1600 BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::Keccakf1600>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::Keccakf1600>::serialize(const Circuit::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::Keccakf1600 serde::Deserializable<Circuit::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::Keccakf1600 obj;
+    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) {
+        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
+        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
+        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
+        if (!(lhs.signature == rhs.signature)) { return false; }
+        if (!(lhs.result == rhs.result)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::EcdsaSecp256k1>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::EcdsaSecp256k1 BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256k1>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
+    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
+    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
+    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
+    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::EcdsaSecp256k1 obj;
+    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
+    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
+    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
+    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
+    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) {
+        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
+        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
+        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
+        if (!(lhs.signature == rhs.signature)) { return false; }
+        if (!(lhs.result == rhs.result)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::EcdsaSecp256r1>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::EcdsaSecp256r1 BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256r1>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
+    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
+    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
+    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
+    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::EcdsaSecp256r1 obj;
+    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
+    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
+    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
+    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
+    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, const BlackBoxOp::SchnorrVerify &rhs) {
+        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
+        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
+        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.signature == rhs.signature)) { return false; }
+        if (!(lhs.result == rhs.result)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::SchnorrVerify::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::SchnorrVerify>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::SchnorrVerify BlackBoxOp::SchnorrVerify::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::SchnorrVerify>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::SchnorrVerify>::serialize(const Circuit::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
+    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
+    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
+    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::SchnorrVerify serde::Deserializable<Circuit::BlackBoxOp::SchnorrVerify>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::SchnorrVerify obj;
+    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
+    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
+    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
+    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) {
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::PedersenCommitment::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::PedersenCommitment>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::PedersenCommitment BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::PedersenCommitment>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::PedersenCommitment>::serialize(const Circuit::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::PedersenCommitment serde::Deserializable<Circuit::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::PedersenCommitment obj;
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) {
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::PedersenHash::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::PedersenHash>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::PedersenHash BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::PedersenHash>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::PedersenHash>::serialize(const Circuit::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::PedersenHash serde::Deserializable<Circuit::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::PedersenHash obj;
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::FixedBaseScalarMul &lhs, const BlackBoxOp::FixedBaseScalarMul &rhs) {
+        if (!(lhs.low == rhs.low)) { return false; }
+        if (!(lhs.high == rhs.high)) { return false; }
+        if (!(lhs.result == rhs.result)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::FixedBaseScalarMul::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::FixedBaseScalarMul>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::FixedBaseScalarMul BlackBoxOp::FixedBaseScalarMul::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::FixedBaseScalarMul>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::serialize(const Circuit::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
+    serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
+    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::FixedBaseScalarMul serde::Deserializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::FixedBaseScalarMul obj;
+    obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
+    obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
     obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) {
-        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
-        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
-        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
-        if (!(lhs.signature == rhs.signature)) { return false; }
+    inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) {
+        if (!(lhs.input1_x == rhs.input1_x)) { return false; }
+        if (!(lhs.input1_y == rhs.input1_y)) { return false; }
+        if (!(lhs.input2_x == rhs.input2_x)) { return false; }
+        if (!(lhs.input2_y == rhs.input2_y)) { return false; }
         if (!(lhs.result == rhs.result)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::EmbeddedCurveAdd::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::EcdsaSecp256r1>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::EmbeddedCurveAdd>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::EcdsaSecp256r1 BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::EmbeddedCurveAdd BlackBoxOp::EmbeddedCurveAdd::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256r1>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::EmbeddedCurveAdd>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2796,46 +3471,44 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
-    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
-    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
-    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
+void serde::Serializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::serialize(const Circuit::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
+    serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
+    serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
+    serde::Serializable<decltype(obj.input2_y)>::serialize(obj.input2_y, serializer);
     serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EcdsaSecp256r1 obj;
-    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
-    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
-    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
-    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
+Circuit::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::EmbeddedCurveAdd obj;
+    obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
+    obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
+    obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
+    obj.input2_y = serde::Deserializable<decltype(obj.input2_y)>::deserialize(deserializer);
     obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, const BlackBoxOp::SchnorrVerify &rhs) {
-        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
-        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
-        if (!(lhs.message == rhs.message)) { return false; }
-        if (!(lhs.signature == rhs.signature)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
+    inline bool operator==(const BlackBoxOp::BigIntAdd &lhs, const BlackBoxOp::BigIntAdd &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::SchnorrVerify::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::BigIntAdd::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::SchnorrVerify>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::BigIntAdd>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::SchnorrVerify BlackBoxOp::SchnorrVerify::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::BigIntAdd BlackBoxOp::BigIntAdd::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::SchnorrVerify>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::BigIntAdd>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2846,44 +3519,40 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::SchnorrVerify>::serialize(const Circuit::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
-    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
-    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+void serde::Serializable<Circuit::BlackBoxOp::BigIntAdd>::serialize(const Circuit::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::SchnorrVerify serde::Deserializable<Circuit::BlackBoxOp::SchnorrVerify>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::SchnorrVerify obj;
-    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
-    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
-    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+Circuit::BlackBoxOp::BigIntAdd serde::Deserializable<Circuit::BlackBoxOp::BigIntAdd>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::BigIntAdd obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
+    inline bool operator==(const BlackBoxOp::BigIntNeg &lhs, const BlackBoxOp::BigIntNeg &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::PedersenCommitment::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::BigIntNeg::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::PedersenCommitment>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::BigIntNeg>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::PedersenCommitment BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::BigIntNeg BlackBoxOp::BigIntNeg::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::PedersenCommitment>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::BigIntNeg>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2894,40 +3563,128 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::PedersenCommitment>::serialize(const Circuit::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
+void serde::Serializable<Circuit::BlackBoxOp::BigIntNeg>::serialize(const Circuit::BlackBoxOp::BigIntNeg &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::PedersenCommitment serde::Deserializable<Circuit::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::PedersenCommitment obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
+Circuit::BlackBoxOp::BigIntNeg serde::Deserializable<Circuit::BlackBoxOp::BigIntNeg>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::BigIntNeg obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) {
+    inline bool operator==(const BlackBoxOp::BigIntMul &lhs, const BlackBoxOp::BigIntMul &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::BigIntMul::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::BigIntMul>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::BigIntMul BlackBoxOp::BigIntMul::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::BigIntMul>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::BigIntMul>::serialize(const Circuit::BlackBoxOp::BigIntMul &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::BigIntMul serde::Deserializable<Circuit::BlackBoxOp::BigIntMul>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::BigIntMul obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, const BlackBoxOp::BigIntDiv &rhs) {
+        if (!(lhs.lhs == rhs.lhs)) { return false; }
+        if (!(lhs.rhs == rhs.rhs)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BlackBoxOp::BigIntDiv::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BlackBoxOp::BigIntDiv>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BlackBoxOp::BigIntDiv BlackBoxOp::BigIntDiv::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BlackBoxOp::BigIntDiv>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BlackBoxOp::BigIntDiv>::serialize(const Circuit::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
+    serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BlackBoxOp::BigIntDiv serde::Deserializable<Circuit::BlackBoxOp::BigIntDiv>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::BigIntDiv obj;
+    obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
+    obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, const BlackBoxOp::BigIntFromLeBytes &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
+        if (!(lhs.modulus == rhs.modulus)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::PedersenHash::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::BigIntFromLeBytes::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::PedersenHash>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::BigIntFromLeBytes>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::PedersenHash BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::BigIntFromLeBytes BlackBoxOp::BigIntFromLeBytes::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::PedersenHash>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::BigIntFromLeBytes>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2938,40 +3695,39 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::PedersenHash>::serialize(const Circuit::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
+void serde::Serializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::serialize(const Circuit::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
+    serde::Serializable<decltype(obj.modulus)>::serialize(obj.modulus, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::PedersenHash serde::Deserializable<Circuit::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::PedersenHash obj;
+Circuit::BlackBoxOp::BigIntFromLeBytes serde::Deserializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::BigIntFromLeBytes obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
+    obj.modulus = serde::Deserializable<decltype(obj.modulus)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::FixedBaseScalarMul &lhs, const BlackBoxOp::FixedBaseScalarMul &rhs) {
-        if (!(lhs.low == rhs.low)) { return false; }
-        if (!(lhs.high == rhs.high)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
+    inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, const BlackBoxOp::BigIntToLeBytes &rhs) {
+        if (!(lhs.input == rhs.input)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::FixedBaseScalarMul::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::BigIntToLeBytes::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::FixedBaseScalarMul>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::BigIntToLeBytes>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::FixedBaseScalarMul BlackBoxOp::FixedBaseScalarMul::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::BigIntToLeBytes BlackBoxOp::BigIntToLeBytes::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::FixedBaseScalarMul>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::BigIntToLeBytes>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2982,42 +3738,38 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::serialize(const Circuit::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
-    serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+void serde::Serializable<Circuit::BlackBoxOp::BigIntToLeBytes>::serialize(const Circuit::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::FixedBaseScalarMul serde::Deserializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::FixedBaseScalarMul obj;
-    obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
-    obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+Circuit::BlackBoxOp::BigIntToLeBytes serde::Deserializable<Circuit::BlackBoxOp::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::BigIntToLeBytes obj;
+    obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) {
-        if (!(lhs.input1_x == rhs.input1_x)) { return false; }
-        if (!(lhs.input1_y == rhs.input1_y)) { return false; }
-        if (!(lhs.input2_x == rhs.input2_x)) { return false; }
-        if (!(lhs.input2_y == rhs.input2_y)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
+    inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, const BlackBoxOp::Poseidon2Permutation &rhs) {
+        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
+        if (!(lhs.len == rhs.len)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::EmbeddedCurveAdd::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::Poseidon2Permutation::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::EmbeddedCurveAdd>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::Poseidon2Permutation>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::EmbeddedCurveAdd BlackBoxOp::EmbeddedCurveAdd::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::Poseidon2Permutation BlackBoxOp::Poseidon2Permutation::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::EmbeddedCurveAdd>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::Poseidon2Permutation>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -3028,44 +3780,40 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::serialize(const Circuit::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
-    serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
-    serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
-    serde::Serializable<decltype(obj.input2_y)>::serialize(obj.input2_y, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+void serde::Serializable<Circuit::BlackBoxOp::Poseidon2Permutation>::serialize(const Circuit::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+    serde::Serializable<decltype(obj.len)>::serialize(obj.len, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EmbeddedCurveAdd obj;
-    obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
-    obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
-    obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
-    obj.input2_y = serde::Deserializable<decltype(obj.input2_y)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+Circuit::BlackBoxOp::Poseidon2Permutation serde::Deserializable<Circuit::BlackBoxOp::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::Poseidon2Permutation obj;
+    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    obj.len = serde::Deserializable<decltype(obj.len)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::EmbeddedCurveDouble &lhs, const BlackBoxOp::EmbeddedCurveDouble &rhs) {
-        if (!(lhs.input1_x == rhs.input1_x)) { return false; }
-        if (!(lhs.input1_y == rhs.input1_y)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
+    inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, const BlackBoxOp::Sha256Compression &rhs) {
+        if (!(lhs.input == rhs.input)) { return false; }
+        if (!(lhs.hash_values == rhs.hash_values)) { return false; }
+        if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::EmbeddedCurveDouble::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::Sha256Compression::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::EmbeddedCurveDouble>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::Sha256Compression>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::EmbeddedCurveDouble BlackBoxOp::EmbeddedCurveDouble::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::Sha256Compression BlackBoxOp::Sha256Compression::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::EmbeddedCurveDouble>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::Sha256Compression>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -3076,19 +3824,19 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EmbeddedCurveDouble>::serialize(const Circuit::BlackBoxOp::EmbeddedCurveDouble &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
-    serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+void serde::Serializable<Circuit::BlackBoxOp::Sha256Compression>::serialize(const Circuit::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
+    serde::Serializable<decltype(obj.hash_values)>::serialize(obj.hash_values, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EmbeddedCurveDouble serde::Deserializable<Circuit::BlackBoxOp::EmbeddedCurveDouble>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EmbeddedCurveDouble obj;
-    obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
-    obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+Circuit::BlackBoxOp::Sha256Compression serde::Deserializable<Circuit::BlackBoxOp::Sha256Compression>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::Sha256Compression obj;
+    obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
+    obj.hash_values = serde::Deserializable<decltype(obj.hash_values)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
diff --git a/acvm-repo/acir/src/circuit/black_box_functions.rs b/acvm-repo/acir/src/circuit/black_box_functions.rs
index d1f5560313b..97b4759d350 100644
--- a/acvm-repo/acir/src/circuit/black_box_functions.rs
+++ b/acvm-repo/acir/src/circuit/black_box_functions.rs
@@ -47,8 +47,22 @@ pub enum BlackBoxFunc {
     RecursiveAggregation,
     /// Addition over the embedded curve on which [`FieldElement`][acir_field::FieldElement] is defined.
     EmbeddedCurveAdd,
-    /// Point doubling over the embedded curve on which [`FieldElement`][acir_field::FieldElement] is defined.
-    EmbeddedCurveDouble,
+    /// BigInt addition
+    BigIntAdd,
+    /// BigInt subtraction
+    BigIntNeg,
+    /// BigInt multiplication
+    BigIntMul,
+    /// BigInt division
+    BigIntDiv,
+    /// BigInt from le bytes
+    BigIntFromLeBytes,
+    /// BigInt to le bytes
+    BigIntToLeBytes,
+    /// Permutation function of Poseidon2
+    Poseidon2Permutation,
+    /// SHA256 compression function
+    Sha256Compression,
 }
 
 impl std::fmt::Display for BlackBoxFunc {
@@ -68,8 +82,7 @@ impl BlackBoxFunc {
             BlackBoxFunc::PedersenHash => "pedersen_hash",
             BlackBoxFunc::EcdsaSecp256k1 => "ecdsa_secp256k1",
             BlackBoxFunc::FixedBaseScalarMul => "fixed_base_scalar_mul",
-            BlackBoxFunc::EmbeddedCurveAdd => "ec_add",
-            BlackBoxFunc::EmbeddedCurveDouble => "ec_double",
+            BlackBoxFunc::EmbeddedCurveAdd => "embedded_curve_add",
             BlackBoxFunc::AND => "and",
             BlackBoxFunc::XOR => "xor",
             BlackBoxFunc::RANGE => "range",
@@ -77,8 +90,17 @@ impl BlackBoxFunc {
             BlackBoxFunc::Keccakf1600 => "keccakf1600",
             BlackBoxFunc::RecursiveAggregation => "recursive_aggregation",
             BlackBoxFunc::EcdsaSecp256r1 => "ecdsa_secp256r1",
+            BlackBoxFunc::BigIntAdd => "bigint_add",
+            BlackBoxFunc::BigIntNeg => "bigint_neg",
+            BlackBoxFunc::BigIntMul => "bigint_mul",
+            BlackBoxFunc::BigIntDiv => "bigint_div",
+            BlackBoxFunc::BigIntFromLeBytes => "bigint_from_le_bytes",
+            BlackBoxFunc::BigIntToLeBytes => "bigint_to_le_bytes",
+            BlackBoxFunc::Poseidon2Permutation => "poseidon2_permutation",
+            BlackBoxFunc::Sha256Compression => "sha256_compression",
         }
     }
+
     pub fn lookup(op_name: &str) -> Option<BlackBoxFunc> {
         match op_name {
             "sha256" => Some(BlackBoxFunc::SHA256),
@@ -90,17 +112,25 @@ impl BlackBoxFunc {
             "ecdsa_secp256k1" => Some(BlackBoxFunc::EcdsaSecp256k1),
             "ecdsa_secp256r1" => Some(BlackBoxFunc::EcdsaSecp256r1),
             "fixed_base_scalar_mul" => Some(BlackBoxFunc::FixedBaseScalarMul),
-            "ec_add" => Some(BlackBoxFunc::EmbeddedCurveAdd),
-            "ec_double" => Some(BlackBoxFunc::EmbeddedCurveDouble),
+            "embedded_curve_add" => Some(BlackBoxFunc::EmbeddedCurveAdd),
             "and" => Some(BlackBoxFunc::AND),
             "xor" => Some(BlackBoxFunc::XOR),
             "range" => Some(BlackBoxFunc::RANGE),
             "keccak256" => Some(BlackBoxFunc::Keccak256),
             "keccakf1600" => Some(BlackBoxFunc::Keccakf1600),
             "recursive_aggregation" => Some(BlackBoxFunc::RecursiveAggregation),
+            "bigint_add" => Some(BlackBoxFunc::BigIntAdd),
+            "bigint_neg" => Some(BlackBoxFunc::BigIntNeg),
+            "bigint_mul" => Some(BlackBoxFunc::BigIntMul),
+            "bigint_div" => Some(BlackBoxFunc::BigIntDiv),
+            "bigint_from_le_bytes" => Some(BlackBoxFunc::BigIntFromLeBytes),
+            "bigint_to_le_bytes" => Some(BlackBoxFunc::BigIntToLeBytes),
+            "poseidon2_permutation" => Some(BlackBoxFunc::Poseidon2Permutation),
+            "sha256_compression" => Some(BlackBoxFunc::Sha256Compression),
             _ => None,
         }
     }
+
     pub fn is_valid_black_box_func_name(op_name: &str) -> bool {
         BlackBoxFunc::lookup(op_name).is_some()
     }
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index b248b30b1d9..dcb09d429eb 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -38,6 +38,10 @@ pub struct Circuit {
     // Note: This should be a BTreeMap, but serde-reflect is creating invalid
     // c++ code at the moment when it is, due to OpcodeLocation needing a comparison
     // implementation which is never generated.
+    //
+    // TODO: These are only used for constraints that are explicitly created during code generation (such as index out of bounds on slices)
+    // TODO: We should move towards having all the checks being evaluated in the same manner
+    // TODO: as runtime assert messages specified by the user. This will also be a breaking change as the `Circuit` structure will change.
     pub assert_messages: Vec<(OpcodeLocation, String)>,
 }
 
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index 7ee4e2498a5..ba4964c8912 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -86,11 +86,6 @@ pub enum BlackBoxFuncCall {
         input2_y: FunctionInput,
         outputs: (Witness, Witness),
     },
-    EmbeddedCurveDouble {
-        input_x: FunctionInput,
-        input_y: FunctionInput,
-        outputs: (Witness, Witness),
-    },
     Keccak256 {
         inputs: Vec<FunctionInput>,
         outputs: Vec<Witness>,
@@ -120,6 +115,61 @@ pub enum BlackBoxFuncCall {
         /// key provided to the circuit matches the key produced by the circuit creator
         key_hash: FunctionInput,
     },
+    BigIntAdd {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntNeg {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntMul {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntDiv {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntFromLeBytes {
+        inputs: Vec<FunctionInput>,
+        modulus: Vec<u8>,
+        output: u32,
+    },
+    BigIntToLeBytes {
+        input: u32,
+        outputs: Vec<Witness>,
+    },
+    /// Applies the Poseidon2 permutation function to the given state,
+    /// outputting the permuted state.
+    Poseidon2Permutation {
+        /// Input state for the permutation of Poseidon2
+        inputs: Vec<FunctionInput>,
+        /// Permuted state
+        outputs: Vec<Witness>,
+        /// State length (in number of field elements)
+        /// It is the length of inputs and outputs vectors
+        len: u32,
+    },
+    /// Applies the SHA-256 compression function to the input message
+    ///
+    /// # Arguments
+    ///
+    /// * `inputs` - input message block
+    /// * `hash_values` - state from the previous compression
+    /// * `outputs` - result of the input compressed into 256 bits
+    Sha256Compression {
+        /// 512 bits of the input message, represented by 16 u32s
+        inputs: Vec<FunctionInput>,
+        /// Vector of 8 u32s used to compress the input
+        hash_values: Vec<FunctionInput>,
+        /// Output of the compression, represented by 8 u32s
+        outputs: Vec<Witness>,
+    },
 }
 
 impl BlackBoxFuncCall {
@@ -138,11 +188,18 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
             BlackBoxFuncCall::FixedBaseScalarMul { .. } => BlackBoxFunc::FixedBaseScalarMul,
             BlackBoxFuncCall::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
-            BlackBoxFuncCall::EmbeddedCurveDouble { .. } => BlackBoxFunc::EmbeddedCurveDouble,
             BlackBoxFuncCall::Keccak256 { .. } => BlackBoxFunc::Keccak256,
             BlackBoxFuncCall::Keccak256VariableLength { .. } => BlackBoxFunc::Keccak256,
             BlackBoxFuncCall::Keccakf1600 { .. } => BlackBoxFunc::Keccakf1600,
             BlackBoxFuncCall::RecursiveAggregation { .. } => BlackBoxFunc::RecursiveAggregation,
+            BlackBoxFuncCall::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
+            BlackBoxFuncCall::BigIntNeg { .. } => BlackBoxFunc::BigIntNeg,
+            BlackBoxFuncCall::BigIntMul { .. } => BlackBoxFunc::BigIntMul,
+            BlackBoxFuncCall::BigIntDiv { .. } => BlackBoxFunc::BigIntDiv,
+            BlackBoxFuncCall::BigIntFromLeBytes { .. } => BlackBoxFunc::BigIntFromLeBytes,
+            BlackBoxFuncCall::BigIntToLeBytes { .. } => BlackBoxFunc::BigIntToLeBytes,
+            BlackBoxFuncCall::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
+            BlackBoxFuncCall::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
         }
     }
 
@@ -158,17 +215,22 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::Keccak256 { inputs, .. }
             | BlackBoxFuncCall::Keccakf1600 { inputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
-            | BlackBoxFuncCall::PedersenHash { inputs, .. } => inputs.to_vec(),
+            | BlackBoxFuncCall::PedersenHash { inputs, .. }
+            | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
+            | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. }
+            | BlackBoxFuncCall::Sha256Compression { inputs, .. } => inputs.to_vec(),
             BlackBoxFuncCall::AND { lhs, rhs, .. } | BlackBoxFuncCall::XOR { lhs, rhs, .. } => {
                 vec![*lhs, *rhs]
             }
+            BlackBoxFuncCall::BigIntAdd { .. }
+            | BlackBoxFuncCall::BigIntNeg { .. }
+            | BlackBoxFuncCall::BigIntMul { .. }
+            | BlackBoxFuncCall::BigIntDiv { .. }
+            | BlackBoxFuncCall::BigIntToLeBytes { .. } => Vec::new(),
             BlackBoxFuncCall::FixedBaseScalarMul { low, high, .. } => vec![*low, *high],
             BlackBoxFuncCall::EmbeddedCurveAdd {
                 input1_x, input1_y, input2_x, input2_y, ..
             } => vec![*input1_x, *input1_y, *input2_x, *input2_y],
-            BlackBoxFuncCall::EmbeddedCurveDouble { input_x, input_y, .. } => {
-                vec![*input_x, *input_y]
-            }
             BlackBoxFuncCall::RANGE { input } => vec![*input],
             BlackBoxFuncCall::SchnorrVerify {
                 public_key_x,
@@ -249,7 +311,10 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::Blake2s { outputs, .. }
             | BlackBoxFuncCall::Blake3 { outputs, .. }
             | BlackBoxFuncCall::Keccak256 { outputs, .. }
-            | BlackBoxFuncCall::Keccakf1600 { outputs, .. } => outputs.to_vec(),
+            | BlackBoxFuncCall::Keccakf1600 { outputs, .. }
+            | BlackBoxFuncCall::Keccak256VariableLength { outputs, .. }
+            | BlackBoxFuncCall::Poseidon2Permutation { outputs, .. }
+            | BlackBoxFuncCall::Sha256Compression { outputs, .. } => outputs.to_vec(),
             BlackBoxFuncCall::AND { output, .. }
             | BlackBoxFuncCall::XOR { output, .. }
             | BlackBoxFuncCall::SchnorrVerify { output, .. }
@@ -258,12 +323,17 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
             BlackBoxFuncCall::FixedBaseScalarMul { outputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { outputs, .. }
-            | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. }
-            | BlackBoxFuncCall::EmbeddedCurveDouble { outputs, .. } => vec![outputs.0, outputs.1],
-            BlackBoxFuncCall::RANGE { .. } | BlackBoxFuncCall::RecursiveAggregation { .. } => {
+            | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => vec![outputs.0, outputs.1],
+            BlackBoxFuncCall::RANGE { .. }
+            | BlackBoxFuncCall::RecursiveAggregation { .. }
+            | BlackBoxFuncCall::BigIntFromLeBytes { .. }
+            | BlackBoxFuncCall::BigIntAdd { .. }
+            | BlackBoxFuncCall::BigIntNeg { .. }
+            | BlackBoxFuncCall::BigIntMul { .. }
+            | BlackBoxFuncCall::BigIntDiv { .. } => {
                 vec![]
             }
-            BlackBoxFuncCall::Keccak256VariableLength { outputs, .. } => outputs.to_vec(),
+            BlackBoxFuncCall::BigIntToLeBytes { outputs, .. } => outputs.to_vec(),
         }
     }
 }
diff --git a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
index 5d19f9629ba..ecabd98b3b1 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
@@ -3,8 +3,7 @@ use acir::{
         opcodes::{BlackBoxFuncCall, FunctionInput},
         Circuit, Opcode,
     },
-    native_types::{Expression, Witness},
-    FieldElement,
+    native_types::Witness,
 };
 use std::collections::{BTreeMap, HashSet};
 
@@ -105,9 +104,11 @@ impl RangeOptimizer {
         let mut new_order_list = Vec::with_capacity(order_list.len());
         let mut optimized_opcodes = Vec::with_capacity(self.circuit.opcodes.len());
         for (idx, opcode) in self.circuit.opcodes.into_iter().enumerate() {
-            let (witness, num_bits) = match extract_range_opcode(&opcode) {
-                Some(range_opcode) => range_opcode,
-                None => {
+            let (witness, num_bits) = match &opcode {
+                Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE { input }) => {
+                    (input.witness, input.num_bits)
+                }
+                _ => {
                     // If its not the range opcode, add it to the opcode
                     // list and continue;
                     optimized_opcodes.push(opcode);
@@ -131,7 +132,7 @@ impl RangeOptimizer {
             if is_lowest_bit_size {
                 already_seen_witness.insert(witness);
                 new_order_list.push(order_list[idx]);
-                optimized_opcodes.push(optimized_range_opcode(witness, num_bits));
+                optimized_opcodes.push(opcode);
             }
         }
 
@@ -139,36 +140,11 @@ impl RangeOptimizer {
     }
 }
 
-/// Extract the range opcode from the `Opcode` enum
-/// Returns None, if `Opcode` is not the range opcode.
-fn extract_range_opcode(opcode: &Opcode) -> Option<(Witness, u32)> {
-    match opcode {
-        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE { input }) => {
-            Some((input.witness, input.num_bits))
-        }
-        _ => None,
-    }
-}
-
-fn optimized_range_opcode(witness: Witness, num_bits: u32) -> Opcode {
-    if num_bits == 1 {
-        Opcode::AssertZero(Expression {
-            mul_terms: vec![(FieldElement::one(), witness, witness)],
-            linear_combinations: vec![(-FieldElement::one(), witness)],
-            q_c: FieldElement::zero(),
-        })
-    } else {
-        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE {
-            input: FunctionInput { witness, num_bits },
-        })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeSet;
 
-    use crate::compiler::optimizers::redundant_range::{extract_range_opcode, RangeOptimizer};
+    use crate::compiler::optimizers::redundant_range::RangeOptimizer;
     use acir::{
         circuit::{
             opcodes::{BlackBoxFuncCall, FunctionInput},
@@ -218,11 +194,12 @@ mod tests {
         let (optimized_circuit, _) = optimizer.replace_redundant_ranges(acir_opcode_positions);
         assert_eq!(optimized_circuit.opcodes.len(), 1);
 
-        let (witness, num_bits) =
-            extract_range_opcode(&optimized_circuit.opcodes[0]).expect("expected one range opcode");
-
-        assert_eq!(witness, Witness(1));
-        assert_eq!(num_bits, 16);
+        assert_eq!(
+            optimized_circuit.opcodes[0],
+            Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE {
+                input: FunctionInput { witness: Witness(1), num_bits: 16 }
+            })
+        );
     }
 
     #[test]
@@ -240,15 +217,18 @@ mod tests {
         let (optimized_circuit, _) = optimizer.replace_redundant_ranges(acir_opcode_positions);
         assert_eq!(optimized_circuit.opcodes.len(), 2);
 
-        let (witness_a, num_bits_a) =
-            extract_range_opcode(&optimized_circuit.opcodes[0]).expect("expected two range opcode");
-        let (witness_b, num_bits_b) =
-            extract_range_opcode(&optimized_circuit.opcodes[1]).expect("expected two range opcode");
-
-        assert_eq!(witness_a, Witness(1));
-        assert_eq!(witness_b, Witness(2));
-        assert_eq!(num_bits_a, 16);
-        assert_eq!(num_bits_b, 23);
+        assert_eq!(
+            optimized_circuit.opcodes[0],
+            Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE {
+                input: FunctionInput { witness: Witness(1), num_bits: 16 }
+            })
+        );
+        assert_eq!(
+            optimized_circuit.opcodes[1],
+            Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE {
+                input: FunctionInput { witness: Witness(2), num_bits: 23 }
+            })
+        );
     }
 
     #[test]
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 306ea1b7c12..e184401c5d4 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -99,50 +99,8 @@ pub(super) fn transform_internal(
                 }
             }
             Opcode::BlackBoxFuncCall(ref func) => {
-                match func {
-                    acir::circuit::opcodes::BlackBoxFuncCall::AND { output, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::XOR { output, .. } => {
-                        transformer.mark_solvable(*output);
-                    }
-                    acir::circuit::opcodes::BlackBoxFuncCall::RANGE { .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::RecursiveAggregation { .. } => (),
-                    acir::circuit::opcodes::BlackBoxFuncCall::SHA256 { outputs, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::Keccak256 { outputs, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::Keccak256VariableLength {
-                        outputs,
-                        ..
-                    }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::Keccakf1600 { outputs, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::Blake2s { outputs, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::Blake3 { outputs, .. } => {
-                        for witness in outputs {
-                            transformer.mark_solvable(*witness);
-                        }
-                    }
-                    acir::circuit::opcodes::BlackBoxFuncCall::FixedBaseScalarMul {
-                        outputs,
-                        ..
-                    }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::EmbeddedCurveAdd {
-                        outputs, ..
-                    }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::EmbeddedCurveDouble {
-                        outputs,
-                        ..
-                    }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::PedersenCommitment {
-                        outputs,
-                        ..
-                    } => {
-                        transformer.mark_solvable(outputs.0);
-                        transformer.mark_solvable(outputs.1);
-                    }
-                    acir::circuit::opcodes::BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::EcdsaSecp256r1 { output, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::SchnorrVerify { output, .. }
-                    | acir::circuit::opcodes::BlackBoxFuncCall::PedersenHash { output, .. } => {
-                        transformer.mark_solvable(*output);
-                    }
+                for witness in func.get_outputs_vec() {
+                    transformer.mark_solvable(witness);
                 }
 
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
diff --git a/acvm-repo/acvm/src/pwg/blackbox/fixed_base_scalar_mul.rs b/acvm-repo/acvm/src/pwg/blackbox/fixed_base_scalar_mul.rs
index 582ed56584b..c5bfd1d5646 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/fixed_base_scalar_mul.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/fixed_base_scalar_mul.rs
@@ -23,3 +23,24 @@ pub(super) fn fixed_base_scalar_mul(
 
     Ok(())
 }
+
+pub(super) fn embedded_curve_add(
+    backend: &impl BlackBoxFunctionSolver,
+    initial_witness: &mut WitnessMap,
+    input1_x: FunctionInput,
+    input1_y: FunctionInput,
+    input2_x: FunctionInput,
+    input2_y: FunctionInput,
+    outputs: (Witness, Witness),
+) -> Result<(), OpcodeResolutionError> {
+    let input1_x = witness_to_value(initial_witness, input1_x.witness)?;
+    let input1_y = witness_to_value(initial_witness, input1_y.witness)?;
+    let input2_x = witness_to_value(initial_witness, input2_x.witness)?;
+    let input2_y = witness_to_value(initial_witness, input2_y.witness)?;
+    let (res_x, res_y) = backend.ec_add(input1_x, input1_y, input2_x, input2_y)?;
+
+    insert_value(&outputs.0, res_x, initial_witness)?;
+    insert_value(&outputs.1, res_y, initial_witness)?;
+
+    Ok(())
+}
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 5eea234885c..0f026cd274a 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -17,7 +17,7 @@ mod pedersen;
 mod range;
 mod signature;
 
-use fixed_base_scalar_mul::fixed_base_scalar_mul;
+use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul};
 // Hash functions should eventually be exposed for external consumers.
 use hash::solve_generic_256_hash_opcode;
 use logic::{and, xor};
@@ -177,13 +177,26 @@ pub(crate) fn solve(
         BlackBoxFuncCall::FixedBaseScalarMul { low, high, outputs } => {
             fixed_base_scalar_mul(backend, initial_witness, *low, *high, *outputs)
         }
-        BlackBoxFuncCall::EmbeddedCurveAdd { .. } => {
-            todo!();
-        }
-        BlackBoxFuncCall::EmbeddedCurveDouble { .. } => {
-            todo!();
+        BlackBoxFuncCall::EmbeddedCurveAdd { input1_x, input1_y, input2_x, input2_y, outputs } => {
+            embedded_curve_add(
+                backend,
+                initial_witness,
+                *input1_x,
+                *input1_y,
+                *input2_x,
+                *input2_y,
+                *outputs,
+            )
         }
         // Recursive aggregation will be entirely handled by the backend and is not solved by the ACVM
         BlackBoxFuncCall::RecursiveAggregation { .. } => Ok(()),
+        BlackBoxFuncCall::BigIntAdd { .. } => todo!(),
+        BlackBoxFuncCall::BigIntNeg { .. } => todo!(),
+        BlackBoxFuncCall::BigIntMul { .. } => todo!(),
+        BlackBoxFuncCall::BigIntDiv { .. } => todo!(),
+        BlackBoxFuncCall::BigIntFromLeBytes { .. } => todo!(),
+        BlackBoxFuncCall::BigIntToLeBytes { .. } => todo!(),
+        BlackBoxFuncCall::Poseidon2Permutation { .. } => todo!(),
+        BlackBoxFuncCall::Sha256Compression { .. } => todo!(),
     }
 }
diff --git a/acvm-repo/acvm_js/src/logging.rs b/acvm-repo/acvm_js/src/logging.rs
index f5d71fae067..483c23ab624 100644
--- a/acvm-repo/acvm_js/src/logging.rs
+++ b/acvm-repo/acvm_js/src/logging.rs
@@ -1,3 +1,4 @@
+use js_sys::{Error, JsString};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::EnvFilter;
 use tracing_web::MakeWebConsoleWriter;
@@ -7,12 +8,15 @@ use wasm_bindgen::prelude::*;
 ///
 /// @param {LogLevel} level - The maximum level of logging to be emitted.
 #[wasm_bindgen(js_name = initLogLevel, skip_jsdoc)]
-pub fn init_log_level(filter: String) {
+pub fn init_log_level(filter: String) -> Result<(), JsLogInitError> {
     // Set the static variable from Rust
     use std::sync::Once;
 
-    let filter: EnvFilter =
-        filter.parse().expect("Could not parse log filter while initializing logger");
+    let filter: EnvFilter = filter.parse().map_err(|err| {
+        JsLogInitError::constructor(
+            format!("Could not parse log filter while initializing logger: {err}").into(),
+        )
+    })?;
 
     static SET_HOOK: Once = Once::new();
     SET_HOOK.call_once(|| {
@@ -23,4 +27,19 @@ pub fn init_log_level(filter: String) {
 
         tracing_subscriber::registry().with(fmt_layer.with_filter(filter)).init();
     });
+
+    Ok(())
+}
+
+/// `LogInitError` is a raw js error.
+/// It'd be ideal that `LogInitError` was a subclass of Error, but for that we'd need to use JS snippets or a js module.
+/// Currently JS snippets don't work with a nodejs target. And a module would be too much for just a custom error type.
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Error, js_name = "LogInitError", typescript_type = "LogInitError")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsLogInitError;
+
+    #[wasm_bindgen(constructor, js_class = "Error")]
+    fn constructor(message: JsString) -> JsLogInitError;
 }
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index 82941e91d61..2234710dec0 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -36,11 +36,6 @@ pub trait BlackBoxFunctionSolver {
         input2_x: &FieldElement,
         input2_y: &FieldElement,
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError>;
-    fn ec_double(
-        &self,
-        input_x: &FieldElement,
-        input_x: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError>;
 }
 
 pub struct StubbedBlackBoxSolver;
@@ -94,11 +89,4 @@ impl BlackBoxFunctionSolver for StubbedBlackBoxSolver {
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::EmbeddedCurveAdd))
     }
-    fn ec_double(
-        &self,
-        _input_x: &FieldElement,
-        _input_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Err(Self::fail(BlackBoxFunc::EmbeddedCurveDouble))
-    }
 }
diff --git a/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs b/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
index 7f004de0fe9..5e68c7d4030 100644
--- a/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/fixed_base_scalar_mul.rs
@@ -47,6 +47,26 @@ pub fn fixed_base_scalar_mul(
     }
 }
 
+pub fn embedded_curve_add(
+    input1_x: FieldElement,
+    input1_y: FieldElement,
+    input2_x: FieldElement,
+    input2_y: FieldElement,
+) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+    let mut point1 = grumpkin::SWAffine::new(input1_x.into_repr(), input1_y.into_repr());
+    let point2 = grumpkin::SWAffine::new(input2_x.into_repr(), input2_y.into_repr());
+    let res = point1 + point2;
+    point1 = res.into();
+    if let Some((res_x, res_y)) = point1.xy() {
+        Ok((FieldElement::from_repr(*res_x), FieldElement::from_repr(*res_y)))
+    } else {
+        Err(BlackBoxResolutionError::Failed(
+            BlackBoxFunc::EmbeddedCurveAdd,
+            "Point is not on curve".to_string(),
+        ))
+    }
+}
+
 #[cfg(test)]
 mod grumpkin_fixed_base_scalar_mul {
     use ark_ff::BigInteger;
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 92c45e93dea..13aa956f9e1 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -8,7 +8,7 @@ use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 mod fixed_base_scalar_mul;
 mod wasm;
 
-pub use fixed_base_scalar_mul::fixed_base_scalar_mul;
+pub use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul};
 use wasm::Barretenberg;
 
 use self::wasm::{Pedersen, SchnorrSig};
@@ -90,19 +90,11 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver {
 
     fn ec_add(
         &self,
-        _input1_x: &FieldElement,
-        _input1_y: &FieldElement,
-        _input2_x: &FieldElement,
-        _input2_y: &FieldElement,
+        input1_x: &FieldElement,
+        input1_y: &FieldElement,
+        input2_x: &FieldElement,
+        input2_y: &FieldElement,
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        todo!();
-    }
-
-    fn ec_double(
-        &self,
-        _input_x: &FieldElement,
-        _input_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        todo!();
+        embedded_curve_add(*input1_x, *input1_y, *input2_x, *input2_y)
     }
 }
diff --git a/acvm-repo/brillig/src/black_box.rs b/acvm-repo/brillig/src/black_box.rs
index c007e78b785..22fac6f3ba3 100644
--- a/acvm-repo/brillig/src/black_box.rs
+++ b/acvm-repo/brillig/src/black_box.rs
@@ -6,15 +6,30 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BlackBoxOp {
     /// Calculates the SHA256 hash of the inputs.
-    Sha256 { message: HeapVector, output: HeapArray },
+    Sha256 {
+        message: HeapVector,
+        output: HeapArray,
+    },
     /// Calculates the Blake2s hash of the inputs.
-    Blake2s { message: HeapVector, output: HeapArray },
+    Blake2s {
+        message: HeapVector,
+        output: HeapArray,
+    },
     /// Calculates the Blake3 hash of the inputs.
-    Blake3 { message: HeapVector, output: HeapArray },
+    Blake3 {
+        message: HeapVector,
+        output: HeapArray,
+    },
     /// Calculates the Keccak256 hash of the inputs.
-    Keccak256 { message: HeapVector, output: HeapArray },
+    Keccak256 {
+        message: HeapVector,
+        output: HeapArray,
+    },
     /// Keccak Permutation function of 1600 width
-    Keccakf1600 { message: HeapVector, output: HeapArray },
+    Keccakf1600 {
+        message: HeapVector,
+        output: HeapArray,
+    },
     /// Verifies a ECDSA signature over the secp256k1 curve.
     EcdsaSecp256k1 {
         hashed_msg: HeapVector,
@@ -40,11 +55,23 @@ pub enum BlackBoxOp {
         result: RegisterIndex,
     },
     /// Calculates a Pedersen commitment to the inputs.
-    PedersenCommitment { inputs: HeapVector, domain_separator: RegisterIndex, output: HeapArray },
+    PedersenCommitment {
+        inputs: HeapVector,
+        domain_separator: RegisterIndex,
+        output: HeapArray,
+    },
     /// Calculates a Pedersen hash to the inputs.
-    PedersenHash { inputs: HeapVector, domain_separator: RegisterIndex, output: RegisterIndex },
+    PedersenHash {
+        inputs: HeapVector,
+        domain_separator: RegisterIndex,
+        output: RegisterIndex,
+    },
     /// Performs scalar multiplication over the embedded curve.
-    FixedBaseScalarMul { low: RegisterIndex, high: RegisterIndex, result: HeapArray },
+    FixedBaseScalarMul {
+        low: RegisterIndex,
+        high: RegisterIndex,
+        result: HeapArray,
+    },
     /// Performs addition over the embedded curve.
     EmbeddedCurveAdd {
         input1_x: RegisterIndex,
@@ -53,6 +80,43 @@ pub enum BlackBoxOp {
         input2_y: RegisterIndex,
         result: HeapArray,
     },
-    /// Performs point doubling over the embedded curve.
-    EmbeddedCurveDouble { input1_x: RegisterIndex, input1_y: RegisterIndex, result: HeapArray },
+    BigIntAdd {
+        lhs: RegisterIndex,
+        rhs: RegisterIndex,
+        output: RegisterIndex,
+    },
+    BigIntNeg {
+        lhs: RegisterIndex,
+        rhs: RegisterIndex,
+        output: RegisterIndex,
+    },
+    BigIntMul {
+        lhs: RegisterIndex,
+        rhs: RegisterIndex,
+        output: RegisterIndex,
+    },
+    BigIntDiv {
+        lhs: RegisterIndex,
+        rhs: RegisterIndex,
+        output: RegisterIndex,
+    },
+    BigIntFromLeBytes {
+        inputs: HeapVector,
+        modulus: HeapVector,
+        output: RegisterIndex,
+    },
+    BigIntToLeBytes {
+        input: RegisterIndex,
+        output: HeapVector,
+    },
+    Poseidon2Permutation {
+        message: HeapVector,
+        output: HeapArray,
+        len: RegisterIndex,
+    },
+    Sha256Compression {
+        input: HeapVector,
+        hash_values: HeapVector,
+        output: HeapArray,
+    },
 }
diff --git a/acvm-repo/brillig/src/foreign_call.rs b/acvm-repo/brillig/src/foreign_call.rs
index 1359d7d604d..3f124a9a0a7 100644
--- a/acvm-repo/brillig/src/foreign_call.rs
+++ b/acvm-repo/brillig/src/foreign_call.rs
@@ -37,7 +37,7 @@ impl ForeignCallParam {
 }
 
 /// Represents the full output of a [foreign call][crate::Opcode::ForeignCall].
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, Default)]
 pub struct ForeignCallResult {
     /// Resolved output values of the foreign call.
     pub values: Vec<ForeignCallParam>,
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 463038509e1..e9c25200c47 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -165,13 +165,6 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             memory.write_slice(registers.get(result.pointer).to_usize(), &[x.into(), y.into()]);
             Ok(())
         }
-        BlackBoxOp::EmbeddedCurveDouble { input1_x, input1_y, result } => {
-            let input1_x = registers.get(*input1_x).to_field();
-            let input1_y = registers.get(*input1_y).to_field();
-            let (x, y) = solver.ec_double(&input1_x, &input1_y)?;
-            memory.write_slice(registers.get(result.pointer).to_usize(), &[x.into(), y.into()]);
-            Ok(())
-        }
         BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
             let inputs: Vec<FieldElement> =
                 read_heap_vector(memory, registers, inputs).iter().map(|x| x.to_field()).collect();
@@ -200,6 +193,14 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             registers.set(*output, hash.into());
             Ok(())
         }
+        BlackBoxOp::BigIntAdd { .. } => todo!(),
+        BlackBoxOp::BigIntNeg { .. } => todo!(),
+        BlackBoxOp::BigIntMul { .. } => todo!(),
+        BlackBoxOp::BigIntDiv { .. } => todo!(),
+        BlackBoxOp::BigIntFromLeBytes { .. } => todo!(),
+        BlackBoxOp::BigIntToLeBytes { .. } => todo!(),
+        BlackBoxOp::Poseidon2Permutation { .. } => todo!(),
+        BlackBoxOp::Sha256Compression { .. } => todo!(),
     }
 }
 
@@ -217,7 +218,14 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
         BlackBoxOp::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
         BlackBoxOp::FixedBaseScalarMul { .. } => BlackBoxFunc::FixedBaseScalarMul,
         BlackBoxOp::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
-        BlackBoxOp::EmbeddedCurveDouble { .. } => BlackBoxFunc::EmbeddedCurveDouble,
+        BlackBoxOp::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
+        BlackBoxOp::BigIntNeg { .. } => BlackBoxFunc::BigIntNeg,
+        BlackBoxOp::BigIntMul { .. } => BlackBoxFunc::BigIntMul,
+        BlackBoxOp::BigIntDiv { .. } => BlackBoxFunc::BigIntDiv,
+        BlackBoxOp::BigIntFromLeBytes { .. } => BlackBoxFunc::BigIntFromLeBytes,
+        BlackBoxOp::BigIntToLeBytes { .. } => BlackBoxFunc::BigIntToLeBytes,
+        BlackBoxOp::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
+        BlackBoxOp::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
     }
 }
 
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 00c20a704da..38a562e65a1 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -242,7 +242,7 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                                 self.registers.set(*value_index, *value);
                             }
                             _ => unreachable!(
-                                "Function result size does not match brillig bytecode (expected 1 result)"
+                                "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}"
                             ),
                         },
                         RegisterOrMemory::HeapArray(HeapArray { pointer: pointer_index, size }) => {
@@ -460,13 +460,6 @@ impl BlackBoxFunctionSolver for DummyBlackBoxSolver {
     ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
         Ok((5_u128.into(), 6_u128.into()))
     }
-    fn ec_double(
-        &self,
-        _input1_x: &FieldElement,
-        _input1_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Ok((7_u128.into(), 8_u128.into()))
-    }
 }
 
 #[cfg(test)]
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index c9adece4eb5..baabd9aa1dc 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -26,8 +26,12 @@ impl MacroProcessor for AztecMacro {
         transform(ast, crate_id, context)
     }
 
-    fn process_typed_ast(&self, crate_id: &CrateId, context: &mut HirContext) {
-        transform_hir(crate_id, context)
+    fn process_typed_ast(
+        &self,
+        crate_id: &CrateId,
+        context: &mut HirContext,
+    ) -> Result<(), (MacroError, FileId)> {
+        transform_hir(crate_id, context).map_err(|(err, file_id)| (err.into(), file_id))
     }
 }
 
@@ -41,6 +45,7 @@ pub enum AztecMacroError {
     ContractHasTooManyFunctions { span: Span },
     ContractConstructorMissing { span: Span },
     UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
+    EventError { span: Span, message: String },
 }
 
 impl From<AztecMacroError> for MacroError {
@@ -71,6 +76,11 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: Some(span),
             },
+            AztecMacroError::EventError { span, message } => MacroError {
+                primary_message: message,
+                secondary_message: None,
+                span: Some(span),
+            },
         }
     }
 }
@@ -237,8 +247,11 @@ fn transform(
 //
 
 /// Completes the Hir with data gathered from type resolution
-fn transform_hir(crate_id: &CrateId, context: &mut HirContext) {
-    transform_events(crate_id, context);
+fn transform_hir(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+) -> Result<(), (AztecMacroError, FileId)> {
+    transform_events(crate_id, context)
 }
 
 /// Includes an import to the aztec library if it has not been included yet
@@ -472,19 +485,30 @@ fn collect_crate_structs(crate_id: &CrateId, context: &HirContext) -> Vec<Struct
 }
 
 /// Substitutes the signature literal that was introduced in the selector method previously with the actual signature.
-fn transform_event(struct_id: StructId, interner: &mut NodeInterner) {
+fn transform_event(
+    struct_id: StructId,
+    interner: &mut NodeInterner,
+) -> Result<(), (AztecMacroError, FileId)> {
     let struct_type = interner.get_struct(struct_id);
     let selector_id = interner
-        .lookup_method(&Type::Struct(struct_type, vec![]), struct_id, "selector", false)
-        .expect("Selector method not found");
+        .lookup_method(&Type::Struct(struct_type.clone(), vec![]), struct_id, "selector", false)
+        .ok_or_else(|| {
+            let error = AztecMacroError::EventError {
+                span: struct_type.borrow().location.span,
+                message: "Selector method not found".to_owned(),
+            };
+            (error, struct_type.borrow().location.file)
+        })?;
     let selector_function = interner.function(&selector_id);
 
     let compute_selector_statement = interner.statement(
-        selector_function
-            .block(interner)
-            .statements()
-            .first()
-            .expect("Compute selector statement not found"),
+        selector_function.block(interner).statements().first().ok_or_else(|| {
+            let error = AztecMacroError::EventError {
+                span: struct_type.borrow().location.span,
+                message: "Compute selector statement not found".to_owned(),
+            };
+            (error, struct_type.borrow().location.file)
+        })?,
     );
 
     let compute_selector_expression = match compute_selector_statement {
@@ -494,12 +518,21 @@ fn transform_event(struct_id: StructId, interner: &mut NodeInterner) {
         },
         _ => None,
     }
-    .expect("Compute selector statement is not a call expression");
-
-    let first_arg_id = compute_selector_expression
-        .arguments
-        .first()
-        .expect("Missing argument for compute selector");
+    .ok_or_else(|| {
+        let error = AztecMacroError::EventError {
+            span: struct_type.borrow().location.span,
+            message: "Compute selector statement is not a call expression".to_owned(),
+        };
+        (error, struct_type.borrow().location.file)
+    })?;
+
+    let first_arg_id = compute_selector_expression.arguments.first().ok_or_else(|| {
+        let error = AztecMacroError::EventError {
+            span: struct_type.borrow().location.span,
+            message: "Compute selector statement is not a call expression".to_owned(),
+        };
+        (error, struct_type.borrow().location.file)
+    })?;
 
     match interner.expression(first_arg_id) {
         HirExpression::Literal(HirLiteral::Str(signature))
@@ -518,18 +551,29 @@ fn transform_event(struct_id: StructId, interner: &mut NodeInterner) {
                 selector_literal_id,
                 Type::String(Box::new(Type::Constant(signature.len() as u64))),
             );
+            Ok(())
         }
-        _ => unreachable!("Signature placeholder literal does not match"),
+        _ => Err((
+            AztecMacroError::EventError {
+                span: struct_type.borrow().location.span,
+                message: "Signature placeholder literal does not match".to_owned(),
+            },
+            struct_type.borrow().location.file,
+        )),
     }
 }
 
-fn transform_events(crate_id: &CrateId, context: &mut HirContext) {
+fn transform_events(
+    crate_id: &CrateId,
+    context: &mut HirContext,
+) -> Result<(), (AztecMacroError, FileId)> {
     for struct_id in collect_crate_structs(crate_id, context) {
         let attributes = context.def_interner.struct_attributes(&struct_id);
         if attributes.iter().any(|attr| matches!(attr, SecondaryAttribute::Event)) {
-            transform_event(struct_id, &mut context.def_interner);
+            transform_event(struct_id, &mut context.def_interner)?;
         }
     }
+    Ok(())
 }
 
 const SIGNATURE_PLACEHOLDER: &str = "SIGNATURE_PLACEHOLDER";
diff --git a/compiler/noirc_driver/Cargo.toml b/compiler/noirc_driver/Cargo.toml
index eb9650e8aec..d9b240101d8 100644
--- a/compiler/noirc_driver/Cargo.toml
+++ b/compiler/noirc_driver/Cargo.toml
@@ -25,3 +25,4 @@ rust-embed.workspace = true
 tracing.workspace = true
 
 aztec_macros = { path = "../../aztec_macros" }
+noirc_macros = { path = "../../noirc_macros" }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 6fd69f8b576..25d4229048e 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -76,7 +76,7 @@ pub struct CompileOptions {
     #[arg(long, hide = true)]
     pub only_acir: bool,
 
-    /// Disables the builtin macros being used in the compiler
+    /// Disables the builtin Aztec macros being used in the compiler
     #[arg(long, hide = true)]
     pub disable_macros: bool,
 
@@ -191,9 +191,12 @@ pub fn check_crate(
     disable_macros: bool,
 ) -> CompilationResult<()> {
     let macros: Vec<&dyn MacroProcessor> = if disable_macros {
-        vec![]
+        vec![&noirc_macros::AssertMessageMacro as &dyn MacroProcessor]
     } else {
-        vec![&aztec_macros::AztecMacro as &dyn MacroProcessor]
+        vec![
+            &aztec_macros::AztecMacro as &dyn MacroProcessor,
+            &noirc_macros::AssertMessageMacro as &dyn MacroProcessor,
+        ]
     };
 
     let mut errors = vec![];
@@ -244,6 +247,7 @@ pub fn compile_main(
     let compiled_program =
         compile_no_check(context, options, main, cached_program, options.force_compile)
             .map_err(FileDiagnostic::from)?;
+
     let compilation_warnings = vecmap(compiled_program.warnings.clone(), FileDiagnostic::from);
     if options.deny_warnings && !compilation_warnings.is_empty() {
         return Err(compilation_warnings);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index c081806f4a7..96d80cb8131 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -215,23 +215,6 @@ pub(crate) fn convert_black_box_call(
                 )
             }
         }
-        BlackBoxFunc::EmbeddedCurveDouble => {
-            if let (
-                [BrilligVariable::Simple(input1_x), BrilligVariable::Simple(input1_y)],
-                [BrilligVariable::BrilligArray(result_array)],
-            ) = (function_arguments, function_results)
-            {
-                brillig_context.black_box_op_instruction(BlackBoxOp::EmbeddedCurveDouble {
-                    input1_x: *input1_x,
-                    input1_y: *input1_y,
-                    result: result_array.to_heap_array(),
-                });
-            } else {
-                unreachable!(
-                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
-                )
-            }
-        }
         BlackBoxFunc::AND => {
             unreachable!("ICE: `BlackBoxFunc::AND` calls should be transformed into a `BinaryOp`")
         }
@@ -244,6 +227,138 @@ pub(crate) fn convert_black_box_call(
         BlackBoxFunc::RecursiveAggregation => unimplemented!(
             "ICE: `BlackBoxFunc::RecursiveAggregation` is not implemented by the Brillig VM"
         ),
+        BlackBoxFunc::BigIntAdd => {
+            if let (
+                [BrilligVariable::Simple(lhs), BrilligVariable::Simple(rhs)],
+                [BrilligVariable::Simple(output)],
+            ) = (function_arguments, function_results)
+            {
+                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntAdd {
+                    lhs: *lhs,
+                    rhs: *rhs,
+                    output: *output,
+                });
+            } else {
+                unreachable!(
+                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                )
+            }
+        }
+        BlackBoxFunc::BigIntNeg => {
+            if let (
+                [BrilligVariable::Simple(lhs), BrilligVariable::Simple(rhs)],
+                [BrilligVariable::Simple(output)],
+            ) = (function_arguments, function_results)
+            {
+                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntNeg {
+                    lhs: *lhs,
+                    rhs: *rhs,
+                    output: *output,
+                });
+            } else {
+                unreachable!(
+                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                )
+            }
+        }
+        BlackBoxFunc::BigIntMul => {
+            if let (
+                [BrilligVariable::Simple(lhs), BrilligVariable::Simple(rhs)],
+                [BrilligVariable::Simple(output)],
+            ) = (function_arguments, function_results)
+            {
+                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntMul {
+                    lhs: *lhs,
+                    rhs: *rhs,
+                    output: *output,
+                });
+            } else {
+                unreachable!(
+                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                )
+            }
+        }
+        BlackBoxFunc::BigIntDiv => {
+            if let (
+                [BrilligVariable::Simple(lhs), BrilligVariable::Simple(rhs)],
+                [BrilligVariable::Simple(output)],
+            ) = (function_arguments, function_results)
+            {
+                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntDiv {
+                    lhs: *lhs,
+                    rhs: *rhs,
+                    output: *output,
+                });
+            } else {
+                unreachable!(
+                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                )
+            }
+        }
+        BlackBoxFunc::BigIntFromLeBytes => {
+            if let ([inputs, modulus], [BrilligVariable::Simple(output)]) =
+                (function_arguments, function_results)
+            {
+                let inputs_vector = convert_array_or_vector(brillig_context, inputs, bb_func);
+                let modulus_vector = convert_array_or_vector(brillig_context, modulus, bb_func);
+                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntFromLeBytes {
+                    inputs: inputs_vector.to_heap_vector(),
+                    modulus: modulus_vector.to_heap_vector(),
+                    output: *output,
+                });
+            } else {
+                unreachable!(
+                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                )
+            }
+        }
+        BlackBoxFunc::BigIntToLeBytes => {
+            if let (
+                [BrilligVariable::Simple(input)],
+                [BrilligVariable::BrilligVector(result_vector)],
+            ) = (function_arguments, function_results)
+            {
+                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntToLeBytes {
+                    input: *input,
+                    output: result_vector.to_heap_vector(),
+                });
+            } else {
+                unreachable!(
+                    "ICE: EmbeddedCurveAdd expects two register arguments and one array result"
+                )
+            }
+        }
+        BlackBoxFunc::Poseidon2Permutation => {
+            if let (
+                [message, BrilligVariable::Simple(state_len)],
+                [BrilligVariable::BrilligArray(result_array)],
+            ) = (function_arguments, function_results)
+            {
+                let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
+                brillig_context.black_box_op_instruction(BlackBoxOp::Poseidon2Permutation {
+                    message: message_vector.to_heap_vector(),
+                    output: result_array.to_heap_array(),
+                    len: *state_len,
+                });
+            } else {
+                unreachable!("ICE: Poseidon2Permutation expects one array argument, a length and one array result")
+            }
+        }
+        BlackBoxFunc::Sha256Compression => {
+            if let ([message, hash_values], [BrilligVariable::BrilligArray(result_array)]) =
+                (function_arguments, function_results)
+            {
+                let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
+                let hash_vector = convert_array_or_vector(brillig_context, hash_values, bb_func);
+                brillig_context.black_box_op_instruction(BlackBoxOp::Sha256Compression {
+                    input: message_vector.to_heap_vector(),
+                    hash_values: hash_vector.to_heap_vector(),
+                    output: result_array.to_heap_array(),
+                });
+            } else {
+                unreachable!("ICE: Sha256Compression expects two array argument, one array result")
+            }
+        }
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index b084042981b..632add74e6d 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -3,6 +3,7 @@ use crate::brillig::brillig_ir::{
     BrilligBinaryOp, BrilligContext, BRILLIG_INTEGER_ARITHMETIC_BIT_SIZE,
 };
 use crate::ssa::ir::dfg::CallStack;
+use crate::ssa::ir::instruction::ConstrainError;
 use crate::ssa::ir::{
     basic_block::{BasicBlock, BasicBlockId},
     dfg::DataFlowGraph,
@@ -265,7 +266,30 @@ impl<'block> BrilligBlock<'block> {
                     condition,
                 );
 
-                self.brillig_context.constrain_instruction(condition, assert_message.clone());
+                let assert_message = if let Some(error) = assert_message {
+                    match error.as_ref() {
+                        ConstrainError::Static(string) => Some(string.clone()),
+                        ConstrainError::Dynamic(call_instruction) => {
+                            let Instruction::Call { func, arguments } = call_instruction else {
+                                unreachable!("expected a call instruction")
+                            };
+
+                            let Value::Function(func_id) =  &dfg[*func]  else {
+                                unreachable!("expected a function value")
+                            };
+
+                            self.convert_ssa_function_call(*func_id, arguments, dfg, &[]);
+
+                            // Dynamic assert messages are handled in the generated function call.
+                            // We then don't need to attach one to the constrain instruction.
+                            None
+                        }
+                    }
+                } else {
+                    None
+                };
+
+                self.brillig_context.constrain_instruction(condition, assert_message);
                 self.brillig_context.deallocate_register(condition);
             }
             Instruction::Allocate => {
@@ -369,7 +393,8 @@ impl<'block> BrilligBlock<'block> {
                     }
                 }
                 Value::Function(func_id) => {
-                    self.convert_ssa_function_call(*func_id, arguments, dfg, instruction_id);
+                    let result_ids = dfg.instruction_results(instruction_id);
+                    self.convert_ssa_function_call(*func_id, arguments, dfg, result_ids);
                 }
                 Value::Intrinsic(Intrinsic::BlackBox(bb_func)) => {
                     // Slices are represented as a tuple of (length, slice contents).
@@ -638,7 +663,7 @@ impl<'block> BrilligBlock<'block> {
         func_id: FunctionId,
         arguments: &[ValueId],
         dfg: &DataFlowGraph,
-        instruction_id: InstructionId,
+        result_ids: &[ValueId],
     ) {
         // Convert the arguments to registers casting those to the types of the receiving function
         let argument_registers: Vec<RegisterIndex> = arguments
@@ -646,8 +671,6 @@ impl<'block> BrilligBlock<'block> {
             .flat_map(|argument_id| self.convert_ssa_value(*argument_id, dfg).extract_registers())
             .collect();
 
-        let result_ids = dfg.instruction_results(instruction_id);
-
         // Create label for the function that will be called
         let label_of_function_to_call = FunctionContext::function_id_to_function_label(func_id);
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index db3cd501ca0..3e6c3d4d7de 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -1096,14 +1096,6 @@ pub(crate) mod tests {
         ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
             panic!("Path not trodden by this test")
         }
-
-        fn ec_double(
-            &self,
-            _input_x: &FieldElement,
-            _input_y: &FieldElement,
-        ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-            panic!("Path not trodden by this test")
-        }
     }
 
     pub(crate) fn create_context() -> BrilligContext {
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index dc8c6b6694c..a8563dc9efe 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -413,15 +413,6 @@ impl DebugShow {
                     result
                 );
             }
-            BlackBoxOp::EmbeddedCurveDouble { input1_x, input1_y, result } => {
-                debug_println!(
-                    self.enable_debug_trace,
-                    "  EMBEDDED_CURVE_DOUBLE ({} {}) -> {}",
-                    input1_x,
-                    input1_y,
-                    result
-                );
-            }
             BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
                 debug_println!(
                     self.enable_debug_trace,
@@ -457,6 +448,77 @@ impl DebugShow {
                     result
                 );
             }
+            BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  BIGINT_ADD {} {} -> {}",
+                    lhs,
+                    rhs,
+                    output
+                );
+            }
+            BlackBoxOp::BigIntNeg { lhs, rhs, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  BIGINT_NEG {} {} -> {}",
+                    lhs,
+                    rhs,
+                    output
+                );
+            }
+            BlackBoxOp::BigIntMul { lhs, rhs, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  BIGINT_MUL {} {} -> {}",
+                    lhs,
+                    rhs,
+                    output
+                );
+            }
+            BlackBoxOp::BigIntDiv { lhs, rhs, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  BIGINT_DIV {} {} -> {}",
+                    lhs,
+                    rhs,
+                    output
+                );
+            }
+            BlackBoxOp::BigIntFromLeBytes { inputs, modulus, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  BIGINT_FROM_LE_BYTES {} {} -> {}",
+                    inputs,
+                    modulus,
+                    output
+                );
+            }
+            BlackBoxOp::BigIntToLeBytes { input, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  BIGINT_TO_LE_BYTES {} -> {}",
+                    input,
+                    output
+                );
+            }
+            BlackBoxOp::Poseidon2Permutation { message, output, len } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  POSEIDON2_PERMUTATION {} {} -> {}",
+                    message,
+                    len,
+                    output
+                );
+            }
+            BlackBoxOp::Sha256Compression { input, hash_values, output } => {
+                debug_println!(
+                    self.enable_debug_trace,
+                    "  SHA256COMPRESSION {} {} -> {}",
+                    input,
+                    hash_values,
+                    output
+                );
+            }
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index 2582c48555a..73b6e671bd5 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -44,6 +44,8 @@ pub enum RuntimeError {
     AssertConstantFailed { call_stack: CallStack },
     #[error("Nested slices are not supported")]
     NestedSlice { call_stack: CallStack },
+    #[error("Big Integer modulus do no match")]
+    BigIntModulus { call_stack: CallStack },
 }
 
 // We avoid showing the actual lhs and rhs since most of the time they are just 0
@@ -132,7 +134,8 @@ impl RuntimeError {
             | RuntimeError::AssertConstantFailed { call_stack }
             | RuntimeError::IntegerOutOfBounds { call_stack, .. }
             | RuntimeError::UnsupportedIntegerSize { call_stack, .. }
-            | RuntimeError::NestedSlice { call_stack, .. } => call_stack,
+            | RuntimeError::NestedSlice { call_stack, .. }
+            | RuntimeError::BigIntModulus { call_stack, .. } => call_stack,
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs
index 96800b22ad0..1ddbae0f339 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs
@@ -1,3 +1,4 @@
 pub(crate) mod acir_variable;
+pub(crate) mod big_int;
 pub(crate) mod generated_acir;
 pub(crate) mod sort;
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index cd96f6f8cb9..13d1ad707c2 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1,3 +1,4 @@
+use super::big_int::BigIntContext;
 use super::generated_acir::GeneratedAcir;
 use crate::brillig::brillig_gen::brillig_directive;
 use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
@@ -107,6 +108,9 @@ pub(crate) struct AcirContext {
     /// then the `acir_ir` will be populated to assert this
     /// addition.
     acir_ir: GeneratedAcir,
+
+    /// The BigIntContext, used to generate identifiers for BigIntegers
+    big_int_ctx: BigIntContext,
 }
 
 impl AcirContext {
@@ -396,8 +400,8 @@ impl AcirContext {
             // Operands are booleans.
             //
             // a ^ b == a + b - 2*a*b
-            let sum = self.add_var(lhs, rhs)?;
             let prod = self.mul_var(lhs, rhs)?;
+            let sum = self.add_var(lhs, rhs)?;
             self.add_mul_var(sum, -FieldElement::from(2_i128), prod)
         } else {
             let inputs = vec![AcirValue::Var(lhs, typ.clone()), AcirValue::Var(rhs, typ)];
@@ -457,8 +461,8 @@ impl AcirContext {
         if bit_size == 1 {
             // Operands are booleans
             // a + b - ab
-            let sum = self.add_var(lhs, rhs)?;
             let mul = self.mul_var(lhs, rhs)?;
+            let sum = self.add_var(lhs, rhs)?;
             self.sub_var(sum, mul)
         } else {
             // Implement OR in terms of AND
@@ -1140,10 +1144,10 @@ impl AcirContext {
         &mut self,
         name: BlackBoxFunc,
         mut inputs: Vec<AcirValue>,
-        output_count: usize,
+        mut output_count: usize,
     ) -> Result<Vec<AcirVar>, RuntimeError> {
         // Separate out any arguments that should be constants
-        let constants = match name {
+        let (constant_inputs, constant_outputs) = match name {
             BlackBoxFunc::PedersenCommitment | BlackBoxFunc::PedersenHash => {
                 // The last argument of pedersen is the domain separator, which must be a constant
                 let domain_var = match inputs.pop() {
@@ -1167,23 +1171,140 @@ impl AcirContext {
                     }
                 };
 
-                vec![domain_constant]
+                (vec![domain_constant], Vec::new())
+            }
+            BlackBoxFunc::Poseidon2Permutation => {
+                // The last argument is the state length, which must be a constant
+                let state_len = match inputs.pop() {
+                    Some(state_len) => state_len.into_var()?,
+                    None => {
+                        return Err(RuntimeError::InternalError(InternalError::MissingArg {
+                            name: "poseidon_2_permutation call".to_string(),
+                            arg: "length".to_string(),
+                            call_stack: self.get_call_stack(),
+                        }))
+                    }
+                };
+
+                let state_len = match self.vars[&state_len].as_constant() {
+                    Some(state_len) => state_len,
+                    None => {
+                        return Err(RuntimeError::InternalError(InternalError::NotAConstant {
+                            name: "length".to_string(),
+                            call_stack: self.get_call_stack(),
+                        }))
+                    }
+                };
+
+                (vec![state_len], Vec::new())
+            }
+            BlackBoxFunc::BigIntAdd
+            | BlackBoxFunc::BigIntNeg
+            | BlackBoxFunc::BigIntMul
+            | BlackBoxFunc::BigIntDiv => {
+                assert_eq!(inputs.len(), 4, "ICE - bigint operation requires 4 inputs");
+                let const_inputs = vecmap(inputs, |i| {
+                    let var = i.into_var()?;
+                    match self.vars[&var].as_constant() {
+                        Some(const_var) => Ok(const_var),
+                        None => Err(RuntimeError::InternalError(InternalError::NotAConstant {
+                            name: "big integer".to_string(),
+                            call_stack: self.get_call_stack(),
+                        })),
+                    }
+                });
+                inputs = Vec::new();
+                output_count = 0;
+                let mut field_inputs = Vec::new();
+                for i in const_inputs {
+                    field_inputs.push(i?);
+                }
+                if field_inputs[1] != field_inputs[3] {
+                    return Err(RuntimeError::BigIntModulus { call_stack: self.get_call_stack() });
+                }
+
+                let result_id = self.big_int_ctx.new_big_int(field_inputs[1]);
+                (
+                    vec![field_inputs[0], field_inputs[2]],
+                    vec![result_id.bigint_id(), result_id.modulus_id()],
+                )
+            }
+            BlackBoxFunc::BigIntToLeBytes => {
+                let const_inputs = vecmap(inputs, |i| {
+                    let var = i.into_var()?;
+                    match self.vars[&var].as_constant() {
+                        Some(const_var) => Ok(const_var),
+                        None => Err(RuntimeError::InternalError(InternalError::NotAConstant {
+                            name: "big integer".to_string(),
+                            call_stack: self.get_call_stack(),
+                        })),
+                    }
+                });
+                inputs = Vec::new();
+                let mut field_inputs = Vec::new();
+                for i in const_inputs {
+                    field_inputs.push(i?);
+                }
+                let modulus = self.big_int_ctx.modulus(field_inputs[0]);
+                let bytes_len = ((modulus - BigUint::from(1_u32)).bits() - 1) / 8 + 1;
+                output_count = bytes_len as usize;
+                (field_inputs, vec![FieldElement::from(bytes_len as u128)])
+            }
+            BlackBoxFunc::BigIntFromLeBytes => {
+                let invalid_input = "ICE - bigint operation requires 2 inputs";
+                assert_eq!(inputs.len(), 2, "{invalid_input}");
+                let mut modulus = Vec::new();
+                match inputs.pop().expect(invalid_input) {
+                    AcirValue::Array(values) => {
+                        for value in values {
+                            modulus.push(self.vars[&value.into_var()?].as_constant().ok_or(
+                                RuntimeError::InternalError(InternalError::NotAConstant {
+                                    name: "big integer".to_string(),
+                                    call_stack: self.get_call_stack(),
+                                }),
+                            )?);
+                        }
+                    }
+                    _ => {
+                        return Err(RuntimeError::InternalError(InternalError::MissingArg {
+                            name: "big_int_from_le_bytes".to_owned(),
+                            arg: "modulus".to_owned(),
+                            call_stack: self.get_call_stack(),
+                        }));
+                    }
+                }
+                let big_modulus = BigUint::from_bytes_le(&vecmap(&modulus, |b| b.to_u128() as u8));
+                output_count = 0;
+
+                let modulus_id = self.big_int_ctx.get_or_insert_modulus(big_modulus);
+                let result_id =
+                    self.big_int_ctx.new_big_int(FieldElement::from(modulus_id as u128));
+                (modulus, vec![result_id.bigint_id(), result_id.modulus_id()])
             }
-            _ => vec![],
+            _ => (vec![], vec![]),
         };
 
         // Convert `AcirVar` to `FunctionInput`
         let inputs = self.prepare_inputs_for_black_box_func_call(inputs)?;
-
         // Call Black box with `FunctionInput`
-        let outputs = self.acir_ir.call_black_box(name, &inputs, constants, output_count)?;
+        let mut results = vecmap(&constant_outputs, |c| self.add_constant(*c));
+        let outputs = self.acir_ir.call_black_box(
+            name,
+            &inputs,
+            constant_inputs,
+            constant_outputs,
+            output_count,
+        )?;
 
         // Convert `Witness` values which are now constrained to be the output of the
         // black box function call into `AcirVar`s.
         //
         // We do not apply range information on the output of the black box function.
         // See issue #1439
-        Ok(vecmap(&outputs, |witness_index| self.add_data(AcirVarData::Witness(*witness_index))))
+        results.extend(vecmap(&outputs, |witness_index| {
+            self.add_data(AcirVarData::Witness(*witness_index))
+        }));
+        Ok(results)
     }
 
     /// Black box function calls expect their inputs to be in a specific data structure (FunctionInput).
@@ -1320,20 +1441,22 @@ impl AcirContext {
         inputs: Vec<AcirValue>,
         outputs: Vec<AcirType>,
         attempt_execution: bool,
-    ) -> Result<Vec<AcirValue>, InternalError> {
-        let b_inputs = try_vecmap(inputs, |i| match i {
-            AcirValue::Var(var, _) => Ok(BrilligInputs::Single(self.var_to_expression(var)?)),
-            AcirValue::Array(vars) => {
-                let mut var_expressions: Vec<Expression> = Vec::new();
-                for var in vars {
-                    self.brillig_array_input(&mut var_expressions, var)?;
+    ) -> Result<Vec<AcirValue>, RuntimeError> {
+        let b_inputs = try_vecmap(inputs, |i| -> Result<_, InternalError> {
+            match i {
+                AcirValue::Var(var, _) => Ok(BrilligInputs::Single(self.var_to_expression(var)?)),
+                AcirValue::Array(vars) => {
+                    let mut var_expressions: Vec<Expression> = Vec::new();
+                    for var in vars {
+                        self.brillig_array_input(&mut var_expressions, var)?;
+                    }
+                    Ok(BrilligInputs::Array(var_expressions))
+                }
+                AcirValue::DynamicArray(_) => {
+                    let mut var_expressions = Vec::new();
+                    self.brillig_array_input(&mut var_expressions, i)?;
+                    Ok(BrilligInputs::Array(var_expressions))
                 }
-                Ok(BrilligInputs::Array(var_expressions))
-            }
-            AcirValue::DynamicArray(_) => {
-                let mut var_expressions = Vec::new();
-                self.brillig_array_input(&mut var_expressions, i)?;
-                Ok(BrilligInputs::Array(var_expressions))
             }
         })?;
 
@@ -1368,6 +1491,34 @@ impl AcirContext {
         let predicate = self.var_to_expression(predicate)?;
         self.acir_ir.brillig(Some(predicate), generated_brillig, b_inputs, b_outputs);
 
+        fn range_constraint_value(
+            context: &mut AcirContext,
+            value: &AcirValue,
+        ) -> Result<(), RuntimeError> {
+            match value {
+                AcirValue::Var(var, typ) => {
+                    let numeric_type = match typ {
+                        AcirType::NumericType(numeric_type) => numeric_type,
+                        _ => unreachable!("`AcirValue::Var` may only hold primitive values"),
+                    };
+                    context.range_constrain_var(*var, numeric_type, None)?;
+                }
+                AcirValue::Array(values) => {
+                    for value in values {
+                        range_constraint_value(context, value)?;
+                    }
+                }
+                AcirValue::DynamicArray(_) => {
+                    unreachable!("Brillig opcodes cannot return dynamic arrays")
+                }
+            }
+            Ok(())
+        }
+
+        for output_var in &outputs_var {
+            range_constraint_value(self, output_var)?;
+        }
+
         Ok(outputs_var)
     }
 
@@ -1498,7 +1649,6 @@ impl AcirContext {
         &mut self,
         inputs: Vec<AcirVar>,
         bit_size: u32,
-        predicate: AcirVar,
     ) -> Result<Vec<AcirVar>, RuntimeError> {
         let len = inputs.len();
         // Convert the inputs into expressions
@@ -1515,25 +1665,16 @@ impl AcirContext {
         self.acir_ir.permutation(&inputs_expr, &output_expr)?;
 
         // Enforce the outputs to be sorted
+        let true_var = self.add_constant(true);
         for i in 0..(outputs_var.len() - 1) {
-            self.less_than_constrain(outputs_var[i], outputs_var[i + 1], bit_size, predicate)?;
+            let less_than_next_element =
+                self.more_than_eq_var(outputs_var[i + 1], outputs_var[i], bit_size)?;
+            self.assert_eq_var(less_than_next_element, true_var, None)?;
         }
 
         Ok(outputs_var)
     }
 
-    /// Constrain lhs to be less than rhs
-    fn less_than_constrain(
-        &mut self,
-        lhs: AcirVar,
-        rhs: AcirVar,
-        bit_size: u32,
-        predicate: AcirVar,
-    ) -> Result<(), RuntimeError> {
-        let lhs_less_than_rhs = self.more_than_eq_var(rhs, lhs, bit_size)?;
-        self.maybe_eq_predicate(lhs_less_than_rhs, predicate)
-    }
-
     /// Returns a Variable that is constrained to be the result of reading
     /// from the memory `block_id` at the given `index`.
     pub(crate) fn read_from_memory(
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
new file mode 100644
index 00000000000..c21188a8dbc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
@@ -0,0 +1,57 @@
+use acvm::FieldElement;
+use num_bigint::BigUint;
+
+/// Represents a bigint value in the form (id, modulus) where
+///     id is the identifier of the big integer number, and
+///     modulus is the identifier of the big integer size
+#[derive(Default, Clone, Copy, Debug)]
+pub(crate) struct BigIntId {
+    pub(crate) bigint_id: u32,
+    pub(crate) modulus_id: u32,
+}
+
+impl BigIntId {
+    pub(crate) fn bigint_id(&self) -> FieldElement {
+        FieldElement::from(self.bigint_id as u128)
+    }
+
+    pub(crate) fn modulus_id(&self) -> FieldElement {
+        FieldElement::from(self.modulus_id as u128)
+    }
+}
+
+/// BigIntContext is used to generate identifiers for big integers and their modulus
+#[derive(Default, Debug)]
+pub(crate) struct BigIntContext {
+    modulus: Vec<BigUint>,
+    big_integers: Vec<BigIntId>,
+}
+
+impl BigIntContext {
+    /// Creates a new BigIntId for the given modulus identifier and returns it.
+    pub(crate) fn new_big_int(&mut self, modulus_id: FieldElement) -> BigIntId {
+        let id = self.big_integers.len() as u32;
+        let result = BigIntId { bigint_id: id, modulus_id: modulus_id.to_u128() as u32 };
+        self.big_integers.push(result);
+        result
+    }
+
+    /// Returns the modulus corresponding to the given modulus index
+    pub(crate) fn modulus(&self, idx: FieldElement) -> BigUint {
+        self.modulus[idx.to_u128() as usize].clone()
+    }
+
+    /// Returns the BigIntId corresponding to the given identifier
+    pub(crate) fn get(&self, id: FieldElement) -> BigIntId {
+        self.big_integers[id.to_u128() as usize]
+    }
+
+    /// Adds a modulus to the context (if it is not already present)
+    pub(crate) fn get_or_insert_modulus(&mut self, modulus: BigUint) -> u32 {
+        if let Some(pos) = self.modulus.iter().position(|x| x == &modulus) {
+            return pos as u32;
+        }
+        self.modulus.push(modulus);
+        (self.modulus.len() - 1) as u32
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index efc64c5286e..b86fc4eeb5f 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -138,7 +138,8 @@ impl GeneratedAcir {
         &mut self,
         func_name: BlackBoxFunc,
         inputs: &[Vec<FunctionInput>],
-        constants: Vec<FieldElement>,
+        constant_inputs: Vec<FieldElement>,
+        constant_outputs: Vec<FieldElement>,
         output_count: usize,
     ) -> Result<Vec<Witness>, InternalError> {
         let input_count = inputs.iter().fold(0usize, |sum, val| sum + val.len());
@@ -176,12 +177,12 @@ impl GeneratedAcir {
             BlackBoxFunc::PedersenCommitment => BlackBoxFuncCall::PedersenCommitment {
                 inputs: inputs[0].clone(),
                 outputs: (outputs[0], outputs[1]),
-                domain_separator: constants[0].to_u128() as u32,
+                domain_separator: constant_inputs[0].to_u128() as u32,
             },
             BlackBoxFunc::PedersenHash => BlackBoxFuncCall::PedersenHash {
                 inputs: inputs[0].clone(),
                 output: outputs[0],
-                domain_separator: constants[0].to_u128() as u32,
+                domain_separator: constant_inputs[0].to_u128() as u32,
             },
             BlackBoxFunc::EcdsaSecp256k1 => {
                 BlackBoxFuncCall::EcdsaSecp256k1 {
@@ -219,11 +220,6 @@ impl GeneratedAcir {
                 input2_y: inputs[3][0],
                 outputs: (outputs[0], outputs[1]),
             },
-            BlackBoxFunc::EmbeddedCurveDouble => BlackBoxFuncCall::EmbeddedCurveDouble {
-                input_x: inputs[0][0],
-                input_y: inputs[1][0],
-                outputs: (outputs[0], outputs[1]),
-            },
             BlackBoxFunc::Keccak256 => {
                 let var_message_size = match inputs.to_vec().pop() {
                     Some(var_message_size) => var_message_size[0],
@@ -251,6 +247,45 @@ impl GeneratedAcir {
                 public_inputs: inputs[2].clone(),
                 key_hash: inputs[3][0],
             },
+            BlackBoxFunc::BigIntAdd => BlackBoxFuncCall::BigIntAdd {
+                lhs: constant_inputs[0].to_u128() as u32,
+                rhs: constant_inputs[1].to_u128() as u32,
+                output: constant_outputs[0].to_u128() as u32,
+            },
+            BlackBoxFunc::BigIntNeg => BlackBoxFuncCall::BigIntNeg {
+                lhs: constant_inputs[0].to_u128() as u32,
+                rhs: constant_inputs[1].to_u128() as u32,
+                output: constant_outputs[0].to_u128() as u32,
+            },
+            BlackBoxFunc::BigIntMul => BlackBoxFuncCall::BigIntMul {
+                lhs: constant_inputs[0].to_u128() as u32,
+                rhs: constant_inputs[1].to_u128() as u32,
+                output: constant_outputs[0].to_u128() as u32,
+            },
+            BlackBoxFunc::BigIntDiv => BlackBoxFuncCall::BigIntDiv {
+                lhs: constant_inputs[0].to_u128() as u32,
+                rhs: constant_inputs[1].to_u128() as u32,
+                output: constant_outputs[0].to_u128() as u32,
+            },
+            BlackBoxFunc::BigIntFromLeBytes => BlackBoxFuncCall::BigIntFromLeBytes {
+                inputs: inputs[0].clone(),
+                modulus: vecmap(constant_inputs, |c| c.to_u128() as u8),
+                output: constant_outputs[0].to_u128() as u32,
+            },
+            BlackBoxFunc::BigIntToLeBytes => BlackBoxFuncCall::BigIntToLeBytes {
+                input: constant_inputs[0].to_u128() as u32,
+                outputs,
+            },
+            BlackBoxFunc::Poseidon2Permutation => BlackBoxFuncCall::Poseidon2Permutation {
+                inputs: inputs[0].clone(),
+                outputs,
+                len: constant_inputs[0].to_u128() as u32,
+            },
+            BlackBoxFunc::Sha256Compression => BlackBoxFuncCall::Sha256Compression {
+                inputs: inputs[0].clone(),
+                hash_values: inputs[1].clone(),
+                outputs,
+            },
         };
 
         self.push_opcode(AcirOpcode::BlackBoxFuncCall(black_box_func_call));
@@ -573,6 +608,7 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
     match name {
         // Bitwise opcodes will take in 2 parameters
         BlackBoxFunc::AND | BlackBoxFunc::XOR => Some(2),
+
         // All of the hash/cipher methods will take in a
         // variable number of inputs.
         BlackBoxFunc::Keccak256
@@ -583,7 +619,11 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
         | BlackBoxFunc::PedersenHash => None,
 
         BlackBoxFunc::Keccakf1600 => Some(25),
+        // The permutation takes a fixed number of inputs, but the inputs length depends on the proving system implementation.
+        BlackBoxFunc::Poseidon2Permutation => None,
 
+        // SHA256 compression requires 16 u32s as input message and 8 u32s for the hash state.
+        BlackBoxFunc::Sha256Compression => Some(24),
         // Can only apply a range constraint to one
         // witness at a time.
         BlackBoxFunc::RANGE => Some(1),
@@ -593,15 +633,26 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
         BlackBoxFunc::SchnorrVerify
         | BlackBoxFunc::EcdsaSecp256k1
         | BlackBoxFunc::EcdsaSecp256r1 => None,
+
         // Inputs for fixed based scalar multiplication
         // is the low and high limbs of the scalar
         BlackBoxFunc::FixedBaseScalarMul => Some(2),
+
         // Recursive aggregation has a variable number of inputs
         BlackBoxFunc::RecursiveAggregation => None,
+
         // Addition over the embedded curve: input are coordinates (x1,y1) and (x2,y2) of the Grumpkin points
         BlackBoxFunc::EmbeddedCurveAdd => Some(4),
-        // Doubling over the embedded curve: input is (x,y) coordinate of the point.
-        BlackBoxFunc::EmbeddedCurveDouble => Some(2),
+
+        // Big integer operations take in 0 inputs. They use constants for their inputs.
+        BlackBoxFunc::BigIntAdd
+        | BlackBoxFunc::BigIntNeg
+        | BlackBoxFunc::BigIntMul
+        | BlackBoxFunc::BigIntDiv
+        | BlackBoxFunc::BigIntToLeBytes => Some(0),
+
+        // FromLeBytes takes a variable array of bytes as input
+        BlackBoxFunc::BigIntFromLeBytes => None,
     }
 }
 
@@ -612,28 +663,47 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
         // Bitwise opcodes will return 1 parameter which is the output
         // or the operation.
         BlackBoxFunc::AND | BlackBoxFunc::XOR => Some(1),
+
         // 32 byte hash algorithms
         BlackBoxFunc::Keccak256
         | BlackBoxFunc::SHA256
         | BlackBoxFunc::Blake2s
         | BlackBoxFunc::Blake3 => Some(32),
+
         BlackBoxFunc::Keccakf1600 => Some(25),
+        // The permutation returns a fixed number of outputs, equals to the inputs length which depends on the proving system implementation.
+        BlackBoxFunc::Poseidon2Permutation => None,
+
+        BlackBoxFunc::Sha256Compression => Some(8),
         // Pedersen commitment returns a point
         BlackBoxFunc::PedersenCommitment => Some(2),
+
         // Pedersen hash returns a field
         BlackBoxFunc::PedersenHash => Some(1),
+
         // Can only apply a range constraint to one
         // witness at a time.
         BlackBoxFunc::RANGE => Some(0),
+
         // Signature verification algorithms will return a boolean
         BlackBoxFunc::SchnorrVerify
         | BlackBoxFunc::EcdsaSecp256k1
         | BlackBoxFunc::EcdsaSecp256r1 => Some(1),
+
         // Output of operations over the embedded curve
         // will be 2 field elements representing the point.
-        BlackBoxFunc::FixedBaseScalarMul
-        | BlackBoxFunc::EmbeddedCurveAdd
-        | BlackBoxFunc::EmbeddedCurveDouble => Some(2),
+        BlackBoxFunc::FixedBaseScalarMul | BlackBoxFunc::EmbeddedCurveAdd => Some(2),
+
+        // Big integer operations return a big integer
+        BlackBoxFunc::BigIntAdd
+        | BlackBoxFunc::BigIntNeg
+        | BlackBoxFunc::BigIntMul
+        | BlackBoxFunc::BigIntDiv
+        | BlackBoxFunc::BigIntFromLeBytes => Some(0),
+
+        // ToLeBytes returns a variable array of bytes
+        BlackBoxFunc::BigIntToLeBytes => None,
+
         // Recursive aggregation has a variable number of outputs
         BlackBoxFunc::RecursiveAggregation => None,
     }
@@ -690,5 +760,5 @@ fn intrinsics_check_outputs(name: BlackBoxFunc, output_count: usize) {
         None => return,
     };
 
-    assert_eq!(expected_num_outputs,output_count,"Tried to call black box function {name} with {output_count} inputs, but this function's definition requires {expected_num_outputs} inputs");
+    assert_eq!(expected_num_outputs,output_count,"Tried to call black box function {name} with {output_count} outputs, but this function's definition requires {expected_num_outputs} outputs");
 }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index d832b8d0fbb..211506a6d15 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -7,6 +7,7 @@ use std::fmt::Debug;
 use self::acir_ir::acir_variable::{AcirContext, AcirType, AcirVar};
 use super::function_builder::data_bus::DataBus;
 use super::ir::dfg::CallStack;
+use super::ir::instruction::ConstrainError;
 use super::{
     ir::{
         dfg::DataFlowGraph,
@@ -413,15 +414,94 @@ impl Context {
                 let lhs = self.convert_numeric_value(*lhs, dfg)?;
                 let rhs = self.convert_numeric_value(*rhs, dfg)?;
 
-                self.acir_context.assert_eq_var(lhs, rhs, assert_message.clone())?;
+                let assert_message = if let Some(error) = assert_message {
+                    match error.as_ref() {
+                        ConstrainError::Static(string) => Some(string.clone()),
+                        ConstrainError::Dynamic(call_instruction) => {
+                            self.convert_ssa_call(call_instruction, dfg, ssa, brillig, &[])?;
+                            None
+                        }
+                    }
+                } else {
+                    None
+                };
+
+                self.acir_context.assert_eq_var(lhs, rhs, assert_message)?;
             }
             Instruction::Cast(value_id, _) => {
                 let acir_var = self.convert_numeric_value(*value_id, dfg)?;
                 self.define_result_var(dfg, instruction_id, acir_var);
             }
-            Instruction::Call { func, arguments } => {
+            Instruction::Call { .. } => {
                 let result_ids = dfg.instruction_results(instruction_id);
-                match &dfg[*func] {
+                warnings.extend(self.convert_ssa_call(
+                    instruction,
+                    dfg,
+                    ssa,
+                    brillig,
+                    result_ids,
+                )?);
+            }
+            Instruction::Not(value_id) => {
+                let (acir_var, typ) = match self.convert_value(*value_id, dfg) {
+                    AcirValue::Var(acir_var, typ) => (acir_var, typ),
+                    _ => unreachable!("NOT is only applied to numerics"),
+                };
+                let result_acir_var = self.acir_context.not_var(acir_var, typ)?;
+                self.define_result_var(dfg, instruction_id, result_acir_var);
+            }
+            Instruction::Truncate { value, bit_size, max_bit_size } => {
+                let result_acir_var =
+                    self.convert_ssa_truncate(*value, *bit_size, *max_bit_size, dfg)?;
+                self.define_result_var(dfg, instruction_id, result_acir_var);
+            }
+            Instruction::EnableSideEffects { condition } => {
+                let acir_var = self.convert_numeric_value(*condition, dfg)?;
+                self.current_side_effects_enabled_var = acir_var;
+            }
+            Instruction::ArrayGet { .. } | Instruction::ArraySet { .. } => {
+                self.handle_array_operation(instruction_id, dfg, last_array_uses)?;
+            }
+            Instruction::Allocate => {
+                unreachable!("Expected all allocate instructions to be removed before acir_gen")
+            }
+            Instruction::Store { .. } => {
+                unreachable!("Expected all store instructions to be removed before acir_gen")
+            }
+            Instruction::Load { .. } => {
+                unreachable!("Expected all load instructions to be removed before acir_gen")
+            }
+            Instruction::IncrementRc { .. } => {
+                // Do nothing. Only Brillig needs to worry about reference counted arrays
+            }
+            Instruction::RangeCheck { value, max_bit_size, assert_message } => {
+                let acir_var = self.convert_numeric_value(*value, dfg)?;
+                self.acir_context.range_constrain_var(
+                    acir_var,
+                    &NumericType::Unsigned { bit_size: *max_bit_size },
+                    assert_message.clone(),
+                )?;
+            }
+        }
+
+        self.acir_context.set_call_stack(CallStack::new());
+        Ok(warnings)
+    }
+
+    fn convert_ssa_call(
+        &mut self,
+        instruction: &Instruction,
+        dfg: &DataFlowGraph,
+        ssa: &Ssa,
+        brillig: &Brillig,
+        result_ids: &[ValueId],
+    ) -> Result<Vec<SsaReport>, RuntimeError> {
+        let mut warnings = Vec::new();
+
+        match instruction {
+            Instruction::Call { func, arguments } => {
+                let function_value = &dfg[*func];
+                match function_value {
                     Value::Function(id) => {
                         let func = &ssa.functions[id];
                         match func.runtime() {
@@ -495,51 +575,11 @@ impl Context {
                     Value::ForeignFunction(_) => unreachable!(
                         "All `oracle` methods should be wrapped in an unconstrained fn"
                     ),
-                    _ => unreachable!("expected calling a function"),
+                    _ => unreachable!("expected calling a function but got {function_value:?}"),
                 }
             }
-            Instruction::Not(value_id) => {
-                let (acir_var, typ) = match self.convert_value(*value_id, dfg) {
-                    AcirValue::Var(acir_var, typ) => (acir_var, typ),
-                    _ => unreachable!("NOT is only applied to numerics"),
-                };
-                let result_acir_var = self.acir_context.not_var(acir_var, typ)?;
-                self.define_result_var(dfg, instruction_id, result_acir_var);
-            }
-            Instruction::Truncate { value, bit_size, max_bit_size } => {
-                let result_acir_var =
-                    self.convert_ssa_truncate(*value, *bit_size, *max_bit_size, dfg)?;
-                self.define_result_var(dfg, instruction_id, result_acir_var);
-            }
-            Instruction::EnableSideEffects { condition } => {
-                let acir_var = self.convert_numeric_value(*condition, dfg)?;
-                self.current_side_effects_enabled_var = acir_var;
-            }
-            Instruction::ArrayGet { .. } | Instruction::ArraySet { .. } => {
-                self.handle_array_operation(instruction_id, dfg, last_array_uses)?;
-            }
-            Instruction::Allocate => {
-                unreachable!("Expected all allocate instructions to be removed before acir_gen")
-            }
-            Instruction::Store { .. } => {
-                unreachable!("Expected all store instructions to be removed before acir_gen")
-            }
-            Instruction::Load { .. } => {
-                unreachable!("Expected all load instructions to be removed before acir_gen")
-            }
-            Instruction::IncrementRc { .. } => {
-                // Do nothing. Only Brillig needs to worry about reference counted arrays
-            }
-            Instruction::RangeCheck { value, max_bit_size, assert_message } => {
-                let acir_var = self.convert_numeric_value(*value, dfg)?;
-                self.acir_context.range_constrain_var(
-                    acir_var,
-                    &NumericType::Unsigned { bit_size: *max_bit_size },
-                    assert_message.clone(),
-                )?;
-            }
+            _ => unreachable!("expected calling a call instruction"),
         }
-        self.acir_context.set_call_stack(CallStack::new());
         Ok(warnings)
     }
 
@@ -1541,7 +1581,7 @@ impl Context {
 
                 let vars = self.acir_context.black_box_function(black_box, inputs, output_count)?;
 
-                Ok(Self::convert_vars_to_values(vars, dfg, result_ids))
+                Ok(self.convert_vars_to_values(vars, dfg, result_ids))
             }
             Intrinsic::ApplyRangeConstraint => {
                 unreachable!("ICE: `Intrinsic::ApplyRangeConstraint` calls should be transformed into an `Instruction::RangeCheck`");
@@ -1583,12 +1623,9 @@ impl Context {
                     }
                 }
                 // Generate the sorted output variables
-                let out_vars = self
-                    .acir_context
-                    .sort(input_vars, bit_size, self.current_side_effects_enabled_var)
-                    .expect("Could not sort");
+                let out_vars = self.acir_context.sort(input_vars, bit_size)?;
 
-                Ok(Self::convert_vars_to_values(out_vars, dfg, result_ids))
+                Ok(self.convert_vars_to_values(out_vars, dfg, result_ids))
             }
             Intrinsic::ArrayLen => {
                 let len = match self.convert_value(arguments[0], dfg) {
@@ -2101,16 +2138,35 @@ impl Context {
     /// Convert a Vec<AcirVar> into a Vec<AcirValue> using the given result ids.
     /// If the type of a result id is an array, several acir vars are collected into
     /// a single AcirValue::Array of the same length.
+    /// If the type of a result id is a slice, the slice length must precede it and we can
+    /// convert to an AcirValue::Array when the length is known (constant).
     fn convert_vars_to_values(
+        &self,
         vars: Vec<AcirVar>,
         dfg: &DataFlowGraph,
         result_ids: &[ValueId],
     ) -> Vec<AcirValue> {
         let mut vars = vars.into_iter();
-        vecmap(result_ids, |result| {
+        let mut values: Vec<AcirValue> = Vec::new();
+        for result in result_ids {
             let result_type = dfg.type_of_value(*result);
-            Self::convert_var_type_to_values(&result_type, &mut vars)
-        })
+            if let Type::Slice(elements_type) = result_type {
+                let error = "ICE - cannot get slice length when converting slice to AcirValue";
+                let len = values.last().expect(error).borrow_var().expect(error);
+                let len = self.acir_context.constant(len).to_u128();
+                let mut element_values = im::Vector::new();
+                for _ in 0..len {
+                    for element_type in elements_type.iter() {
+                        let element = Self::convert_var_type_to_values(element_type, &mut vars);
+                        element_values.push_back(element);
+                    }
+                }
+                values.push(AcirValue::Array(element_values));
+            } else {
+                values.push(Self::convert_var_type_to_values(&result_type, &mut vars));
+            }
+        }
+        values
     }
 
     /// Recursive helper for convert_vars_to_values.
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 44be423be10..1cac0aa67ed 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -18,7 +18,7 @@ use super::{
         basic_block::BasicBlock,
         dfg::{CallStack, InsertInstructionResult},
         function::RuntimeType,
-        instruction::{Endian, InstructionId, Intrinsic},
+        instruction::{ConstrainError, Endian, InstructionId, Intrinsic},
         types::NumericType,
     },
     ssa_gen::Ssa,
@@ -250,7 +250,7 @@ impl FunctionBuilder {
         &mut self,
         lhs: ValueId,
         rhs: ValueId,
-        assert_message: Option<String>,
+        assert_message: Option<Box<ConstrainError>>,
     ) {
         self.insert_instruction(Instruction::Constrain(lhs, rhs, assert_message), None);
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index 331a02a6974..fa5bc0f6697 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -157,7 +157,7 @@ pub(crate) enum Instruction {
     Truncate { value: ValueId, bit_size: u32, max_bit_size: u32 },
 
     /// Constrains two values to be equal to one another.
-    Constrain(ValueId, ValueId, Option<String>),
+    Constrain(ValueId, ValueId, Option<Box<ConstrainError>>),
 
     /// Range constrain `value` to `max_bit_size`
     RangeCheck { value: ValueId, max_bit_size: u32, assert_message: Option<String> },
@@ -326,7 +326,17 @@ impl Instruction {
                 max_bit_size: *max_bit_size,
             },
             Instruction::Constrain(lhs, rhs, assert_message) => {
-                Instruction::Constrain(f(*lhs), f(*rhs), assert_message.clone())
+                // Must map the `lhs` and `rhs` first as the value `f` is moved with the closure
+                let lhs = f(*lhs);
+                let rhs = f(*rhs);
+                let assert_message = assert_message.as_ref().map(|error| match error.as_ref() {
+                    ConstrainError::Dynamic(call_instr) => {
+                        let new_instr = call_instr.map_values(f);
+                        Box::new(ConstrainError::Dynamic(new_instr))
+                    }
+                    _ => error.clone(),
+                });
+                Instruction::Constrain(lhs, rhs, assert_message)
             }
             Instruction::Call { func, arguments } => Instruction::Call {
                 func: f(*func),
@@ -376,9 +386,14 @@ impl Instruction {
             | Instruction::Load { address: value } => {
                 f(*value);
             }
-            Instruction::Constrain(lhs, rhs, _) => {
+            Instruction::Constrain(lhs, rhs, assert_error) => {
                 f(*lhs);
                 f(*rhs);
+                if let Some(error) = assert_error.as_ref() {
+                    if let ConstrainError::Dynamic(call_instr) = error.as_ref() {
+                        call_instr.for_each_value(f);
+                    }
+                }
             }
 
             Instruction::Store { address, value } => {
@@ -441,7 +456,7 @@ impl Instruction {
                 }
             }
             Instruction::Constrain(lhs, rhs, msg) => {
-                let constraints = decompose_constrain(*lhs, *rhs, msg.clone(), dfg);
+                let constraints = decompose_constrain(*lhs, *rhs, msg, dfg);
                 if constraints.is_empty() {
                     Remove
                 } else {
@@ -475,6 +490,9 @@ impl Instruction {
                 None
             }
             Instruction::Truncate { value, bit_size, max_bit_size } => {
+                if bit_size == max_bit_size {
+                    return SimplifiedTo(*value);
+                }
                 if let Some((numeric_constant, typ)) = dfg.get_numeric_constant_with_type(*value) {
                     let integer_modulus = 2_u128.pow(*bit_size);
                     let truncated = numeric_constant.to_u128() % integer_modulus;
@@ -551,6 +569,28 @@ impl Instruction {
     }
 }
 
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub(crate) enum ConstrainError {
+    // These are errors which have been hardcoded during SSA gen
+    Static(String),
+    // These are errors which come from runtime expressions specified by a Noir program
+    // We store an `Instruction` as we want this Instruction to be atomic in SSA with
+    // a constrain instruction, and leave codegen of this instruction to lower level passes.
+    Dynamic(Instruction),
+}
+
+impl From<String> for ConstrainError {
+    fn from(value: String) -> Self {
+        ConstrainError::Static(value)
+    }
+}
+
+impl From<String> for Box<ConstrainError> {
+    fn from(value: String) -> Self {
+        Box::new(value.into())
+    }
+}
+
 /// The possible return values for Instruction::return_types
 pub(crate) enum InstructionResultType {
     /// The result type of this instruction matches that of this operand
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index d1991abab37..0178ae9dba1 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -417,7 +417,7 @@ fn simplify_black_box_func(
                 _ => SimplifyResult::None,
             }
         }
-
+        BlackBoxFunc::Poseidon2Permutation => SimplifyResult::None, //TODO(Guillaume)
         BlackBoxFunc::EcdsaSecp256k1 => {
             simplify_signature(dfg, arguments, acvm::blackbox_solver::ecdsa_secp256k1_verify)
         }
@@ -429,13 +429,17 @@ fn simplify_black_box_func(
         | BlackBoxFunc::SchnorrVerify
         | BlackBoxFunc::PedersenCommitment
         | BlackBoxFunc::PedersenHash
-        | BlackBoxFunc::EmbeddedCurveAdd
-        | BlackBoxFunc::EmbeddedCurveDouble => {
+        | BlackBoxFunc::EmbeddedCurveAdd => {
             // Currently unsolvable here as we rely on an implementation in the backend.
             SimplifyResult::None
         }
-
-        BlackBoxFunc::RecursiveAggregation => SimplifyResult::None,
+        BlackBoxFunc::BigIntAdd
+        | BlackBoxFunc::BigIntNeg
+        | BlackBoxFunc::BigIntMul
+        | BlackBoxFunc::BigIntDiv
+        | BlackBoxFunc::RecursiveAggregation
+        | BlackBoxFunc::BigIntFromLeBytes
+        | BlackBoxFunc::BigIntToLeBytes => SimplifyResult::None,
 
         BlackBoxFunc::AND => {
             unreachable!("ICE: `BlackBoxFunc::AND` calls should be transformed into a `BinaryOp`")
@@ -448,6 +452,7 @@ fn simplify_black_box_func(
                 "ICE: `BlackBoxFunc::RANGE` calls should be transformed into a `Instruction::Cast`"
             )
         }
+        BlackBoxFunc::Sha256Compression => SimplifyResult::None, //TODO(Guillaume)
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
index 7fb0970c834..0ae0f8f2892 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
@@ -1,13 +1,13 @@
 use acvm::FieldElement;
 
-use super::{Binary, BinaryOp, DataFlowGraph, Instruction, Type, Value, ValueId};
+use super::{Binary, BinaryOp, ConstrainError, DataFlowGraph, Instruction, Type, Value, ValueId};
 
 /// Try to decompose this constrain instruction. This constraint will be broken down such that it instead constrains
 /// all the values which are used to compute the values which were being constrained.
 pub(super) fn decompose_constrain(
     lhs: ValueId,
     rhs: ValueId,
-    msg: Option<String>,
+    msg: &Option<Box<ConstrainError>>,
     dfg: &mut DataFlowGraph,
 ) -> Vec<Instruction> {
     let lhs = dfg.resolve(lhs);
@@ -39,7 +39,7 @@ pub(super) fn decompose_constrain(
                         // Note that this doesn't remove the value `v2` as it may be used in other instructions, but it
                         // will likely be removed through dead instruction elimination.
 
-                        vec![Instruction::Constrain(lhs, rhs, msg)]
+                        vec![Instruction::Constrain(lhs, rhs, msg.clone())]
                     }
 
                     Instruction::Binary(Binary { lhs, rhs, operator: BinaryOp::Mul })
@@ -64,7 +64,7 @@ pub(super) fn decompose_constrain(
                         let one = dfg.make_constant(one, Type::bool());
 
                         [
-                            decompose_constrain(lhs, one, msg.clone(), dfg),
+                            decompose_constrain(lhs, one, msg, dfg),
                             decompose_constrain(rhs, one, msg, dfg),
                         ]
                         .concat()
@@ -92,7 +92,7 @@ pub(super) fn decompose_constrain(
                         let zero = dfg.make_constant(zero, dfg.type_of_value(lhs));
 
                         [
-                            decompose_constrain(lhs, zero, msg.clone(), dfg),
+                            decompose_constrain(lhs, zero, msg, dfg),
                             decompose_constrain(rhs, zero, msg, dfg),
                         ]
                         .concat()
@@ -116,11 +116,11 @@ pub(super) fn decompose_constrain(
                         decompose_constrain(value, reversed_constant, msg, dfg)
                     }
 
-                    _ => vec![Instruction::Constrain(lhs, rhs, msg)],
+                    _ => vec![Instruction::Constrain(lhs, rhs, msg.clone())],
                 }
             }
 
-            _ => vec![Instruction::Constrain(lhs, rhs, msg)],
+            _ => vec![Instruction::Constrain(lhs, rhs, msg.clone())],
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index 2899b987c1d..9bd43fab1ff 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -9,7 +9,7 @@ use iter_extended::vecmap;
 use super::{
     basic_block::BasicBlockId,
     function::Function,
-    instruction::{Instruction, InstructionId, TerminatorInstruction},
+    instruction::{ConstrainError, Instruction, InstructionId, TerminatorInstruction},
     value::ValueId,
 };
 
@@ -133,9 +133,17 @@ pub(crate) fn display_instruction(
         write!(f, "{} = ", value_list(function, results))?;
     }
 
+    display_instruction_inner(function, &function.dfg[instruction], f)
+}
+
+fn display_instruction_inner(
+    function: &Function,
+    instruction: &Instruction,
+    f: &mut Formatter,
+) -> Result {
     let show = |id| value(function, id);
 
-    match &function.dfg[instruction] {
+    match instruction {
         Instruction::Binary(binary) => {
             writeln!(f, "{} {}, {}", binary.operator, show(binary.lhs), show(binary.rhs))
         }
@@ -145,10 +153,15 @@ pub(crate) fn display_instruction(
             let value = show(*value);
             writeln!(f, "truncate {value} to {bit_size} bits, max_bit_size: {max_bit_size}",)
         }
-        Instruction::Constrain(lhs, rhs, message) => match message {
-            Some(message) => writeln!(f, "constrain {} == {} '{message}'", show(*lhs), show(*rhs)),
-            None => writeln!(f, "constrain {} == {}", show(*lhs), show(*rhs)),
-        },
+        Instruction::Constrain(lhs, rhs, error) => {
+            write!(f, "constrain {} == {}", show(*lhs), show(*rhs))?;
+            if let Some(error) = error {
+                write!(f, " ")?;
+                display_constrain_error(function, error, f)
+            } else {
+                writeln!(f)
+            }
+        }
         Instruction::Call { func, arguments } => {
             writeln!(f, "call {}({})", show(*func), value_list(function, arguments))
         }
@@ -180,3 +193,18 @@ pub(crate) fn display_instruction(
         }
     }
 }
+
+fn display_constrain_error(
+    function: &Function,
+    error: &ConstrainError,
+    f: &mut Formatter,
+) -> Result {
+    match error {
+        ConstrainError::Static(assert_message_string) => {
+            writeln!(f, "{assert_message_string:?}")
+        }
+        ConstrainError::Dynamic(assert_message_call) => {
+            display_instruction_inner(function, assert_message_call, f)
+        }
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
index 8a903cbd87b..b737c51d145 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
@@ -109,11 +109,11 @@ mod test {
 
         let v1 = builder.insert_binary(v0, BinaryOp::Add, one);
         let v2 = builder.insert_binary(v1, BinaryOp::Add, one);
-        builder.insert_constrain(v0, one, Some("With message".to_string()));
+        builder.insert_constrain(v0, one, Some("With message".to_string().into()));
         builder.insert_constrain(v2, three, None);
         builder.insert_constrain(v0, one, None);
         builder.insert_constrain(v1, two, None);
-        builder.insert_constrain(v1, two, Some("With message".to_string()));
+        builder.insert_constrain(v1, two, Some("With message".to_string().into()));
         builder.terminate_with_return(vec![]);
 
         let ssa = builder.finish();
@@ -137,11 +137,11 @@ mod test {
         assert_eq!(block.instructions().len(), 7);
 
         let expected_instructions = vec![
-            Instruction::Constrain(v0, one, Some("With message".to_string())),
+            Instruction::Constrain(v0, one, Some("With message".to_string().into())),
             Instruction::Constrain(v0, one, None),
             Instruction::Binary(Binary { lhs: v0, rhs: one, operator: BinaryOp::Add }),
             Instruction::Constrain(v1, two, None),
-            Instruction::Constrain(v1, two, Some("With message".to_string())),
+            Instruction::Constrain(v1, two, Some("With message".to_string().into())),
             Instruction::Binary(Binary { lhs: v1, rhs: one, operator: BinaryOp::Add }),
             Instruction::Constrain(v2, three, None),
         ];
diff --git a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
index b7f154397a6..1f09a132132 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
@@ -14,7 +14,7 @@ use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         function::{Function, FunctionId, RuntimeType, Signature},
-        instruction::{BinaryOp, Instruction},
+        instruction::{BinaryOp, ConstrainError, Instruction},
         types::{NumericType, Type},
         value::{Value, ValueId},
     },
@@ -86,9 +86,22 @@ impl DefunctionalizationContext {
                 let instruction = func.dfg[instruction_id].clone();
                 let mut replacement_instruction = None;
                 // Operate on call instructions
-                let (target_func_id, mut arguments) = match instruction {
+                let (target_func_id, arguments) = match &instruction {
                     Instruction::Call { func: target_func_id, arguments } => {
-                        (target_func_id, arguments)
+                        (*target_func_id, arguments)
+                    }
+                    // Constrain instruction potentially hold a call instruction themselves
+                    // thus we need to account for them.
+                    Instruction::Constrain(_, _, Some(constrain_error)) => {
+                        if let ConstrainError::Dynamic(Instruction::Call {
+                            func: target_func_id,
+                            arguments,
+                        }) = constrain_error.as_ref()
+                        {
+                            (*target_func_id, arguments)
+                        } else {
+                            continue;
+                        }
                     }
                     _ => continue,
                 };
@@ -96,6 +109,7 @@ impl DefunctionalizationContext {
                 match func.dfg[target_func_id] {
                     // If the target is a function used as value
                     Value::Param { .. } | Value::Instruction { .. } => {
+                        let mut arguments = arguments.clone();
                         let results = func.dfg.instruction_results(instruction_id);
                         let signature = Signature {
                             params: vecmap(&arguments, |param| func.dfg.type_of_value(*param)),
@@ -120,7 +134,20 @@ impl DefunctionalizationContext {
                     }
                     _ => {}
                 }
-                if let Some(new_instruction) = replacement_instruction {
+                if let Some(mut new_instruction) = replacement_instruction {
+                    if let Instruction::Constrain(lhs, rhs, constrain_error_call) = instruction {
+                        let new_error_call = if let Some(error) = constrain_error_call {
+                            match error.as_ref() {
+                                ConstrainError::Dynamic(_) => {
+                                    Some(Box::new(ConstrainError::Dynamic(new_instruction)))
+                                }
+                                _ => None,
+                            }
+                        } else {
+                            None
+                        };
+                        new_instruction = Instruction::Constrain(lhs, rhs, new_error_call);
+                    }
                     func.dfg[instruction_id] = new_instruction;
                 }
             }
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index 0e155776545..adf68bacba4 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -435,7 +435,7 @@ impl<'a> FunctionContext<'a> {
             self.builder.set_location(location).insert_constrain(
                 sign,
                 one,
-                Some("attempt to bit-shift with overflow".to_string()),
+                Some("attempt to bit-shift with overflow".to_owned().into()),
             );
         }
 
@@ -446,7 +446,7 @@ impl<'a> FunctionContext<'a> {
         self.builder.set_location(location).insert_constrain(
             overflow,
             one,
-            Some("attempt to bit-shift with overflow".to_owned()),
+            Some("attempt to bit-shift with overflow".to_owned().into()),
         );
         self.builder.insert_truncate(result, bit_size, bit_size + 1)
     }
@@ -498,8 +498,11 @@ impl<'a> FunctionContext<'a> {
                 let sign_diff = self.builder.insert_binary(result_sign, BinaryOp::Eq, lhs_sign);
                 let sign_diff_with_predicate =
                     self.builder.insert_binary(sign_diff, BinaryOp::Mul, same_sign);
-                let overflow_check =
-                    Instruction::Constrain(sign_diff_with_predicate, same_sign, Some(message));
+                let overflow_check = Instruction::Constrain(
+                    sign_diff_with_predicate,
+                    same_sign,
+                    Some(message.into()),
+                );
                 self.builder.set_location(location).insert_instruction(overflow_check, None);
             }
             BinaryOpKind::Multiply => {
@@ -509,11 +512,10 @@ impl<'a> FunctionContext<'a> {
                 let rhs_abs = self.absolute_value_helper(rhs, rhs_sign, bit_size);
                 let product_field = self.builder.insert_binary(lhs_abs, BinaryOp::Mul, rhs_abs);
                 // It must not already overflow the bit_size
-                let message = "attempt to multiply with overflow".to_string();
                 self.builder.set_location(location).insert_range_check(
                     product_field,
                     bit_size,
-                    Some(message.clone()),
+                    Some("attempt to multiply with overflow".to_string()),
                 );
                 let product = self.builder.insert_cast(product_field, Type::unsigned(bit_size));
 
@@ -530,7 +532,7 @@ impl<'a> FunctionContext<'a> {
                 self.builder.set_location(location).insert_constrain(
                     product_overflow_check,
                     one,
-                    Some(message),
+                    Some(message.into()),
                 );
             }
             _ => unreachable!("operator {} should not overflow", operator),
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 9d9635fed34..0efc73fb85b 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -13,7 +13,7 @@ use noirc_frontend::{
 };
 
 use crate::{
-    errors::RuntimeError,
+    errors::{InternalError, RuntimeError},
     ssa::{
         function_builder::data_bus::DataBusBuilder,
         ir::{instruction::Intrinsic, types::NumericType},
@@ -29,7 +29,7 @@ use super::{
     function_builder::data_bus::DataBus,
     ir::{
         function::RuntimeType,
-        instruction::{BinaryOp, TerminatorInstruction},
+        instruction::{BinaryOp, ConstrainError, Instruction, TerminatorInstruction},
         types::Type,
         value::ValueId,
     },
@@ -141,7 +141,7 @@ impl<'a> FunctionContext<'a> {
             Expression::Call(call) => self.codegen_call(call),
             Expression::Let(let_expr) => self.codegen_let(let_expr),
             Expression::Constrain(expr, location, assert_message) => {
-                self.codegen_constrain(expr, *location, assert_message.clone())
+                self.codegen_constrain(expr, *location, assert_message)
             }
             Expression::Assign(assign) => self.codegen_assign(assign),
             Expression::Semi(semi) => self.codegen_semi(semi),
@@ -438,10 +438,11 @@ impl<'a> FunctionContext<'a> {
 
         let is_offset_out_of_bounds = self.builder.insert_binary(index, BinaryOp::Lt, array_len);
         let true_const = self.builder.numeric_constant(true, Type::bool());
+
         self.builder.insert_constrain(
             is_offset_out_of_bounds,
             true_const,
-            Some("Index out of bounds".to_owned()),
+            Some(Box::new("Index out of bounds".to_owned().into())),
         );
     }
 
@@ -665,15 +666,59 @@ impl<'a> FunctionContext<'a> {
         &mut self,
         expr: &Expression,
         location: Location,
-        assert_message: Option<String>,
+        assert_message: &Option<Box<Expression>>,
     ) -> Result<Values, RuntimeError> {
         let expr = self.codegen_non_tuple_expression(expr)?;
         let true_literal = self.builder.numeric_constant(true, Type::bool());
-        self.builder.set_location(location).insert_constrain(expr, true_literal, assert_message);
+
+        // Set the location here for any errors that may occur when we codegen the assert message
+        self.builder.set_location(location);
+
+        let assert_message = self.codegen_constrain_error(assert_message)?;
+
+        self.builder.insert_constrain(expr, true_literal, assert_message);
 
         Ok(Self::unit_value())
     }
 
+    // This method does not necessary codegen the full assert message expression, thus it does not
+    // return a `Values` object. Instead we check the internals of the expression to make sure
+    // we have an `Expression::Call` as expected. An `Instruction::Call` is then constructed but not
+    // inserted to the SSA as we want that instruction to be atomic in SSA with a constrain instruction.
+    fn codegen_constrain_error(
+        &mut self,
+        assert_message: &Option<Box<Expression>>,
+    ) -> Result<Option<Box<ConstrainError>>, RuntimeError> {
+        let Some(assert_message_expr) = assert_message else {
+            return Ok(None)
+        };
+
+        let ast::Expression::Call(call) = assert_message_expr.as_ref() else {
+            return Err(InternalError::Unexpected {
+                expected: "Expected a call expression".to_owned(),
+                found: "Instead found {expr:?}".to_owned(),
+                call_stack: self.builder.get_call_stack(),
+            }
+            .into());
+        };
+
+        let func = self.codegen_non_tuple_expression(&call.func)?;
+        let mut arguments = Vec::with_capacity(call.arguments.len());
+
+        for argument in &call.arguments {
+            let mut values = self.codegen_expression(argument)?.into_value_list(self);
+            arguments.append(&mut values);
+        }
+
+        // If an array is passed as an argument we increase its reference count
+        for argument in &arguments {
+            self.builder.increment_array_reference_count(*argument);
+        }
+
+        let instr = Instruction::Call { func, arguments };
+        Ok(Some(Box::new(ConstrainError::Dynamic(instr))))
+    }
+
     fn codegen_assign(&mut self, assign: &ast::Assign) -> Result<Values, RuntimeError> {
         let lhs = self.extract_current_value(&assign.lvalue)?;
         let rhs = self.codegen_expression(&assign.expression)?;
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 73b1f68778d..a2c29a8c52e 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -416,7 +416,7 @@ pub enum LValue {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct ConstrainStatement(pub Expression, pub Option<String>, pub ConstrainKind);
+pub struct ConstrainStatement(pub Expression, pub Option<Expression>, pub ConstrainKind);
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ConstrainKind {
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index a6ab6b1d825..f7441750fc8 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -14,7 +14,7 @@ use crate::hir::resolution::{
 use crate::hir::type_check::{type_check_func, TypeCheckError, TypeChecker};
 use crate::hir::Context;
 
-use crate::macros_api::MacroProcessor;
+use crate::macros_api::{MacroError, MacroProcessor};
 use crate::node_interner::{FuncId, NodeInterner, StmtId, StructId, TraitId, TypeAliasId};
 
 use crate::parser::{ParserError, SortedModule};
@@ -155,6 +155,12 @@ impl From<CompilationError> for CustomDiagnostic {
     }
 }
 
+impl From<MacroError> for CompilationError {
+    fn from(value: MacroError) -> Self {
+        CompilationError::DefinitionError(DefCollectorErrorKind::MacroError(value))
+    }
+}
+
 impl From<ParserError> for CompilationError {
     fn from(value: ParserError) -> Self {
         CompilationError::ParseError(value)
@@ -359,7 +365,11 @@ impl DefCollector {
         errors.extend(resolved_globals.errors);
 
         for macro_processor in macro_processors {
-            macro_processor.process_typed_ast(&crate_id, context);
+            macro_processor.process_typed_ast(&crate_id, context).unwrap_or_else(
+                |(macro_err, file_id)| {
+                    errors.push((macro_err.into(), file_id));
+                },
+            );
         }
         errors.extend(type_check_globals(&mut context.def_interner, resolved_globals.globals));
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index 390807afd17..7bd4de77e84 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -84,6 +84,8 @@ pub enum ResolverError {
     InvalidTypeForEntryPoint { span: Span },
     #[error("Nested slices are not supported")]
     NestedSlices { span: Span },
+    #[error("Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library")]
+    LowLevelFunctionOutsideOfStdlib { ident: Ident },
 }
 
 impl ResolverError {
@@ -311,6 +313,11 @@ impl From<ResolverError> for Diagnostic {
                 "Try to use a constant sized array instead".into(),
                 span,
             ),
+            ResolverError::LowLevelFunctionOutsideOfStdlib { ident } => Diagnostic::simple_error(
+                "Definition of low-level function outside of standard library".into(),
+                "Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library".into(),
+                ident.span(),
+            ),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index df533f6a4ae..7b876244601 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -191,10 +191,18 @@ impl<'a> Resolver<'a> {
         self.add_generics(&func.def.generics);
         self.trait_bounds = func.def.where_clause.clone();
 
+        let is_low_level_or_oracle = func
+            .attributes()
+            .function
+            .as_ref()
+            .map_or(false, |func| func.is_low_level() || func.is_oracle());
         let (hir_func, func_meta) = self.intern_function(func, func_id);
         let func_scope_tree = self.scopes.end_function();
 
-        self.check_for_unused_variables_in_scope_tree(func_scope_tree);
+        // The arguments to low-level and oracle functions are always unused so we do not produce warnings for them.
+        if !is_low_level_or_oracle {
+            self.check_for_unused_variables_in_scope_tree(func_scope_tree);
+        }
 
         self.trait_bounds.clear();
         (hir_func, func_meta, self.errors)
@@ -900,6 +908,13 @@ impl<'a> Resolver<'a> {
                 position: PubPosition::ReturnType,
             });
         }
+        let is_low_level_function =
+            func.attributes().function.as_ref().map_or(false, |func| func.is_low_level());
+        if !self.path_resolver.module_id().krate.is_stdlib() && is_low_level_function {
+            let error =
+                ResolverError::LowLevelFunctionOutsideOfStdlib { ident: func.name_ident().clone() };
+            self.push_err(error);
+        }
 
         // 'pub' is required on return types for entry point functions
         if self.is_entry_point_function(func)
@@ -1118,9 +1133,16 @@ impl<'a> Resolver<'a> {
                 })
             }
             StatementKind::Constrain(constrain_stmt) => {
+                let span = constrain_stmt.0.span;
+                let assert_msg_call_expr_id =
+                    self.resolve_assert_message(constrain_stmt.1, span, constrain_stmt.0.clone());
                 let expr_id = self.resolve_expression(constrain_stmt.0);
-                let assert_message = constrain_stmt.1;
-                HirStatement::Constrain(HirConstrainStatement(expr_id, self.file, assert_message))
+
+                HirStatement::Constrain(HirConstrainStatement(
+                    expr_id,
+                    self.file,
+                    assert_msg_call_expr_id,
+                ))
             }
             StatementKind::Expression(expr) => {
                 HirStatement::Expression(self.resolve_expression(expr))
@@ -1169,6 +1191,41 @@ impl<'a> Resolver<'a> {
         }
     }
 
+    fn resolve_assert_message(
+        &mut self,
+        assert_message_expr: Option<Expression>,
+        span: Span,
+        condition: Expression,
+    ) -> Option<ExprId> {
+        let mut assert_msg_call_args = if let Some(assert_message_expr) = assert_message_expr {
+            vec![assert_message_expr.clone()]
+        } else {
+            return None;
+        };
+        assert_msg_call_args.push(condition);
+
+        let is_in_stdlib = self.path_resolver.module_id().krate.is_stdlib();
+        let assert_msg_call_path = if is_in_stdlib {
+            ExpressionKind::Variable(Path {
+                segments: vec![Ident::from("resolve_assert_message")],
+                kind: PathKind::Crate,
+                span,
+            })
+        } else {
+            ExpressionKind::Variable(Path {
+                segments: vec![Ident::from("std"), Ident::from("resolve_assert_message")],
+                kind: PathKind::Dep,
+                span,
+            })
+        };
+        let assert_msg_call_expr = Expression::call(
+            Expression { kind: assert_msg_call_path, span },
+            assert_msg_call_args,
+            span,
+        );
+        Some(self.resolve_expression(assert_msg_call_expr))
+    }
+
     pub fn intern_stmt(&mut self, stmt: StatementKind) -> StmtId {
         let hir_stmt = self.resolve_stmt(stmt);
         self.interner.push_stmt(hir_stmt)
diff --git a/compiler/noirc_frontend/src/hir/type_check/stmt.rs b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
index fd8ae62d34e..a38a16a6580 100644
--- a/compiler/noirc_frontend/src/hir/type_check/stmt.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/stmt.rs
@@ -303,6 +303,9 @@ impl<'interner> TypeChecker<'interner> {
         let expr_type = self.check_expression(&stmt.0);
         let expr_span = self.interner.expr_span(&stmt.0);
 
+        // Must type check the assertion message expression so that we instantiate bindings
+        stmt.2.map(|assert_msg_expr| self.check_expression(&assert_msg_expr));
+
         self.unify(&expr_type, &Type::Bool, || TypeCheckError::TypeMismatch {
             expr_typ: expr_type.to_string(),
             expected_typ: Type::Bool.to_string(),
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 34c9302c251..4d946690151 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -55,7 +55,7 @@ pub struct HirAssignStatement {
 /// originates from. This is used later in the SSA pass to issue
 /// an error if a constrain is found to be always false.
 #[derive(Debug, Clone)]
-pub struct HirConstrainStatement(pub ExprId, pub FileId, pub Option<String>);
+pub struct HirConstrainStatement(pub ExprId, pub FileId, pub Option<ExprId>);
 
 #[derive(Debug, Clone, Hash)]
 pub enum HirPattern {
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index ab131ccd880..835a0baae3f 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -562,6 +562,10 @@ impl FunctionAttribute {
         matches!(self, FunctionAttribute::Foreign(_))
     }
 
+    pub fn is_oracle(&self) -> bool {
+        matches!(self, FunctionAttribute::Oracle(_))
+    }
+
     pub fn is_low_level(&self) -> bool {
         matches!(self, FunctionAttribute::Foreign(_) | FunctionAttribute::Builtin(_))
     }
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 9582b80dcba..b14cb632f81 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -48,7 +48,7 @@ pub mod macros_api {
     pub use crate::hir_def::expr::{HirExpression, HirLiteral};
     pub use crate::hir_def::stmt::HirStatement;
     pub use crate::node_interner::{NodeInterner, StructId};
-    pub use crate::parser::SortedModule;
+    pub use crate::parser::{parse_program, SortedModule};
     pub use crate::token::SecondaryAttribute;
 
     pub use crate::hir::def_map::ModuleDefId;
@@ -75,6 +75,10 @@ pub mod macros_api {
         ) -> Result<SortedModule, (MacroError, FileId)>;
         /// Function to manipulate the AST after type checking has been completed.
         /// The AST after type checking has been done is called the HIR.
-        fn process_typed_ast(&self, crate_id: &CrateId, context: &mut HirContext);
+        fn process_typed_ast(
+            &self,
+            crate_id: &CrateId,
+            context: &mut HirContext,
+        ) -> Result<(), (MacroError, FileId)>;
     }
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 42a618e7d77..5172eabde46 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -31,7 +31,7 @@ pub enum Expression {
     ExtractTupleField(Box<Expression>, usize),
     Call(Call),
     Let(Let),
-    Constrain(Box<Expression>, Location, Option<String>),
+    Constrain(Box<Expression>, Location, Option<Box<Expression>>),
     Assign(Assign),
     Semi(Box<Expression>),
 }
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 67b246a02ce..7e06b94ca5a 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -479,7 +479,9 @@ impl<'interner> Monomorphizer<'interner> {
             HirStatement::Constrain(constrain) => {
                 let expr = self.expr(constrain.0);
                 let location = self.interner.expr_location(&constrain.0);
-                ast::Expression::Constrain(Box::new(expr), location, constrain.2)
+                let assert_message =
+                    constrain.2.map(|assert_msg_expr| Box::new(self.expr(assert_msg_expr)));
+                ast::Expression::Constrain(Box::new(expr), location, assert_message)
             }
             HirStatement::Assign(assign) => self.assign(assign),
             HirStatement::For(for_loop) => {
@@ -929,6 +931,9 @@ impl<'interner> Monomorphizer<'interner> {
                     // The first argument to the `print` oracle is a bool, indicating a newline to be inserted at the end of the input
                     // The second argument is expected to always be an ident
                     self.append_printable_type_info(&hir_arguments[1], &mut arguments);
+                } else if name.as_str() == "assert_message" {
+                    // The first argument to the `assert_message` oracle is the expression passed as a mesage to an `assert` or `assert_eq` statement
+                    self.append_printable_type_info(&hir_arguments[0], &mut arguments);
                 }
             }
         }
@@ -1024,7 +1029,7 @@ impl<'interner> Monomorphizer<'interner> {
                 // The caller needs information as to whether it is handling a format string or a single type
                 arguments.push(ast::Expression::Literal(ast::Literal::Bool(is_fmt_str)));
             }
-            _ => unreachable!("logging expr {:?} is not supported", arguments[0]),
+            _ => unreachable!("logging expr {:?} is not supported", hir_argument),
         }
     }
 
@@ -1033,10 +1038,10 @@ impl<'interner> Monomorphizer<'interner> {
         // since they cannot be passed from ACIR into Brillig
         if let HirType::Array(size, _) = typ {
             if let HirType::NotConstant = **size {
-                unreachable!("println does not support slices. Convert the slice to an array before passing it to println");
+                unreachable!("println and format strings do not support slices. Convert the slice to an array before passing it to println");
             }
         } else if matches!(typ, HirType::MutableReference(_)) {
-            unreachable!("println does not support mutable references.");
+            unreachable!("println and format strings do not support mutable references.");
         }
 
         let printable_type: PrintableType = typ.into();
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index f82ce95c718..1bdb276d4fb 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -832,23 +832,10 @@ where
 
     ignore_then_commit(keyword(Keyword::Assert), parenthesized(argument_parser))
         .labelled(ParsingRuleLabel::Statement)
-        .validate(|expressions, span, emit| {
+        .validate(|expressions, span, _| {
             let condition = expressions.get(0).unwrap_or(&Expression::error(span)).clone();
-            let mut message_str = None;
-
-            if let Some(message) = expressions.get(1) {
-                if let ExpressionKind::Literal(Literal::Str(message)) = &message.kind {
-                    message_str = Some(message.clone());
-                } else {
-                    emit(ParserError::with_reason(ParserErrorReason::AssertMessageNotString, span));
-                }
-            }
-
-            StatementKind::Constrain(ConstrainStatement(
-                condition,
-                message_str,
-                ConstrainKind::Assert,
-            ))
+            let message = expressions.get(1).cloned();
+            StatementKind::Constrain(ConstrainStatement(condition, message, ConstrainKind::Assert))
         })
 }
 
@@ -861,7 +848,7 @@ where
 
     ignore_then_commit(keyword(Keyword::AssertEq), parenthesized(argument_parser))
         .labelled(ParsingRuleLabel::Statement)
-        .validate(|exprs: Vec<Expression>, span, emit| {
+        .validate(|exprs: Vec<Expression>, span, _| {
             let predicate = Expression::new(
                 ExpressionKind::Infix(Box::new(InfixExpression {
                     lhs: exprs.get(0).unwrap_or(&Expression::error(span)).clone(),
@@ -870,18 +857,10 @@ where
                 })),
                 span,
             );
-            let mut message_str = None;
-
-            if let Some(message) = exprs.get(2) {
-                if let ExpressionKind::Literal(Literal::Str(message)) = &message.kind {
-                    message_str = Some(message.clone());
-                } else {
-                    emit(ParserError::with_reason(ParserErrorReason::AssertMessageNotString, span));
-                }
-            }
+            let message = exprs.get(2).cloned();
             StatementKind::Constrain(ConstrainStatement(
                 predicate,
-                message_str,
+                message,
                 ConstrainKind::AssertEq,
             ))
         })
@@ -2092,7 +2071,13 @@ mod test {
         match parse_with(assertion(expression()), "assert(x == y, \"assertion message\")").unwrap()
         {
             StatementKind::Constrain(ConstrainStatement(_, message, _)) => {
-                assert_eq!(message, Some("assertion message".to_owned()));
+                let message = message.unwrap();
+                match message.kind {
+                    ExpressionKind::Literal(Literal::Str(message_string)) => {
+                        assert_eq!(message_string, "assertion message".to_owned());
+                    }
+                    _ => unreachable!(),
+                }
             }
             _ => unreachable!(),
         }
@@ -2116,7 +2101,13 @@ mod test {
             .unwrap()
         {
             StatementKind::Constrain(ConstrainStatement(_, message, _)) => {
-                assert_eq!(message, Some("assertion message".to_owned()));
+                let message = message.unwrap();
+                match message.kind {
+                    ExpressionKind::Literal(Literal::Str(message_string)) => {
+                        assert_eq!(message_string, "assertion message".to_owned());
+                    }
+                    _ => unreachable!(),
+                }
             }
             _ => unreachable!(),
         }
@@ -2483,7 +2474,7 @@ mod test {
             Case {
                 source: "assert(x == x, x)",
                 expect: "constrain (plain::x == plain::x)",
-                errors: 1,
+                errors: 0,
             },
             Case { source: "assert_eq(x,)", expect: "constrain (Error == Error)", errors: 1 },
             Case {
@@ -2494,7 +2485,7 @@ mod test {
             Case {
                 source: "assert_eq(x, x, x)",
                 expect: "constrain (plain::x == plain::x)",
-                errors: 1,
+                errors: 0,
             },
         ];
 
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 9ccbddab9ec..a4246a9fe7d 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -52,10 +52,12 @@ mod test {
     ) -> (ParsedModule, Context, Vec<(CompilationError, FileId)>) {
         let root = std::path::Path::new("/");
         let fm = FileManager::new(root);
+
         let mut context = Context::new(fm, Default::default());
         context.def_interner.populate_dummy_operator_traits();
         let root_file_id = FileId::dummy();
         let root_crate_id = context.crate_graph.add_crate_root(root_file_id);
+
         let (program, parser_errors) = parse_program(src);
         let mut errors = vecmap(parser_errors, |e| (e.into(), root_file_id));
         remove_experimental_warnings(&mut errors);
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index 18f2fe0a873..eb206f0af3d 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -69,6 +69,9 @@ pub enum ForeignCallError {
 
     #[error("Failed calling external resolver. {0}")]
     ExternalResolverError(#[from] jsonrpc::Error),
+
+    #[error("Assert message resolved after an unsatisified constrain. {0}")]
+    ResolvedAssertMessage(String),
 }
 
 impl TryFrom<&[ForeignCallParam]> for PrintableValueDisplay {
diff --git a/docs/docs/explainers/explainer-recursion.md b/docs/docs/explainers/explainer-recursion.md
index 8f992ec29fd..18846176ca7 100644
--- a/docs/docs/explainers/explainer-recursion.md
+++ b/docs/docs/explainers/explainer-recursion.md
@@ -16,12 +16,13 @@ keywords:
     "Optimizing Computational Resources",
     "Improving Efficiency",
     "Verification Key",
-    "Aggregation Objects",
+    "Aggregation",
     "Recursive zkSNARK schemes",
     "PLONK",
     "Proving and Verification Keys"
   ]
 sidebar_position: 1
+pagination_next: how_to/how-to-recursion
 ---
 
 In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
@@ -64,7 +65,7 @@ So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob w
 
 This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
 
-As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?". 
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
 
 She can then generate a proof that she verified his proof, and so on.
 
@@ -116,25 +117,19 @@ As you can see in the [recursion reference](noir/standard_library/recursion.md),
 - The Verification Key of the circuit that generated the proof
 - A hash of this verification key, as it's needed for some backends
 - The public inputs for the proof
-- The input aggregation object
 
-It also returns the `output aggregation object`. These aggregation objects can be confusing at times, so let's dive in a little bit.
-
-### Aggregation objects
+:::info
 
 Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
 
-In the case of PLONK the recursive aggregation object is two G1 points (expressed as 16 witness values). The final verifier (in our case this is most often the smart contract verifier) has to be aware of this aggregation object to execute a pairing and check the validity of these points.
-
 So, taking the example of Alice and Bob and their guessing game:
 
 - Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
-- Bob verifies Alice's proof and makes his own guess. In this circuit, he is verifying a proof, so it needs to output an `aggregation object`: he is generating a recursive proof!
-- Alice verifies Bob's *recursive proof*, and uses Bob's `output aggregation object` as the `input aggregation object` in her proof... Which in turn, generates another `output aggregation object`.
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
 
-One should notice that when Bob generates his first proof, he has no input aggregation object. Because he is not verifying an recursive proof, he has no `input aggregation object`. In this case, he may use zeros instead.
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
 
-We can imagine the `aggregation object` as the baton in a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+:::
 
 ## Some architecture
 
@@ -175,3 +170,7 @@ In this example, a regulator could verify that taxes were paid for a specific pu
 At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
 
 Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/docs/how_to/how-to-recursion.md b/docs/docs/how_to/how-to-recursion.md
index 39db23f1f3a..4c45bb87ae2 100644
--- a/docs/docs/how_to/how-to-recursion.md
+++ b/docs/docs/how_to/how-to-recursion.md
@@ -42,9 +42,9 @@ In short:
 
 :::
 
-In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume these two:
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
 
-- `main`: a circuit of type `assert(x != y)`
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
 - `recursive`: a circuit that verifies `main`
 
 For a full example on how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
@@ -77,7 +77,7 @@ const { witness } = noir.execute(input)
 With this witness, you are now able to generate the intermediate proof for the main circuit:
 
 ```js
-const { proof, publicInputs } = await backend.generateIntermediateProof(witness)
+const { proof, publicInputs } = await backend.generateProof(witness)
 ```
 
 :::warning
@@ -95,24 +95,20 @@ With this in mind, it becomes clear that our intermediate proof is the one *mean
 Optionally, you are able to verify the intermediate proof:
 
 ```js
-const verified = await backend.verifyIntermediateProof({ proof, publicInputs })
+const verified = await backend.verifyProof({ proof, publicInputs })
 ```
 
-This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate the intermediate artifacts:
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
 
 ```js
-const { proofAsFields, vkAsFields, vkHash } = await backend.generateIntermediateProofArtifacts( { publicInputs, proof }, publicInputsCount)
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
 ```
 
 This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
 
 :::info
 
-The `proofAsFields` has a constant size `[Field; 93]`. However, currently the backend doesn't remove the public inputs from the proof when converting it.
-
-This means that if your `main` circuit has two public inputs, then you should also modify the recursive circuit to accept a proof with the public inputs appended. This means that in our example, since `y` is a public input, our `proofAsFields` is of type `[Field; 94]`.
-
-Verification keys in Barretenberg are always of size 114.
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
 
 :::
 
@@ -136,15 +132,14 @@ const recursiveInputs = {
     proof: proofAsFields, // array of length 93 + size of public inputs
     publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
     key_hash: vkHash,
-    input_aggregation_object: Array(16).fill(0) // this circuit is verifying a non-recursive proof, so there's no input aggregation object: just use zero
 }
 
 const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
-const { proof, publicInputs } = backend.generateFinalProof(witness)
-const verified = backend.verifyFinalProof({ proof, publicInputs })
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
 ```
 
-You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way! In that case, you should keep in mind the `returnValue`, as it will contain the `input_aggregation_object` for the next proof.
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
 
 :::tip
 
@@ -152,16 +147,16 @@ Managing circuits and "who does what" can be confusing. To make sure your naming
 
 ```js
 const circuits = {
-main: mainJSON, 
-recursive: recursiveJSON
+  main: mainJSON, 
+  recursive: recursiveJSON
 }
 const backends = {
-main: new BarretenbergBackend(circuits.main),
-recursive: new BarretenbergBackend(circuits.recursive)
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
 }
 const noir_programs = {
-main: new Noir(circuits.main, backends.main),
-recursive: new Noir(circuits.recursive, backends.recursive)
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
 }
 ```
 
@@ -170,15 +165,15 @@ This allows you to neatly call exactly the method you want without conflicting n
 ```js
 // Alice runs this 👇
 const { witness: mainWitness } = await noir_programs.main.execute(input)
-const proof = await backends.main.generateIntermediateProof(mainWitness)
+const proof = await backends.main.generateProof(mainWitness)
 
 // Bob runs this 👇
-const verified = await backends.main.verifyIntermediateProof(proof)
-const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateIntermediateProofArtifacts(
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
     proof,
     numPublicInputs,
 );
-const recursiveProof = await noir_programs.recursive.generateFinalProof(recursiveInputs)
+const recursiveProof = await noir_programs.recursive.generateProof(recursiveInputs)
 ```
 
 :::
diff --git a/docs/docs/noir/concepts/assert.md b/docs/docs/noir/concepts/assert.md
index c5f9aff139c..bcff613a695 100644
--- a/docs/docs/noir/concepts/assert.md
+++ b/docs/docs/noir/concepts/assert.md
@@ -18,10 +18,28 @@ fn main(x : Field, y : Field) {
 }
 ```
 
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
 You can optionally provide a message to be logged when the assertion fails:
 
 ```rust
 assert(x == y, "x and y are not equal");
 ```
 
-> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
diff --git a/docs/docs/noir/concepts/data_types/fields.md b/docs/docs/noir/concepts/data_types/fields.md
index a1c67945d66..7870c98c858 100644
--- a/docs/docs/noir/concepts/data_types/fields.md
+++ b/docs/docs/noir/concepts/data_types/fields.md
@@ -157,6 +157,23 @@ fn main() {
 }
 ```
 
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust
+fn assert_max_bit_size(self, bit_size: u32)
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
 ### sgn0
 
 Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ \{0, ..., p-1\} is even, otherwise sgn0(x mod p) = 1.
diff --git a/docs/docs/noir/concepts/unconstrained.md b/docs/docs/noir/concepts/unconstrained.md
index 6b3424f7993..89d12c1c971 100644
--- a/docs/docs/noir/concepts/unconstrained.md
+++ b/docs/docs/noir/concepts/unconstrained.md
@@ -40,7 +40,7 @@ Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
 Backend circuit size: 3619
 ```
 
-A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the XOR against 0xff. This saves us ~480 gates in total.
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
 
 ```rust
 fn main(num: u72) -> pub [u8; 8] {
diff --git a/docs/docs/noir/standard_library/options.md b/docs/docs/noir/standard_library/options.md
index 970c9cfbf11..a1bd4e1de5f 100644
--- a/docs/docs/noir/standard_library/options.md
+++ b/docs/docs/noir/standard_library/options.md
@@ -56,6 +56,10 @@ Returns the wrapped value if `self.is_some()`. Otherwise, returns the given defa
 
 Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
 
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
 ### map
 
 If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
diff --git a/docs/docs/noir/standard_library/recursion.md b/docs/docs/noir/standard_library/recursion.md
index 67962082a8f..f252150c8b5 100644
--- a/docs/docs/noir/standard_library/recursion.md
+++ b/docs/docs/noir/standard_library/recursion.md
@@ -1,16 +1,16 @@
 ---
 title: Recursive Proofs
 description: Learn about how to write recursive proofs in Noir.
-keywords: [recursion, recursive proofs, verification_key, aggregation object, verify_proof]
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
 ---
 
 Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
 
-The `verify_proof` function takes a verification key, proof and public inputs for a zk program, as well as a key hash and an input aggregation object. The key hash is used to check the validity of the verification key and the input aggregation object is required by some proving systems. The `verify_proof` function returns an output aggregation object that can then be fed into future iterations of the proof verification if required.
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
 
 ```rust
 #[foreign(verify_proof)]
-fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : Field, _key_hash : Field, _input_aggregation_object : [Field]) -> [Field] {}
+fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : Field, _key_hash : Field) {}
 ```
 
 :::info
@@ -26,36 +26,29 @@ use dep::std;
 
 fn main(
     verification_key : [Field; 114],
-    proof : [Field; 94],
+    proof : [Field; 93],
     public_inputs : [Field; 1],
     key_hash : Field,
-    input_aggregation_object : [Field; 16],
-    proof_b : [Field; 94],
-) -> pub [Field; 16] {
-    let output_aggregation_object_a = std::verify_proof(
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
         verification_key.as_slice(),
         proof.as_slice(),
         public_inputs.as_slice(),
-        key_hash,
-        input_aggregation_object
+        key_hash
     );
 
-    let output_aggregation_object = std::verify_proof(
+    std::verify_proof(
         verification_key.as_slice(),
         proof_b.as_slice(),
         public_inputs.as_slice(),
-        key_hash,
-        output_aggregation_object_a
+        key_hash
     );
-
-    let mut output = [0; 16];
-    for i in 0..16 {
-        output[i] = output_aggregation_object[i];
-    }
-    output
 }
 ```
 
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
 ## Parameters
 
 ### `verification_key`
@@ -68,23 +61,8 @@ The proof for the zk program that is being verified.
 
 ### `public_inputs`
 
-These represent the public inputs of the proof we are verifying. They should be checked against in the circuit after construction of a new aggregation state.
+These represent the public inputs of the proof we are verifying.
 
 ### `key_hash`
 
 A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
-
-### `input_aggregation_object`
-
-An aggregation object is blob of data that the top-level verifier must run some proof system specific algorithm on to complete verification. The size is proof system specific and will be set by the backend integrating this opcode. The input aggregation object is only not `None` when we are verifying a previous recursive aggregation in the current circuit. If this is the first recursive aggregation there is no input aggregation object. It is left to the backend to determine how to handle when there is no input aggregation object.
-
-## Return value
-
-### `output_aggregation_object`
-
-This is the result of a recursive aggregation and is what will be fed into the next verifier.
-The next verifier can either perform a final verification (returning true or false) or perform another recursive aggregation where this output aggregation object will be the input aggregation object of the next recursive aggregation.
-
-## Example
-
-You can see an example of how to do recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/docs/reference/NoirJS/backend_barretenberg/.nojekyll
deleted file mode 100644
index e2ac6616add..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/.nojekyll
+++ /dev/null
@@ -1 +0,0 @@
-TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/docs/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
deleted file mode 100644
index 5cbe9421b92..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
+++ /dev/null
@@ -1,185 +0,0 @@
-# BarretenbergBackend
-
-## Implements
-
-- [`Backend`](../interfaces/Backend.md)
-
-## Constructors
-
-### new BarretenbergBackend(acirCircuit, options)
-
-```ts
-new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `acirCircuit` | [`CompiledCircuit`](../type-aliases/CompiledCircuit.md) |
-| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
-
-#### Returns
-
-[`BarretenbergBackend`](BarretenbergBackend.md)
-
-## Methods
-
-### destroy()
-
-```ts
-destroy(): Promise<void>
-```
-
-#### Returns
-
-`Promise`\<`void`\>
-
-#### Implementation of
-
-[`Backend`](../interfaces/Backend.md).[`destroy`](../interfaces/Backend.md#destroy)
-
-#### Description
-
-Destroys the backend
-
-***
-
-### generateFinalProof()
-
-```ts
-generateFinalProof(decompressedWitness): Promise<ProofData>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `decompressedWitness` | `Uint8Array` |
-
-#### Returns
-
-`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
-
-#### Implementation of
-
-[`Backend`](../interfaces/Backend.md).[`generateFinalProof`](../interfaces/Backend.md#generatefinalproof)
-
-#### Description
-
-Generates a final proof (not meant to be verified in another circuit)
-
-***
-
-### generateIntermediateProof()
-
-```ts
-generateIntermediateProof(witness): Promise<ProofData>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `witness` | `Uint8Array` |
-
-#### Returns
-
-`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
-
-#### Implementation of
-
-[`Backend`](../interfaces/Backend.md).[`generateIntermediateProof`](../interfaces/Backend.md#generateintermediateproof)
-
-#### Example
-
-```typescript
-const intermediateProof = await backend.generateIntermediateProof(witness);
-```
-
-***
-
-### generateIntermediateProofArtifacts()
-
-```ts
-generateIntermediateProofArtifacts(proofData, numOfPublicInputs): Promise<object>
-```
-
-#### Parameters
-
-| Parameter | Type | Default value |
-| :------ | :------ | :------ |
-| `proofData` | [`ProofData`](../type-aliases/ProofData.md) | `undefined` |
-| `numOfPublicInputs` | `number` | `0` |
-
-#### Returns
-
-`Promise`\<`object`\>
-
-#### Implementation of
-
-[`Backend`](../interfaces/Backend.md).[`generateIntermediateProofArtifacts`](../interfaces/Backend.md#generateintermediateproofartifacts)
-
-#### Example
-
-```typescript
-const artifacts = await backend.generateIntermediateProofArtifacts(proof, numOfPublicInputs);
-```
-
-***
-
-### verifyFinalProof()
-
-```ts
-verifyFinalProof(proofData): Promise<boolean>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
-
-#### Returns
-
-`Promise`\<`boolean`\>
-
-#### Implementation of
-
-[`Backend`](../interfaces/Backend.md).[`verifyFinalProof`](../interfaces/Backend.md#verifyfinalproof)
-
-#### Description
-
-Verifies a final proof
-
-***
-
-### verifyIntermediateProof()
-
-```ts
-verifyIntermediateProof(proofData): Promise<boolean>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
-
-#### Returns
-
-`Promise`\<`boolean`\>
-
-#### Implementation of
-
-[`Backend`](../interfaces/Backend.md).[`verifyIntermediateProof`](../interfaces/Backend.md#verifyintermediateproof)
-
-#### Example
-
-```typescript
-const isValidIntermediate = await backend.verifyIntermediateProof(proof);
-```
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/index.md b/docs/docs/reference/NoirJS/backend_barretenberg/index.md
deleted file mode 100644
index e32501acb71..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/index.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# backend_barretenberg
-
-## Exports
-
-### Classes
-
-| Class | Description |
-| :------ | :------ |
-| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
-
-### Interfaces
-
-| Interface | Description |
-| :------ | :------ |
-| [Backend](interfaces/Backend.md) | - |
-
-### Type Aliases
-
-| Type alias | Description |
-| :------ | :------ |
-| [BackendOptions](type-aliases/BackendOptions.md) | - |
-| [CompiledCircuit](type-aliases/CompiledCircuit.md) | - |
-| [ProofData](type-aliases/ProofData.md) | - |
-
-## Functions
-
-### publicInputsToWitnessMap()
-
-```ts
-publicInputsToWitnessMap(publicInputs, abi): WitnessMap
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `publicInputs` | `string`[] |
-| `abi` | `Abi` |
-
-#### Returns
-
-`WitnessMap`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/interfaces/Backend.md b/docs/docs/reference/NoirJS/backend_barretenberg/interfaces/Backend.md
deleted file mode 100644
index 3eb9645c8d2..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/interfaces/Backend.md
+++ /dev/null
@@ -1,132 +0,0 @@
-# Backend
-
-## Methods
-
-### destroy()
-
-```ts
-destroy(): Promise<void>
-```
-
-#### Returns
-
-`Promise`\<`void`\>
-
-#### Description
-
-Destroys the backend
-
-***
-
-### generateFinalProof()
-
-```ts
-generateFinalProof(decompressedWitness): Promise<ProofData>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `decompressedWitness` | `Uint8Array` |
-
-#### Returns
-
-`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
-
-#### Description
-
-Generates a final proof (not meant to be verified in another circuit)
-
-***
-
-### generateIntermediateProof()
-
-```ts
-generateIntermediateProof(decompressedWitness): Promise<ProofData>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `decompressedWitness` | `Uint8Array` |
-
-#### Returns
-
-`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
-
-#### Description
-
-Generates an intermediate proof (meant to be verified in another circuit)
-
-***
-
-### generateIntermediateProofArtifacts()
-
-```ts
-generateIntermediateProofArtifacts(proofData, numOfPublicInputs): Promise<object>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
-| `numOfPublicInputs` | `number` |
-
-#### Returns
-
-`Promise`\<`object`\>
-
-#### Description
-
-Retrieves the artifacts from a proof in the Field format
-
-***
-
-### verifyFinalProof()
-
-```ts
-verifyFinalProof(proofData): Promise<boolean>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
-
-#### Returns
-
-`Promise`\<`boolean`\>
-
-#### Description
-
-Verifies a final proof
-
-***
-
-### verifyIntermediateProof()
-
-```ts
-verifyIntermediateProof(proofData): Promise<boolean>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
-
-#### Returns
-
-`Promise`\<`boolean`\>
-
-#### Description
-
-Verifies an intermediate proof
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
deleted file mode 100644
index 266ade75d17..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# BackendOptions
-
-```ts
-type BackendOptions: object;
-```
-
-## Description
-
-An options object, currently only used to specify the number of threads to use.
-
-## Type declaration
-
-| Member | Type | Description |
-| :------ | :------ | :------ |
-| `threads` | `number` | **Description**<br /><br />Number of threads |
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit.md b/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit.md
deleted file mode 100644
index 34e0dd04205..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# CompiledCircuit
-
-```ts
-type CompiledCircuit: object;
-```
-
-## Description
-
-The representation of a compiled circuit
-
-## Type declaration
-
-| Member | Type | Description |
-| :------ | :------ | :------ |
-| `abi` | `Abi` | **Description**<br /><br />ABI representation of the circuit |
-| `bytecode` | `string` | **Description**<br /><br />The bytecode of the circuit |
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/ProofData.md b/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/ProofData.md
deleted file mode 100644
index 05cebbc4e94..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/type-aliases/ProofData.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# ProofData
-
-```ts
-type ProofData: object;
-```
-
-## Description
-
-The representation of a proof
-
-## Type declaration
-
-| Member | Type | Description |
-| :------ | :------ | :------ |
-| `proof` | `Uint8Array` | **Description**<br /><br />An byte array representing the proof |
-| `publicInputs` | `string`[] | **Description**<br /><br />Public inputs of a proof |
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/docs/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
deleted file mode 100644
index 2aaa55bccf6..00000000000
--- a/docs/docs/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
+++ /dev/null
@@ -1,4 +0,0 @@
-// @ts-check
-/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
-const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"}]},{"type":"category","label":"Interfaces","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/interfaces/Backend","label":"Backend"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/CompiledCircuit","label":"CompiledCircuit"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/ProofData","label":"ProofData"}]}]};
-module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/docs/reference/NoirJS/noir_js/.nojekyll b/docs/docs/reference/NoirJS/noir_js/.nojekyll
deleted file mode 100644
index e2ac6616add..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/.nojekyll
+++ /dev/null
@@ -1 +0,0 @@
-TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/docs/reference/NoirJS/noir_js/classes/Noir.md b/docs/docs/reference/NoirJS/noir_js/classes/Noir.md
deleted file mode 100644
index 34e20d99684..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/classes/Noir.md
+++ /dev/null
@@ -1,132 +0,0 @@
-# Noir
-
-## Constructors
-
-### new Noir(circuit, backend)
-
-```ts
-new Noir(circuit, backend?): Noir
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `circuit` | [`CompiledCircuit`](../type-aliases/CompiledCircuit.md) |
-| `backend`? | `Backend` |
-
-#### Returns
-
-[`Noir`](Noir.md)
-
-## Methods
-
-### destroy()
-
-```ts
-destroy(): Promise<void>
-```
-
-#### Returns
-
-`Promise`\<`void`\>
-
-#### Description
-
-Destroys the underlying backend instance.
-
-#### Example
-
-```typescript
-await noir.destroy();
-```
-
-***
-
-### execute()
-
-```ts
-execute(inputs, foreignCallHandler?): Promise<object>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `inputs` | [`InputMap`](../type-aliases/InputMap.md) |
-| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
-
-#### Returns
-
-`Promise`\<`object`\>
-
-#### Description
-
-Allows to execute a circuit to get its witness and return value.
-
-#### Example
-
-```typescript
-async execute(inputs)
-```
-
-***
-
-### generateFinalProof()
-
-```ts
-generateFinalProof(inputs, foreignCallHandler?): Promise<ProofData>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `inputs` | [`InputMap`](../type-aliases/InputMap.md) |
-| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
-
-#### Returns
-
-`Promise`\<[`ProofData`](../type-aliases/ProofData.md)\>
-
-#### Description
-
-Generates a witness and a proof given an object as input.
-
-#### Example
-
-```typescript
-async generateFinalProof(input)
-```
-
-***
-
-### verifyFinalProof()
-
-```ts
-verifyFinalProof(proofData): Promise<boolean>
-```
-
-#### Parameters
-
-| Parameter | Type |
-| :------ | :------ |
-| `proofData` | [`ProofData`](../type-aliases/ProofData.md) |
-
-#### Returns
-
-`Promise`\<`boolean`\>
-
-#### Description
-
-Instantiates the verification key and verifies a proof.
-
-#### Example
-
-```typescript
-async verifyFinalProof(proof)
-```
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/functions/and.md b/docs/docs/reference/NoirJS/noir_js/functions/and.md
deleted file mode 100644
index c783283e396..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/functions/and.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# and()
-
-```ts
-and(lhs, rhs): string
-```
-
-Performs a bitwise AND operation between `lhs` and `rhs`
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `lhs` | `string` |  |
-| `rhs` | `string` |  |
-
-## Returns
-
-`string`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/docs/reference/NoirJS/noir_js/functions/blake2s256.md
deleted file mode 100644
index 7882d0da8d5..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/functions/blake2s256.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# blake2s256()
-
-```ts
-blake2s256(inputs): Uint8Array
-```
-
-Calculates the Blake2s256 hash of the input bytes
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `inputs` | `Uint8Array` |  |
-
-## Returns
-
-`Uint8Array`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/docs/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
deleted file mode 100644
index 5e3cd53e9d3..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# ecdsa\_secp256k1\_verify()
-
-```ts
-ecdsa_secp256k1_verify(
-   hashed_msg, 
-   public_key_x_bytes, 
-   public_key_y_bytes, 
-   signature): boolean
-```
-
-Verifies a ECDSA signature over the secp256k1 curve.
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `hashed_msg` | `Uint8Array` |  |
-| `public_key_x_bytes` | `Uint8Array` |  |
-| `public_key_y_bytes` | `Uint8Array` |  |
-| `signature` | `Uint8Array` |  |
-
-## Returns
-
-`boolean`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/docs/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
deleted file mode 100644
index 0b20ff68957..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# ecdsa\_secp256r1\_verify()
-
-```ts
-ecdsa_secp256r1_verify(
-   hashed_msg, 
-   public_key_x_bytes, 
-   public_key_y_bytes, 
-   signature): boolean
-```
-
-Verifies a ECDSA signature over the secp256r1 curve.
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `hashed_msg` | `Uint8Array` |  |
-| `public_key_x_bytes` | `Uint8Array` |  |
-| `public_key_y_bytes` | `Uint8Array` |  |
-| `signature` | `Uint8Array` |  |
-
-## Returns
-
-`boolean`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/functions/keccak256.md b/docs/docs/reference/NoirJS/noir_js/functions/keccak256.md
deleted file mode 100644
index d10f155ce86..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/functions/keccak256.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# keccak256()
-
-```ts
-keccak256(inputs): Uint8Array
-```
-
-Calculates the Keccak256 hash of the input bytes
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `inputs` | `Uint8Array` |  |
-
-## Returns
-
-`Uint8Array`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/functions/sha256.md b/docs/docs/reference/NoirJS/noir_js/functions/sha256.md
deleted file mode 100644
index 6ba4ecac022..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/functions/sha256.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# sha256()
-
-```ts
-sha256(inputs): Uint8Array
-```
-
-Calculates the SHA256 hash of the input bytes
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `inputs` | `Uint8Array` |  |
-
-## Returns
-
-`Uint8Array`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/functions/xor.md b/docs/docs/reference/NoirJS/noir_js/functions/xor.md
deleted file mode 100644
index 8d762b895d3..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/functions/xor.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# xor()
-
-```ts
-xor(lhs, rhs): string
-```
-
-Performs a bitwise XOR operation between `lhs` and `rhs`
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `lhs` | `string` |  |
-| `rhs` | `string` |  |
-
-## Returns
-
-`string`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/index.md b/docs/docs/reference/NoirJS/noir_js/index.md
deleted file mode 100644
index d600e21b299..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/index.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# noir_js
-
-## Exports
-
-### Classes
-
-| Class | Description |
-| :------ | :------ |
-| [Noir](classes/Noir.md) | - |
-
-### Type Aliases
-
-| Type alias | Description |
-| :------ | :------ |
-| [CompiledCircuit](type-aliases/CompiledCircuit.md) | - |
-| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
-| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
-| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
-| [InputMap](type-aliases/InputMap.md) | - |
-| [ProofData](type-aliases/ProofData.md) | - |
-| [WitnessMap](type-aliases/WitnessMap.md) | - |
-
-### Functions
-
-| Function | Description |
-| :------ | :------ |
-| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
-| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
-| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
-| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
-| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
-| [sha256](functions/sha256.md) | Calculates the SHA256 hash of the input bytes |
-| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/type-aliases/CompiledCircuit.md b/docs/docs/reference/NoirJS/noir_js/type-aliases/CompiledCircuit.md
deleted file mode 100644
index 34e0dd04205..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/type-aliases/CompiledCircuit.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# CompiledCircuit
-
-```ts
-type CompiledCircuit: object;
-```
-
-## Description
-
-The representation of a compiled circuit
-
-## Type declaration
-
-| Member | Type | Description |
-| :------ | :------ | :------ |
-| `abi` | `Abi` | **Description**<br /><br />ABI representation of the circuit |
-| `bytecode` | `string` | **Description**<br /><br />The bytecode of the circuit |
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
deleted file mode 100644
index 812b8b16481..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# ForeignCallHandler
-
-```ts
-type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
-```
-
-A callback which performs an foreign call and returns the response.
-
-## Parameters
-
-| Parameter | Type | Description |
-| :------ | :------ | :------ |
-| `name` | `string` | The identifier for the type of foreign call being performed. |
-| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
-
-## Returns
-
-`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
-
-outputs - An array of hex encoded outputs containing the results of the foreign call.
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
deleted file mode 100644
index dd95809186a..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# ForeignCallInput
-
-```ts
-type ForeignCallInput: string[];
-```
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
deleted file mode 100644
index b71fb78a946..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# ForeignCallOutput
-
-```ts
-type ForeignCallOutput: string | string[];
-```
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/type-aliases/InputMap.md b/docs/docs/reference/NoirJS/noir_js/type-aliases/InputMap.md
deleted file mode 100644
index c714e999d93..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/type-aliases/InputMap.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# InputMap
-
-```ts
-type InputMap: object;
-```
-
-## Index signature
-
- \[`key`: `string`\]: `InputValue`
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/type-aliases/ProofData.md b/docs/docs/reference/NoirJS/noir_js/type-aliases/ProofData.md
deleted file mode 100644
index 05cebbc4e94..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/type-aliases/ProofData.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# ProofData
-
-```ts
-type ProofData: object;
-```
-
-## Description
-
-The representation of a proof
-
-## Type declaration
-
-| Member | Type | Description |
-| :------ | :------ | :------ |
-| `proof` | `Uint8Array` | **Description**<br /><br />An byte array representing the proof |
-| `publicInputs` | `string`[] | **Description**<br /><br />Public inputs of a proof |
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/docs/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
deleted file mode 100644
index 258c46f9d0c..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# WitnessMap
-
-```ts
-type WitnessMap: Map<number, string>;
-```
-
-***
-
-Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/docs/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/docs/reference/NoirJS/noir_js/typedoc-sidebar.cjs
deleted file mode 100644
index fe2629ddc9f..00000000000
--- a/docs/docs/reference/NoirJS/noir_js/typedoc-sidebar.cjs
+++ /dev/null
@@ -1,4 +0,0 @@
-// @ts-check
-/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
-const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/CompiledCircuit","label":"CompiledCircuit"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/InputMap","label":"InputMap"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ProofData","label":"ProofData"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/sha256","label":"sha256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
-module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/docusaurus.config.ts b/docs/docusaurus.config.ts
index 4e0d053f61e..d1d344ba635 100644
--- a/docs/docusaurus.config.ts
+++ b/docs/docusaurus.config.ts
@@ -155,7 +155,7 @@ export default {
         entryPoints: ['../tooling/noir_js/src/index.ts'],
         tsconfig: '../tooling/noir_js/tsconfig.json',
         entryPointStrategy: 'resolve',
-        out: 'docs/reference/NoirJS/noir_js',
+        out: 'processed-docs/reference/NoirJS/noir_js',
         plugin: ['typedoc-plugin-markdown'],
         name: 'noir_js',
         disableSources: true,
@@ -186,7 +186,7 @@ export default {
         entryPoints: ['../tooling/noir_js_backend_barretenberg/src/index.ts'],
         tsconfig: '../tooling/noir_js_backend_barretenberg/tsconfig.json',
         entryPointStrategy: 'resolve',
-        out: 'docs/reference/NoirJS/backend_barretenberg',
+        out: 'processed-docs/reference/NoirJS/backend_barretenberg',
         plugin: ['typedoc-plugin-markdown'],
         name: 'backend_barretenberg',
         disableSources: true,
diff --git a/docs/versioned_docs/version-v0.23.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.23.0/explainers/explainer-recursion.md
index 8f992ec29fd..18846176ca7 100644
--- a/docs/versioned_docs/version-v0.23.0/explainers/explainer-recursion.md
+++ b/docs/versioned_docs/version-v0.23.0/explainers/explainer-recursion.md
@@ -16,12 +16,13 @@ keywords:
     "Optimizing Computational Resources",
     "Improving Efficiency",
     "Verification Key",
-    "Aggregation Objects",
+    "Aggregation",
     "Recursive zkSNARK schemes",
     "PLONK",
     "Proving and Verification Keys"
   ]
 sidebar_position: 1
+pagination_next: how_to/how-to-recursion
 ---
 
 In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
@@ -64,7 +65,7 @@ So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob w
 
 This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
 
-As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?". 
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
 
 She can then generate a proof that she verified his proof, and so on.
 
@@ -116,25 +117,19 @@ As you can see in the [recursion reference](noir/standard_library/recursion.md),
 - The Verification Key of the circuit that generated the proof
 - A hash of this verification key, as it's needed for some backends
 - The public inputs for the proof
-- The input aggregation object
 
-It also returns the `output aggregation object`. These aggregation objects can be confusing at times, so let's dive in a little bit.
-
-### Aggregation objects
+:::info
 
 Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
 
-In the case of PLONK the recursive aggregation object is two G1 points (expressed as 16 witness values). The final verifier (in our case this is most often the smart contract verifier) has to be aware of this aggregation object to execute a pairing and check the validity of these points.
-
 So, taking the example of Alice and Bob and their guessing game:
 
 - Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
-- Bob verifies Alice's proof and makes his own guess. In this circuit, he is verifying a proof, so it needs to output an `aggregation object`: he is generating a recursive proof!
-- Alice verifies Bob's *recursive proof*, and uses Bob's `output aggregation object` as the `input aggregation object` in her proof... Which in turn, generates another `output aggregation object`.
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
 
-One should notice that when Bob generates his first proof, he has no input aggregation object. Because he is not verifying an recursive proof, he has no `input aggregation object`. In this case, he may use zeros instead.
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
 
-We can imagine the `aggregation object` as the baton in a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+:::
 
 ## Some architecture
 
@@ -175,3 +170,7 @@ In this example, a regulator could verify that taxes were paid for a specific pu
 At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
 
 Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.23.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.23.0/how_to/how-to-recursion.md
index 39db23f1f3a..f34647a99d5 100644
--- a/docs/versioned_docs/version-v0.23.0/how_to/how-to-recursion.md
+++ b/docs/versioned_docs/version-v0.23.0/how_to/how-to-recursion.md
@@ -108,11 +108,7 @@ This call takes the public inputs and the proof, but also the public inputs coun
 
 :::info
 
-The `proofAsFields` has a constant size `[Field; 93]`. However, currently the backend doesn't remove the public inputs from the proof when converting it.
-
-This means that if your `main` circuit has two public inputs, then you should also modify the recursive circuit to accept a proof with the public inputs appended. This means that in our example, since `y` is a public input, our `proofAsFields` is of type `[Field; 94]`.
-
-Verification keys in Barretenberg are always of size 114.
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
 
 :::
 
@@ -136,7 +132,6 @@ const recursiveInputs = {
     proof: proofAsFields, // array of length 93 + size of public inputs
     publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
     key_hash: vkHash,
-    input_aggregation_object: Array(16).fill(0) // this circuit is verifying a non-recursive proof, so there's no input aggregation object: just use zero
 }
 
 const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
@@ -144,7 +139,7 @@ const { proof, publicInputs } = backend.generateFinalProof(witness)
 const verified = backend.verifyFinalProof({ proof, publicInputs })
 ```
 
-You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way! In that case, you should keep in mind the `returnValue`, as it will contain the `input_aggregation_object` for the next proof.
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
 
 :::tip
 
@@ -152,16 +147,16 @@ Managing circuits and "who does what" can be confusing. To make sure your naming
 
 ```js
 const circuits = {
-main: mainJSON, 
-recursive: recursiveJSON
+  main: mainJSON, 
+  recursive: recursiveJSON
 }
 const backends = {
-main: new BarretenbergBackend(circuits.main),
-recursive: new BarretenbergBackend(circuits.recursive)
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
 }
 const noir_programs = {
-main: new Noir(circuits.main, backends.main),
-recursive: new Noir(circuits.recursive, backends.recursive)
+  main: new Noir(circuits.main, backends.main),
+  recursive: new Noir(circuits.recursive, backends.recursive)
 }
 ```
 
diff --git a/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md
index 67962082a8f..f252150c8b5 100644
--- a/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.23.0/noir/standard_library/recursion.md
@@ -1,16 +1,16 @@
 ---
 title: Recursive Proofs
 description: Learn about how to write recursive proofs in Noir.
-keywords: [recursion, recursive proofs, verification_key, aggregation object, verify_proof]
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
 ---
 
 Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
 
-The `verify_proof` function takes a verification key, proof and public inputs for a zk program, as well as a key hash and an input aggregation object. The key hash is used to check the validity of the verification key and the input aggregation object is required by some proving systems. The `verify_proof` function returns an output aggregation object that can then be fed into future iterations of the proof verification if required.
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
 
 ```rust
 #[foreign(verify_proof)]
-fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : Field, _key_hash : Field, _input_aggregation_object : [Field]) -> [Field] {}
+fn verify_proof(_verification_key : [Field], _proof : [Field], _public_input : Field, _key_hash : Field) {}
 ```
 
 :::info
@@ -26,36 +26,29 @@ use dep::std;
 
 fn main(
     verification_key : [Field; 114],
-    proof : [Field; 94],
+    proof : [Field; 93],
     public_inputs : [Field; 1],
     key_hash : Field,
-    input_aggregation_object : [Field; 16],
-    proof_b : [Field; 94],
-) -> pub [Field; 16] {
-    let output_aggregation_object_a = std::verify_proof(
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
         verification_key.as_slice(),
         proof.as_slice(),
         public_inputs.as_slice(),
-        key_hash,
-        input_aggregation_object
+        key_hash
     );
 
-    let output_aggregation_object = std::verify_proof(
+    std::verify_proof(
         verification_key.as_slice(),
         proof_b.as_slice(),
         public_inputs.as_slice(),
-        key_hash,
-        output_aggregation_object_a
+        key_hash
     );
-
-    let mut output = [0; 16];
-    for i in 0..16 {
-        output[i] = output_aggregation_object[i];
-    }
-    output
 }
 ```
 
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
 ## Parameters
 
 ### `verification_key`
@@ -68,23 +61,8 @@ The proof for the zk program that is being verified.
 
 ### `public_inputs`
 
-These represent the public inputs of the proof we are verifying. They should be checked against in the circuit after construction of a new aggregation state.
+These represent the public inputs of the proof we are verifying.
 
 ### `key_hash`
 
 A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
-
-### `input_aggregation_object`
-
-An aggregation object is blob of data that the top-level verifier must run some proof system specific algorithm on to complete verification. The size is proof system specific and will be set by the backend integrating this opcode. The input aggregation object is only not `None` when we are verifying a previous recursive aggregation in the current circuit. If this is the first recursive aggregation there is no input aggregation object. It is left to the backend to determine how to handle when there is no input aggregation object.
-
-## Return value
-
-### `output_aggregation_object`
-
-This is the result of a recursive aggregation and is what will be fed into the next verifier.
-The next verifier can either perform a final verification (returning true or false) or perform another recursive aggregation where this output aggregation object will be the input aggregation object of the next recursive aggregation.
-
-## Example
-
-You can see an example of how to do recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index bcdf56dd7aa..87cf4167dac 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -3,10 +3,10 @@
 // by the methods in the `slice` module
 impl<T, N> [T; N] {
     #[builtin(array_len)]
-    pub fn len(_self: Self) -> Field {}
+    pub fn len(self) -> Field {}
 
     #[builtin(arraysort)]
-    pub fn sort(_self: Self) -> Self {}
+    pub fn sort(self) -> Self {}
 
     // Sort with a custom sorting function.
     pub fn sort_via<Env>(mut a: Self, ordering: fn[Env](T, T) -> bool) -> Self { 
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
new file mode 100644
index 00000000000..14790f69241
--- /dev/null
+++ b/noir_stdlib/src/bigint.nr
@@ -0,0 +1,53 @@
+use crate::ops::{Add, Sub, Mul, Div, Rem,};
+
+struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+
+impl BigInt {
+    #[builtin(bigint_add)]
+    pub fn bigint_add(_self: Self, _other: BigInt) -> BigInt {
+    }
+    #[builtin(bigint_neg)]
+    pub fn bigint_neg(_self: Self, _other: BigInt) -> BigInt {
+    }
+    #[builtin(bigint_mul)]
+    pub fn bigint_mul(_self: Self, _other: BigInt) -> BigInt {
+    }
+    #[builtin(bigint_div)]
+    pub fn bigint_div(_self: Self, _other: BigInt) -> BigInt {
+    }
+    #[builtin(bigint_from_le_bytes)]
+    pub fn from_le_bytes(_bytes: [u8], _modulus: [u8]) -> BigInt {}
+    #[builtin(bigint_to_le_bytes)]
+    pub fn to_le_bytes(_self: Self) -> [u8] {}
+}
+
+impl Add for BigInt { 
+    fn add(self: Self, other: BigInt) -> BigInt {
+        self.bigint_add(other)
+    }
+}
+impl Sub for BigInt { 
+    fn sub(self: Self, other: BigInt) -> BigInt {
+        self.bigint_neg(other)
+    }
+}
+impl Mul for BigInt { 
+    fn mul(self: Self, other: BigInt) -> BigInt {
+        self.bigint_mul(other)
+    }
+}
+impl Div for BigInt { 
+    fn div(self: Self, other: BigInt) -> BigInt {
+        self.bigint_div(other)
+    }
+}
+impl Rem for BigInt { 
+    fn rem(self: Self, other: BigInt) -> BigInt {
+        let quotient = self.bigint_div(other);
+        self.bigint_neg(quotient.bigint_mul(other))
+    }
+}
+
diff --git a/noir_stdlib/src/collections.nr b/noir_stdlib/src/collections.nr
index e06c662e658..177ca96816f 100644
--- a/noir_stdlib/src/collections.nr
+++ b/noir_stdlib/src/collections.nr
@@ -1 +1,2 @@
 mod vec;
+mod bounded_vec;
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
new file mode 100644
index 00000000000..332fefa63f9
--- /dev/null
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -0,0 +1,88 @@
+struct BoundedVec<T, MaxLen> {
+    storage: [T; MaxLen],
+    // TODO: change this to return a u64 as Noir now
+    // uses u64 for indexing
+    len: Field,
+    empty_value: T,
+}
+
+impl<T, MaxLen> BoundedVec<T, MaxLen> {
+    pub fn new(initial_value: T) -> Self {
+        BoundedVec { storage: [initial_value; MaxLen], len: 0, empty_value: initial_value }
+    }
+
+    pub fn get(mut self: Self, index: Field) -> T {
+        assert(index as u64 < self.len as u64);
+        self.storage[index]
+    }
+
+    pub fn get_unchecked(mut self: Self, index: Field) -> T {
+        self.storage[index]
+    }
+
+    pub fn push(&mut self, elem: T) {
+        assert(self.len as u64 < MaxLen as u64, "push out of bounds");
+
+        self.storage[self.len] = elem;
+        self.len += 1;
+    }
+
+    pub fn len(self) -> Field {
+        self.len
+    }
+
+    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> Field {
+        MaxLen
+    }
+
+    // This is a intermediate method, while we don't have an
+    // .extend method
+    pub fn storage(self) -> [T; MaxLen] {
+        self.storage
+    }
+
+    pub fn extend_from_array<Len>(&mut self, array: [T; Len]) {
+        let new_len = self.len + array.len();
+        assert(new_len as u64 <= MaxLen as u64, "extend_from_array out of bounds");
+        for i in 0..array.len() {
+            self.storage[self.len + i] = array[i];
+        }
+        self.len = new_len;
+    }
+
+    pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>) {
+        let append_len = vec.len();
+        let new_len = self.len + append_len;
+        assert(new_len as u64 <= MaxLen as u64, "extend_from_bounded_vec out of bounds");
+
+        let mut exceeded_len = false;
+        for i in 0..Len {
+            exceeded_len |= i == append_len;
+            if !exceeded_len {
+                self.storage[self.len + (i as Field)] = vec.get_unchecked(i as Field);
+            }
+        }
+        self.len = new_len;
+    }
+
+    pub fn pop(&mut self) -> T {
+        assert(self.len as u64 > 0);
+        self.len -= 1;
+
+        let elem = self.storage[self.len];
+        self.storage[self.len] = self.empty_value;
+        elem
+    }
+
+    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {
+        let mut ret = false;
+        let mut exceeded_len = false;
+        for i in 0..MaxLen {
+            exceeded_len |= i == self.len;
+            if (!exceeded_len) {
+                ret |= predicate(self.storage[i]);
+            }
+        }
+        ret
+    }
+}
\ No newline at end of file
diff --git a/noir_stdlib/src/ecdsa_secp256k1.nr b/noir_stdlib/src/ecdsa_secp256k1.nr
index 290ccba27e5..e8d9af2230f 100644
--- a/noir_stdlib/src/ecdsa_secp256k1.nr
+++ b/noir_stdlib/src/ecdsa_secp256k1.nr
@@ -1,10 +1,10 @@
 #[foreign(ecdsa_secp256k1)]
 // docs:start:ecdsa_secp256k1
 pub fn verify_signature<N>(
-    _public_key_x: [u8; 32],
-    _public_key_y: [u8; 32],
-    _signature: [u8; 64],
-    _message_hash: [u8; N]
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
 ) -> bool
 // docs:end:ecdsa_secp256k1
-{}
+{}
\ No newline at end of file
diff --git a/noir_stdlib/src/ecdsa_secp256r1.nr b/noir_stdlib/src/ecdsa_secp256r1.nr
index 390f8ed39d2..9fe932a2f3d 100644
--- a/noir_stdlib/src/ecdsa_secp256r1.nr
+++ b/noir_stdlib/src/ecdsa_secp256r1.nr
@@ -1,10 +1,10 @@
 #[foreign(ecdsa_secp256r1)]
 // docs:start:ecdsa_secp256r1
 pub fn verify_signature<N>(
-    _public_key_x: [u8; 32],
-    _public_key_y: [u8; 32],
-    _signature: [u8; 64],
-    _message_hash: [u8; N]
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
 ) -> bool
 // docs:end:ecdsa_secp256r1
-{}
+{}
\ No newline at end of file
diff --git a/noir_stdlib/src/field.nr b/noir_stdlib/src/field.nr
index fbd76a1e8a2..66fb50119f9 100644
--- a/noir_stdlib/src/field.nr
+++ b/noir_stdlib/src/field.nr
@@ -13,13 +13,13 @@ impl Field {
     }
 
     #[builtin(to_le_bits)]
-    fn __to_le_bits(_self: Self, _bit_size: u32) -> [u1] {}
+    fn __to_le_bits(self, _bit_size: u32) -> [u1] {}
     
     #[builtin(to_be_bits)]
-    fn __to_be_bits(_self: Self, _bit_size: u32) -> [u1] {}
+    fn __to_be_bits(self, bit_size: u32) -> [u1] {}
 
     #[builtin(apply_range_constraint)]
-    fn __assert_max_bit_size(_self: Self, _bit_size: u32) {}
+    fn __assert_max_bit_size(self, bit_size: u32) {}
 
     pub fn assert_max_bit_size(self: Self, bit_size: u32) {
         crate::assert_constant(bit_size);
@@ -53,10 +53,10 @@ impl Field {
     // decompose `_self` into a `_result_len` vector over the `_radix` basis
     // `_radix` must be less than 256
     #[builtin(to_le_radix)]
-    fn __to_le_radix(_self: Self, _radix: u32, _result_len: u32) -> [u8] {}
+    fn __to_le_radix(self, radix: u32, result_len: u32) -> [u8] {}
     
     #[builtin(to_be_radix)]
-    fn __to_be_radix(_self: Self, _radix: u32, _result_len: u32) -> [u8] {}
+    fn __to_be_radix(self, radix: u32, result_len: u32) -> [u8] {}
 
 
     // Returns self to the power of the given exponent value.
diff --git a/noir_stdlib/src/hash.nr b/noir_stdlib/src/hash.nr
index 09154038f4e..cc864039a90 100644
--- a/noir_stdlib/src/hash.nr
+++ b/noir_stdlib/src/hash.nr
@@ -3,19 +3,19 @@ mod mimc;
 
 #[foreign(sha256)]
 // docs:start:sha256
-pub fn sha256<N>(_input: [u8; N]) -> [u8; 32]
+pub fn sha256<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:sha256
 {}
 
 #[foreign(blake2s)]
 // docs:start:blake2s
-pub fn blake2s<N>(_input: [u8; N]) -> [u8; 32]
+pub fn blake2s<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake2s
 {}
 
 #[foreign(blake3)]
 // docs:start:blake3
-pub fn blake3<N>(_input: [u8; N]) -> [u8; 32]
+pub fn blake3<N>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake3
 {}
 
@@ -32,7 +32,7 @@ pub fn pedersen_commitment<N>(input: [Field; N]) -> PedersenPoint
 }
 
 #[foreign(pedersen_commitment)]
-pub fn __pedersen_commitment_with_separator<N>(_input: [Field; N], _separator: u32) -> [Field; 2] {}
+pub fn __pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> [Field; 2] {}
 
 pub fn pedersen_commitment_with_separator<N>(input: [Field; N], separator: u32) -> PedersenPoint {
     let values = __pedersen_commitment_with_separator(input, separator);
@@ -47,13 +47,13 @@ pub fn pedersen_hash<N>(input: [Field; N]) -> Field
 }
 
 #[foreign(pedersen_hash)]
-pub fn pedersen_hash_with_separator<N>(_input: [Field; N], _separator: u32) -> Field {}
+pub fn pedersen_hash_with_separator<N>(input: [Field; N], separator: u32) -> Field {}
 
-pub fn hash_to_field<N>(_input: [Field; N]) -> Field {
+pub fn hash_to_field<N>(input: [Field; N]) -> Field {
     let mut inputs_as_bytes = [];
 
     for i in 0..N {
-        let input_bytes = _input[i].to_le_bytes(32);
+        let input_bytes = input[i].to_le_bytes(32);
         for i in 0..32 {
             inputs_as_bytes = inputs_as_bytes.push_back(input_bytes[i]);
         }
@@ -65,7 +65,12 @@ pub fn hash_to_field<N>(_input: [Field; N]) -> Field {
 
 #[foreign(keccak256)]
 // docs:start:keccak256
-pub fn keccak256<N>(_input: [u8; N], _message_size: u32) -> [u8; 32]
+pub fn keccak256<N>(input: [u8; N], message_size: u32) -> [u8; 32]
 // docs:end:keccak256
 {}
 
+#[foreign(poseidon2_permutation)]
+pub fn poseidon2_permutation<N>(_input: [u8; N], _state_length: u32) -> [u8; N] {}
+
+#[foreign(sha256_compression)]
+pub fn sha256_compression(_input: [u32; 16], _state: [u32; 8]) -> [u32; 8] {}
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index b86834712a6..5165d1ee07b 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -25,11 +25,12 @@ mod ops;
 mod default;
 mod prelude;
 mod uint128;
+// mod bigint;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident
 #[oracle(print)]
-unconstrained fn print_oracle<T>(_with_newline: bool, _input: T) {}
+unconstrained fn print_oracle<T>(with_newline: bool, input: T) {}
 
 unconstrained pub fn print<T>(input: T) {
     print_oracle(false, input);
@@ -40,20 +41,20 @@ unconstrained pub fn println<T>(input: T) {
 }
 
 #[foreign(recursive_aggregation)]
-pub fn verify_proof<N>(_verification_key: [Field], _proof: [Field], _public_inputs: [Field], _key_hash: Field) {}
+pub fn verify_proof<N>(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
 
 // Asserts that the given value is known at compile-time.
 // Useful for debugging for-loop bounds.
 #[builtin(assert_constant)]
-pub fn assert_constant<T>(_x: T) {}
+pub fn assert_constant<T>(x: T) {}
 // from_field and as_field are private since they are not valid for every type.
 // `as` should be the default for users to cast between primitive types, and in the future
 // traits can be used to work with generic types.
 #[builtin(from_field)]
-fn from_field<T>(_x: Field) -> T {}
+fn from_field<T>(x: Field) -> T {}
 
 #[builtin(as_field)]
-fn as_field<T>(_x: T) -> Field {}
+fn as_field<T>(x: T) -> Field {}
 
 pub fn wrapping_add<T>(x: T, y: T) -> T {
     crate::from_field(crate::as_field(x) + crate::as_field(y))
diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr
index 137d57f33db..cab95731d05 100644
--- a/noir_stdlib/src/option.nr
+++ b/noir_stdlib/src/option.nr
@@ -56,6 +56,12 @@ impl<T> Option<T> {
         }
     }
 
+    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value
+    fn expect<N, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {
+        assert(self.is_some(), message);
+        self._value
+    }
+
     /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
     pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {
         if self._is_some {
diff --git a/noir_stdlib/src/prelude.nr b/noir_stdlib/src/prelude.nr
index 26c6a805d54..3244329aa4b 100644
--- a/noir_stdlib/src/prelude.nr
+++ b/noir_stdlib/src/prelude.nr
@@ -1,4 +1,5 @@
 use crate::collections::vec::Vec;
+use crate::collections::bounded_vec::BoundedVec;
 use crate::option::Option;
 use crate::{print, println, assert_constant};
 use crate::uint128::U128;
diff --git a/noir_stdlib/src/scalar_mul.nr b/noir_stdlib/src/scalar_mul.nr
index c045e72d400..26378e4839a 100644
--- a/noir_stdlib/src/scalar_mul.nr
+++ b/noir_stdlib/src/scalar_mul.nr
@@ -1,3 +1,22 @@
+use crate::ops::Add;
+
+struct EmbeddedCurvePoint {
+    x: Field,
+    y: Field,
+}
+
+impl EmbeddedCurvePoint {
+    fn double(self) -> EmbeddedCurvePoint { 
+        embedded_curve_add(self, self)
+    }
+}
+
+impl Add for EmbeddedCurvePoint {
+    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint { 
+        embedded_curve_add(self, other)
+    }
+}
+
 // Computes a fixed base scalar multiplication over the embedded curve.
 // For bn254, We have Grumpkin and Baby JubJub.
 // For bls12-381, we have JubJub and Bandersnatch.
@@ -7,8 +26,11 @@
 #[foreign(fixed_base_scalar_mul)]
 // docs:start:fixed_base_embedded_curve
 pub fn fixed_base_embedded_curve(
-    _low: Field,
-    _high: Field
+    low: Field,
+    high: Field
 ) -> [Field; 2]
 // docs:end:fixed_base_embedded_curve
 {}
+
+#[foreign(embedded_curve_add)]
+fn embedded_curve_add(_point1: EmbeddedCurvePoint, _point2: EmbeddedCurvePoint) -> EmbeddedCurvePoint {}
diff --git a/noir_stdlib/src/schnorr.nr b/noir_stdlib/src/schnorr.nr
index 025c3a0f921..33656254550 100644
--- a/noir_stdlib/src/schnorr.nr
+++ b/noir_stdlib/src/schnorr.nr
@@ -1,10 +1,10 @@
 #[foreign(schnorr_verify)]
 // docs:start:schnorr_verify
 pub fn verify_signature<N>(
-    _public_key_x: Field,
-    _public_key_y: Field,
-    _signature: [u8; 64],
-    _message: [u8; N]
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
 ) -> bool
 // docs:end:schnorr_verify
-{}
+{}
\ No newline at end of file
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index a5a9a38ed53..aa4b73edc1a 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -3,34 +3,34 @@ impl<T> [T] {
     /// new slice with a length one greater than the
     /// original unmodified slice.
     #[builtin(slice_push_back)]
-    pub fn push_back(_self: Self, _elem: T) -> Self { }
+    pub fn push_back(self, elem: T) -> Self { }
 
     /// Push a new element to the front of the slice, returning a
     /// new slice with a length one greater than the 
     /// original unmodified slice. 
     #[builtin(slice_push_front)]
-    pub fn push_front(_self: Self, _elem: T) -> Self { }
+    pub fn push_front(self, elem: T) -> Self { }
 
     /// Remove the last element of the slice, returning the
     /// popped slice and the element in a tuple
     #[builtin(slice_pop_back)]
-    pub fn pop_back(_self: Self) -> (Self, T) { }
+    pub fn pop_back(self) -> (Self, T) { }
 
     /// Remove the first element of the slice, returning the
     /// element and the popped slice in a tuple
     #[builtin(slice_pop_front)]
-    pub fn pop_front(_self: Self) -> (T, Self) { }
+    pub fn pop_front(self) -> (T, Self) { }
 
     /// Insert an element at a specified index, shifting all elements 
     /// after it to the right
     #[builtin(slice_insert)]
-    pub fn insert(_self: Self, _index: Field, _elem: T) -> Self { }
+    pub fn insert(self, index: Field, elem: T) -> Self { }
 
     /// Remove an element at a specified index, shifting all elements
     /// after it to the left, returning the altered slice and 
     /// the removed element
     #[builtin(slice_remove)]
-    pub fn remove(_self: Self, _index: Field) -> (Self, T) { }
+    pub fn remove(self, index: Field) -> (Self, T) { }
 
     // Append each element of the `other` slice to the end of `self`.
     // This returns a new slice and leaves both input slices unchanged.
diff --git a/noir_stdlib/src/string.nr b/noir_stdlib/src/string.nr
index e402abf9ab6..ad6fd19e2de 100644
--- a/noir_stdlib/src/string.nr
+++ b/noir_stdlib/src/string.nr
@@ -2,7 +2,7 @@ use crate::collections::vec::Vec;
 impl<N> str<N> {
     /// Converts the given string into a byte array
     #[builtin(str_as_bytes)]
-    pub fn as_bytes(_self: Self) -> [u8; N] { }
+    pub fn as_bytes(self) -> [u8; N] { }
 
     /// return a byte vector of the str content
     pub fn as_bytes_vec(self: Self) -> Vec<u8> {
diff --git a/noir_stdlib/src/test.nr b/noir_stdlib/src/test.nr
index 47b31f4acea..560cfde741c 100644
--- a/noir_stdlib/src/test.nr
+++ b/noir_stdlib/src/test.nr
@@ -1,17 +1,17 @@
 #[oracle(create_mock)]
-unconstrained fn create_mock_oracle<N>(_name: str<N>) -> Field {}
+unconstrained fn create_mock_oracle<N>(name: str<N>) -> Field {}
 
 #[oracle(set_mock_params)]
-unconstrained fn set_mock_params_oracle<P>(_id: Field, _params: P) {}
+unconstrained fn set_mock_params_oracle<P>(id: Field, params: P) {}
 
 #[oracle(set_mock_returns)]
-unconstrained fn set_mock_returns_oracle<R>(_id: Field, _returns: R) {}
+unconstrained fn set_mock_returns_oracle<R>(id: Field, returns: R) {}
 
 #[oracle(set_mock_times)]
-unconstrained fn set_mock_times_oracle(_id: Field, _times: u64) {}
+unconstrained fn set_mock_times_oracle(id: Field, times: u64) {}
 
 #[oracle(clear_mock)]
-unconstrained fn clear_mock_oracle(_id: Field) {}
+unconstrained fn clear_mock_oracle(id: Field) {}
 
 struct OracleMock {
     id: Field,
diff --git a/noirc_macros/Cargo.toml b/noirc_macros/Cargo.toml
new file mode 100644
index 00000000000..699e6b01cae
--- /dev/null
+++ b/noirc_macros/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "noirc_macros"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+noirc_frontend.workspace = true
+iter-extended.workspace = true
\ No newline at end of file
diff --git a/noirc_macros/src/lib.rs b/noirc_macros/src/lib.rs
new file mode 100644
index 00000000000..4337214d69f
--- /dev/null
+++ b/noirc_macros/src/lib.rs
@@ -0,0 +1,61 @@
+use noirc_frontend::macros_api::parse_program;
+use noirc_frontend::macros_api::HirContext;
+use noirc_frontend::macros_api::SortedModule;
+use noirc_frontend::macros_api::{CrateId, FileId};
+use noirc_frontend::macros_api::{MacroError, MacroProcessor};
+
+pub struct AssertMessageMacro;
+
+impl MacroProcessor for AssertMessageMacro {
+    fn process_untyped_ast(
+        &self,
+        ast: SortedModule,
+        crate_id: &CrateId,
+        _context: &HirContext,
+    ) -> Result<SortedModule, (MacroError, FileId)> {
+        transform(ast, crate_id)
+    }
+
+    // This macro does not need to process any information after name resolution
+    fn process_typed_ast(
+        &self,
+        _crate_id: &CrateId,
+        _context: &mut HirContext,
+    ) -> Result<(), (MacroError, FileId)> {
+        Ok(())
+    }
+}
+
+fn transform(ast: SortedModule, crate_id: &CrateId) -> Result<SortedModule, (MacroError, FileId)> {
+    let ast = add_resolve_assert_message_funcs(ast, crate_id)?;
+
+    Ok(ast)
+}
+
+fn add_resolve_assert_message_funcs(
+    mut ast: SortedModule,
+    crate_id: &CrateId,
+) -> Result<SortedModule, (MacroError, FileId)> {
+    if !crate_id.is_stdlib() {
+        return Ok(ast);
+    }
+    let assert_message_oracles = "
+    #[oracle(assert_message)]
+    unconstrained fn assert_message_oracle<T>(_input: T) {}
+    unconstrained pub fn resolve_assert_message<T>(input: T, condition: bool) {
+        if !condition {
+            assert_message_oracle(input);
+        }
+    }";
+
+    let (assert_msg_funcs_ast, errors) = parse_program(assert_message_oracles);
+    assert_eq!(errors.len(), 0, "Failed to parse Noir macro code. This is either a bug in the compiler or the Noir macro code");
+
+    let assert_msg_funcs_ast = assert_msg_funcs_ast.into_sorted();
+
+    for func in assert_msg_funcs_ast.functions {
+        ast.functions.push(func)
+    }
+
+    Ok(ast)
+}
diff --git a/scripts/bootstrap_native.sh b/scripts/bootstrap_native.sh
index 3e0e2ed853a..974f0edcfec 100755
--- a/scripts/bootstrap_native.sh
+++ b/scripts/bootstrap_native.sh
@@ -12,6 +12,12 @@ else
   export GIT_COMMIT=$(git rev-parse --verify HEAD)
 fi
 
+# Check if the 'cargo' command is available in the system
+if ! command -v cargo > /dev/null; then
+    echo "Cargo is not installed. Please install Cargo and the Rust toolchain."
+    exit 1
+fi
+
 # Build native.
 if [ -n "${DEBUG:-}" ]; then
   cargo build
diff --git a/test_programs/compile_failure/assert_msg_runtime/Nargo.toml b/test_programs/compile_failure/assert_msg_runtime/Nargo.toml
new file mode 100644
index 00000000000..765f632ff74
--- /dev/null
+++ b/test_programs/compile_failure/assert_msg_runtime/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "assert_msg_runtime"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/assert_msg_runtime/Prover.toml b/test_programs/compile_failure/assert_msg_runtime/Prover.toml
new file mode 100644
index 00000000000..f28f2f8cc48
--- /dev/null
+++ b/test_programs/compile_failure/assert_msg_runtime/Prover.toml
@@ -0,0 +1,2 @@
+x = "5"
+y = "10"
diff --git a/test_programs/compile_failure/assert_msg_runtime/src/main.nr b/test_programs/compile_failure/assert_msg_runtime/src/main.nr
new file mode 100644
index 00000000000..bec3082550a
--- /dev/null
+++ b/test_programs/compile_failure/assert_msg_runtime/src/main.nr
@@ -0,0 +1,7 @@
+fn main(x: Field, y: pub Field) {
+    assert(x != y, f"Expected x != y, but got both equal {x}");
+    assert(x != y);
+    let z = x + y;
+    assert(z != y, f"Expected z != y, but got both equal {z}");
+    assert_eq(x, y, f"Expected x == y, but x is {x} and y is {y}");
+}
\ No newline at end of file
diff --git a/test_programs/compile_failure/brillig_assert_msg_runtime/Nargo.toml b/test_programs/compile_failure/brillig_assert_msg_runtime/Nargo.toml
new file mode 100644
index 00000000000..00f97b7273a
--- /dev/null
+++ b/test_programs/compile_failure/brillig_assert_msg_runtime/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "brillig_assert_msg_runtime"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/brillig_assert_msg_runtime/Prover.toml b/test_programs/compile_failure/brillig_assert_msg_runtime/Prover.toml
new file mode 100644
index 00000000000..0e5dfd5638d
--- /dev/null
+++ b/test_programs/compile_failure/brillig_assert_msg_runtime/Prover.toml
@@ -0,0 +1 @@
+x = "5"
diff --git a/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr b/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr
new file mode 100644
index 00000000000..428b2006363
--- /dev/null
+++ b/test_programs/compile_failure/brillig_assert_msg_runtime/src/main.nr
@@ -0,0 +1,10 @@
+fn main(x: Field) {
+    assert(1 == conditional(x));
+}
+
+unconstrained fn conditional(x: Field) -> Field {
+    let z = x as u8 + 20;
+    assert_eq(z, 25, f"Expected 25 but got {z}");
+    assert(x == 10, f"Expected x to equal 10, but got {x}");
+    1
+}
\ No newline at end of file
diff --git a/test_programs/compile_failure/builtin_function_declaration/Nargo.toml b/test_programs/compile_failure/builtin_function_declaration/Nargo.toml
new file mode 100644
index 00000000000..3835292a6ba
--- /dev/null
+++ b/test_programs/compile_failure/builtin_function_declaration/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "builtin_function_declaration"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
diff --git a/test_programs/compile_failure/builtin_function_declaration/src/main.nr b/test_programs/compile_failure/builtin_function_declaration/src/main.nr
new file mode 100644
index 00000000000..ed376557371
--- /dev/null
+++ b/test_programs/compile_failure/builtin_function_declaration/src/main.nr
@@ -0,0 +1,10 @@
+// This test prevents users from trying to create their own builtin functions as these should only exist in the stdlib.
+
+// This would otherwise be a perfectly valid declaration of the `to_le_bits` builtin function
+#[builtin(to_le_bits)]
+fn to_le_bits(_x: Field, _bit_size: u32) -> [u1] {}
+
+fn main(x: Field) -> pub u1 {
+    let bits = to_le_bits(x, 100);
+    bits[0]
+}
diff --git a/test_programs/compile_failure/foreign_function_declaration/Nargo.toml b/test_programs/compile_failure/foreign_function_declaration/Nargo.toml
new file mode 100644
index 00000000000..951658d7fb8
--- /dev/null
+++ b/test_programs/compile_failure/foreign_function_declaration/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "foreign_function_declaration"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
diff --git a/test_programs/compile_failure/foreign_function_declaration/src/main.nr b/test_programs/compile_failure/foreign_function_declaration/src/main.nr
new file mode 100644
index 00000000000..6273067f6a7
--- /dev/null
+++ b/test_programs/compile_failure/foreign_function_declaration/src/main.nr
@@ -0,0 +1,10 @@
+// This test prevents users from trying to create their own blackbox functions as these should only exist in the stdlib.
+
+// This would otherwise be a perfectly valid definition of the `pedersen_hash` black box function,
+// however executing the circuit results in an unhelpful ICE.
+#[foreign(pedersen_hash)]
+fn my_pedersen_hash<N>(_input: [Field; N]) -> Field {}
+
+fn main() -> pub Field {
+    my_pedersen_hash([1])
+}
diff --git a/test_programs/compile_failure/option_expect/Nargo.toml b/test_programs/compile_failure/option_expect/Nargo.toml
new file mode 100644
index 00000000000..1ee1215ff71
--- /dev/null
+++ b/test_programs/compile_failure/option_expect/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "option_expect"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/option_expect/src/main.nr b/test_programs/compile_failure/option_expect/src/main.nr
new file mode 100644
index 00000000000..439ce4f386e
--- /dev/null
+++ b/test_programs/compile_failure/option_expect/src/main.nr
@@ -0,0 +1,8 @@
+fn main() {
+    let inner_value = 3;
+    let none = Option::none();
+    let some = Option::some(inner_value);
+
+    assert(some.expect(f"Should have the value {inner_value}") == 3);
+    assert(none.expect(f"Should have the value {inner_value}") == 3);
+}
diff --git a/test_programs/compile_failure/option_expect_bad_input/Nargo.toml b/test_programs/compile_failure/option_expect_bad_input/Nargo.toml
new file mode 100644
index 00000000000..0555681e188
--- /dev/null
+++ b/test_programs/compile_failure/option_expect_bad_input/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "option_expect_bad_input"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/option_expect_bad_input/src/main.nr b/test_programs/compile_failure/option_expect_bad_input/src/main.nr
new file mode 100644
index 00000000000..cc93e767975
--- /dev/null
+++ b/test_programs/compile_failure/option_expect_bad_input/src/main.nr
@@ -0,0 +1,6 @@
+fn main() {
+    let inner_value = 3;
+    let some = Option::some(inner_value);
+
+    assert(some.expect("Should have the value {inner_value}") == 3);
+}
diff --git a/test_programs/compile_success_empty/method_call_regression/Nargo.toml b/test_programs/compile_success_empty/method_call_regression/Nargo.toml
index 92c9b942008..09f95590aad 100644
--- a/test_programs/compile_success_empty/method_call_regression/Nargo.toml
+++ b/test_programs/compile_success_empty/method_call_regression/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "short"
+name = "method_call_regression"
 type = "bin"
 authors = [""]
 compiler_version = ">=0.19.4"
diff --git a/test_programs/compile_success_empty/option/src/main.nr b/test_programs/compile_success_empty/option/src/main.nr
index 1f879bd375f..989c8f65bf4 100644
--- a/test_programs/compile_success_empty/option/src/main.nr
+++ b/test_programs/compile_success_empty/option/src/main.nr
@@ -1,5 +1,3 @@
-use dep::std::option::Option;
-
 fn main() {
     let ten = 10; // giving this a name, to ensure that the Option functions work with closures
     let none = Option::none();
@@ -22,6 +20,8 @@ fn main() {
     assert(some.map(|x| x * 2).unwrap() == 6);
     assert(some.map(|x| x * ten).unwrap() == 30);
 
+    assert(some.expect(f"Should have a value") == 3);
+
     assert(none.map_or(0, |x| x * 2) == 0);
     assert(some.map_or(0, |x| x * 2) == 6);
     assert(none.map_or(0, |x| x * ten) == 0);
diff --git a/test_programs/compile_success_empty/trait_static_methods/Nargo.toml b/test_programs/compile_success_empty/trait_static_methods/Nargo.toml
index 71c541ccd4f..ea30031b9a5 100644
--- a/test_programs/compile_success_empty/trait_static_methods/Nargo.toml
+++ b/test_programs/compile_success_empty/trait_static_methods/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "trait_self"
+name = "trait_static_methods"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/brillig_assert/src/main.nr b/test_programs/execution_success/brillig_assert/src/main.nr
index 91e4cebd9d3..16fe7b29061 100644
--- a/test_programs/execution_success/brillig_assert/src/main.nr
+++ b/test_programs/execution_success/brillig_assert/src/main.nr
@@ -6,7 +6,7 @@ fn main(x: Field) {
 }
 
 unconstrained fn conditional(x: bool) -> Field {
-    assert(x, "x is false");
-    assert_eq(x, true, "x is false");
+    assert(x, f"Expected x to be false but got {x}");
+    assert_eq(x, true, f"Expected x to be false but got {x}");
     1
 }
diff --git a/test_programs/execution_success/debug_logs/src/main.nr b/test_programs/execution_success/debug_logs/src/main.nr
index 52c910065c1..b640e4f5f0c 100644
--- a/test_programs/execution_success/debug_logs/src/main.nr
+++ b/test_programs/execution_success/debug_logs/src/main.nr
@@ -3,8 +3,15 @@ use dep::std;
 fn main(x: Field, y: pub Field) {
     let string = "i: {i}, j: {j}";
     std::println(string);
+
+    // TODO: fmtstr cannot be printed
+    // let fmt_str: fmtstr<14, (Field, Field)> = f"i: {x}, j: {y}";
+    // let fmt_fmt_str = f"fmtstr: {fmt_str}, i: {x}";
+    // std::println(fmt_fmt_str);
+
     // A `fmtstr` lets you easily perform string interpolation.
     let fmt_str: fmtstr<14, (Field, Field)> = f"i: {x}, j: {y}";
+
     let fmt_str = string_identity(fmt_str);
     std::println(fmt_str);
 
diff --git a/test_programs/execution_success/missing_closure_env/Nargo.toml b/test_programs/execution_success/missing_closure_env/Nargo.toml
new file mode 100644
index 00000000000..284e61b1144
--- /dev/null
+++ b/test_programs/execution_success/missing_closure_env/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "missing_closure_env"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/missing_closure_env/Prover.toml b/test_programs/execution_success/missing_closure_env/Prover.toml
new file mode 100644
index 00000000000..2d76abaa89f
--- /dev/null
+++ b/test_programs/execution_success/missing_closure_env/Prover.toml
@@ -0,0 +1 @@
+x = 42
diff --git a/test_programs/execution_success/missing_closure_env/src/main.nr b/test_programs/execution_success/missing_closure_env/src/main.nr
new file mode 100644
index 00000000000..0bc99b0671c
--- /dev/null
+++ b/test_programs/execution_success/missing_closure_env/src/main.nr
@@ -0,0 +1,16 @@
+fn main(x: Field) {
+    let x1 = &mut 42;
+    let set_x1 = |y| { *x1 = y; };
+
+    assert(*x1 == 42);
+    set_x1(44);
+    assert(*x1 == 44);
+    set_x1(*x1);
+    assert(*x1 == 44);
+    assert(x == 42);
+}
+
+#[test]
+fn test_main() {
+    main(42);
+}
diff --git a/test_programs/execution_success/scalar_mul/src/main.nr b/test_programs/execution_success/scalar_mul/src/main.nr
index 2ddf22cf71e..e20f47907db 100644
--- a/test_programs/execution_success/scalar_mul/src/main.nr
+++ b/test_programs/execution_success/scalar_mul/src/main.nr
@@ -20,4 +20,12 @@ fn main(
     let res = std::scalar_mul::fixed_base_embedded_curve(priv_key, 0);
     assert(res[0] == pub_x);
     assert(res[1] == pub_y);
+    let pub_point= std::scalar_mul::EmbeddedCurvePoint { x: pub_x, y: pub_y };
+    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
+    let g1= std::scalar_mul::EmbeddedCurvePoint { x: 1, y: g1_y };
+
+    let res = pub_point.double();
+    let double = g1.add(g1);
+
+    assert(double.x == res.x);
 }
diff --git a/test_programs/execution_success/u128/src/main.nr b/test_programs/execution_success/u128/src/main.nr
index 4c734f3a8f9..dc586408795 100644
--- a/test_programs/execution_success/u128/src/main.nr
+++ b/test_programs/execution_success/u128/src/main.nr
@@ -39,6 +39,6 @@ fn main(mut x: u32, y: u32, z: u32, big_int: U128, hexa: str<7>) {
     assert(shift >> small_int == small_int);
     assert(shift >> U128::from_integer(127) == U128::from_integer(0));
     assert(shift << U128::from_integer(127) == U128::from_integer(0));
-
+    assert(U128::from_integer(3).to_integer() == 3);
 }
 
diff --git a/test_programs/noir_test_success/bounded_vec/Nargo.toml b/test_programs/noir_test_success/bounded_vec/Nargo.toml
new file mode 100644
index 00000000000..0d58f5872ef
--- /dev/null
+++ b/test_programs/noir_test_success/bounded_vec/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bounded_vec"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/noir_test_success/bounded_vec/Prover.toml b/test_programs/noir_test_success/bounded_vec/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/noir_test_success/bounded_vec/src/main.nr b/test_programs/noir_test_success/bounded_vec/src/main.nr
new file mode 100644
index 00000000000..d51d2cc3685
--- /dev/null
+++ b/test_programs/noir_test_success/bounded_vec/src/main.nr
@@ -0,0 +1,105 @@
+#[test]
+fn test_vec_push_pop() {
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    assert(vec.len == 0);
+    vec.push(2);
+    assert(vec.len == 1);
+    vec.push(4);
+    assert(vec.len == 2);
+    vec.push(6);
+    assert(vec.len == 3);
+    let x = vec.pop();
+    assert(x == 6);
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+}
+
+#[test]
+fn test_vec_extend_from_array() {
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    vec.extend_from_array([2, 4]);
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+}
+
+#[test(should_fail_with="extend_from_array out of bounds")]
+fn test_vec_extend_from_array_out_of_bound() {
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    vec.extend_from_array([2, 4, 6]);
+}
+
+#[test(should_fail_with="extend_from_array out of bounds")]
+fn test_vec_extend_from_array_twice_out_of_bound() {
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    vec.extend_from_array([2]);
+    assert(vec.len == 1);
+    vec.extend_from_array([4, 6]);
+}
+
+#[test(should_fail)]
+fn test_vec_get_out_of_bound() {
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    vec.extend_from_array([2, 4]);
+    let _x = vec.get(2);
+}
+
+#[test(should_fail)]
+fn test_vec_get_not_declared() {
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    vec.extend_from_array([2]);
+    let _x = vec.get(1);
+}
+
+#[test(should_fail)]
+fn test_vec_get_uninitialized() {
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    let _x = vec.get(0);
+}
+
+#[test(should_fail_with="push out of bounds")]
+fn test_vec_push_out_of_bound() {
+    let mut vec: BoundedVec<Field, 1> = BoundedVec::new(0);
+    vec.push(1);
+    vec.push(2);
+}
+
+#[test(should_fail_with="extend_from_bounded_vec out of bounds")]
+fn test_vec_extend_from_bounded_vec_out_of_bound() {
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+
+    let mut another_vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    another_vec.extend_from_array([1, 2, 3]);
+
+    vec.extend_from_bounded_vec(another_vec);
+}
+
+#[test(should_fail_with="extend_from_bounded_vec out of bounds")]
+fn test_vec_extend_from_bounded_vec_twice_out_of_bound() {
+    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);
+    vec.extend_from_array([1, 2]);
+
+    let mut another_vec: BoundedVec<Field, 1> = BoundedVec::new(0);
+    another_vec.push(3);
+
+    vec.extend_from_bounded_vec(another_vec);
+}
+
+#[test]
+fn test_vec_any() {
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);
+    vec.extend_from_array([2, 4, 6]);
+    assert(vec.any(|v| v == 2) == true);
+    assert(vec.any(|v| v == 4) == true);
+    assert(vec.any(|v| v == 6) == true);
+    assert(vec.any(|v| v == 3) == false);
+}
+
+#[test]
+fn test_vec_any_not_default() {
+    let default_value = 1;
+    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(default_value);
+    vec.extend_from_array([2, 4]);
+    assert(vec.any(|v| v == default_value) == false);
+}
\ No newline at end of file
diff --git a/tooling/backend_interface/src/cli/mod.rs b/tooling/backend_interface/src/cli/mod.rs
index 3ea65f28103..b4dec859839 100644
--- a/tooling/backend_interface/src/cli/mod.rs
+++ b/tooling/backend_interface/src/cli/mod.rs
@@ -1,4 +1,4 @@
-// Reference: https://github.com/AztecProtocol/aztec-packages/blob/master/circuits/cpp/barretenberg/cpp/src/barretenberg/bb/main.cpp
+// Reference: https://github.com/AztecProtocol/aztec-packages/blob/master/barretenberg/cpp/src/barretenberg/bb/main.cpp
 
 mod contract;
 mod gates;
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index 18413f87793..6197f52cb4b 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.19.0";
+const VERSION: &str = "0.21.0";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index 12b55708b15..ab807c65a46 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -1,5 +1,6 @@
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap};
+use acvm::brillig_vm::brillig::ForeignCallResult;
 use acvm::brillig_vm::{brillig::Value, Registers};
 use acvm::pwg::{
     ACVMStatus, BrilligSolver, BrilligSolverStatus, ForeignCallWaitInfo, StepResult, ACVM,
@@ -224,6 +225,9 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         let foreign_call_result = self.foreign_call_executor.execute(&foreign_call);
         match foreign_call_result {
             Ok(foreign_call_result) => {
+                let foreign_call_result = foreign_call_result
+                    .get_brillig_output()
+                    .unwrap_or(ForeignCallResult::default());
                 if let Some(mut solver) = self.brillig_solver.take() {
                     solver.resolve_pending_foreign_call(foreign_call_result);
                     self.brillig_solver = Some(solver);
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index 6217b7ad71f..f001cebaa4d 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -49,12 +49,4 @@ impl BlackBoxFunctionSolver for WrapperSolver {
     ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
         self.0.ec_add(input1_x, input1_y, input2_x, input2_y)
     }
-
-    fn ec_double(
-        &self,
-        input_x: &acvm::FieldElement,
-        input_y: &acvm::FieldElement,
-    ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
-        self.0.ec_double(input_x, input_y)
-    }
 }
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 4fc7f7b599f..370393fea09 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -1,3 +1,4 @@
+use acvm::brillig_vm::brillig::ForeignCallResult;
 use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeResolutionError, ACVM};
 use acvm::BlackBoxFunctionSolver;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
@@ -5,7 +6,7 @@ use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 use crate::errors::ExecutionError;
 use crate::NargoError;
 
-use super::foreign_calls::ForeignCallExecutor;
+use super::foreign_calls::{ForeignCallExecutor, NargoForeignCallResult};
 
 #[tracing::instrument(level = "trace", skip_all)]
 pub fn execute_circuit<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
@@ -16,6 +17,8 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
 ) -> Result<WitnessMap, NargoError> {
     let mut acvm = ACVM::new(blackbox_solver, &circuit.opcodes, initial_witness);
 
+    // This message should be resolved by a nargo foreign call only when we have an unsatisfied assertion.
+    let mut assert_message: Option<String> = None;
     loop {
         let solver_status = acvm.solve();
 
@@ -37,7 +40,13 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
 
                 return Err(NargoError::ExecutionError(match call_stack {
                     Some(call_stack) => {
-                        if let Some(assert_message) = circuit.get_assert_message(
+                        // First check whether we have a runtime assertion message that should be resolved on an ACVM failure
+                        // If we do not have a runtime assertion message, we should check whether the circuit has any hardcoded
+                        // messages associated with a specific `OpcodeLocation`.
+                        // Otherwise return the provided opcode resolution error.
+                        if let Some(assert_message) = assert_message {
+                            ExecutionError::AssertionFailed(assert_message.to_owned(), call_stack)
+                        } else if let Some(assert_message) = circuit.get_assert_message(
                             *call_stack.last().expect("Call stacks should not be empty"),
                         ) {
                             ExecutionError::AssertionFailed(assert_message.to_owned(), call_stack)
@@ -50,7 +59,19 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
             }
             ACVMStatus::RequiresForeignCall(foreign_call) => {
                 let foreign_call_result = foreign_call_executor.execute(&foreign_call)?;
-                acvm.resolve_pending_foreign_call(foreign_call_result);
+                match foreign_call_result {
+                    NargoForeignCallResult::BrilligOutput(foreign_call_result) => {
+                        acvm.resolve_pending_foreign_call(foreign_call_result);
+                    }
+                    NargoForeignCallResult::ResolvedAssertMessage(message) => {
+                        if assert_message.is_some() {
+                            unreachable!("Resolving an assert message should happen only once as the VM should have failed");
+                        }
+                        assert_message = Some(message);
+
+                        acvm.resolve_pending_foreign_call(ForeignCallResult::default());
+                    }
+                }
             }
         }
     }
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
index e3a3174f8dc..f600b3047fc 100644
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ b/tooling/nargo/src/ops/foreign_calls.rs
@@ -9,13 +9,69 @@ pub trait ForeignCallExecutor {
     fn execute(
         &mut self,
         foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<ForeignCallResult, ForeignCallError>;
+    ) -> Result<NargoForeignCallResult, ForeignCallError>;
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum NargoForeignCallResult {
+    BrilligOutput(ForeignCallResult),
+    ResolvedAssertMessage(String),
+}
+
+impl NargoForeignCallResult {
+    pub fn get_assert_message(self) -> Option<String> {
+        match self {
+            Self::ResolvedAssertMessage(msg) => Some(msg),
+            _ => None,
+        }
+    }
+
+    pub fn get_brillig_output(self) -> Option<ForeignCallResult> {
+        match self {
+            Self::BrilligOutput(foreign_call_result) => Some(foreign_call_result),
+            _ => None,
+        }
+    }
+}
+
+impl From<ForeignCallResult> for NargoForeignCallResult {
+    fn from(value: ForeignCallResult) -> Self {
+        Self::BrilligOutput(value)
+    }
+}
+
+impl From<String> for NargoForeignCallResult {
+    fn from(value: String) -> Self {
+        Self::ResolvedAssertMessage(value)
+    }
+}
+
+impl From<Value> for NargoForeignCallResult {
+    fn from(value: Value) -> Self {
+        let foreign_call_result: ForeignCallResult = value.into();
+        foreign_call_result.into()
+    }
+}
+
+impl From<Vec<Value>> for NargoForeignCallResult {
+    fn from(values: Vec<Value>) -> Self {
+        let foreign_call_result: ForeignCallResult = values.into();
+        foreign_call_result.into()
+    }
+}
+
+impl From<Vec<ForeignCallParam>> for NargoForeignCallResult {
+    fn from(values: Vec<ForeignCallParam>) -> Self {
+        let foreign_call_result: ForeignCallResult = values.into();
+        foreign_call_result.into()
+    }
 }
 
 /// This enumeration represents the Brillig foreign calls that are natively supported by nargo.
 /// After resolution of a foreign call, nargo will restart execution of the ACVM
 pub(crate) enum ForeignCall {
     Print,
+    AssertMessage,
     CreateMock,
     SetMockParams,
     SetMockReturns,
@@ -33,6 +89,7 @@ impl ForeignCall {
     pub(crate) fn name(&self) -> &'static str {
         match self {
             ForeignCall::Print => "print",
+            ForeignCall::AssertMessage => "assert_message",
             ForeignCall::CreateMock => "create_mock",
             ForeignCall::SetMockParams => "set_mock_params",
             ForeignCall::SetMockReturns => "set_mock_returns",
@@ -44,6 +101,7 @@ impl ForeignCall {
     pub(crate) fn lookup(op_name: &str) -> Option<ForeignCall> {
         match op_name {
             "print" => Some(ForeignCall::Print),
+            "assert_message" => Some(ForeignCall::AssertMessage),
             "create_mock" => Some(ForeignCall::CreateMock),
             "set_mock_params" => Some(ForeignCall::SetMockParams),
             "set_mock_returns" => Some(ForeignCall::SetMockReturns),
@@ -134,29 +192,49 @@ impl DefaultForeignCallExecutor {
 
     fn execute_print(foreign_call_inputs: &[ForeignCallParam]) -> Result<(), ForeignCallError> {
         let skip_newline = foreign_call_inputs[0].unwrap_value().is_zero();
-        let display_values: PrintableValueDisplay = foreign_call_inputs
-            .split_first()
-            .ok_or(ForeignCallError::MissingForeignCallInputs)?
-            .1
-            .try_into()?;
-        print!("{display_values}{}", if skip_newline { "" } else { "\n" });
+
+        let foreign_call_inputs =
+            foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?.1;
+        let display_string = Self::format_printable_value(foreign_call_inputs, skip_newline)?;
+
+        print!("{display_string}");
+
         Ok(())
     }
+
+    fn execute_assert_message(
+        foreign_call_inputs: &[ForeignCallParam],
+    ) -> Result<NargoForeignCallResult, ForeignCallError> {
+        let display_string = Self::format_printable_value(foreign_call_inputs, true)?;
+        Ok(display_string.into())
+    }
+
+    fn format_printable_value(
+        foreign_call_inputs: &[ForeignCallParam],
+        skip_newline: bool,
+    ) -> Result<String, ForeignCallError> {
+        let display_values: PrintableValueDisplay = foreign_call_inputs.try_into()?;
+
+        let result = format!("{display_values}{}", if skip_newline { "" } else { "\n" });
+
+        Ok(result)
+    }
 }
 
 impl ForeignCallExecutor for DefaultForeignCallExecutor {
     fn execute(
         &mut self,
         foreign_call: &ForeignCallWaitInfo,
-    ) -> Result<ForeignCallResult, ForeignCallError> {
+    ) -> Result<NargoForeignCallResult, ForeignCallError> {
         let foreign_call_name = foreign_call.function.as_str();
         match ForeignCall::lookup(foreign_call_name) {
             Some(ForeignCall::Print) => {
                 if self.show_output {
                     Self::execute_print(&foreign_call.inputs)?;
                 }
-                Ok(ForeignCallResult { values: vec![] })
+                Ok(ForeignCallResult::default().into())
             }
+            Some(ForeignCall::AssertMessage) => Self::execute_assert_message(&foreign_call.inputs),
             Some(ForeignCall::CreateMock) => {
                 let mock_oracle_name = Self::parse_string(&foreign_call.inputs[0]);
                 assert!(ForeignCall::lookup(&mock_oracle_name).is_none());
@@ -164,7 +242,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                 self.mocked_responses.push(MockedCall::new(id, mock_oracle_name));
                 self.last_mock_id += 1;
 
-                Ok(ForeignCallResult { values: vec![Value::from(id).into()] })
+                Ok(Value::from(id).into())
             }
             Some(ForeignCall::SetMockParams) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
@@ -172,7 +250,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .params = Some(params.to_vec());
 
-                Ok(ForeignCallResult { values: vec![] })
+                Ok(ForeignCallResult::default().into())
             }
             Some(ForeignCall::SetMockReturns) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
@@ -180,7 +258,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .result = ForeignCallResult { values: params.to_vec() };
 
-                Ok(ForeignCallResult { values: vec![] })
+                Ok(ForeignCallResult::default().into())
             }
             Some(ForeignCall::SetMockTimes) => {
                 let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
@@ -194,12 +272,12 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                     .unwrap_or_else(|| panic!("Unknown mock id {}", id))
                     .times_left = Some(times);
 
-                Ok(ForeignCallResult { values: vec![] })
+                Ok(ForeignCallResult::default().into())
             }
             Some(ForeignCall::ClearMock) => {
                 let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
                 self.mocked_responses.retain(|response| response.id != id);
-                Ok(ForeignCallResult { values: vec![] })
+                Ok(ForeignCallResult::default().into())
             }
             None => {
                 let mock_response_position = self
@@ -222,7 +300,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
                             }
                         }
 
-                        Ok(ForeignCallResult { values: result })
+                        Ok(result.into())
                     }
                     (None, Some(external_resolver)) => {
                         let encoded_params: Vec<_> =
@@ -235,7 +313,7 @@ impl ForeignCallExecutor for DefaultForeignCallExecutor {
 
                         let parsed_response: ForeignCallResult = response.result()?;
 
-                        Ok(parsed_response)
+                        Ok(parsed_response.into())
                     }
                     (None, None) => panic!("Unknown foreign call {}", foreign_call_name),
                 }
@@ -312,7 +390,7 @@ mod tests {
         };
 
         let result = executor.execute(&foreign_call);
-        assert_eq!(result.unwrap(), ForeignCallResult { values: foreign_call.inputs });
+        assert_eq!(result.unwrap(), ForeignCallResult { values: foreign_call.inputs }.into());
 
         server.close();
     }
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
index 800a8656ef3..cfe5acb21a7 100644
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ b/tooling/nargo_fmt/src/visitor/stmt.rs
@@ -38,8 +38,7 @@ impl super::FmtVisitor<'_> {
 
                     nested_shape.indent.block_indent(self.config);
 
-                    let message =
-                        message.map_or(String::new(), |message| format!(", \"{message}\""));
+                    let message = message.map_or(String::new(), |message| format!(", {message}"));
 
                     let (callee, args) = match kind {
                         ConstrainKind::Assert => {
diff --git a/tooling/noir_js/src/witness_generation.ts b/tooling/noir_js/src/witness_generation.ts
index 1f233422061..cef1d817d9b 100644
--- a/tooling/noir_js/src/witness_generation.ts
+++ b/tooling/noir_js/src/witness_generation.ts
@@ -26,6 +26,12 @@ const defaultForeignCallHandler: ForeignCallHandler = async (name: string, args:
     //
     // If a user needs to print values then they should provide a custom foreign call handler.
     return [];
+  } else if (name == 'assert_message') {
+    // By default we do not do anything for `assert_message` foreign calls due to a need for formatting,
+    // however we provide an empty response in order to not halt execution.
+    //
+    // If a user needs to use dynamic assertion messages then they should provide a custom foreign call handler.
+    return [];
   }
   throw Error(`Unexpected oracle during execution: ${name}(${args.join(', ')})`);
 };
diff --git a/tooling/noir_js/test/node/execute.test.ts b/tooling/noir_js/test/node/execute.test.ts
index bfaf80882ab..491bcb0dfc4 100644
--- a/tooling/noir_js/test/node/execute.test.ts
+++ b/tooling/noir_js/test/node/execute.test.ts
@@ -1,9 +1,11 @@
 import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
+import assert_msg_json from '../noir_compiled_examples/assert_msg_runtime/target/assert_msg_runtime.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
 import { CompiledCircuit } from '@noir-lang/types';
 import { expect } from 'chai';
 
 const assert_lt_program = assert_lt_json as CompiledCircuit;
+const assert_msg_runtime = assert_msg_json as CompiledCircuit;
 
 it('returns the return value of the circuit', async () => {
   const inputs = {
@@ -14,3 +16,16 @@ it('returns the return value of the circuit', async () => {
 
   expect(returnValue).to.be.eq('0x05');
 });
+
+it('circuit with a dynamic assert message should fail on an assert failure not the foreign call handler', async () => {
+  const inputs = {
+    x: '10',
+    y: '5',
+  };
+  try {
+    await new Noir(assert_msg_runtime).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
+  }
+});
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr b/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
index 693e7285736..a9aaae5f2f7 100644
--- a/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
@@ -4,6 +4,10 @@ fn main(x: u64, y: pub u64) -> pub u64 {
     // We include a println statement to show that noirJS will ignore this and continue execution
     std::println("foo");
 
+    // A dynamic assertion message is used to show that noirJS will ignore the call and continue execution
+    // The assertion passes and thus the foreign call for resolving an assertion message should not be called.
+    assert(x < y, f"Expected x < y but got {x} < {y}");
+
     assert(x < y);
     x + y
 }
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_lt/target/assert_lt.json b/tooling/noir_js/test/noir_compiled_examples/assert_lt/target/assert_lt.json
index 5b511cdc140..027df0b39d9 100644
--- a/tooling/noir_js/test/noir_compiled_examples/assert_lt/target/assert_lt.json
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_lt/target/assert_lt.json
@@ -1 +1 @@
-{"noir_version":"0.20.0+010fdb69616f47fc0a9f252a65a903316d3cbe80","hash":17538653710107541030,"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"public"}],"param_witnesses":{"x":[{"start":1,"end":2}],"y":[{"start":2,"end":3}]},"return_type":{"abi_type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"public"},"return_witnesses":[5]},"bytecode":"H4sIAAAAAAAA/9Wa627aMBiGHcKhBBLOR+0Hl+Ak5PQP9U6gBK3SNqoqWm9kFzzMYu2DujhbPjvFEkrsJu/7vJ+TFDAtQkiH/GnG6VXLtxvQr+V9Mx/jx5pE3Db5lpZqYahI96Ba91e+bee1g60J6objS90mehbqN8nfuUbSpLAeNVAjXg++bZxeD/m+k9esjlyz6+t3A/p1MFfYvkyzharpPrXzmsFmXPU3YL8F8jUV5HvA1aRMs42qGe2YhgVqwuvH2Tvg721QLwu5Xgbw5Lq8bynz9Tye8Vb+joCjozF/R5lveJ7/riR/V8DR1Zi/q8w3TJiGLclvCzhsjfltZb5hyjQcSX5HwOFozO8o8w3XTKMnyd8TcPQ05od8RVmtilnxff0t0+hL8vcFHH2N+SFfUVarYlZ838hnGgNJ/oGAY6Ax/0CZb3R+rgwl+YcCjqHG/ENlvtH5fdVIkn8k4BhpzA/5irJ274jVrpgV3zeMmMZYkn8s4BhrzA/5irJaFbPi+3pPTGMiyT8RcEw05od8RVmtilnxfcPzXE0l+acCjqnG/FNlvmHANGaS/DMBx0xjfshXlNW+I9bRHbEOKmbF9w1jpjGX5J8LOOYa80O+oqzWHbH2KmbF9/XPnwUXkvwLAcdCY/6FMt9ozzSWkvxLAcdSY/4l8MVet3gAmV9en39kHKAOYPg+X2xlzQRjXOALOIeDtsj7hR60qpnk/eolAWNYPgbQ8k/fTK7TyEtd391SL9nFAV0HuzB2YzeIg70X+34ar+Mo2SURTdy1n7qHIPEPuVjt/7nc6wFBdDRtWFe46tgAE18D44/geLgCb4A5eQTniI4xPtBpgzF+vkMUXljQHEvTJJc/T+C6ZS8oE4+R8kmtk8vlWELwfxKg6qYqq9VErOet+v0jJ73idE3EzHXEeS1Rv5sPuM9839yaZ1quXdwntFxzMe+TBsF/7nDNj/6B8P0GuXz4848R/B3INsvS7y/ZKjuutvv96u05+7o6/kxfD9+Ob78Bhjydn08mAAA="}
\ No newline at end of file
+{"noir_version":"0.23.0+2dc4805116123ecde584fe0f2cd280de817d3915","hash":17955244824623030861,"abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"public"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":{"abi_type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"public"},"return_witnesses":[4]},"bytecode":"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","debug_symbols":"ndvNilVHFIbhezljCftbq/auqr6VkIEkBgTREJ1J33sSYjLQ/uE8Mx180OhLD55d6+vtw6df3355/+nj59vD11vdHn7+evv8x9uP//zt85e3f365PeRcb27vPv7295/mfHxz+/39h3e3h1GPv7y59VODcexvg5Hx3WDcOzjvHVz3Dua9g3XvYD85mP/9s47V3w1y3Luon578qeqY3ybV5/+TWv9O9v2Tp3+yOerbZl7zx01gU7Bp2AzYnLC5YDNhs2Cz798UdFDQQUEHBR0UdFDQQUEHBR0UdFDQQUMHDR00dNDQQUMHDR00dNDQQUMHDR0M6GBABwM6GNDBgA4GdDCggwEdDOhgQAcndHBCByd0cEIHJ3RwQgcndHBCByd0cEIHF3RwQQcXdHBBBxd0cEEHF3RwQQcXdHBBBxM6mNDBhA4mdDChgwkdTOhgQgcTOpjQwYIOFnSwoIMFHSzoYEEHCzpY0MGCDhZ0sKGDDR1s6GBDBxs62NDBhg42dLChgw0d5BBIOkSSDqGkQyzpEEw6RJMO4aRDPOkQUDqkCKNFKYJwkXSReJF8kYCRhJGIUYwxgowp0mYpQpwxAo0RaYxQY8QaI9gY0cYIN0a8MU0fIKQIIceIOUbQMaKOEXaMuGMEHiPyGKHHDPomJUWIPuZ+fpzPfMp66ePkfOZT1subOmAT2Dz5//rSZ9D5zCemVzYDNidsLthM2CzY7Ps3T//Of2UT2EAHDR00dNDQQUMHDR00dNDQwYAOBnQwoIMBHQzoYEAHAzoY0MGADgZ0cEIHJ3RwQgcndHBCByd0cEIHJ3RwQgcndHBBBxd0cEEHF3RwQQcXdHBBBxd0cEEHF3QwoYMJHUzoYEIHEzqY0MGEDiZ0MKGDCR0s6GBBBws6WNDBgg4WdLCggwUdLOhgQQcbOtjQwYYONnSwoYMNHWzoYEMHGzrY0MEzn5heG0VGJaOW0ZDRKaNLRlNGS0ZSRKSISBGRIiJFRIqIFBEpIlJEpIhIESVFlBQhzBhxxgg0RqQxQo0Ra4xgY0QbI9wY8cYIOEbEMUKOEXOMoGNEHSPsGHHHCDxG5DFCjxF7jOBjRB8j/BjxxwhARgQyQpARg4wgZEQhIwwZccgIREYkMkKREYuMYGREIyMcGfHICEhGRDJCkhGTjKBkRCUjLBlxyQhMRmQyQpMRm4zgZEQnIzwZ8ckIUEaEMkKUEaOMIGVEKSNMGXHKCFRGpDJClRGrjGBlRCsjXBnxyghYRsQyQpYRsywxyxKzLDHLErMsMcsSsywxyxKzLDHLErMsMcsSsywxyxKzLDHLErMsMcsSsywxyxKzLDHLErMsehpJbyPpcSS9jqTnkfQ+kh5IilmWmGWJWVbTY1kpQsyyxCxLzLLELEvMssQsS8yyxCxLzLIGvZ+WIsQsS8yyxCxLzLLELEvMssQsS8yyxCxLzLLELEvMssQsS8yyxCxLzLLELEvMssQsS8yyLrqykCLELEvMssQsS8yyxCxLzLLELEvMssQsa9LhjRQhZlliliVmWWKWJWZZYpYlZlliliVmWYtusaQIMcsSsywxyxKzLDHLErMsMcsSsywxy9p0nkf3eXKgJ2bZYpYtZtlili1m2WKWLWbZYpYtZtmhk00pQsyyxSxbzLLFLFvMssUsW8yyxSxbzLKLrnilCDHLFrNsMcsWs2wxyxazbLrqprNuuuu2w24pgk676babjrvpupvOu8UsW8yyxSxbzLIH3fpLEWKWLWbZYpZ9r1k+Pv4F","file_map":{"28":{"source":"mod hash;\nmod array;\nmod slice;\nmod merkle;\nmod schnorr;\nmod ecdsa_secp256k1;\nmod ecdsa_secp256r1;\nmod eddsa;\nmod grumpkin_scalar;\nmod grumpkin_scalar_mul;\nmod scalar_mul;\nmod sha256;\nmod sha512;\nmod field;\nmod ec;\nmod unsafe;\nmod collections;\nmod compat;\nmod convert;\nmod option;\nmod string;\nmod test;\nmod cmp;\nmod ops;\nmod default;\nmod prelude;\nmod uint128;\n// mod bigint;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained pub fn print<T>(input: T) {\n    print_oracle(false, input);\n}\n\nunconstrained pub fn println<T>(input: T) {\n    print_oracle(true, input);\n}\n\n#[foreign(recursive_aggregation)]\npub fn verify_proof<N>(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n// from_field and as_field are private since they are not valid for every type.\n// `as` should be the default for users to cast between primitive types, and in the future\n// traits can be used to work with generic types.\n#[builtin(from_field)]\nfn from_field<T>(x: Field) -> T {}\n\n#[builtin(as_field)]\nfn as_field<T>(x: T) -> Field {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T {\n    crate::from_field(crate::as_field(x) + crate::as_field(y))\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T {\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    crate::from_field(crate::as_field(x) + 340282366920938463463374607431768211456 - crate::as_field(y))\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T {\n    crate::from_field(crate::as_field(x) * crate::as_field(y))\n}\n","path":"std/lib.nr"},"42":{"source":"use dep::std;\n\nfn main(x: u64, y: pub u64) -> pub u64 {\n    // We include a println statement to show that noirJS will ignore this and continue execution\n    std::println(\"foo\");\n\n    // A dynamic assertion message is used to show that noirJS will ignore the call and continue execution\n    // The assertion passes and thus the foreign call for resolving an assertion message should not be called.\n    assert(x < y, f\"Expected x < y but got {x} < {y}\");\n\n    assert(x < y);\n    x + y\n}\n","path":"/mnt/user-data/maxim/noir/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr"}}}
\ No newline at end of file
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/Nargo.toml b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/Nargo.toml
new file mode 100644
index 00000000000..765f632ff74
--- /dev/null
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "assert_msg_runtime"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/src/main.nr b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/src/main.nr
new file mode 100644
index 00000000000..40e447cad02
--- /dev/null
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/src/main.nr
@@ -0,0 +1,6 @@
+fn main(x: u64, y: pub u64) {
+    // A dynamic assertion message is used to show that noirJS will ignore the call and continue execution
+    // We need this assertion to fail as the `assert_message` oracle in Noir is only called
+    // upon a failing condition in an assert.
+    assert(x < y, f"Expected x < y but got {x} < {y}");
+}
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/target/assert_msg_runtime.json b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/target/assert_msg_runtime.json
new file mode 100644
index 00000000000..300e9a06e13
--- /dev/null
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_msg_runtime/target/assert_msg_runtime.json
@@ -0,0 +1 @@
+{"noir_version":"0.23.0+2dc4805116123ecde584fe0f2cd280de817d3915","hash":8331765605233675558,"abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"public"}],"param_witnesses":{"x":[{"start":0,"end":1}],"y":[{"start":1,"end":2}]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2c2W6bQBSGwVviJBi870si9Z4dfFflQRrZDelVb+q+vxqWUU/wNEPrM0OPlJEsYDDnfP/PsHgG3NY07VrLi/76aRTzn8GyXiw3wXpY4DZpsS8rDozl2aHvJ5GbOJ5zsN39MQ5sPziGsRM7QRw8u7HnJbEfR/vjPrL3ju8lzkuw916KYPq/cznlCo50tNgNjp+p323Ovmm9fh7B93Uw1UGMR7AN7zv6H+J0OSw9sP5S8WdmMHFNEFMDJmDmgrEwG9elsVp4Gu33/PtLTrvE6TQQNTcR9+sF/p0djOUDb6fxCw67H8iJG8WS4tpy4oaSfAg9ST74xHyQxOtKag+y2q8sXu8rMX/3tHhDV5IPss6/xI63MJIU9+XD34z3KCmurOv8My1/yZ1/ZbUHSef18/aAF9t+c27XcWM7iLFsmZy6pobz0t9tDeR9k5anAjLtfGhrb0un+GB6nea5KvmT1rHOsAaoYx0iTVB3U8y3AKOGyujaHQ29jdldoK0N9DRLOrpA2xWoY9tcgzq4DZuybW5ALquY7xXbdHG1ZccP7MzUQQ7G0wTfGRXTVOcX/bf+awlczF8Wt1nysQO8wsnrBrA9a8AXrcTCyg1gwd43acxb3JjZ8XGHGjO/JhvAE+bfLZiy9XfALwPZLx3kZHHZsiEtr5tdh3sC/T0OR0+h/p60vGG2/02BfpPDYSrUb0rLG2b3jpZAv8XhsBTqt6TlDZM0Rl+gv8/h6CvU35eWN+8jHAj0DzgcA4X6IV9VVqNmVvy83iGNMRToH3I4hgr1Q76qrEbNrPh58z7GkUD/iMMxUqgf8lVltWpmxc8bZeNFY4H+MYdjrFA/5KvKatbMip8377OeCPRPOBwThfohX1VWq2ZW/Lz5uOZUoH/K4Zgq1A/5qrL2CbGahFitmlnx8+ZjVjOB/hmHY6ZQP+SryjohxDomxFq3r/h5o6yPaS7QP+dwzBXqh3xVWY2aWfHzutmY6kKgf8HhWCjUD/mqsho1s+LnjbJ74aVA/5LDsVSoH/JVZTUJsfYJsU5rZsXPG2bPwqwE+lccjpVC/ZCvKqtBiHVQMyt+Xi9MY6wF+tccjrVC/Wtpeb3sd8tGoH/D4dgo1L+Rljd/9mkr0L/lcGwV6t+CvDvUvPmzBDBvWt57lmAn0YM05j1uzOx5qQfAz7Teg2W2Ho77PyBr00FOFpctQ76qrAYh1h4hVpMQq0WItU+IldKxNSDESsnXISFWSueBESFWSteCMSFWSu11QoiV0jX24z5LDuuUECulY4vS+ZWSrzNCrJTuX+eEWCn5uiDESukaS+nehdI1dkmI9aPfRQ7rihDrmhDrpmZWCeMlTjr+xfrrD6dT8uPn0/fkdDp8SxgJfLu6UczvAGkLzMM3vjtgOzbK9gnU3ZbqNKAOvsl7pUn8yzoYUy/F/o9er7d1DueZKa/lFybuFpAIUgAA"}
\ No newline at end of file
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index cd2a6354ac4..a0123883efd 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.19.0",
+    "@aztec/bb.js": "0.21.0",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/yarn.lock b/yarn.lock
index db3f493bc62..743068f1907 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -235,9 +235,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.19.0":
-  version: 0.19.0
-  resolution: "@aztec/bb.js@npm:0.19.0"
+"@aztec/bb.js@npm:0.21.0":
+  version: 0.21.0
+  resolution: "@aztec/bb.js@npm:0.21.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -245,7 +245,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: c78c22c3b8c43e0010a43145f973489aa7da9fcf0b8527884107f1f34ac3ca5f5d4ab087d74ce50cb75d6dbaef88bfc693e23745282faa30b81dc78481c65874
+  checksum: a0fb97476f52025f3c31b7a5e890966ac375ed47c5cfd3434f5c3e4265af3c7566a162f37d6c56f394f44bfe4ba67e5002b7c5998ecc4f6abe70e04f5b8abe34
   languageName: node
   linkType: hard
 
@@ -4435,7 +4435,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.19.0
+    "@aztec/bb.js": 0.21.0
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3