diff --git a/avm-transpiler/src/transpile_contract.rs b/avm-transpiler/src/transpile_contract.rs
index 10b9367a4abd..0c38dbe1e0b9 100644
--- a/avm-transpiler/src/transpile_contract.rs
+++ b/avm-transpiler/src/transpile_contract.rs
@@ -6,11 +6,8 @@ use serde::{Deserialize, Serialize};
 use acvm::acir::circuit::Program;
 use noirc_errors::debug_info::ProgramDebugInfo;
 
-use crate::transpile::{
-    brillig_to_avm, map_brillig_pcs_to_avm_pcs, patch_assert_message_pcs, patch_debug_info_pcs,
-};
-use crate::utils::{extract_brillig_from_acir_program, extract_static_assert_messages};
-use fxhash::FxHashMap as HashMap;
+use crate::transpile::{brillig_to_avm, map_brillig_pcs_to_avm_pcs, patch_debug_info_pcs};
+use crate::utils::extract_brillig_from_acir_program;
 
 /// Representation of a contract with some transpiled functions
 #[derive(Debug, Serialize, Deserialize)]
@@ -51,7 +48,6 @@ pub struct AvmContractFunctionArtifact {
     )]
     pub debug_symbols: ProgramDebugInfo,
     pub brillig_names: Vec<String>,
-    pub assert_messages: HashMap<usize, String>,
 }
 
 /// Representation of an ACIR contract function but with
