diff --git a/acir_tests/run_acir_tests.sh b/acir_tests/run_acir_tests.sh
index 20845e978a..1deabdaf3e 100755
--- a/acir_tests/run_acir_tests.sh
+++ b/acir_tests/run_acir_tests.sh
@@ -7,7 +7,7 @@ set -e
 
 BB=$PWD/${BB:-../cpp/build/bin/bb}
 CRS_PATH=~/.bb-crs
-BRANCH=master
+BRANCH=kw/acvm-0-24
 
 # Pull down the test vectors from the noir repo, if we don't have the folder already.
 if [ ! -d acir_tests ]; then
@@ -29,7 +29,7 @@ fi
 cd acir_tests
 
 # Convert them to array
-skip_array=(diamond_deps_0 workspace workspace_default_member)
+skip_array=(diamond_deps_0 workspace workspace_default_member double_verify_proof)
 
 function test() {
   echo -n "Testing $1... "
diff --git a/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
index 34e87c391d..60ca1a2c07 100644
--- a/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
+++ b/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
@@ -755,31 +755,6 @@ struct Brillig {
     static Brillig bincodeDeserialize(std::vector<uint8_t>);
 };
 
-struct LogInfo {
-
-    struct FinalizedOutput {
-        std::string value;
-
-        friend bool operator==(const FinalizedOutput&, const FinalizedOutput&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static FinalizedOutput bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct WitnessOutput {
-        std::vector<Circuit::Witness> value;
-
-        friend bool operator==(const WitnessOutput&, const WitnessOutput&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static WitnessOutput bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    std::variant<FinalizedOutput, WitnessOutput> value;
-
-    friend bool operator==(const LogInfo&, const LogInfo&);
-    std::vector<uint8_t> bincodeSerialize() const;
-    static LogInfo bincodeDeserialize(std::vector<uint8_t>);
-};
-
 struct QuotientDirective {
     Circuit::Expression a;
     Circuit::Expression b;
@@ -794,15 +769,6 @@ struct QuotientDirective {
 
 struct Directive {
 
-    struct Invert {
-        Circuit::Witness x;
-        Circuit::Witness result;
-
-        friend bool operator==(const Invert&, const Invert&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static Invert bincodeDeserialize(std::vector<uint8_t>);
-    };
-
     struct Quotient {
         Circuit::QuotientDirective value;
 
@@ -832,15 +798,7 @@ struct Directive {
         static PermutationSort bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct Log {
-        Circuit::LogInfo value;
-
-        friend bool operator==(const Log&, const Log&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static Log bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    std::variant<Invert, Quotient, ToLeRadix, PermutationSort, Log> value;
+    std::variant<Quotient, ToLeRadix, PermutationSort> value;
 
     friend bool operator==(const Directive&, const Directive&);
     std::vector<uint8_t> bincodeSerialize() const;
@@ -894,6 +852,7 @@ struct Opcode {
     struct MemoryOp {
         Circuit::BlockId block_id;
         Circuit::MemOp op;
+        std::optional<Circuit::Expression> predicate;
 
         friend bool operator==(const MemoryOp&, const MemoryOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -916,6 +875,32 @@ struct Opcode {
     static Opcode bincodeDeserialize(std::vector<uint8_t>);
 };
 
+struct OpcodeLocation {
+
+    struct Acir {
+        uint64_t value;
+
+        friend bool operator==(const Acir&, const Acir&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Acir bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct Brillig {
+        uint64_t acir_index;
+        uint64_t brillig_index;
+
+        friend bool operator==(const Brillig&, const Brillig&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Brillig bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    std::variant<Acir, Brillig> value;
+
+    friend bool operator==(const OpcodeLocation&, const OpcodeLocation&);
+    std::vector<uint8_t> bincodeSerialize() const;
+    static OpcodeLocation bincodeDeserialize(std::vector<uint8_t>);
+};
+
 struct PublicInputs {
     std::vector<Circuit::Witness> value;
 
@@ -930,6 +915,7 @@ struct Circuit {
     std::vector<Witness> private_parameters;
     PublicInputs public_parameters;
     PublicInputs return_values;
+    std::vector<std::tuple<OpcodeLocation, std::string>> assert_messages;
 
     friend bool operator==(const Circuit&, const Circuit&);
     std::vector<uint8_t> bincodeSerialize() const;
@@ -4429,6 +4415,9 @@ inline bool operator==(const Circuit& lhs, const Circuit& rhs)
     if (!(lhs.return_values == rhs.return_values)) {
         return false;
     }
+    if (!(lhs.assert_messages == rhs.assert_messages)) {
+        return false;
+    }
     return true;
 }
 
@@ -4461,6 +4450,7 @@ void serde::Serializable<Circuit::Circuit>::serialize(const Circuit::Circuit& ob
     serde::Serializable<decltype(obj.private_parameters)>::serialize(obj.private_parameters, serializer);
     serde::Serializable<decltype(obj.public_parameters)>::serialize(obj.public_parameters, serializer);
     serde::Serializable<decltype(obj.return_values)>::serialize(obj.return_values, serializer);
+    serde::Serializable<decltype(obj.assert_messages)>::serialize(obj.assert_messages, serializer);
     serializer.decrease_container_depth();
 }
 
@@ -4475,6 +4465,7 @@ Circuit::Circuit serde::Deserializable<Circuit::Circuit>::deserialize(Deserializ
     obj.private_parameters = serde::Deserializable<decltype(obj.private_parameters)>::deserialize(deserializer);
     obj.public_parameters = serde::Deserializable<decltype(obj.public_parameters)>::deserialize(deserializer);
     obj.return_values = serde::Deserializable<decltype(obj.return_values)>::deserialize(deserializer);
+    obj.assert_messages = serde::Deserializable<decltype(obj.assert_messages)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
@@ -4530,57 +4521,6 @@ Circuit::Directive serde::Deserializable<Circuit::Directive>::deserialize(Deseri
 
 namespace Circuit {
 
-inline bool operator==(const Directive::Invert& lhs, const Directive::Invert& rhs)
-{
-    if (!(lhs.x == rhs.x)) {
-        return false;
-    }
-    if (!(lhs.result == rhs.result)) {
-        return false;
-    }
-    return true;
-}
-
-inline std::vector<uint8_t> Directive::Invert::bincodeSerialize() const
-{
-    auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Directive::Invert>::serialize(*this, serializer);
-    return std::move(serializer).bytes();
-}
-
-inline Directive::Invert Directive::Invert::bincodeDeserialize(std::vector<uint8_t> input)
-{
-    auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Directive::Invert>::deserialize(deserializer);
-    if (deserializer.get_buffer_offset() < input.size()) {
-        throw_or_abort("Some input bytes were not read");
-    }
-    return value;
-}
-
-} // end of namespace Circuit
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Circuit::Directive::Invert>::serialize(const Circuit::Directive::Invert& obj,
-                                                                Serializer& serializer)
-{
-    serde::Serializable<decltype(obj.x)>::serialize(obj.x, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Circuit::Directive::Invert serde::Deserializable<Circuit::Directive::Invert>::deserialize(Deserializer& deserializer)
-{
-    Circuit::Directive::Invert obj;
-    obj.x = serde::Deserializable<decltype(obj.x)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Circuit {
-
 inline bool operator==(const Directive::Quotient& lhs, const Directive::Quotient& rhs)
 {
     if (!(lhs.value == rhs.value)) {
@@ -4747,51 +4687,6 @@ Circuit::Directive::PermutationSort serde::Deserializable<Circuit::Directive::Pe
 
 namespace Circuit {
 
-inline bool operator==(const Directive::Log& lhs, const Directive::Log& rhs)
-{
-    if (!(lhs.value == rhs.value)) {
-        return false;
-    }
-    return true;
-}
-
-inline std::vector<uint8_t> Directive::Log::bincodeSerialize() const
-{
-    auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Directive::Log>::serialize(*this, serializer);
-    return std::move(serializer).bytes();
-}
-
-inline Directive::Log Directive::Log::bincodeDeserialize(std::vector<uint8_t> input)
-{
-    auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Directive::Log>::deserialize(deserializer);
-    if (deserializer.get_buffer_offset() < input.size()) {
-        throw_or_abort("Some input bytes were not read");
-    }
-    return value;
-}
-
-} // end of namespace Circuit
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Circuit::Directive::Log>::serialize(const Circuit::Directive::Log& obj, Serializer& serializer)
-{
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Circuit::Directive::Log serde::Deserializable<Circuit::Directive::Log>::deserialize(Deserializer& deserializer)
-{
-    Circuit::Directive::Log obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Circuit {
-
 inline bool operator==(const Expression& lhs, const Expression& rhs)
 {
     if (!(lhs.mul_terms == rhs.mul_terms)) {
@@ -5207,25 +5102,31 @@ Circuit::HeapVector serde::Deserializable<Circuit::HeapVector>::deserialize(Dese
 
 namespace Circuit {
 
-inline bool operator==(const LogInfo& lhs, const LogInfo& rhs)
+inline bool operator==(const MemOp& lhs, const MemOp& rhs)
 {
+    if (!(lhs.operation == rhs.operation)) {
+        return false;
+    }
+    if (!(lhs.index == rhs.index)) {
+        return false;
+    }
     if (!(lhs.value == rhs.value)) {
         return false;
     }
     return true;
 }
 
-inline std::vector<uint8_t> LogInfo::bincodeSerialize() const
+inline std::vector<uint8_t> MemOp::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<LogInfo>::serialize(*this, serializer);
+    serde::Serializable<MemOp>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline LogInfo LogInfo::bincodeDeserialize(std::vector<uint8_t> input)
+inline MemOp MemOp::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<LogInfo>::deserialize(deserializer);
+    auto value = serde::Deserializable<MemOp>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5236,19 +5137,23 @@ inline LogInfo LogInfo::bincodeDeserialize(std::vector<uint8_t> input)
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::LogInfo>::serialize(const Circuit::LogInfo& obj, Serializer& serializer)
+void serde::Serializable<Circuit::MemOp>::serialize(const Circuit::MemOp& obj, Serializer& serializer)
 {
     serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.operation)>::serialize(obj.operation, serializer);
+    serde::Serializable<decltype(obj.index)>::serialize(obj.index, serializer);
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
 }
 
 template <>
 template <typename Deserializer>
-Circuit::LogInfo serde::Deserializable<Circuit::LogInfo>::deserialize(Deserializer& deserializer)
+Circuit::MemOp serde::Deserializable<Circuit::MemOp>::deserialize(Deserializer& deserializer)
 {
     deserializer.increase_container_depth();
-    Circuit::LogInfo obj;
+    Circuit::MemOp obj;
+    obj.operation = serde::Deserializable<decltype(obj.operation)>::deserialize(deserializer);
+    obj.index = serde::Deserializable<decltype(obj.index)>::deserialize(deserializer);
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
@@ -5256,7 +5161,7 @@ Circuit::LogInfo serde::Deserializable<Circuit::LogInfo>::deserialize(Deserializ
 
 namespace Circuit {
 
-inline bool operator==(const LogInfo::FinalizedOutput& lhs, const LogInfo::FinalizedOutput& rhs)
+inline bool operator==(const Opcode& lhs, const Opcode& rhs)
 {
     if (!(lhs.value == rhs.value)) {
         return false;
@@ -5264,17 +5169,17 @@ inline bool operator==(const LogInfo::FinalizedOutput& lhs, const LogInfo::Final
     return true;
 }
 
-inline std::vector<uint8_t> LogInfo::FinalizedOutput::bincodeSerialize() const
+inline std::vector<uint8_t> Opcode::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<LogInfo::FinalizedOutput>::serialize(*this, serializer);
+    serde::Serializable<Opcode>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline LogInfo::FinalizedOutput LogInfo::FinalizedOutput::bincodeDeserialize(std::vector<uint8_t> input)
+inline Opcode Opcode::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<LogInfo::FinalizedOutput>::deserialize(deserializer);
+    auto value = serde::Deserializable<Opcode>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5285,25 +5190,27 @@ inline LogInfo::FinalizedOutput LogInfo::FinalizedOutput::bincodeDeserialize(std
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::LogInfo::FinalizedOutput>::serialize(const Circuit::LogInfo::FinalizedOutput& obj,
-                                                                       Serializer& serializer)
+void serde::Serializable<Circuit::Opcode>::serialize(const Circuit::Opcode& 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::LogInfo::FinalizedOutput serde::Deserializable<Circuit::LogInfo::FinalizedOutput>::deserialize(
-    Deserializer& deserializer)
+Circuit::Opcode serde::Deserializable<Circuit::Opcode>::deserialize(Deserializer& deserializer)
 {
-    Circuit::LogInfo::FinalizedOutput obj;
+    deserializer.increase_container_depth();
+    Circuit::Opcode obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const LogInfo::WitnessOutput& lhs, const LogInfo::WitnessOutput& rhs)
+inline bool operator==(const Opcode::Arithmetic& lhs, const Opcode::Arithmetic& rhs)
 {
     if (!(lhs.value == rhs.value)) {
         return false;
@@ -5311,17 +5218,17 @@ inline bool operator==(const LogInfo::WitnessOutput& lhs, const LogInfo::Witness
     return true;
 }
 
-inline std::vector<uint8_t> LogInfo::WitnessOutput::bincodeSerialize() const
+inline std::vector<uint8_t> Opcode::Arithmetic::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<LogInfo::WitnessOutput>::serialize(*this, serializer);
+    serde::Serializable<Opcode::Arithmetic>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline LogInfo::WitnessOutput LogInfo::WitnessOutput::bincodeDeserialize(std::vector<uint8_t> input)
+inline Opcode::Arithmetic Opcode::Arithmetic::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<LogInfo::WitnessOutput>::deserialize(deserializer);
+    auto value = serde::Deserializable<Opcode::Arithmetic>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5332,49 +5239,42 @@ inline LogInfo::WitnessOutput LogInfo::WitnessOutput::bincodeDeserialize(std::ve
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::LogInfo::WitnessOutput>::serialize(const Circuit::LogInfo::WitnessOutput& obj,
-                                                                     Serializer& serializer)
+void serde::Serializable<Circuit::Opcode::Arithmetic>::serialize(const Circuit::Opcode::Arithmetic& obj,
+                                                                 Serializer& serializer)
 {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::LogInfo::WitnessOutput serde::Deserializable<Circuit::LogInfo::WitnessOutput>::deserialize(
-    Deserializer& deserializer)
+Circuit::Opcode::Arithmetic serde::Deserializable<Circuit::Opcode::Arithmetic>::deserialize(Deserializer& deserializer)
 {
-    Circuit::LogInfo::WitnessOutput obj;
+    Circuit::Opcode::Arithmetic obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const MemOp& lhs, const MemOp& rhs)
+inline bool operator==(const Opcode::BlackBoxFuncCall& lhs, const Opcode::BlackBoxFuncCall& rhs)
 {
-    if (!(lhs.operation == rhs.operation)) {
-        return false;
-    }
-    if (!(lhs.index == rhs.index)) {
-        return false;
-    }
     if (!(lhs.value == rhs.value)) {
         return false;
     }
     return true;
 }
 
-inline std::vector<uint8_t> MemOp::bincodeSerialize() const
+inline std::vector<uint8_t> Opcode::BlackBoxFuncCall::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<MemOp>::serialize(*this, serializer);
+    serde::Serializable<Opcode::BlackBoxFuncCall>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline MemOp MemOp::bincodeDeserialize(std::vector<uint8_t> input)
+inline Opcode::BlackBoxFuncCall Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<MemOp>::deserialize(deserializer);
+    auto value = serde::Deserializable<Opcode::BlackBoxFuncCall>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5385,31 +5285,25 @@ inline MemOp MemOp::bincodeDeserialize(std::vector<uint8_t> input)
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::MemOp>::serialize(const Circuit::MemOp& obj, Serializer& serializer)
+void serde::Serializable<Circuit::Opcode::BlackBoxFuncCall>::serialize(const Circuit::Opcode::BlackBoxFuncCall& obj,
+                                                                       Serializer& serializer)
 {
-    serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.operation)>::serialize(obj.operation, serializer);
-    serde::Serializable<decltype(obj.index)>::serialize(obj.index, serializer);
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-    serializer.decrease_container_depth();
 }
 
 template <>
 template <typename Deserializer>
-Circuit::MemOp serde::Deserializable<Circuit::MemOp>::deserialize(Deserializer& deserializer)
+Circuit::Opcode::BlackBoxFuncCall serde::Deserializable<Circuit::Opcode::BlackBoxFuncCall>::deserialize(
+    Deserializer& deserializer)
 {
-    deserializer.increase_container_depth();
-    Circuit::MemOp obj;
-    obj.operation = serde::Deserializable<decltype(obj.operation)>::deserialize(deserializer);
-    obj.index = serde::Deserializable<decltype(obj.index)>::deserialize(deserializer);
+    Circuit::Opcode::BlackBoxFuncCall obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    deserializer.decrease_container_depth();
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const Opcode& lhs, const Opcode& rhs)
+inline bool operator==(const Opcode::Directive& lhs, const Opcode::Directive& rhs)
 {
     if (!(lhs.value == rhs.value)) {
         return false;
@@ -5417,17 +5311,17 @@ inline bool operator==(const Opcode& lhs, const Opcode& rhs)
     return true;
 }
 
-inline std::vector<uint8_t> Opcode::bincodeSerialize() const
+inline std::vector<uint8_t> Opcode::Directive::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Opcode>::serialize(*this, serializer);
+    serde::Serializable<Opcode::Directive>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline Opcode Opcode::bincodeDeserialize(std::vector<uint8_t> input)
+inline Opcode::Directive Opcode::Directive::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Opcode>::deserialize(deserializer);
+    auto value = serde::Deserializable<Opcode::Directive>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5438,27 +5332,24 @@ inline Opcode Opcode::bincodeDeserialize(std::vector<uint8_t> input)
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode>::serialize(const Circuit::Opcode& obj, Serializer& serializer)
+void serde::Serializable<Circuit::Opcode::Directive>::serialize(const Circuit::Opcode::Directive& 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::Opcode serde::Deserializable<Circuit::Opcode>::deserialize(Deserializer& deserializer)
+Circuit::Opcode::Directive serde::Deserializable<Circuit::Opcode::Directive>::deserialize(Deserializer& deserializer)
 {
-    deserializer.increase_container_depth();
-    Circuit::Opcode obj;
+    Circuit::Opcode::Directive obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    deserializer.decrease_container_depth();
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const Opcode::Arithmetic& lhs, const Opcode::Arithmetic& rhs)
+inline bool operator==(const Opcode::Brillig& lhs, const Opcode::Brillig& rhs)
 {
     if (!(lhs.value == rhs.value)) {
         return false;
@@ -5466,17 +5357,17 @@ inline bool operator==(const Opcode::Arithmetic& lhs, const Opcode::Arithmetic&
     return true;
 }
 
-inline std::vector<uint8_t> Opcode::Arithmetic::bincodeSerialize() const
+inline std::vector<uint8_t> Opcode::Brillig::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Opcode::Arithmetic>::serialize(*this, serializer);
+    serde::Serializable<Opcode::Brillig>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline Opcode::Arithmetic Opcode::Arithmetic::bincodeDeserialize(std::vector<uint8_t> input)
+inline Opcode::Brillig Opcode::Brillig::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Opcode::Arithmetic>::deserialize(deserializer);
+    auto value = serde::Deserializable<Opcode::Brillig>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5487,42 +5378,48 @@ inline Opcode::Arithmetic Opcode::Arithmetic::bincodeDeserialize(std::vector<uin
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Arithmetic>::serialize(const Circuit::Opcode::Arithmetic& obj,
-                                                                 Serializer& serializer)
+void serde::Serializable<Circuit::Opcode::Brillig>::serialize(const Circuit::Opcode::Brillig& obj,
+                                                              Serializer& serializer)
 {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Arithmetic serde::Deserializable<Circuit::Opcode::Arithmetic>::deserialize(Deserializer& deserializer)
+Circuit::Opcode::Brillig serde::Deserializable<Circuit::Opcode::Brillig>::deserialize(Deserializer& deserializer)
 {
-    Circuit::Opcode::Arithmetic obj;
+    Circuit::Opcode::Brillig obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const Opcode::BlackBoxFuncCall& lhs, const Opcode::BlackBoxFuncCall& rhs)
+inline bool operator==(const Opcode::MemoryOp& lhs, const Opcode::MemoryOp& rhs)
 {
-    if (!(lhs.value == rhs.value)) {
+    if (!(lhs.block_id == rhs.block_id)) {
+        return false;
+    }
+    if (!(lhs.op == rhs.op)) {
+        return false;
+    }
+    if (!(lhs.predicate == rhs.predicate)) {
         return false;
     }
     return true;
 }
 
-inline std::vector<uint8_t> Opcode::BlackBoxFuncCall::bincodeSerialize() const
+inline std::vector<uint8_t> Opcode::MemoryOp::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Opcode::BlackBoxFuncCall>::serialize(*this, serializer);
+    serde::Serializable<Opcode::MemoryOp>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline Opcode::BlackBoxFuncCall Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector<uint8_t> input)
+inline Opcode::MemoryOp Opcode::MemoryOp::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Opcode::BlackBoxFuncCall>::deserialize(deserializer);
+    auto value = serde::Deserializable<Opcode::MemoryOp>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5533,43 +5430,49 @@ inline Opcode::BlackBoxFuncCall Opcode::BlackBoxFuncCall::bincodeDeserialize(std
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::BlackBoxFuncCall>::serialize(const Circuit::Opcode::BlackBoxFuncCall& obj,
-                                                                       Serializer& serializer)
+void serde::Serializable<Circuit::Opcode::MemoryOp>::serialize(const Circuit::Opcode::MemoryOp& obj,
+                                                               Serializer& serializer)
 {
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
+    serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
+    serde::Serializable<decltype(obj.predicate)>::serialize(obj.predicate, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::BlackBoxFuncCall serde::Deserializable<Circuit::Opcode::BlackBoxFuncCall>::deserialize(
-    Deserializer& deserializer)
+Circuit::Opcode::MemoryOp serde::Deserializable<Circuit::Opcode::MemoryOp>::deserialize(Deserializer& deserializer)
 {
-    Circuit::Opcode::BlackBoxFuncCall obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    Circuit::Opcode::MemoryOp obj;
+    obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
+    obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
+    obj.predicate = serde::Deserializable<decltype(obj.predicate)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const Opcode::Directive& lhs, const Opcode::Directive& rhs)
+inline bool operator==(const Opcode::MemoryInit& lhs, const Opcode::MemoryInit& rhs)
 {
-    if (!(lhs.value == rhs.value)) {
+    if (!(lhs.block_id == rhs.block_id)) {
+        return false;
+    }
+    if (!(lhs.init == rhs.init)) {
         return false;
     }
     return true;
 }
 
-inline std::vector<uint8_t> Opcode::Directive::bincodeSerialize() const
+inline std::vector<uint8_t> Opcode::MemoryInit::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Opcode::Directive>::serialize(*this, serializer);
+    serde::Serializable<Opcode::MemoryInit>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline Opcode::Directive Opcode::Directive::bincodeDeserialize(std::vector<uint8_t> input)
+inline Opcode::MemoryInit Opcode::MemoryInit::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Opcode::Directive>::deserialize(deserializer);
+    auto value = serde::Deserializable<Opcode::MemoryInit>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5580,24 +5483,26 @@ inline Opcode::Directive Opcode::Directive::bincodeDeserialize(std::vector<uint8
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Directive>::serialize(const Circuit::Opcode::Directive& obj,
-                                                                Serializer& serializer)
+void serde::Serializable<Circuit::Opcode::MemoryInit>::serialize(const Circuit::Opcode::MemoryInit& obj,
+                                                                 Serializer& serializer)
 {
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
+    serde::Serializable<decltype(obj.init)>::serialize(obj.init, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Directive serde::Deserializable<Circuit::Opcode::Directive>::deserialize(Deserializer& deserializer)
+Circuit::Opcode::MemoryInit serde::Deserializable<Circuit::Opcode::MemoryInit>::deserialize(Deserializer& deserializer)
 {
-    Circuit::Opcode::Directive obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    Circuit::Opcode::MemoryInit obj;
+    obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
+    obj.init = serde::Deserializable<decltype(obj.init)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const Opcode::Brillig& lhs, const Opcode::Brillig& rhs)
+inline bool operator==(const OpcodeLocation& lhs, const OpcodeLocation& rhs)
 {
     if (!(lhs.value == rhs.value)) {
         return false;
@@ -5605,17 +5510,17 @@ inline bool operator==(const Opcode::Brillig& lhs, const Opcode::Brillig& rhs)
     return true;
 }
 
-inline std::vector<uint8_t> Opcode::Brillig::bincodeSerialize() const
+inline std::vector<uint8_t> OpcodeLocation::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Opcode::Brillig>::serialize(*this, serializer);
+    serde::Serializable<OpcodeLocation>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline Opcode::Brillig Opcode::Brillig::bincodeDeserialize(std::vector<uint8_t> input)
+inline OpcodeLocation OpcodeLocation::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Opcode::Brillig>::deserialize(deserializer);
+    auto value = serde::Deserializable<OpcodeLocation>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5626,45 +5531,45 @@ inline Opcode::Brillig Opcode::Brillig::bincodeDeserialize(std::vector<uint8_t>
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Brillig>::serialize(const Circuit::Opcode::Brillig& obj,
-                                                              Serializer& serializer)
+void serde::Serializable<Circuit::OpcodeLocation>::serialize(const Circuit::OpcodeLocation& 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::Opcode::Brillig serde::Deserializable<Circuit::Opcode::Brillig>::deserialize(Deserializer& deserializer)
+Circuit::OpcodeLocation serde::Deserializable<Circuit::OpcodeLocation>::deserialize(Deserializer& deserializer)
 {
-    Circuit::Opcode::Brillig obj;
+    deserializer.increase_container_depth();
+    Circuit::OpcodeLocation obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const Opcode::MemoryOp& lhs, const Opcode::MemoryOp& rhs)
+inline bool operator==(const OpcodeLocation::Acir& lhs, const OpcodeLocation::Acir& rhs)
 {
-    if (!(lhs.block_id == rhs.block_id)) {
-        return false;
-    }
-    if (!(lhs.op == rhs.op)) {
+    if (!(lhs.value == rhs.value)) {
         return false;
     }
     return true;
 }
 
-inline std::vector<uint8_t> Opcode::MemoryOp::bincodeSerialize() const
+inline std::vector<uint8_t> OpcodeLocation::Acir::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Opcode::MemoryOp>::serialize(*this, serializer);
+    serde::Serializable<OpcodeLocation::Acir>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline Opcode::MemoryOp Opcode::MemoryOp::bincodeDeserialize(std::vector<uint8_t> input)
+inline OpcodeLocation::Acir OpcodeLocation::Acir::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Opcode::MemoryOp>::deserialize(deserializer);
+    auto value = serde::Deserializable<OpcodeLocation::Acir>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5675,47 +5580,46 @@ inline Opcode::MemoryOp Opcode::MemoryOp::bincodeDeserialize(std::vector<uint8_t
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::MemoryOp>::serialize(const Circuit::Opcode::MemoryOp& obj,
-                                                               Serializer& serializer)
+void serde::Serializable<Circuit::OpcodeLocation::Acir>::serialize(const Circuit::OpcodeLocation::Acir& obj,
+                                                                   Serializer& serializer)
 {
-    serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
-    serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::MemoryOp serde::Deserializable<Circuit::Opcode::MemoryOp>::deserialize(Deserializer& deserializer)
+Circuit::OpcodeLocation::Acir serde::Deserializable<Circuit::OpcodeLocation::Acir>::deserialize(
+    Deserializer& deserializer)
 {
-    Circuit::Opcode::MemoryOp obj;
-    obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
-    obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
+    Circuit::OpcodeLocation::Acir obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Circuit {
 
-inline bool operator==(const Opcode::MemoryInit& lhs, const Opcode::MemoryInit& rhs)
+inline bool operator==(const OpcodeLocation::Brillig& lhs, const OpcodeLocation::Brillig& rhs)
 {
-    if (!(lhs.block_id == rhs.block_id)) {
+    if (!(lhs.acir_index == rhs.acir_index)) {
         return false;
     }
-    if (!(lhs.init == rhs.init)) {
+    if (!(lhs.brillig_index == rhs.brillig_index)) {
         return false;
     }
     return true;
 }
 
-inline std::vector<uint8_t> Opcode::MemoryInit::bincodeSerialize() const
+inline std::vector<uint8_t> OpcodeLocation::Brillig::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<Opcode::MemoryInit>::serialize(*this, serializer);
+    serde::Serializable<OpcodeLocation::Brillig>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline Opcode::MemoryInit Opcode::MemoryInit::bincodeDeserialize(std::vector<uint8_t> input)
+inline OpcodeLocation::Brillig OpcodeLocation::Brillig::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<Opcode::MemoryInit>::deserialize(deserializer);
+    auto value = serde::Deserializable<OpcodeLocation::Brillig>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -5726,20 +5630,21 @@ inline Opcode::MemoryInit Opcode::MemoryInit::bincodeDeserialize(std::vector<uin
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::MemoryInit>::serialize(const Circuit::Opcode::MemoryInit& obj,
-                                                                 Serializer& serializer)
+void serde::Serializable<Circuit::OpcodeLocation::Brillig>::serialize(const Circuit::OpcodeLocation::Brillig& obj,
+                                                                      Serializer& serializer)
 {
-    serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
-    serde::Serializable<decltype(obj.init)>::serialize(obj.init, serializer);
+    serde::Serializable<decltype(obj.acir_index)>::serialize(obj.acir_index, serializer);
+    serde::Serializable<decltype(obj.brillig_index)>::serialize(obj.brillig_index, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::MemoryInit serde::Deserializable<Circuit::Opcode::MemoryInit>::deserialize(Deserializer& deserializer)
+Circuit::OpcodeLocation::Brillig serde::Deserializable<Circuit::OpcodeLocation::Brillig>::deserialize(
+    Deserializer& deserializer)
 {
-    Circuit::Opcode::MemoryInit obj;
-    obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
-    obj.init = serde::Deserializable<decltype(obj.init)>::deserialize(deserializer);
+    Circuit::OpcodeLocation::Brillig obj;
+    obj.acir_index = serde::Deserializable<decltype(obj.acir_index)>::deserialize(deserializer);
+    obj.brillig_index = serde::Deserializable<decltype(obj.brillig_index)>::deserialize(deserializer);
     return obj;
 }
 
diff --git a/ts/Dockerfile b/ts/Dockerfile
index 14f47a9ea5..e664aebf15 100644
--- a/ts/Dockerfile
+++ b/ts/Dockerfile
@@ -14,8 +14,4 @@ COPY . .
 ENV DOCKER_ENV=true
 RUN yarn formatting && yarn build:ts:browser && yarn build:ts:node
 
-# Run bb.js binary tests
-WORKDIR /usr/src/barretenberg/ts/bin-test
-RUN ./bin-test.sh
-
 CMD ["yarn", "test"]
diff --git a/ts/package.json b/ts/package.json
index 5d0fda1ce7..4c36557654 100644
--- a/ts/package.json
+++ b/ts/package.json
@@ -30,7 +30,7 @@
     "serve": "webpack serve",
     "formatting": "prettier --check ./src && eslint --max-warnings 0 ./src",
     "formatting:fix": "prettier -w ./src",
-    "test": "yarn build:ts:browser && yarn build:ts:node && yarn test:jest && yarn test:bin",
+    "test": "yarn build:ts:browser && yarn build:ts:node && yarn test:jest",
     "test:jest": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --passWithNoTests",
     "test:bin": "cd ./bin-test && ./bin-test.sh",
     "test:debug": "NODE_NO_WARNINGS=1 node --inspect-brk=0.0.0.0 --experimental-vm-modules $(yarn bin jest) --no-cache --passWithNoTests --runInBand",