@@ -96,16 +92,11 @@ impl From<CompiledAcirContractArtifact> for TranspiledContractArtifact {
                 // Extract Brillig Opcodes from acir
                 let acir_program = function.bytecode;
                 let brillig_bytecode = extract_brillig_from_acir_program(&acir_program);
-                let assert_messages = extract_static_assert_messages(&acir_program);
                 info!("Extracted Brillig program has {} instructions", brillig_bytecode.len());
 
                 // Map Brillig pcs to AVM pcs (index is Brillig PC, value is AVM PC)
                 let brillig_pcs_to_avm_pcs = map_brillig_pcs_to_avm_pcs(brillig_bytecode);
 
-                // Patch the assert messages with updated PCs
-                let assert_messages =
-                    patch_assert_message_pcs(assert_messages, &brillig_pcs_to_avm_pcs);
-
                 // Transpile to AVM
                 let avm_bytecode = brillig_to_avm(brillig_bytecode, &brillig_pcs_to_avm_pcs);
 
@@ -132,7 +123,6 @@ impl From<CompiledAcirContractArtifact> for TranspiledContractArtifact {
                         bytecode: base64::prelude::BASE64_STANDARD.encode(avm_bytecode),
                         debug_symbols: ProgramDebugInfo { debug_infos },
                         brillig_names: function.brillig_names,
-                        assert_messages,
                     },
                 ));
             } else {
diff --git a/avm-transpiler/src/utils.rs b/avm-transpiler/src/utils.rs
index 3f5269f5daa8..018276e4b6d9 100644
--- a/avm-transpiler/src/utils.rs
+++ b/avm-transpiler/src/utils.rs
@@ -1,11 +1,9 @@
-use fxhash::FxHashMap as HashMap;
-
 use acvm::acir::circuit::brillig::BrilligFunctionId;
 use acvm::{AcirField, FieldElement};
 use log::{debug, info, trace};
 
 use acvm::acir::brillig::Opcode as BrilligOpcode;
-use acvm::acir::circuit::{AssertionPayload, Opcode, Program};
+use acvm::acir::circuit::{Opcode, Program};
 
 use crate::instructions::{AvmInstruction, AvmOperand};
 use crate::opcodes::AvmOpcode;
@@ -39,33 +37,6 @@ pub fn extract_brillig_from_acir_program(
     &program.unconstrained_functions[0].bytecode
 }
 
-/// Assertion messages that are static strings are stored in the assert_messages map of the ACIR program.
-pub fn extract_static_assert_messages(program: &Program<FieldElement>) -> HashMap<usize, String> {
-    assert_eq!(
-        program.functions.len(),
-        1,
-        "An AVM program should have only a single ACIR function with a 'BrilligCall'"
-    );
-    let main_function = &program.functions[0];
-    main_function
-        .assert_messages
-        .iter()
-        .filter_map(|(location, payload)| {
-            if let AssertionPayload::StaticString(static_string) = payload {
-                Some((
-                    location
-                        .to_brillig_location()
-                        .expect("Assert message is not for the brillig function")
-                        .0,
-                    static_string.clone(),
-                ))
-            } else {
-                None
-            }
-        })
-        .collect()
-}
-
 /// Print inputs, outputs, and instructions in a Brillig program
 pub fn dbg_print_brillig_program(brillig_bytecode: &[BrilligOpcode<FieldElement>]) {
     trace!("Printing Brillig program...");
diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
index d02312f3d212..a96a5531a0e1 100644
--- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
+++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "barretenberg/common/throw_or_abort.hpp"
 #include "bincode.hpp"
 #include "serde.hpp"
 
@@ -1276,24 +1275,8 @@ struct ExpressionOrMemory {
 };
 
 struct AssertionPayload {
-
-    struct StaticString {
-        std::string value;
-
-        friend bool operator==(const StaticString&, const StaticString&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static StaticString bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    struct Dynamic {
-        std::tuple<uint64_t, std::vector<Program::ExpressionOrMemory>> value;
-
-        friend bool operator==(const Dynamic&, const Dynamic&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static Dynamic bincodeDeserialize(std::vector<uint8_t>);
-    };
-
-    std::variant<StaticString, Dynamic> value;
+    uint64_t error_selector;
+    std::vector<Program::ExpressionOrMemory> payload;
 
     friend bool operator==(const AssertionPayload&, const AssertionPayload&);
     std::vector<uint8_t> bincodeSerialize() const;
@@ -1394,7 +1377,10 @@ namespace Program {
 
 inline bool operator==(const AssertionPayload& lhs, const AssertionPayload& rhs)
 {
-    if (!(lhs.value == rhs.value)) {
+    if (!(lhs.error_selector == rhs.error_selector)) {
+        return false;
+    }
+    if (!(lhs.payload == rhs.payload)) {
         return false;
     }
     return true;
@@ -1425,7 +1411,8 @@ void serde::Serializable<Program::AssertionPayload>::serialize(const Program::As
                                                                Serializer& serializer)
 {
     serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serde::Serializable<decltype(obj.error_selector)>::serialize(obj.error_selector, serializer);
+    serde::Serializable<decltype(obj.payload)>::serialize(obj.payload, serializer);
     serializer.decrease_container_depth();
 }
 
@@ -1435,107 +1422,14 @@ Program::AssertionPayload serde::Deserializable<Program::AssertionPayload>::dese
 {
     deserializer.increase_container_depth();
     Program::AssertionPayload obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    obj.error_selector = serde::Deserializable<decltype(obj.error_selector)>::deserialize(deserializer);
+    obj.payload = serde::Deserializable<decltype(obj.payload)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
 namespace Program {
 
-inline bool operator==(const AssertionPayload::StaticString& lhs, const AssertionPayload::StaticString& rhs)
-{
-    if (!(lhs.value == rhs.value)) {
-        return false;
-    }
-    return true;
-}
-
-inline std::vector<uint8_t> AssertionPayload::StaticString::bincodeSerialize() const
-{
-    auto serializer = serde::BincodeSerializer();
-    serde::Serializable<AssertionPayload::StaticString>::serialize(*this, serializer);
-    return std::move(serializer).bytes();
-}
-
-inline AssertionPayload::StaticString AssertionPayload::StaticString::bincodeDeserialize(std::vector<uint8_t> input)
-{
-    auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<AssertionPayload::StaticString>::deserialize(deserializer);
-    if (deserializer.get_buffer_offset() < input.size()) {
-        throw_or_abort("Some input bytes were not read");
-    }
-    return value;
-}
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::AssertionPayload::StaticString>::serialize(
-    const Program::AssertionPayload::StaticString& obj, Serializer& serializer)
-{
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::AssertionPayload::StaticString serde::Deserializable<Program::AssertionPayload::StaticString>::deserialize(
-    Deserializer& deserializer)
-{
-    Program::AssertionPayload::StaticString obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-inline bool operator==(const AssertionPayload::Dynamic& lhs, const AssertionPayload::Dynamic& rhs)
-{
-    if (!(lhs.value == rhs.value)) {
-        return false;
-    }
-    return true;
-}
-
-inline std::vector<uint8_t> AssertionPayload::Dynamic::bincodeSerialize() const
-{
-    auto serializer = serde::BincodeSerializer();
-    serde::Serializable<AssertionPayload::Dynamic>::serialize(*this, serializer);
-    return std::move(serializer).bytes();
-}
-
-inline AssertionPayload::Dynamic AssertionPayload::Dynamic::bincodeDeserialize(std::vector<uint8_t> input)
-{
-    auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<AssertionPayload::Dynamic>::deserialize(deserializer);
-    if (deserializer.get_buffer_offset() < input.size()) {
-        throw_or_abort("Some input bytes were not read");
-    }
-    return value;
-}
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::AssertionPayload::Dynamic>::serialize(const Program::AssertionPayload::Dynamic& obj,
-                                                                        Serializer& serializer)
-{
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::AssertionPayload::Dynamic serde::Deserializable<Program::AssertionPayload::Dynamic>::deserialize(
-    Deserializer& deserializer)
-{
-    Program::AssertionPayload::Dynamic obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
 inline bool operator==(const BinaryFieldOp& lhs, const BinaryFieldOp& rhs)
 {
     if (!(lhs.value == rhs.value)) {
diff --git a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp
index 96d029a8f41e..8fa471e57bac 100644
--- a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp
+++ b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp
@@ -1216,24 +1216,8 @@ namespace Program {
     };
 
     struct AssertionPayload {
-
-        struct StaticString {
-            std::string value;
-
-            friend bool operator==(const StaticString&, const StaticString&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static StaticString bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct Dynamic {
-            std::tuple<uint64_t, std::vector<Program::ExpressionOrMemory>> value;
-
-            friend bool operator==(const Dynamic&, const Dynamic&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Dynamic bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        std::variant<StaticString, Dynamic> value;
+        uint64_t error_selector;
+        std::vector<Program::ExpressionOrMemory> payload;
 
         friend bool operator==(const AssertionPayload&, const AssertionPayload&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1334,7 +1318,8 @@ namespace Program {
 namespace Program {
 
     inline bool operator==(const AssertionPayload &lhs, const AssertionPayload &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
+        if (!(lhs.error_selector == rhs.error_selector)) { return false; }
+        if (!(lhs.payload == rhs.payload)) { return false; }
         return true;
     }
 
@@ -1359,7 +1344,8 @@ template <>
 template <typename Serializer>
 void serde::Serializable<Program::AssertionPayload>::serialize(const Program::AssertionPayload &obj, Serializer &serializer) {
     serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serde::Serializable<decltype(obj.error_selector)>::serialize(obj.error_selector, serializer);
+    serde::Serializable<decltype(obj.payload)>::serialize(obj.payload, serializer);
     serializer.decrease_container_depth();
 }
 
@@ -1368,87 +1354,12 @@ template <typename Deserializer>
 Program::AssertionPayload serde::Deserializable<Program::AssertionPayload>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
     Program::AssertionPayload obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    obj.error_selector = serde::Deserializable<decltype(obj.error_selector)>::deserialize(deserializer);
+    obj.payload = serde::Deserializable<decltype(obj.payload)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const AssertionPayload::StaticString &lhs, const AssertionPayload::StaticString &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> AssertionPayload::StaticString::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<AssertionPayload::StaticString>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline AssertionPayload::StaticString AssertionPayload::StaticString::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<AssertionPayload::StaticString>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::AssertionPayload::StaticString>::serialize(const Program::AssertionPayload::StaticString &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::AssertionPayload::StaticString serde::Deserializable<Program::AssertionPayload::StaticString>::deserialize(Deserializer &deserializer) {
-    Program::AssertionPayload::StaticString obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const AssertionPayload::Dynamic &lhs, const AssertionPayload::Dynamic &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> AssertionPayload::Dynamic::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<AssertionPayload::Dynamic>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline AssertionPayload::Dynamic AssertionPayload::Dynamic::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<AssertionPayload::Dynamic>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::AssertionPayload::Dynamic>::serialize(const Program::AssertionPayload::Dynamic &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::AssertionPayload::Dynamic serde::Deserializable<Program::AssertionPayload::Dynamic>::deserialize(Deserializer &deserializer) {
-    Program::AssertionPayload::Dynamic obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) {
diff --git a/noir/noir-repo/acvm-repo/acir/src/circuit/mod.rs b/noir/noir-repo/acvm-repo/acir/src/circuit/mod.rs
index eddf61be100d..12990f66175b 100644
--- a/noir/noir-repo/acvm-repo/acir/src/circuit/mod.rs
+++ b/noir/noir-repo/acvm-repo/acir/src/circuit/mod.rs
@@ -77,9 +77,9 @@ pub enum ExpressionOrMemory<F> {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AssertionPayload<F> {
-    StaticString(String),
-    Dynamic(/* error_selector */ u64, Vec<ExpressionOrMemory<F>>),
+pub struct AssertionPayload<F> {
+    pub error_selector: u64,
+    pub payload: Vec<ExpressionOrMemory<F>>,
 }
 
 #[derive(Debug, Copy, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
@@ -115,12 +115,6 @@ impl<'de> Deserialize<'de> for ErrorSelector {
     }
 }
 
-/// This selector indicates that the payload is a string.
-/// This is used to parse any error with a string payload directly,
-/// to avoid users having to parse the error externally to the ACVM.
-/// Only non-string errors need to be parsed externally to the ACVM using the circuit ABI.
-pub const STRING_ERROR_SELECTOR: ErrorSelector = ErrorSelector(0);
-
 #[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
 pub struct RawAssertionPayload<F> {
     pub selector: ErrorSelector,
diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/brillig.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/brillig.rs
index dffa45dbd7a5..a5f5783478ed 100644
--- a/noir/noir-repo/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/brillig.rs
@@ -6,7 +6,6 @@ use acir::{
         brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
         opcodes::BlockId,
         ErrorSelector, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
-        STRING_ERROR_SELECTOR,
     },
     native_types::WitnessMap,
     AcirField,
@@ -307,25 +306,10 @@ fn extract_failure_payload_from_memory<F: AcirField>(
                 .expect("Error selector is not u64"),
         );
 
-        match error_selector {
-            STRING_ERROR_SELECTOR => {
-                // If the error selector is 0, it means the error is a string
-                let string = revert_values_iter
-                    .map(|&memory_value| {
-                        let as_u8: u8 = memory_value.try_into().expect("String item is not u8");
-                        as_u8 as char
-                    })
-                    .collect();
-                Some(ResolvedAssertionPayload::String(string))
-            }
-            _ => {
-                // If the error selector is not 0, it means the error is a custom error
-                Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
-                    selector: error_selector,
-                    data: revert_values_iter.map(|value| value.to_field()).collect(),
-                }))
-            }
-        }
+        Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
+            selector: error_selector,
+            data: revert_values_iter.map(|value| value.to_field()).collect(),
+        }))
     }
 }
 
diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs
index fa3498da6138..e2b9ef1defaf 100644
--- a/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs
+++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs
@@ -10,7 +10,7 @@ use acir::{
             AcirFunctionId, BlockId, ConstantOrWitnessEnum, FunctionInput, InvalidInputBitSize,
         },
         AssertionPayload, ErrorSelector, ExpressionOrMemory, Opcode, OpcodeLocation,
-        RawAssertionPayload, ResolvedAssertionPayload, STRING_ERROR_SELECTOR,
+        RawAssertionPayload, ResolvedAssertionPayload,
     },
     native_types::{Expression, Witness, WitnessMap},
     AcirField, BlackBoxFunc,
@@ -445,59 +445,32 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
         &self,
         location: OpcodeLocation,
     ) -> Option<ResolvedAssertionPayload<F>> {
-        let (_, found_assertion_payload) =
+        let (_, assertion_descriptor) =
             self.assertion_payloads.iter().find(|(loc, _)| location == *loc)?;
-        match found_assertion_payload {
-            AssertionPayload::StaticString(string) => {
-                Some(ResolvedAssertionPayload::String(string.clone()))
-            }
-            AssertionPayload::Dynamic(error_selector, expression) => {
-                let mut fields = vec![];
-                for expr in expression {
-                    match expr {
-                        ExpressionOrMemory::Expression(expr) => {
-                            let value = get_value(expr, &self.witness_map).ok()?;
-                            fields.push(value);
-                        }
-                        ExpressionOrMemory::Memory(block_id) => {
-                            let memory_block = self.block_solvers.get(block_id)?;
-                            fields.extend((0..memory_block.block_len).map(|memory_index| {
-                                *memory_block
-                                    .block_value
-                                    .get(&memory_index)
-                                    .expect("All memory is initialized on creation")
-                            }));
-                        }
-                    }
+        let mut fields = Vec::new();
+        for expr in assertion_descriptor.payload.iter() {
+            match expr {
+                ExpressionOrMemory::Expression(expr) => {
+                    let value = get_value(expr, &self.witness_map).ok()?;
+                    fields.push(value);
+                }
+                ExpressionOrMemory::Memory(block_id) => {
+                    let memory_block = self.block_solvers.get(block_id)?;
+                    fields.extend((0..memory_block.block_len).map(|memory_index| {
+                        *memory_block
+                            .block_value
+                            .get(&memory_index)
+                            .expect("All memory is initialized on creation")
+                    }));
                 }
-                let error_selector = ErrorSelector::new(*error_selector);
-
-                Some(match error_selector {
-                    STRING_ERROR_SELECTOR => {
-                        // If the error selector is 0, it means the error is a string
-                        let string = fields
-                            .iter()
-                            .map(|field| {
-                                let as_u8: u8 = field
-                                    .try_to_u64()
-                                    .expect("String character doesn't fit in u64")
-                                    .try_into()
-                                    .expect("String character doesn't fit in u8");
-                                as_u8 as char
-                            })
-                            .collect();
-                        ResolvedAssertionPayload::String(string)
-                    }
-                    _ => {
-                        // If the error selector is not 0, it means the error is a custom error
-                        ResolvedAssertionPayload::Raw(RawAssertionPayload {
-                            selector: error_selector,
-                            data: fields,
-                        })
-                    }
-                })
             }
         }
+        let error_selector = ErrorSelector::new(assertion_descriptor.error_selector);
+
+        Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
+            selector: error_selector,
+            data: fields,
+        }))
     }
 
     fn solve_brillig_call_opcode(
@@ -530,7 +503,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
             )?,
         };
 
-        let result = solver.solve().map_err(|err| self.map_brillig_error(err))?;
+        let result = solver.solve()?;
 
         match result {
             BrilligSolverStatus::ForeignCallWait(foreign_call) => {
@@ -570,31 +543,6 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
         }
     }
 
-    fn map_brillig_error(&self, mut err: OpcodeResolutionError<F>) -> OpcodeResolutionError<F> {
-        match &mut err {
-            OpcodeResolutionError::BrilligFunctionFailed { call_stack, payload, .. } => {
-                // Some brillig errors have static strings as payloads, we can resolve them here
-                let last_location =
-                    call_stack.last().expect("Call stacks should have at least one item");
-                let assertion_descriptor =
-                    self.assertion_payloads.iter().find_map(|(loc, payload)| {
-                        if loc == last_location {
-                            Some(payload)
-                        } else {
-                            None
-                        }
-                    });
-
-                if let Some(AssertionPayload::StaticString(string)) = assertion_descriptor {
-                    *payload = Some(ResolvedAssertionPayload::String(string.clone()));
-                }
-
-                err
-            }
-            _ => err,
-        }
-    }
-
     pub fn step_into_brillig(&mut self) -> StepResult<'a, F, B> {
         let Opcode::BrilligCall { id, inputs, outputs, predicate } =
             &self.opcodes[self.instruction_pointer]
diff --git a/noir/noir-repo/compiler/noirc_driver/src/abi_gen.rs b/noir/noir-repo/compiler/noirc_driver/src/abi_gen.rs
index ad54d0f7d6bb..bf64c9c920c7 100644
--- a/noir/noir-repo/compiler/noirc_driver/src/abi_gen.rs
+++ b/noir/noir-repo/compiler/noirc_driver/src/abi_gen.rs
@@ -6,6 +6,7 @@ use iter_extended::vecmap;
 use noirc_abi::{
     Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue, AbiVisibility, Sign,
 };
+use noirc_evaluator::ErrorType;
 use noirc_frontend::ast::{Signedness, Visibility};
 use noirc_frontend::TypeBinding;
 use noirc_frontend::{
@@ -25,7 +26,7 @@ pub(super) fn gen_abi(
     context: &Context,
     func_id: &FuncId,
     return_visibility: Visibility,
-    error_types: BTreeMap<ErrorSelector, Type>,
+    error_types: BTreeMap<ErrorSelector, ErrorType>,
 ) -> Abi {
     let (parameters, return_type) = compute_function_abi(context, func_id);
     let return_type = return_type.map(|typ| AbiReturnType {
@@ -34,23 +35,27 @@ pub(super) fn gen_abi(
     });
     let error_types = error_types
         .into_iter()
-        .map(|(selector, typ)| (selector, build_abi_error_type(context, &typ)))
+        .map(|(selector, typ)| (selector, build_abi_error_type(context, typ)))
         .collect();
     Abi { parameters, return_type, error_types }
 }
 
-fn build_abi_error_type(context: &Context, typ: &Type) -> AbiErrorType {
+fn build_abi_error_type(context: &Context, typ: ErrorType) -> AbiErrorType {
     match typ {
-        Type::FmtString(len, item_types) => {
-            let length = len.evaluate_to_u32().expect("Cannot evaluate fmt length");
-            let Type::Tuple(item_types) = item_types.as_ref() else {
-                unreachable!("FmtString items must be a tuple")
-            };
-            let item_types =
-                item_types.iter().map(|typ| abi_type_from_hir_type(context, typ)).collect();
-            AbiErrorType::FmtString { length, item_types }
+        ErrorType::Dynamic(typ) => {
+            if let Type::FmtString(len, item_types) = typ {
+                let length = len.evaluate_to_u32().expect("Cannot evaluate fmt length");
+                let Type::Tuple(item_types) = item_types.as_ref() else {
+                    unreachable!("FmtString items must be a tuple")
+                };
+                let item_types =
+                    item_types.iter().map(|typ| abi_type_from_hir_type(context, typ)).collect();
+                AbiErrorType::FmtString { length, item_types }
+            } else {
+                AbiErrorType::Custom(abi_type_from_hir_type(context, &typ))
+            }
         }
-        _ => AbiErrorType::Custom(abi_type_from_hir_type(context, typ)),
+        ErrorType::String(string) => AbiErrorType::String { string },
     }
 }
 
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 23c802e3a146..48914c6219de 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -259,7 +259,7 @@ impl<'block> BrilligBlock<'block> {
                 };
 
                 match assert_message {
-                    Some(ConstrainError::Dynamic(selector, values)) => {
+                    Some(ConstrainError::Dynamic(selector, _, values)) => {
                         let payload_values =
                             vecmap(values, |value| self.convert_ssa_value(*value, dfg));
                         let payload_as_params = vecmap(values, |value| {
@@ -270,7 +270,7 @@ impl<'block> BrilligBlock<'block> {
                             condition,
                             payload_values,
                             payload_as_params,
-                            selector.as_u64(),
+                            *selector,
                         );
                     }
                     Some(ConstrainError::StaticString(message)) => {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
index f066d967e0d2..469f0b430d6d 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
@@ -67,7 +67,7 @@ pub(crate) fn directive_invert<F: AcirField>() -> GeneratedBrillig<F> {
             },
             BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 1 },
         ],
-        assert_messages: Default::default(),
+        error_types: Default::default(),
         locations: Default::default(),
         name: "directive_invert".to_string(),
     }
@@ -132,7 +132,7 @@ pub(crate) fn directive_quotient<F: AcirField>() -> GeneratedBrillig<F> {
             },
             BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 2 },
         ],
-        assert_messages: Default::default(),
+        error_types: Default::default(),
         locations: Default::default(),
         name: "directive_integer_quotient".to_string(),
     }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index d0bd91e185cb..fa98f960dc60 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -1,8 +1,10 @@
 use acvm::acir::brillig::Opcode as BrilligOpcode;
+use acvm::acir::circuit::ErrorSelector;
 use std::collections::{BTreeMap, HashMap};
 
 use crate::brillig::brillig_ir::procedures::ProcedureId;
 use crate::ssa::ir::{basic_block::BasicBlockId, dfg::CallStack, function::FunctionId};
+use crate::ErrorType;
 
 /// Represents a parameter or a return value of an entry point function.
 #[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
@@ -22,7 +24,7 @@ pub(crate) enum BrilligParameter {
 pub(crate) struct GeneratedBrillig<F> {
     pub(crate) byte_code: Vec<BrilligOpcode<F>>,
     pub(crate) locations: BTreeMap<OpcodeLocation, CallStack>,
-    pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
+    pub(crate) error_types: BTreeMap<ErrorSelector, ErrorType>,
     pub(crate) name: String,
 }
 
@@ -31,10 +33,7 @@ pub(crate) struct GeneratedBrillig<F> {
 /// It includes the bytecode of the function and all the metadata that allows linking with other functions.
 pub(crate) struct BrilligArtifact<F> {
     pub(crate) byte_code: Vec<BrilligOpcode<F>>,
-    /// A map of bytecode positions to assertion messages.
-    /// Some error messages (compiler intrinsics) are not emitted via revert data,
-    /// instead, they are handled externally so they don't add size to user programs.
-    pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
+    pub(crate) error_types: BTreeMap<ErrorSelector, ErrorType>,
     /// The set of jumps that need to have their locations
     /// resolved.
     unresolved_jumps: Vec<(JumpInstructionPosition, UnresolvedJumpLocation)>,
@@ -58,7 +57,7 @@ pub(crate) struct BrilligArtifact<F> {
 /// A pointer to a location in the opcode.
 pub(crate) type OpcodeLocation = usize;
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub(crate) enum LabelType {
     /// Labels for the entry point bytecode
     Entrypoint,
@@ -88,7 +87,7 @@ impl std::fmt::Display for LabelType {
 ///
 /// It is assumed that an entity will keep a map
 /// of labels to Opcode locations.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub(crate) struct Label {
     pub(crate) label_type: LabelType,
     pub(crate) section: Option<usize>,
@@ -96,7 +95,7 @@ pub(crate) struct Label {
 
 impl Label {
     pub(crate) fn add_section(&self, section: usize) -> Self {
-        Label { label_type: self.label_type, section: Some(section) }
+        Label { label_type: self.label_type.clone(), section: Some(section) }
     }
 
     pub(crate) fn function(func_id: FunctionId) -> Self {
@@ -147,14 +146,14 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
         GeneratedBrillig {
             byte_code: self.byte_code,
             locations: self.locations,
-            assert_messages: self.assert_messages,
+            error_types: self.error_types,
             name: self.name,
         }
     }
 
     /// Gets the first unresolved function call of this artifact.
     pub(crate) fn first_unresolved_function_call(&self) -> Option<Label> {
-        self.unresolved_external_call_labels.first().map(|(_, label)| *label)
+        self.unresolved_external_call_labels.first().map(|(_, label)| label.clone())
     }
 
     /// Link with an external brillig artifact called from this artifact.
@@ -166,6 +165,10 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
         // Add the unresolved jumps of the linked function to this artifact.
         self.add_unresolved_jumps_and_calls(obj);
 
+        for (error_selector, error_type) in &obj.error_types {
+            self.error_types.insert(*error_selector, error_type.clone());
+        }
+
         let mut byte_code = obj.byte_code.clone();
 
         // Replace STOP with RETURN because this is not the end of the program now.
@@ -199,20 +202,17 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     fn add_unresolved_jumps_and_calls(&mut self, obj: &BrilligArtifact<F>) {
         let offset = self.index_of_next_opcode();
         for (jump_label, jump_location) in &obj.unresolved_jumps {
-            self.unresolved_jumps.push((jump_label + offset, *jump_location));
+            self.unresolved_jumps.push((jump_label + offset, jump_location.clone()));
         }
 
         for (label_id, position_in_bytecode) in &obj.labels {
-            let old_value = self.labels.insert(*label_id, position_in_bytecode + offset);
+            let old_value = self.labels.insert(label_id.clone(), position_in_bytecode + offset);
             assert!(old_value.is_none(), "overwriting label {label_id} {old_value:?}");
         }
 
         for (position_in_bytecode, label_id) in &obj.unresolved_external_call_labels {
-            self.unresolved_external_call_labels.push((position_in_bytecode + offset, *label_id));
-        }
-
-        for (position_in_bytecode, message) in &obj.assert_messages {
-            self.assert_messages.insert(position_in_bytecode + offset, message.clone());
+            self.unresolved_external_call_labels
+                .push((position_in_bytecode + offset, label_id.clone()));
         }
 
         for (position_in_bytecode, call_stack) in obj.locations.iter() {
@@ -267,7 +267,7 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     /// Adds a label in the bytecode to specify where this block's
     /// opcodes will start.
     pub(crate) fn add_label_at_position(&mut self, label: Label, position: OpcodeLocation) {
-        let old_value = self.labels.insert(label, position);
+        let old_value = self.labels.insert(label.clone(), position);
         assert!(
             old_value.is_none(),
             "overwriting label {label}. old_value = {old_value:?}, new_value = {position}"
@@ -326,9 +326,4 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     pub(crate) fn set_call_stack(&mut self, call_stack: CallStack) {
         self.call_stack = call_stack;
     }
-
-    pub(crate) fn add_assert_message_to_last_opcode(&mut self, message: String) {
-        let position = self.index_of_next_opcode() - 1;
-        self.assert_messages.insert(position, message);
-    }
 }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
index 540d957d5be9..77661fba3a17 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -1,8 +1,13 @@
 use acvm::{
-    acir::brillig::{HeapVector, MemoryAddress},
+    acir::{
+        brillig::{HeapVector, MemoryAddress},
+        circuit::ErrorSelector,
+    },
     AcirField,
 };
 
+use crate::ErrorType;
+
 use super::{
     artifact::BrilligParameter,
     brillig_variable::{BrilligArray, BrilligVariable, SingleAddrVariable},
@@ -138,7 +143,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 
         self.enter_section(then_section);
         f(self, true);
-        self.jump_instruction(end_label);
+        self.jump_instruction(end_label.clone());
 
         self.enter_section(otherwise_section);
         f(self, false);
@@ -187,7 +192,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         condition: SingleAddrVariable,
         revert_data_items: Vec<BrilligVariable>,
         revert_data_types: Vec<BrilligParameter>,
-        error_selector: u64,
+        error_selector: ErrorSelector,
     ) {
         assert!(condition.bit_size == 1);
 
@@ -204,7 +209,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
             ctx.indirect_const_instruction(
                 current_revert_data_pointer,
                 64,
-                (error_selector as u128).into(),
+                (error_selector.as_u64() as u128).into(),
             );
 
             ctx.codegen_usize_op_in_place(current_revert_data_pointer, BrilligBinaryOp::Add, 1);
@@ -259,18 +264,38 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         assert!(condition.bit_size == 1);
 
         self.codegen_if_not(condition.address, |ctx| {
-            let revert_data_size_var = ctx.make_usize_constant_instruction(F::zero());
-            ctx.trap_instruction(HeapVector {
-                pointer: MemoryAddress::direct(0),
-                size: revert_data_size_var.address,
-            });
-            ctx.deallocate_single_addr(revert_data_size_var);
             if let Some(assert_message) = assert_message {
-                ctx.obj.add_assert_message_to_last_opcode(assert_message);
-            }
+                ctx.revert_with_string(assert_message);
+            } else {
+                let revert_data = HeapVector {
+                    pointer: ReservedRegisters::free_memory_pointer(),
+                    size: ctx.make_usize_constant_instruction(0_usize.into()).address,
+                };
+                ctx.trap_instruction(revert_data);
+                ctx.deallocate_register(revert_data.size);
+            };
         });
     }
 
+    pub(super) fn revert_with_string(&mut self, revert_string: String) {
+        if self.can_call_procedures {
+            self.call_revert_with_string_procedure(revert_string);
+        } else {
+            let error_type = ErrorType::String(revert_string);
+            let error_selector = error_type.selector();
+            self.obj.error_types.insert(error_selector, error_type);
+            self.indirect_const_instruction(
+                ReservedRegisters::free_memory_pointer(),
+                64,
+                (error_selector.as_u64() as u128).into(),
+            );
+            self.trap_instruction(HeapVector {
+                pointer: ReservedRegisters::free_memory_pointer(),
+                size: ReservedRegisters::usize_one(),
+            });
+        }
+    }
+
     /// Computes the size of a parameter if it was flattened
     pub(super) fn flattened_size(param: &BrilligParameter) -> usize {
         match param {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 5f0aedb9c5e4..873b47b86949 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -224,7 +224,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
     /// Adds a label to the next opcode
     pub(crate) fn enter_context(&mut self, label: Label) {
         self.debug_show.enter_context(label.to_string());
-        self.context_label = label;
+        self.context_label = label.clone();
         self.current_section = 0;
         // Add a context label to the next opcode
         self.obj.add_label_at_position(label, self.obj.index_of_next_opcode());
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
index 1c3d1f4d0ad1..0201ca8d881d 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
@@ -4,6 +4,7 @@ mod check_max_stack_depth;
 mod mem_copy;
 mod prepare_vector_insert;
 mod prepare_vector_push;
+mod revert_with_string;
 mod vector_copy;
 mod vector_pop_back;
 mod vector_pop_front;
@@ -15,6 +16,7 @@ use check_max_stack_depth::compile_check_max_stack_depth_procedure;
 use mem_copy::compile_mem_copy_procedure;
 use prepare_vector_insert::compile_prepare_vector_insert_procedure;
 use prepare_vector_push::compile_prepare_vector_push_procedure;
+use revert_with_string::compile_revert_with_string_procedure;
 use vector_copy::compile_vector_copy_procedure;
 use vector_pop_back::compile_vector_pop_back_procedure;
 use vector_pop_front::compile_vector_pop_front_procedure;
@@ -31,7 +33,7 @@ use super::{
 /// Procedures are a set of complex operations that are common in the noir language.
 /// Extracting them to reusable procedures allows us to reduce the size of the generated Brillig.
 /// Procedures receive their arguments on scratch space to avoid stack dumping&restoring.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub(crate) enum ProcedureId {
     ArrayCopy,
     ArrayReverse,
@@ -43,13 +45,14 @@ pub(crate) enum ProcedureId {
     PrepareVectorInsert,
     VectorRemove,
     CheckMaxStackDepth,
+    RevertWithString(String),
 }
 
 pub(crate) fn compile_procedure<F: AcirField + DebugToString>(
     procedure_id: ProcedureId,
 ) -> BrilligArtifact<F> {
     let mut brillig_context = BrilligContext::new_for_procedure(false);
-    brillig_context.enter_context(Label::procedure(procedure_id));
+    brillig_context.enter_context(Label::procedure(procedure_id.clone()));
 
     match procedure_id {
         ProcedureId::MemCopy => compile_mem_copy_procedure(&mut brillig_context),
@@ -72,6 +75,9 @@ pub(crate) fn compile_procedure<F: AcirField + DebugToString>(
         ProcedureId::CheckMaxStackDepth => {
             compile_check_max_stack_depth_procedure(&mut brillig_context);
         }
+        ProcedureId::RevertWithString(revert_string) => {
+            compile_revert_with_string_procedure(&mut brillig_context, revert_string);
+        }
     };
 
     brillig_context.stop_instruction();
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/revert_with_string.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/revert_with_string.rs
new file mode 100644
index 000000000000..83d7dfc618d9
--- /dev/null
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/revert_with_string.rs
@@ -0,0 +1,23 @@
+use acvm::AcirField;
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligContext,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    /// Reverts with the error selector of the given string
+    /// This procedure is useful to deduplicate generating code for the same selector.
+    pub(crate) fn call_revert_with_string_procedure(&mut self, revert_string: String) {
+        self.add_procedure_call_instruction(ProcedureId::RevertWithString(revert_string));
+    }
+}
+
+pub(super) fn compile_revert_with_string_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+    revert_string: String,
+) {
+    brillig_context.revert_with_string(revert_string);
+}
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/lib.rs b/noir/noir-repo/compiler/noirc_evaluator/src/lib.rs
index 543769633381..3fddd9da0564 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/lib.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/lib.rs
@@ -12,3 +12,5 @@ pub mod ssa;
 pub mod brillig;
 
 pub use ssa::create_program;
+
+pub use ssa::ir::instruction::ErrorType;
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs
index 282e26dbe061..5a018213866d 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs
@@ -26,13 +26,11 @@ use acvm::{
     FieldElement,
 };
 
+use ir::instruction::ErrorType;
 use noirc_errors::debug_info::{DebugFunctions, DebugInfo, DebugTypes, DebugVariables};
 
 use noirc_frontend::ast::Visibility;
-use noirc_frontend::{
-    hir_def::{function::FunctionSignature, types::Type as HirType},
-    monomorphization::ast::Program,
-};
+use noirc_frontend::{hir_def::function::FunctionSignature, monomorphization::ast::Program};
 use tracing::{span, Level};
 
 use self::{
@@ -171,13 +169,13 @@ pub struct SsaProgramArtifact {
     pub main_return_witnesses: Vec<Witness>,
     pub names: Vec<String>,
     pub brillig_names: Vec<String>,
-    pub error_types: BTreeMap<ErrorSelector, HirType>,
+    pub error_types: BTreeMap<ErrorSelector, ErrorType>,
 }
 
 impl SsaProgramArtifact {
     fn new(
         unconstrained_functions: Vec<BrilligBytecode<FieldElement>>,
-        error_types: BTreeMap<ErrorSelector, HirType>,
+        error_types: BTreeMap<ErrorSelector, ErrorType>,
     ) -> Self {
         let program = AcirProgram { functions: Vec::default(), unconstrained_functions };
         Self {
@@ -201,6 +199,9 @@ impl SsaProgramArtifact {
             self.main_return_witnesses = circuit_artifact.return_witnesses;
         }
         self.names.push(circuit_artifact.name);
+        // Acir and brillig both generate new error types, so we need to merge them
+        // With the ones found during ssa generation.
+        self.error_types.extend(circuit_artifact.error_types);
     }
 
     fn add_warnings(&mut self, mut warnings: Vec<SsaReport>) {
@@ -239,6 +240,12 @@ pub fn create_program(
             "The generated ACIRs should match the supplied function signatures"
         );
     }
+
+    let error_types = error_types
+        .into_iter()
+        .map(|(selector, hir_type)| (selector, ErrorType::Dynamic(hir_type)))
+        .collect();
+
     let mut program_artifact = SsaProgramArtifact::new(generated_brillig, error_types);
 
     // Add warnings collected at the Ssa stage
@@ -269,6 +276,7 @@ pub struct SsaCircuitArtifact {
     warnings: Vec<SsaReport>,
     input_witnesses: Vec<Witness>,
     return_witnesses: Vec<Witness>,
+    error_types: BTreeMap<ErrorSelector, ErrorType>,
 }
 
 fn convert_generated_acir_into_circuit(
@@ -338,6 +346,7 @@ fn convert_generated_acir_into_circuit(
         warnings,
         input_witnesses,
         return_witnesses,
+        error_types: generated_acir.error_types,
     }
 }
 
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 811b728a9d5f..e7d298558c45 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1108,10 +1108,10 @@ impl<F: AcirField> AcirContext<F> {
                 let witness = self.var_to_witness(witness_var)?;
                 self.acir_ir.range_constraint(witness, *bit_size)?;
                 if let Some(message) = message {
-                    self.acir_ir.assertion_payloads.insert(
-                        self.acir_ir.last_acir_opcode_location(),
-                        AssertionPayload::StaticString(message.clone()),
-                    );
+                    let payload = self.generate_assertion_message_payload(message.clone());
+                    self.acir_ir
+                        .assertion_payloads
+                        .insert(self.acir_ir.last_acir_opcode_location(), payload);
                 }
             }
             NumericType::NativeField => {
@@ -2068,6 +2068,13 @@ impl<F: AcirField> AcirContext<F> {
         self.acir_ir.push_opcode(Opcode::Call { id, inputs, outputs, predicate });
         Ok(results)
     }
+
+    pub(crate) fn generate_assertion_message_payload(
+        &mut self,
+        message: String,
+    ) -> AssertionPayload<F> {
+        self.acir_ir.generate_assertion_message_payload(message)
+    }
 }
 
 /// Enum representing the possible values that a
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index 01fcaef90425..bb42d682798e 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -5,13 +5,13 @@ use std::{collections::BTreeMap, u32};
 use crate::{
     brillig::{brillig_gen::brillig_directive, brillig_ir::artifact::GeneratedBrillig},
     errors::{InternalError, RuntimeError, SsaReport},
-    ssa::ir::dfg::CallStack,
+    ssa::ir::{dfg::CallStack, instruction::ErrorType},
 };
 use acvm::acir::{
     circuit::{
         brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, FunctionInput, Opcode as AcirOpcode},
-        AssertionPayload, BrilligOpcodeLocation, OpcodeLocation,
+        AssertionPayload, BrilligOpcodeLocation, ErrorSelector, OpcodeLocation,
     },
     native_types::Witness,
     BlackBoxFunc,
@@ -62,6 +62,9 @@ pub(crate) struct GeneratedAcir<F: AcirField> {
     /// Correspondence between an opcode index and the error message associated with it.
     pub(crate) assertion_payloads: BTreeMap<OpcodeLocation, AssertionPayload<F>>,
 
+    /// Correspondence between error selectors and types associated with them.
+    pub(crate) error_types: BTreeMap<ErrorSelector, ErrorType>,
+
     pub(crate) warnings: Vec<SsaReport>,
 
     /// Name for the corresponding entry point represented by this Acir-gen output.
@@ -576,15 +579,8 @@ impl<F: AcirField> GeneratedAcir<F> {
             return;
         }
 
-        // TODO(https://github.com/noir-lang/noir/issues/5792)
-        for (brillig_index, message) in generated_brillig.assert_messages.iter() {
-            self.assertion_payloads.insert(
-                OpcodeLocation::Brillig {
-                    acir_index: self.opcodes.len() - 1,
-                    brillig_index: *brillig_index,
-                },
-                AssertionPayload::StaticString(message.clone()),
-            );
+        for (error_selector, error_type) in generated_brillig.error_types.iter() {
+            self.record_error_type(*error_selector, error_type.clone());
         }
 
         if inserted_func_before {
@@ -619,6 +615,20 @@ impl<F: AcirField> GeneratedAcir<F> {
     pub(crate) fn last_acir_opcode_location(&self) -> OpcodeLocation {
         OpcodeLocation::Acir(self.opcodes.len() - 1)
     }
+
+    pub(crate) fn record_error_type(&mut self, selector: ErrorSelector, typ: ErrorType) {
+        self.error_types.insert(selector, typ);
+    }
+
+    pub(crate) fn generate_assertion_message_payload(
+        &mut self,
+        message: String,
+    ) -> AssertionPayload<F> {
+        let error_type = ErrorType::String(message);
+        let error_selector = error_type.selector();
+        self.record_error_type(error_selector, error_type);
+        AssertionPayload { error_selector: error_selector.as_u64(), payload: Vec::new() }
+    }
 }
 
 /// This function will return the number of inputs that a blackbox function
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 50a895df2371..d6971756f755 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -9,7 +9,7 @@ use self::acir_ir::generated_acir::BrilligStdlibFunc;
 use super::function_builder::data_bus::DataBus;
 use super::ir::dfg::CallStack;
 use super::ir::function::FunctionId;
-use super::ir::instruction::{ConstrainError, ErrorType};
+use super::ir::instruction::ConstrainError;
 use super::ir::printer::try_to_extract_string_from_error_payload;
 use super::{
     ir::{
@@ -40,6 +40,7 @@ use acvm::{acir::circuit::opcodes::BlockId, acir::AcirField, FieldElement};
 use fxhash::FxHashMap as HashMap;
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
+use noirc_frontend::Type as HirType;
 
 #[derive(Default)]
 struct SharedContext<F> {
@@ -283,7 +284,7 @@ pub(crate) type Artifacts = (
     Vec<GeneratedAcir<FieldElement>>,
     Vec<BrilligBytecode<FieldElement>>,
     Vec<String>,
-    BTreeMap<ErrorSelector, ErrorType>,
+    BTreeMap<ErrorSelector, HirType>,
 );
 
 impl Ssa {
@@ -296,6 +297,7 @@ impl Ssa {
         let mut acirs = Vec::new();
         // TODO: can we parallelize this?
         let mut shared_context = SharedContext::default();
+
         for function in self.functions.values() {
             let context = Context::new(&mut shared_context, expression_width);
             if let Some(mut generated_acir) =
@@ -675,16 +677,19 @@ impl<'a> Context<'a> {
 
                 let assert_payload = if let Some(error) = assert_message {
                     match error {
-                        ConstrainError::StaticString(string) => {
-                            Some(AssertionPayload::StaticString(string.clone()))
-                        }
-                        ConstrainError::Dynamic(error_selector, values) => {
+                        ConstrainError::StaticString(string) => Some(
+                            self.acir_context.generate_assertion_message_payload(string.clone()),
+                        ),
+                        ConstrainError::Dynamic(error_selector, is_string_type, values) => {
                             if let Some(constant_string) = try_to_extract_string_from_error_payload(
-                                *error_selector,
+                                *is_string_type,
                                 values,
                                 dfg,
                             ) {
-                                Some(AssertionPayload::StaticString(constant_string))
+                                Some(
+                                    self.acir_context
+                                        .generate_assertion_message_payload(constant_string),
+                                )
                             } else {
                                 let acir_vars: Vec<_> = values
                                     .iter()
@@ -694,10 +699,10 @@ impl<'a> Context<'a> {
                                 let expressions_or_memory =
                                     self.acir_context.vars_to_expressions_or_memory(&acir_vars)?;
 
-                                Some(AssertionPayload::Dynamic(
-                                    error_selector.as_u64(),
-                                    expressions_or_memory,
-                                ))
+                                Some(AssertionPayload {
+                                    error_selector: error_selector.as_u64(),
+                                    payload: expressions_or_memory,
+                                })
                             }
                         }
                     }
@@ -992,7 +997,7 @@ impl<'a> Context<'a> {
 
         // Link the entry point with all dependencies
         while let Some(unresolved_fn_label) = entry_point.first_unresolved_function_call() {
-            let artifact = &brillig.find_by_label(unresolved_fn_label);
+            let artifact = &brillig.find_by_label(unresolved_fn_label.clone());
             let artifact = match artifact {
                 Some(artifact) => artifact,
                 None => {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index f810b65d105e..7b39f7041e45 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -4,6 +4,7 @@ use std::{borrow::Cow, collections::BTreeMap, sync::Arc};
 
 use acvm::{acir::circuit::ErrorSelector, FieldElement};
 use noirc_errors::Location;
+use noirc_frontend::hir_def::types::Type as HirType;
 use noirc_frontend::monomorphization::ast::InlineType;
 
 use crate::ssa::ir::{
@@ -19,7 +20,7 @@ use super::{
         basic_block::BasicBlock,
         dfg::{CallStack, InsertInstructionResult},
         function::RuntimeType,
-        instruction::{ConstrainError, ErrorType, InstructionId, Intrinsic},
+        instruction::{ConstrainError, InstructionId, Intrinsic},
     },
     ssa_gen::Ssa,
 };
@@ -36,7 +37,7 @@ pub(crate) struct FunctionBuilder {
     current_block: BasicBlockId,
     finished_functions: Vec<Function>,
     call_stack: CallStack,
-    error_types: BTreeMap<ErrorSelector, ErrorType>,
+    error_types: BTreeMap<ErrorSelector, HirType>,
 }
 
 impl FunctionBuilder {
@@ -461,7 +462,7 @@ impl FunctionBuilder {
         }
     }
 
-    pub(crate) fn record_error_type(&mut self, selector: ErrorSelector, typ: ErrorType) {
+    pub(crate) fn record_error_type(&mut self, selector: ErrorSelector, typ: HirType) {
         self.error_types.insert(selector, typ);
     }
 }
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index f187a279b9bb..2b40bccca7b6 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -4,13 +4,10 @@ use std::hash::{Hash, Hasher};
 
 use acvm::{
     acir::AcirField,
-    acir::{
-        circuit::{ErrorSelector, STRING_ERROR_SELECTOR},
-        BlackBoxFunc,
-    },
+    acir::{circuit::ErrorSelector, BlackBoxFunc},
     FieldElement,
 };
-use fxhash::FxHasher;
+use fxhash::FxHasher64;
 use iter_extended::vecmap;
 use noirc_frontend::hir_def::types::Type as HirType;
 
@@ -473,10 +470,13 @@ impl Instruction {
                 let lhs = f(*lhs);
                 let rhs = f(*rhs);
                 let assert_message = assert_message.as_ref().map(|error| match error {
-                    ConstrainError::Dynamic(selector, payload_values) => ConstrainError::Dynamic(
-                        *selector,
-                        payload_values.iter().map(|&value| f(value)).collect(),
-                    ),
+                    ConstrainError::Dynamic(selector, is_string, payload_values) => {
+                        ConstrainError::Dynamic(
+                            *selector,
+                            *is_string,
+                            payload_values.iter().map(|&value| f(value)).collect(),
+                        )
+                    }
                     _ => error.clone(),
                 });
                 Instruction::Constrain(lhs, rhs, assert_message)
@@ -544,7 +544,7 @@ impl Instruction {
             Instruction::Constrain(lhs, rhs, assert_error) => {
                 f(*lhs);
                 f(*rhs);
-                if let Some(ConstrainError::Dynamic(_, values)) = assert_error.as_ref() {
+                if let Some(ConstrainError::Dynamic(_, _, values)) = assert_error.as_ref() {
                     values.iter().for_each(|&val| {
                         f(val);
                     });
@@ -915,18 +915,18 @@ fn try_optimize_array_set_from_previous_get(
     SimplifyResult::None
 }
 
-pub(crate) type ErrorType = HirType;
-
-pub(crate) fn error_selector_from_type(typ: &ErrorType) -> ErrorSelector {
-    match typ {
-        ErrorType::String(_) => STRING_ERROR_SELECTOR,
-        _ => {
-            let mut hasher = FxHasher::default();
-            typ.hash(&mut hasher);
-            let hash = hasher.finish();
-            assert!(hash != 0, "ICE: Error type {} collides with the string error type", typ);
-            ErrorSelector::new(hash)
-        }
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub enum ErrorType {
+    String(String),
+    Dynamic(HirType),
+}
+
+impl ErrorType {
+    pub fn selector(&self) -> ErrorSelector {
+        let mut hasher = FxHasher64::default();
+        self.hash(&mut hasher);
+        let hash = hasher.finish();
+        ErrorSelector::new(hash)
     }
 }
 
@@ -935,7 +935,8 @@ pub(crate) enum ConstrainError {
     // Static string errors are not handled inside the program as data for efficiency reasons.
     StaticString(String),
     // These errors are handled by the program as data.
-    Dynamic(ErrorSelector, Vec<ValueId>),
+    // We use a boolean to indicate if the error is a string for printing purposes.
+    Dynamic(ErrorSelector, /* is_string */ bool, Vec<ValueId>),
 }
 
 impl From<String> for ConstrainError {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index 2b564c14aa7c..93d69f255c37 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -4,7 +4,6 @@ use std::{
     fmt::{Formatter, Result},
 };
 
-use acvm::acir::circuit::{ErrorSelector, STRING_ERROR_SELECTOR};
 use acvm::acir::AcirField;
 use iter_extended::vecmap;
 
@@ -213,11 +212,11 @@ fn display_instruction_inner(
 
 /// Tries to extract a constant string from an error payload.
 pub(crate) fn try_to_extract_string_from_error_payload(
-    error_selector: ErrorSelector,
+    is_string_type: bool,
     values: &[ValueId],
     dfg: &DataFlowGraph,
 ) -> Option<String> {
-    ((error_selector == STRING_ERROR_SELECTOR) && (values.len() == 1))
+    (is_string_type && (values.len() == 1))
         .then_some(())
         .and_then(|()| {
             let Value::Array { array: values, .. } = &dfg[values[0]] else {
@@ -248,9 +247,9 @@ fn display_constrain_error(
         ConstrainError::StaticString(assert_message_string) => {
             writeln!(f, " '{assert_message_string:?}'")
         }
-        ConstrainError::Dynamic(selector, values) => {
+        ConstrainError::Dynamic(_, is_string, values) => {
             if let Some(constant_string) =
-                try_to_extract_string_from_error_payload(*selector, values, &function.dfg)
+                try_to_extract_string_from_error_payload(*is_string, values, &function.dfg)
             {
                 writeln!(f, " '{}'", constant_string)
             } else {
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 8bf3a740b3a7..96e779482a40 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -21,7 +21,7 @@ use self::{
     value::{Tree, Values},
 };
 
-use super::ir::instruction::error_selector_from_type;
+use super::ir::instruction::ErrorType;
 use super::{
     function_builder::data_bus::DataBus,
     ir::{
@@ -701,24 +701,23 @@ impl<'a> FunctionContext<'a> {
         assert_message: &Option<Box<(Expression, HirType)>>,
     ) -> Result<Option<ConstrainError>, RuntimeError> {
         let Some(assert_message_payload) = assert_message else { return Ok(None) };
-
-        if let Expression::Literal(ast::Literal::Str(static_string)) = &assert_message_payload.0 {
-            return Ok(Some(ConstrainError::StaticString(static_string.clone())));
-        }
-
         let (assert_message_expression, assert_message_typ) = assert_message_payload.as_ref();
 
-        let values = self.codegen_expression(assert_message_expression)?.into_value_list(self);
-
-        let error_type_id = error_selector_from_type(assert_message_typ);
-        // Do not record string errors in the ABI
-        match assert_message_typ {
-            HirType::String(_) => {}
-            _ => {
-                self.builder.record_error_type(error_type_id, assert_message_typ.clone());
+        if let Expression::Literal(ast::Literal::Str(static_string)) = assert_message_expression {
+            Ok(Some(ConstrainError::StaticString(static_string.clone())))
+        } else {
+            let error_type = ErrorType::Dynamic(assert_message_typ.clone());
+            let selector = error_type.selector();
+            let values = self.codegen_expression(assert_message_expression)?.into_value_list(self);
+            let is_string_type = matches!(assert_message_typ, HirType::String(_));
+            // Record custom types in the builder, outside of SSA instructions
+            // This is made to avoid having Hir types in the SSA code.
+            if !is_string_type {
+                self.builder.record_error_type(selector, assert_message_typ.clone());
             }
-        };
-        Ok(Some(ConstrainError::Dynamic(error_type_id, values)))
+
+            Ok(Some(ConstrainError::Dynamic(selector, is_string_type, values)))
+        }
     }
 
     fn codegen_assign(&mut self, assign: &ast::Assign) -> Result<Values, RuntimeError> {
diff --git a/noir/noir-repo/tooling/noir_js_types/src/types.ts b/noir/noir-repo/tooling/noir_js_types/src/types.ts
index d4e6a8e4269f..03e2a93f8517 100644
--- a/noir/noir-repo/tooling/noir_js_types/src/types.ts
+++ b/noir/noir-repo/tooling/noir_js_types/src/types.ts
@@ -20,6 +20,7 @@ export type AbiParameter = {
 };
 
 export type AbiErrorType =
+  | { error_kind: 'string'; string: string }
   | {
       error_kind: 'fmtstring';
       length: number;
diff --git a/noir/noir-repo/tooling/noirc_abi/src/lib.rs b/noir/noir-repo/tooling/noirc_abi/src/lib.rs
index 39f2e935618a..b1b199727c2a 100644
--- a/noir/noir-repo/tooling/noirc_abi/src/lib.rs
+++ b/noir/noir-repo/tooling/noirc_abi/src/lib.rs
@@ -464,6 +464,7 @@ pub enum AbiValue {
 pub enum AbiErrorType {
     FmtString { length: u32, item_types: Vec<AbiType> },
     Custom(AbiType),
+    String { string: String },
 }
 
 pub fn display_abi_error<F: AcirField>(
@@ -491,6 +492,13 @@ pub fn display_abi_error<F: AcirField>(
             let decoded = printable_type_decode_value(&mut fields.iter().copied(), &printable_type);
             PrintableValueDisplay::Plain(decoded, printable_type)
         }
+        AbiErrorType::String { string } => {
+            let length = string.len() as u32;
+            PrintableValueDisplay::Plain(
+                PrintableValue::String(string),
+                PrintableType::String { length },
+            )
+        }
     }
 }
 
diff --git a/noir/noir-repo/tooling/noirc_abi_wasm/src/lib.rs b/noir/noir-repo/tooling/noirc_abi_wasm/src/lib.rs
index b0c11979d176..79aecafa7426 100644
--- a/noir/noir-repo/tooling/noirc_abi_wasm/src/lib.rs
+++ b/noir/noir-repo/tooling/noirc_abi_wasm/src/lib.rs
@@ -157,5 +157,6 @@ pub fn abi_decode_error(
             <JsValue as JsValueSerdeExt>::from_serde(&json_types)
                 .map_err(|err| err.to_string().into())
         }
+        AbiErrorType::String { string } => Ok(JsValue::from_str(&string)),
     }
 }
diff --git a/noir/noir-repo/tooling/noirc_abi_wasm/test/shared/decode_error.ts b/noir/noir-repo/tooling/noirc_abi_wasm/test/shared/decode_error.ts
index 662e0acb4169..461cedd26941 100644
--- a/noir/noir-repo/tooling/noirc_abi_wasm/test/shared/decode_error.ts
+++ b/noir/noir-repo/tooling/noirc_abi_wasm/test/shared/decode_error.ts
@@ -4,8 +4,10 @@ export const FAKE_FIELD_SELECTOR = '1';
 export const FAKE_TUPLE_SELECTOR = '2';
 export const FAKE_FMT_STRING_SELECTOR = '3';
 export const FAKE_STRUCT_SELECTOR = '4';
+export const FAKE_STRING_SELECTOR = '5';
 
 export const SAMPLE_FMT_STRING = 'hello {a}';
+export const SAMPLE_STRING = 'hello world';
 
 export const abi: Abi = {
   parameters: [
@@ -40,5 +42,9 @@ export const abi: Abi = {
         { name: 'b', type: { kind: 'field' } },
       ],
     },
+    [FAKE_STRING_SELECTOR]: {
+      error_kind: 'string',
+      string: SAMPLE_STRING,
+    },
   },
 };
diff --git a/yarn-project/aztec-node/src/aztec-node/server.ts b/yarn-project/aztec-node/src/aztec-node/server.ts
index a22e5ce6f8a6..5fcdc0482522 100644
--- a/yarn-project/aztec-node/src/aztec-node/server.ts
+++ b/yarn-project/aztec-node/src/aztec-node/server.ts
@@ -30,7 +30,6 @@ import {
   TxStatus,
   type TxValidator,
   type WorldStateSynchronizer,
-  partitionReverts,
 } from '@aztec/circuit-types';
 import {
   type ARCHIVE_HEIGHT,
@@ -735,18 +734,15 @@ export class AztecNodeService implements AztecNode {
 
       // REFACTOR: Consider merging ProcessReturnValues into ProcessedTx
       const [processedTxs, failedTxs, returns] = await processor.process([tx]);
-      // REFACTOR: Consider returning the error/revert rather than throwing
+      // REFACTOR: Consider returning the error rather than throwing
       if (failedTxs.length) {
         this.log.warn(`Simulated tx ${tx.getTxHash()} fails: ${failedTxs[0].error}`);
         throw failedTxs[0].error;
       }
-      const { reverted } = partitionReverts(processedTxs);
-      if (reverted.length) {
-        this.log.warn(`Simulated tx ${tx.getTxHash()} reverts: ${reverted[0].revertReason}`);
-        throw reverted[0].revertReason;
-      }
-      this.log.debug(`Simulated tx ${tx.getTxHash()} succeeds`);
+
       const [processedTx] = processedTxs;
+      this.log.debug(`Simulated tx ${tx.getTxHash()} ${processedTx.revertReason ? 'Reverts' : 'Succeeds'}`);
+
       return new PublicSimulationOutput(
         processedTx.encryptedLogs,
         processedTx.unencryptedLogs,
diff --git a/yarn-project/aztec.js/src/contract/contract.test.ts b/yarn-project/aztec.js/src/contract/contract.test.ts
index a9fcd9e5dccc..751571bc537b 100644
--- a/yarn-project/aztec.js/src/contract/contract.test.ts
+++ b/yarn-project/aztec.js/src/contract/contract.test.ts
@@ -87,6 +87,7 @@ describe('Contract Class', () => {
           },
         ],
         returnTypes: [],
+        errorTypes: {},
         bytecode: Buffer.alloc(8, 0xfa),
       },
       {
@@ -97,6 +98,7 @@ describe('Contract Class', () => {
         isInternal: false,
         parameters: [],
         returnTypes: [],
+        errorTypes: {},
         bytecode: Buffer.alloc(8, 0xfb),
         debugSymbols: '',
       },
@@ -124,6 +126,7 @@ describe('Contract Class', () => {
         ],
         bytecode: Buffer.alloc(8, 0xfc),
         debugSymbols: '',
+        errorTypes: {},
       },
     ],
     outputs: {
diff --git a/yarn-project/aztec.js/src/entrypoint/default_multi_call_entrypoint.ts b/yarn-project/aztec.js/src/entrypoint/default_multi_call_entrypoint.ts
index c3825e846faf..c4c3a653b733 100644
--- a/yarn-project/aztec.js/src/entrypoint/default_multi_call_entrypoint.ts
+++ b/yarn-project/aztec.js/src/entrypoint/default_multi_call_entrypoint.ts
@@ -86,6 +86,7 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     } as FunctionAbi;
   }
 }
diff --git a/yarn-project/aztec.js/src/wallet/account_wallet.ts b/yarn-project/aztec.js/src/wallet/account_wallet.ts
index 84a21a5f5734..1a891160850c 100644
--- a/yarn-project/aztec.js/src/wallet/account_wallet.ts
+++ b/yarn-project/aztec.js/src/wallet/account_wallet.ts
@@ -191,6 +191,7 @@ export class AccountWallet extends BaseWallet {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
   }
 
@@ -203,6 +204,7 @@ export class AccountWallet extends BaseWallet {
       isStatic: false,
       parameters: [{ name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility }],
       returnTypes: [{ kind: 'boolean' }],
+      errorTypes: {},
     };
   }
 
@@ -226,6 +228,7 @@ export class AccountWallet extends BaseWallet {
         { name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility },
       ],
       returnTypes: [{ kind: 'boolean' }],
+      errorTypes: {},
     };
   }
 }
diff --git a/yarn-project/bb-prover/src/avm_proving.test.ts b/yarn-project/bb-prover/src/avm_proving.test.ts
index 935a6f448fc2..69b9d4f96e7d 100644
--- a/yarn-project/bb-prover/src/avm_proving.test.ts
+++ b/yarn-project/bb-prover/src/avm_proving.test.ts
@@ -131,7 +131,9 @@ const proveAndVerifyAvmTestContract = async (
     // Explicit revert when an assertion failed.
     expect(avmResult.reverted).toBe(true);
     expect(avmResult.revertReason).toBeDefined();
-    expect(resolveAvmTestContractAssertionMessage(functionName, avmResult.revertReason!)).toContain(assertionErrString);
+    expect(resolveAvmTestContractAssertionMessage(functionName, avmResult.revertReason!, avmResult.output)).toContain(
+      assertionErrString,
+    );
   }
 
   const pxResult = trace.toPublicExecutionResult(
diff --git a/yarn-project/circuits.js/src/contract/contract_address.test.ts b/yarn-project/circuits.js/src/contract/contract_address.test.ts
index a23519948ef6..c8918ea0d3e1 100644
--- a/yarn-project/circuits.js/src/contract/contract_address.test.ts
+++ b/yarn-project/circuits.js/src/contract/contract_address.test.ts
@@ -40,6 +40,7 @@ describe('ContractAddress', () => {
       name: 'fun',
       parameters: [{ name: 'param1', type: { kind: 'boolean' }, visibility: 'private' }],
       returnTypes: [],
+      errorTypes: {},
     };
     const mockArgs: any[] = [true];
     const result = computeInitializationHash(mockInitFn, mockArgs);
diff --git a/yarn-project/entrypoints/src/account_entrypoint.ts b/yarn-project/entrypoints/src/account_entrypoint.ts
index 497955901ac1..08a14fc07464 100644
--- a/yarn-project/entrypoints/src/account_entrypoint.ts
+++ b/yarn-project/entrypoints/src/account_entrypoint.ts
@@ -146,6 +146,7 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
         { name: 'cancellable', type: { kind: 'boolean' } },
       ],
       returnTypes: [],
+      errorTypes: {},
     } as FunctionAbi;
   }
 }
diff --git a/yarn-project/entrypoints/src/dapp_entrypoint.ts b/yarn-project/entrypoints/src/dapp_entrypoint.ts
index e05a1ec3148c..65ac61f55c27 100644
--- a/yarn-project/entrypoints/src/dapp_entrypoint.ts
+++ b/yarn-project/entrypoints/src/dapp_entrypoint.ts
@@ -119,6 +119,7 @@ export class DefaultDappEntrypoint implements EntrypointInterface {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     } as FunctionAbi;
   }
 }
diff --git a/yarn-project/foundation/src/abi/abi.ts b/yarn-project/foundation/src/abi/abi.ts
index 160be402bff1..a1d9c6aaab87 100644
--- a/yarn-project/foundation/src/abi/abi.ts
+++ b/yarn-project/foundation/src/abi/abi.ts
@@ -4,6 +4,18 @@ import { type Fr } from '../fields/fields.js';
 import { type FunctionSelector } from './function_selector.js';
 import { type NoteSelector } from './note_selector.js';
 
+/**
+ * An error could be a custom error of any regular type or a string error.
+ */
+export type AbiErrorType =
+  | { error_kind: 'string'; string: string }
+  | {
+      error_kind: 'fmtstring';
+      length: number;
+      item_types: AbiType[];
+    }
+  | ({ error_kind: 'custom' } & AbiType);
+
 /**
  * A basic value.
  */
@@ -194,6 +206,10 @@ export interface FunctionAbi {
    * The types of the return values.
    */
   returnTypes: AbiType[];
+  /**
+   * The types of the errors that the function can throw.
+   */
+  errorTypes: Partial<Record<string, AbiErrorType>>;
   /**
    * Whether the function is flagged as an initializer.
    */
@@ -210,10 +226,6 @@ export interface FunctionArtifact extends FunctionAbi {
   verificationKey?: string;
   /** Maps opcodes to source code pointers */
   debugSymbols: string;
-  /**
-   * Public functions store their static assertion messages externally to the bytecode.
-   */
-  assertMessages?: Record<number, string>;
   /** Debug metadata for the function. */
   debug?: FunctionDebugMetadata;
 }
@@ -387,10 +399,6 @@ export interface FunctionDebugMetadata {
    * Maps the file IDs to the file contents to resolve pointers
    */
   files: DebugFileMap;
-  /**
-   * Public functions store their static assertion messages externally to the bytecode.
-   */
-  assertMessages?: Record<number, string>;
 }
 
 /**
@@ -432,7 +440,6 @@ export function getFunctionDebugMetadata(
     return {
       debugSymbols: programDebugSymbols.debug_infos[0],
       files: contractArtifact.fileMap,
-      assertMessages: functionArtifact.assertMessages,
     };
   }
   return undefined;
diff --git a/yarn-project/foundation/src/abi/encoder.test.ts b/yarn-project/foundation/src/abi/encoder.test.ts
index 1053db02af09..f0fd1a4e72ef 100644
--- a/yarn-project/foundation/src/abi/encoder.test.ts
+++ b/yarn-project/foundation/src/abi/encoder.test.ts
@@ -22,6 +22,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
 
     const field = Fr.random();
@@ -47,6 +48,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
 
     const arr = [Fr.random(), Fr.random()];
@@ -71,6 +73,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
 
     const str = 'abc';
@@ -103,6 +106,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
 
     const address = AztecAddress.random();
@@ -139,6 +143,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
 
     const value = Fr.random();
@@ -164,6 +169,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
     const args = ['garbage'];
 
@@ -189,6 +195,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
     const args = ['garbage'];
     expect(() => encodeArguments(testFunctionAbi, args)).toThrow(`Cannot convert garbage to a BigInt`);
@@ -211,6 +218,7 @@ describe('abi/encoder', () => {
         },
       ],
       returnTypes: [],
+      errorTypes: {},
     };
     const args = [
       {
diff --git a/yarn-project/ivc-integration/src/avm_integration.test.ts b/yarn-project/ivc-integration/src/avm_integration.test.ts
index 0a5ff58015ec..d22d573ead52 100644
--- a/yarn-project/ivc-integration/src/avm_integration.test.ts
+++ b/yarn-project/ivc-integration/src/avm_integration.test.ts
@@ -222,7 +222,9 @@ const proveAvmTestContract = async (
     // Explicit revert when an assertion failed.
     expect(avmResult.reverted).toBe(true);
     expect(avmResult.revertReason).toBeDefined();
-    expect(resolveAvmTestContractAssertionMessage(functionName, avmResult.revertReason!)).toContain(assertionErrString);
+    expect(resolveAvmTestContractAssertionMessage(functionName, avmResult.revertReason!, avmResult.output)).toContain(
+      assertionErrString,
+    );
   }
 
   const pxResult = trace.toPublicExecutionResult(
diff --git a/yarn-project/protocol-contracts/src/protocol_contract_data.ts b/yarn-project/protocol-contracts/src/protocol_contract_data.ts
index d7f5390acb28..b3643734e904 100644
--- a/yarn-project/protocol-contracts/src/protocol_contract_data.ts
+++ b/yarn-project/protocol-contracts/src/protocol_contract_data.ts
@@ -50,14 +50,14 @@ export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress>
 };
 
 export const ProtocolContractLeaf = {
-  AuthRegistry: Fr.fromString('0x2c8f0ae77bbed1244767430f7bf1badf98219c40a1dfc1bba1409caf1a9a01cd'),
+  AuthRegistry: Fr.fromString('0x28a7d6b69b161a277995403f70e5ed4d4bb27fccfe06277f0ce260f0c34665b9'),
   ContractInstanceDeployer: Fr.fromString('0x04a661c9d4d295fc485a7e0f3de40c09b35366343bce8ad229106a8ef4076fe5'),
   ContractClassRegisterer: Fr.fromString('0x147ba3294403576dbad10f86d3ffd4eb83fb230ffbcd5c8b153dd02942d0611f'),
   MultiCallEntrypoint: Fr.fromString('0x154b701b41d6cf6da7204fef36b2ee9578b449d21b3792a9287bf45eba48fd26'),
-  FeeJuice: Fr.fromString('0x14c807b45f74c73f4b7c7aa85162fc1ae78fafa81ece6c22426fec928edd9471'),
-  Router: Fr.fromString('0x2cf76c7258a26c77ec56a5b4903996b1e0a21313f78e166f408e955393144665'),
+  FeeJuice: Fr.fromString('0x094caa4d1259aa99ea4a8a97a9fa8cbae29ecc8ed818b0f0516cf9fd753b97e6'),
+  Router: Fr.fromString('0x215265750d313695cc669740b19f926207cdcf2c8ee69a8504921b361b0dda08'),
 };
 
 export const protocolContractTreeRoot = Fr.fromString(
-  '0x27d6a49f48a8f07db1170672df19cec71fcb71d97588503150628483943e2a14',
+  '0x034740a11a8535c69a6e99b1ca126667c5eb1ea9c7f537d96bc9e51c67b18cfa',
 );
diff --git a/yarn-project/pxe/src/pxe_service/error_enriching.ts b/yarn-project/pxe/src/pxe_service/error_enriching.ts
index 6f40630e35d8..3cc946bfe3c3 100644
--- a/yarn-project/pxe/src/pxe_service/error_enriching.ts
+++ b/yarn-project/pxe/src/pxe_service/error_enriching.ts
@@ -1,7 +1,7 @@
 import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/circuit-types';
 import { AztecAddress, Fr, FunctionSelector, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
 import { type DebugLogger } from '@aztec/foundation/log';
-import { resolveAssertionMessage, resolveOpcodeLocations } from '@aztec/simulator';
+import { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '@aztec/simulator';
 
 import { type ContractDataOracle, type PxeDatabase } from '../index.js';
 
@@ -54,6 +54,7 @@ export async function enrichSimulationError(err: SimulationError, db: PxeDatabas
 
 export async function enrichPublicSimulationError(
   err: SimulationError,
+  revertData: Fr[],
   contractDataOracle: ContractDataOracle,
   db: PxeDatabase,
   logger: DebugLogger,
@@ -64,17 +65,24 @@ export async function enrichPublicSimulationError(
   // To be able to resolve the assertion message, we need to use the information from the public dispatch function,
   // no matter what the call stack selector points to (since we've modified it to point to the target function).
   // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
+
+  const artifact = await contractDataOracle.getFunctionArtifact(
+    originalFailingFunction.contractAddress,
+    FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+  );
+  const assertionMessage = resolveAssertionMessageFromRevertData(revertData, artifact);
+  if (assertionMessage) {
+    err.setOriginalMessage(err.getOriginalMessage() + `${assertionMessage}`);
+  }
+
   const debugInfo = await contractDataOracle.getFunctionDebugMetadata(
     originalFailingFunction.contractAddress,
     FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
   );
+
   const noirCallStack = err.getNoirCallStack();
   if (debugInfo) {
     if (isNoirCallStackUnresolved(noirCallStack)) {
-      const assertionMessage = resolveAssertionMessage(noirCallStack, debugInfo);
-      if (assertionMessage) {
-        err.setOriginalMessage(err.getOriginalMessage() + `: ${assertionMessage}`);
-      }
       try {
         // Public functions are simulated as a single Brillig entry point.
         // Thus, we can safely assume here that the Brillig function id is `0`.
diff --git a/yarn-project/pxe/src/pxe_service/pxe_service.ts b/yarn-project/pxe/src/pxe_service/pxe_service.ts
index 31490047558c..70c66a3eaa69 100644
--- a/yarn-project/pxe/src/pxe_service/pxe_service.ts
+++ b/yarn-project/pxe/src/pxe_service/pxe_service.ts
@@ -764,16 +764,18 @@ export class PXEService implements PXE {
    * @param tx - The transaction to be simulated.
    */
   async #simulatePublicCalls(tx: Tx) {
-    try {
-      return await this.node.simulatePublicCalls(tx);
-    } catch (err) {
-      // Try to fill in the noir call stack since the PXE may have access to the debug metadata
-      if (err instanceof SimulationError) {
-        await enrichPublicSimulationError(err, this.contractDataOracle, this.db, this.log);
-      }
-
-      throw err;
+    const result = await this.node.simulatePublicCalls(tx);
+    if (result.revertReason) {
+      await enrichPublicSimulationError(
+        result.revertReason,
+        result.publicReturnValues[0].values || [],
+        this.contractDataOracle,
+        this.db,
+        this.log,
+      );
+      throw result.revertReason;
     }
+    return result;
   }
 
   /**
diff --git a/yarn-project/simulator/package.json b/yarn-project/simulator/package.json
index 33694b0aea72..7489b5f85968 100644
--- a/yarn-project/simulator/package.json
+++ b/yarn-project/simulator/package.json
@@ -68,6 +68,7 @@
     "@aztec/types": "workspace:^",
     "@aztec/world-state": "workspace:^",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
+    "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi",
     "@noir-lang/types": "portal:../../noir/packages/types",
     "levelup": "^5.1.1",
     "memdown": "^6.1.1",
diff --git a/yarn-project/simulator/src/acvm/acvm.ts b/yarn-project/simulator/src/acvm/acvm.ts
index ba7b3aa05366..bbd031eb315d 100644
--- a/yarn-project/simulator/src/acvm/acvm.ts
+++ b/yarn-project/simulator/src/acvm/acvm.ts
@@ -1,13 +1,16 @@
 import { type NoirCallStack, type SourceCodeLocation } from '@aztec/circuit-types';
-import type { BrilligFunctionId, FunctionDebugMetadata, OpcodeLocation } from '@aztec/foundation/abi';
+import { type Fr } from '@aztec/circuits.js';
+import type { BrilligFunctionId, FunctionAbi, FunctionDebugMetadata, OpcodeLocation } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import {
   type ExecutionError,
   type ForeignCallInput,
   type ForeignCallOutput,
+  type RawAssertionPayload,
   executeCircuitWithReturnWitness,
 } from '@noir-lang/acvm_js';
+import { abiDecodeError } from '@noir-lang/noirc_abi';
 
 import { traverseCauseChain } from '../common/errors.js';
 import { type ACVMWitness } from './acvm_types.js';
@@ -103,26 +106,41 @@ export function resolveOpcodeLocations(
   );
 }
 
-/**
- * Extracts the source code locations for an array of opcode locations
- * @param opcodeLocations - The opcode locations that caused the error.
- * @param debug - The debug metadata of the function.
- * @returns The source code locations.
- */
-export function resolveAssertionMessage(
-  opcodeLocations: OpcodeLocation[],
-  debug: FunctionDebugMetadata,
-): string | undefined {
-  if (opcodeLocations.length === 0) {
-    return undefined;
+export function resolveAssertionMessage(errorPayload: RawAssertionPayload, abi: FunctionAbi): string | undefined {
+  const decoded = abiDecodeError(
+    { parameters: [], error_types: abi.errorTypes, return_type: null }, // eslint-disable-line camelcase
+    errorPayload,
+  );
+
+  if (typeof decoded === 'string') {
+    return decoded;
+  } else {
+    return JSON.stringify(decoded);
   }
+}
 
-  const lastLocation = extractBrilligLocation(opcodeLocations[opcodeLocations.length - 1]);
-  if (!lastLocation) {
+export function resolveAssertionMessageFromRevertData(revertData: Fr[], abi: FunctionAbi): string | undefined {
+  if (revertData.length == 0) {
     return undefined;
   }
 
-  return debug.assertMessages?.[parseInt(lastLocation, 10)];
+  const [errorSelector, ...errorData] = revertData;
+
+  return resolveAssertionMessage(
+    {
+      selector: errorSelector.toBigInt().toString(),
+      data: errorData.map(f => f.toString()),
+    },
+    abi,
+  );
+}
+
+export function resolveAssertionMessageFromError(err: Error, abi: FunctionAbi): string {
+  if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err && err.rawAssertionPayload) {
+    return `Assertion failed: ${resolveAssertionMessage(err.rawAssertionPayload as RawAssertionPayload, abi)}`;
+  } else {
+    return err.message;
+  }
 }
 
 /**
diff --git a/yarn-project/simulator/src/avm/avm_simulator.test.ts b/yarn-project/simulator/src/avm/avm_simulator.test.ts
index eb4beb17b6e1..0bb1fabce161 100644
--- a/yarn-project/simulator/src/avm/avm_simulator.test.ts
+++ b/yarn-project/simulator/src/avm/avm_simulator.test.ts
@@ -287,9 +287,9 @@ describe('AVM simulator: transpiled Noir contracts', () => {
       const results = await new AvmSimulator(initContext()).executeBytecode(bytecode);
       expect(results.reverted).toBe(true);
       expect(results.revertReason).toBeDefined();
-      expect(resolveAvmTestContractAssertionMessage('u128_addition_overflow', results.revertReason!)).toMatch(
-        'attempt to add with overflow',
-      );
+      expect(
+        resolveAvmTestContractAssertionMessage('u128_addition_overflow', results.revertReason!, results.output),
+      ).toMatch('attempt to add with overflow');
     });
 
     it('Expect failure on U128::from_integer() overflow', async () => {
@@ -297,9 +297,9 @@ describe('AVM simulator: transpiled Noir contracts', () => {
       const results = await new AvmSimulator(initContext()).executeBytecode(bytecode);
       expect(results.reverted).toBe(true);
       expect(results.revertReason).toBeDefined();
-      expect(resolveAvmTestContractAssertionMessage('u128_from_integer_overflow', results.revertReason!)).toMatch(
-        'call to assert_max_bit_size',
-      );
+      expect(
+        resolveAvmTestContractAssertionMessage('u128_from_integer_overflow', results.revertReason!, results.output),
+      ).toMatch('call to assert_max_bit_size');
     });
   });
 
@@ -321,10 +321,10 @@ describe('AVM simulator: transpiled Noir contracts', () => {
 
     expect(results.reverted).toBe(true);
     expect(results.revertReason).toBeDefined();
-    expect(resolveAvmTestContractAssertionMessage('assert_nullifier_exists', results.revertReason!)).toMatch(
-      "Nullifier doesn't exist!",
-    );
-    expect(results.output).toEqual([]);
+    expect(
+      resolveAvmTestContractAssertionMessage('assert_nullifier_exists', results.revertReason!, results.output),
+    ).toMatch("Nullifier doesn't exist!");
+    expect(results.output).toHaveLength(1); // Error selector for static string error
   });
 
   describe.each([
@@ -1011,9 +1011,9 @@ describe('AVM simulator: transpiled Noir contracts', () => {
         const results = await new AvmSimulator(context).executeBytecode(callBytecode);
         expect(results.reverted).toBe(true); // The outer call should revert.
         expect(results.revertReason).toBeDefined();
-        expect(resolveAvmTestContractAssertionMessage('public_dispatch', results.revertReason!)).toMatch(
-          'Values are not equal',
-        );
+        expect(
+          resolveAvmTestContractAssertionMessage('public_dispatch', results.revertReason!, results.output),
+        ).toMatch('Values are not equal');
       });
 
       it('Should handle returndatacopy oracle', async () => {
diff --git a/yarn-project/simulator/src/avm/avm_simulator.ts b/yarn-project/simulator/src/avm/avm_simulator.ts
index 582912a91e63..de8478283efa 100644
--- a/yarn-project/simulator/src/avm/avm_simulator.ts
+++ b/yarn-project/simulator/src/avm/avm_simulator.ts
@@ -12,6 +12,7 @@ import {
   AvmExecutionError,
   InvalidProgramCounterError,
   NoBytecodeForContractError,
+  revertDataFromExceptionalHalt,
   revertReasonFromExceptionalHalt,
   revertReasonFromExplicitRevert,
 } from './errors.js';
@@ -137,7 +138,11 @@ export class AvmSimulator {
 
       const revertReason = revertReasonFromExceptionalHalt(err, this.context);
       // Note: "exceptional halts" cannot return data, hence []
-      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], revertReason);
+      const results = new AvmContractCallResult(
+        /*reverted=*/ true,
+        /*output=*/ revertDataFromExceptionalHalt(err),
+        revertReason,
+      );
       this.log.debug(`Context execution results: ${results.toString()}`);
 
       this.printOpcodeTallies();
diff --git a/yarn-project/simulator/src/avm/errors.ts b/yarn-project/simulator/src/avm/errors.ts
index cafd6f92af00..9a311440f807 100644
--- a/yarn-project/simulator/src/avm/errors.ts
+++ b/yarn-project/simulator/src/avm/errors.ts
@@ -84,7 +84,7 @@ export class StaticCallAlterationError extends InstructionExecutionError {
  * @param nestedError - the revert reason of the nested call
  */
 export class RethrownError extends AvmExecutionError {
-  constructor(message: string, public nestedError: AvmRevertReason) {
+  constructor(message: string, public nestedError: AvmRevertReason, public revertData: Fr[]) {
     super(message);
     this.name = 'RethrownError';
   }
@@ -141,6 +141,15 @@ export function revertReasonFromExceptionalHalt(haltingError: AvmExecutionError,
   return createRevertReason(haltingError.message, context, nestedError);
 }
 
+/**
+ * Extracts revert data from an exceptional halt. Currently this is only used to manually bubble up revertadata.
+ * @param haltingError - the lower-level error causing the exceptional halt
+ * @returns the revert data for the exceptional halt
+ */
+export function revertDataFromExceptionalHalt(haltingError: AvmExecutionError): Fr[] {
+  return haltingError instanceof RethrownError ? haltingError.revertData : [];
+}
+
 /**
  * Create a "revert reason" error for an explicit revert (a root cause).
  *
diff --git a/yarn-project/simulator/src/avm/fixtures/index.ts b/yarn-project/simulator/src/avm/fixtures/index.ts
index 3b6495b52a6f..4b511b31ace4 100644
--- a/yarn-project/simulator/src/avm/fixtures/index.ts
+++ b/yarn-project/simulator/src/avm/fixtures/index.ts
@@ -1,6 +1,6 @@
 import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
 import { GasFees, GlobalVariables, MAX_L2_GAS_PER_ENQUEUED_CALL } from '@aztec/circuits.js';
-import { FunctionSelector, getFunctionDebugMetadata } from '@aztec/foundation/abi';
+import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -10,7 +10,7 @@ import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
-import { type WorldStateDB, resolveAssertionMessage, traverseCauseChain } from '../../index.js';
+import { type WorldStateDB, resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../index.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { AvmContext } from '../avm_context.js';
 import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
@@ -136,6 +136,7 @@ export function getAvmTestContractBytecode(functionName: string): Buffer {
 export function resolveAvmTestContractAssertionMessage(
   functionName: string,
   revertReason: AvmRevertReason,
+  output: Fr[],
 ): string | undefined {
   const functionArtifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
 
@@ -147,10 +148,5 @@ export function resolveAvmTestContractAssertionMessage(
     return undefined;
   }
 
-  const debugMetadata = getFunctionDebugMetadata(AvmTestContractArtifact, functionArtifact);
-  if (!debugMetadata) {
-    return undefined;
-  }
-
-  return resolveAssertionMessage(revertReason.noirCallStack, debugMetadata);
+  return resolveAssertionMessageFromRevertData(output, functionArtifact);
 }
diff --git a/yarn-project/simulator/src/avm/opcodes/control_flow.ts b/yarn-project/simulator/src/avm/opcodes/control_flow.ts
index 24ca6762777d..815f5025612e 100644
--- a/yarn-project/simulator/src/avm/opcodes/control_flow.ts
+++ b/yarn-project/simulator/src/avm/opcodes/control_flow.ts
@@ -72,7 +72,7 @@ export class InternalCall extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     context.machineState.consumeGas(this.gasCost());
 
-    context.machineState.internalCallStack.push(context.machineState.pc + 1);
+    context.machineState.internalCallStack.push(context.machineState.pc);
     context.machineState.pc = this.loc;
 
     context.machineState.memory.assert({});
@@ -96,7 +96,7 @@ export class InternalReturn extends Instruction {
     if (jumpOffset === undefined) {
       throw new InstructionExecutionError('Internal call stack empty!');
     }
-    context.machineState.pc = jumpOffset;
+    context.machineState.pc = jumpOffset + 1;
 
     context.machineState.memory.assert({});
   }
diff --git a/yarn-project/simulator/src/avm/opcodes/external_calls.ts b/yarn-project/simulator/src/avm/opcodes/external_calls.ts
index db6b658dade5..3a3aa66b6c8b 100644
--- a/yarn-project/simulator/src/avm/opcodes/external_calls.ts
+++ b/yarn-project/simulator/src/avm/opcodes/external_calls.ts
@@ -83,7 +83,11 @@ abstract class ExternalCall extends Instruction {
         throw new Error('A reverted nested call should be assigned a revert reason in the AVM execution loop');
       }
       // The nested call's revertReason will be used to track the stack of error causes down to the root.
-      throw new RethrownError(nestedCallResults.revertReason.message, nestedCallResults.revertReason);
+      throw new RethrownError(
+        nestedCallResults.revertReason.message,
+        nestedCallResults.revertReason,
+        nestedCallResults.output,
+      );
     }
 
     // Save return/revert data for later.
diff --git a/yarn-project/simulator/src/client/private_execution.ts b/yarn-project/simulator/src/client/private_execution.ts
index 662cfd13222a..d27db358c567 100644
--- a/yarn-project/simulator/src/client/private_execution.ts
+++ b/yarn-project/simulator/src/client/private_execution.ts
@@ -12,7 +12,7 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 
 import { fromACVMField, witnessMapToFields } from '../acvm/deserialize.js';
-import { type ACVMWitness, Oracle, acvm, extractCallStack } from '../acvm/index.js';
+import { type ACVMWitness, Oracle, acvm, extractCallStack, resolveAssertionMessageFromError } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
 import { type ClientExecutionContext } from './client_execution_context.js';
 
@@ -33,6 +33,7 @@ export async function executePrivateFunction(
   const acvmCallback = new Oracle(context);
   const timer = new Timer();
   const acirExecutionResult = await acvm(acir, initialWitness, acvmCallback).catch((err: Error) => {
+    err.message = resolveAssertionMessageFromError(err, artifact);
     throw new ExecutionError(
       err.message,
       {
diff --git a/yarn-project/simulator/src/client/unconstrained_execution.ts b/yarn-project/simulator/src/client/unconstrained_execution.ts
index 7fc622c6987f..f926b29bdca2 100644
--- a/yarn-project/simulator/src/client/unconstrained_execution.ts
+++ b/yarn-project/simulator/src/client/unconstrained_execution.ts
@@ -4,7 +4,7 @@ import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { witnessMapToFields } from '../acvm/deserialize.js';
-import { Oracle, acvm, extractCallStack, toACVMWitness } from '../acvm/index.js';
+import { Oracle, acvm, extractCallStack, resolveAssertionMessageFromError, toACVMWitness } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
 import { type ViewDataOracle } from './view_data_oracle.js';
 
@@ -25,6 +25,7 @@ export async function executeUnconstrainedFunction(
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
   const acirExecutionResult = await acvm(acir, initialWitness, new Oracle(oracle)).catch((err: Error) => {
+    err.message = resolveAssertionMessageFromError(err, artifact);
     throw new ExecutionError(
       err.message,
       {
diff --git a/yarn-project/simulator/src/public/enqueued_call_simulator.ts b/yarn-project/simulator/src/public/enqueued_call_simulator.ts
index e33679b7e23a..c5c501ef551e 100644
--- a/yarn-project/simulator/src/public/enqueued_call_simulator.ts
+++ b/yarn-project/simulator/src/public/enqueued_call_simulator.ts
@@ -218,7 +218,9 @@ export class EnqueuedCallSimulator {
           avmProvingRequest,
           kernelOutput,
           newUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
-          returnValues: NestedProcessReturnValues.empty(),
+          // TODO: Following the above comment, we should continue when a frame reverts and collect all the return/revert data of all frames.
+          // For now, since we stop at the first revert, we can only return the revert reason of the first frame that reverts.
+          returnValues: new NestedProcessReturnValues(result.returnValues),
           gasUsed,
           revertReason: result.revertReason,
         };
diff --git a/yarn-project/simulator/src/public/enqueued_calls_processor.ts b/yarn-project/simulator/src/public/enqueued_calls_processor.ts
index f76be43b1549..6d0d1616d358 100644
--- a/yarn-project/simulator/src/public/enqueued_calls_processor.ts
+++ b/yarn-project/simulator/src/public/enqueued_calls_processor.ts
@@ -300,7 +300,7 @@ export class EnqueuedCallsProcessor {
       publicKernelOutput,
       durationMs: phaseTimer.ms(),
       gasUsed,
-      returnValues: revertReason ? [] : returnValues,
+      returnValues: returnValues,
       revertReason,
     };
   }
diff --git a/yarn-project/txe/src/oracle/txe_oracle.ts b/yarn-project/txe/src/oracle/txe_oracle.ts
index 01c7dc312bbd..b73adb1bb328 100644
--- a/yarn-project/txe/src/oracle/txe_oracle.ts
+++ b/yarn-project/txe/src/oracle/txe_oracle.ts
@@ -67,6 +67,7 @@ import {
   extractCallStack,
   extractPrivateCircuitPublicInputs,
   pickNotes,
+  resolveAssertionMessageFromError,
   toACVMWitness,
   witnessMapToFields,
 } from '@aztec/simulator';
@@ -536,6 +537,8 @@ export class TXE implements TypedOracle {
     const timer = new Timer();
     try {
       const acirExecutionResult = await acvm(acir, initialWitness, acvmCallback).catch((err: Error) => {
+        err.message = resolveAssertionMessageFromError(err, artifact);
+
         const execError = new ExecutionError(
           err.message,
           {
@@ -692,6 +695,7 @@ export class TXE implements TypedOracle {
       if (executionResult.revertReason && executionResult.revertReason instanceof SimulationError) {
         await enrichPublicSimulationError(
           executionResult.revertReason,
+          executionResult.returnValues,
           this.contractDataOracle,
           this.txeDatabase,
           this.logger,
diff --git a/yarn-project/txe/src/txe_service/txe_service.ts b/yarn-project/txe/src/txe_service/txe_service.ts
index 52ceb74f06f5..c5d36e100f38 100644
--- a/yarn-project/txe/src/txe_service/txe_service.ts
+++ b/yarn-project/txe/src/txe_service/txe_service.ts
@@ -743,6 +743,7 @@ export class TXEService {
       if (result.revertReason && result.revertReason instanceof SimulationError) {
         await enrichPublicSimulationError(
           result.revertReason,
+          result.returnValues,
           (this.typedOracle as TXE).getContractDataOracle(),
           (this.typedOracle as TXE).getTXEDatabase(),
           this.logger,
@@ -773,6 +774,7 @@ export class TXEService {
       if (result.revertReason && result.revertReason instanceof SimulationError) {
         await enrichPublicSimulationError(
           result.revertReason,
+          result.returnValues,
           (this.typedOracle as TXE).getContractDataOracle(),
           (this.typedOracle as TXE).getTXEDatabase(),
           this.logger,
diff --git a/yarn-project/types/src/abi/contract_artifact.ts b/yarn-project/types/src/abi/contract_artifact.ts
index a474920eddf3..73896129f2f7 100644
--- a/yarn-project/types/src/abi/contract_artifact.ts
+++ b/yarn-project/types/src/abi/contract_artifact.ts
@@ -182,7 +182,7 @@ function generateFunctionArtifact(fn: NoirCompiledContractFunction, contract: No
     bytecode: Buffer.from(fn.bytecode, 'base64'),
     verificationKey: mockVerificationKey,
     debugSymbols: fn.debug_symbols,
-    assertMessages: fn.assert_messages,
+    errorTypes: fn.abi.error_types,
   };
 }
 
diff --git a/yarn-project/types/src/noir/index.ts b/yarn-project/types/src/noir/index.ts
index 57fefa79aee5..bfe1d3959071 100644
--- a/yarn-project/types/src/noir/index.ts
+++ b/yarn-project/types/src/noir/index.ts
@@ -1,6 +1,7 @@
 import {
   type ABIParameter,
   type ABIParameterVisibility,
+  type AbiErrorType,
   type AbiType,
   type AbiValue,
   type DebugFileMap,
@@ -13,17 +14,6 @@ export const AZTEC_INTERNAL_ATTRIBUTE = 'internal';
 export const AZTEC_INITIALIZER_ATTRIBUTE = 'initializer';
 export const AZTEC_VIEW_ATTRIBUTE = 'view';
 
-/**
- * An error could be a custom error of any regular type or a formatted string error.
- */
-export type AbiErrorType =
-  | {
-      error_kind: 'fmtstring';
-      length: number;
-      item_types: AbiType[];
-    }
-  | ({ error_kind: 'custom' } & AbiType);
-
 /** The ABI of an Aztec.nr function. */
 export interface NoirFunctionAbi {
   /** The parameters of the function. */
diff --git a/yarn-project/yarn.lock b/yarn-project/yarn.lock
index 16c668952a98..0ac57bd35d08 100644
--- a/yarn-project/yarn.lock
+++ b/yarn-project/yarn.lock
@@ -1131,6 +1131,7 @@ __metadata:
     "@aztec/world-state": "workspace:^"
     "@jest/globals": ^29.5.0
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js"
+    "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi"
     "@noir-lang/types": "portal:../../noir/packages/types"
     "@types/jest": ^29.5.0
     "@types/levelup": ^5.1.3