feat: Parsing non-string assertion payloads in noir js

noir/noir-repo/acvm-repo/acir/src/circuit/mod.rs

@@ -75,12 +75,6 @@ pub struct Circuit {
     pub recursive: bool,
 }
 
-/// 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: u64 = 0;
-
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum ExpressionOrMemory {
     Expression(Expression),
@@ -93,10 +87,55 @@ pub enum AssertionPayload {
     Dynamic(/* error_selector */ u64, Vec<ExpressionOrMemory>),
 }
 
+#[derive(Debug, Copy, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
+pub struct ErrorSelector(u64);
+
+impl ErrorSelector {
+    pub fn new(integer: u64) -> Self {
+        ErrorSelector(integer)
+    }
+
+    pub fn as_u64(&self) -> u64 {
+        self.0
+    }
+}
+
+impl Serialize for ErrorSelector {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.0.to_string().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for ErrorSelector {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: String = Deserialize::deserialize(deserializer)?;
+        let as_u64 = s.parse().map_err(serde::de::Error::custom)?;
+        Ok(ErrorSelector(as_u64))
+    }
+}
+
+/// 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 {
+    pub selector: ErrorSelector,
+    pub data: Vec<FieldElement>,
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum ResolvedAssertionPayload {
     String(String),
-    Raw(/*error_selector:*/ u64, Vec<FieldElement>),
+    Raw(RawAssertionPayload),
 }
 
 #[derive(Debug, Copy, Clone)]

noir/noir-repo/acvm-repo/acvm/src/pwg/brillig.rs

@@ -5,7 +5,8 @@ use acir::{
     circuit::{
         brillig::{BrilligInputs, BrilligOutputs},
         opcodes::BlockId,
-        OpcodeLocation, ResolvedAssertionPayload, STRING_ERROR_SELECTOR,
+        ErrorSelector, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
+        STRING_ERROR_SELECTOR,
     },
     native_types::WitnessMap,
     FieldElement,
@@ -173,11 +174,13 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
                             let mut revert_values_iter = memory
                                 [revert_data_offset..(revert_data_offset + revert_data_size)]
                                 .iter();
-                            let error_selector = revert_values_iter
-                                .next()
-                                .expect("Incorrect revert data size")
-                                .try_into()
-                                .expect("Error selector is not u64");
+                            let error_selector = ErrorSelector::new(
+                                revert_values_iter
+                                    .next()
+                                    .expect("Incorrect revert data size")
+                                    .try_into()
+                                    .expect("Error selector is not u64"),
+                            );
 
                             match error_selector {
                                 STRING_ERROR_SELECTOR => {
@@ -194,10 +197,12 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
                                 }
                                 _ => {
                                     // If the error selector is not 0, it means the error is a custom error
-                                    Some(ResolvedAssertionPayload::Raw(
-                                        error_selector,
-                                        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(),
+                                    }))
                                 }
                             }
                         }

noir/noir-repo/acvm-repo/acvm/src/pwg/mod.rs

@@ -5,8 +5,9 @@ use std::collections::HashMap;
 use acir::{
     brillig::ForeignCallResult,
     circuit::{
-        brillig::BrilligBytecode, opcodes::BlockId, AssertionPayload, ExpressionOrMemory, Opcode,
-        OpcodeLocation, ResolvedAssertionPayload, STRING_ERROR_SELECTOR,
+        brillig::BrilligBytecode, opcodes::BlockId, AssertionPayload, ErrorSelector,
+        ExpressionOrMemory, Opcode, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
+        STRING_ERROR_SELECTOR,
     },
     native_types::{Expression, Witness, WitnessMap},
     BlackBoxFunc, FieldElement,
@@ -425,8 +426,9 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                         }
                     }
                 }
+                let error_selector = ErrorSelector::new(*error_selector);
 
-                Some(match *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
@@ -444,7 +446,10 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                     }
                     _ => {
                         // If the error selector is not 0, it means the error is a custom error
-                        ResolvedAssertionPayload::Raw(*error_selector, fields)
+                        ResolvedAssertionPayload::Raw(RawAssertionPayload {
+                            selector: error_selector,
+                            data: fields,
+                        })
                     }
                 })
             }

noir/noir-repo/acvm-repo/acvm_js/src/execute.rs

@@ -272,7 +272,7 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
                         };
                         // If the failed opcode has an assertion message, integrate it into the error message for backwards compatibility.
                         // Otherwise, pass the raw assertion payload as is.
-                        let (message, raw_assertion_payload) = match &error {
+                        let (message, raw_assertion_payload) = match error {
                             OpcodeResolutionError::UnsatisfiedConstrain {
                                 payload: Some(payload),
                                 ..
@@ -281,8 +281,8 @@ impl<'a, B: BlackBoxFunctionSolver> ProgramExecutor<'a, B> {
                                 payload: Some(payload),
                                 ..
                             } => match payload {
-                                ResolvedAssertionPayload::Raw(selector, fields) => {
-                                    (error.to_string(), Some((*selector, fields.clone())))
+                                ResolvedAssertionPayload::Raw(raw_payload) => {
+                                    ("Assertion failed".to_string(), Some(raw_payload))
                                 }
                                 ResolvedAssertionPayload::String(message) => {
                                     (format!("Assertion failed: {}", message), None)

noir/noir-repo/acvm-repo/acvm_js/src/js_execution_error.rs

@@ -1,14 +1,13 @@
-use acvm::{acir::circuit::OpcodeLocation, FieldElement};
-use js_sys::{Array, Error, JsString, Map, Object, Reflect};
+use acvm::acir::circuit::{OpcodeLocation, RawAssertionPayload};
+use gloo_utils::format::JsValueSerdeExt;
+use js_sys::{Array, Error, JsString, Reflect};
 use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
 
-use crate::js_witness_map::field_element_to_js_string;
-
 #[wasm_bindgen(typescript_custom_section)]
 const EXECUTION_ERROR: &'static str = r#"
 export type RawAssertionPayload = {
-    selector: number;
-    fields: string[];
+    selector: string;
+    data: string[];
 };
 export type ExecutionError = Error & {
     callStack?: string[];
@@ -35,7 +34,7 @@ impl JsExecutionError {
     pub fn new(
         message: String,
         call_stack: Option<Vec<OpcodeLocation>>,
-        assertion_payload: Option<(u64, Vec<FieldElement>)>,
+        assertion_payload: Option<RawAssertionPayload>,
     ) -> Self {
         let mut error = JsExecutionError::constructor(JsString::from(message));
         let js_call_stack = match call_stack {
@@ -49,18 +48,8 @@ impl JsExecutionError {
             None => JsValue::UNDEFINED,
         };
         let assertion_payload = match assertion_payload {
-            Some((selector, fields)) => {
-                let raw_payload_map = Map::new();
-                raw_payload_map
-                    .set(&JsValue::from_str("selector"), &JsValue::from(selector.to_string()));
-                let js_fields = Array::new();
-                for field in fields {
-                    js_fields.push(&field_element_to_js_string(&field));
-                }
-                raw_payload_map.set(&JsValue::from_str("fields"), &js_fields.into());
-
-                Object::from_entries(&raw_payload_map).unwrap().into()
-            }
+            Some(raw) => <wasm_bindgen::JsValue as JsValueSerdeExt>::from_serde(&raw)
+                .expect("Cannot serialize assertion payload"),
             None => JsValue::UNDEFINED,
         };
 

noir/noir-repo/compiler/noirc_driver/src/abi_gen.rs

@@ -1,5 +1,6 @@
 use std::collections::BTreeMap;
 
+use acvm::acir::circuit::ErrorSelector;
 use acvm::acir::native_types::Witness;
 use iter_extended::{btree_map, vecmap};
 use noirc_abi::{Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue};
@@ -20,7 +21,7 @@ pub(super) fn gen_abi(
     input_witnesses: Vec<Witness>,
     return_witnesses: Vec<Witness>,
     return_visibility: Visibility,
-    error_types: BTreeMap<u64, Type>,
+    error_types: BTreeMap<ErrorSelector, Type>,
 ) -> Abi {
     let (parameters, return_type) = compute_function_abi(context, func_id);
     let param_witnesses = param_witnesses_from_abi_param(&parameters, input_witnesses);

noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs

@@ -270,7 +270,7 @@ impl<'block> BrilligBlock<'block> {
                             condition,
                             payload_values,
                             payload_as_params,
-                            selector.to_u64(),
+                            selector.as_u64(),
                         );
                     }
                     Some(ConstrainError::Intrinsic(message)) => {

noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs

@@ -12,7 +12,8 @@ use std::collections::{BTreeMap, BTreeSet};
 use crate::errors::{RuntimeError, SsaReport};
 use acvm::acir::{
     circuit::{
-        brillig::BrilligBytecode, Circuit, ExpressionWidth, Program as AcirProgram, PublicInputs,
+        brillig::BrilligBytecode, Circuit, ErrorSelector, ExpressionWidth, Program as AcirProgram,
+        PublicInputs,
     },
     native_types::Witness,
 };
@@ -103,13 +104,13 @@ pub struct SsaProgramArtifact {
     pub main_input_witnesses: Vec<Witness>,
     pub main_return_witnesses: Vec<Witness>,
     pub names: Vec<String>,
-    pub error_types: BTreeMap<u64, HirType>,
+    pub error_types: BTreeMap<ErrorSelector, HirType>,
 }
 
 impl SsaProgramArtifact {
     fn new(
         unconstrained_functions: Vec<BrilligBytecode>,
-        error_types: BTreeMap<u64, HirType>,
+        error_types: BTreeMap<ErrorSelector, HirType>,
     ) -> Self {
         let program = AcirProgram { functions: Vec::default(), unconstrained_functions };
         Self {
@@ -167,11 +168,6 @@ pub fn create_program(
         "The generated ACIRs should match the supplied function signatures"
     );
 
-    let error_types = error_types
-        .into_iter()
-        .map(|(error_typ_id, error_typ)| (error_typ_id.to_u64(), error_typ))
-        .collect();
-
     let mut program_artifact = SsaProgramArtifact::new(generated_brillig, error_types);
     // For setting up the ABI we need separately specify main's input and return witnesses
     let mut is_main = true;

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, ErrorSelector, ErrorType};
+use super::ir::instruction::{ConstrainError, ErrorType};
 use super::ir::printer::try_to_extract_string_from_error_payload;
 use super::{
     ir::{
@@ -32,7 +32,7 @@ pub(crate) use acir_ir::generated_acir::GeneratedAcir;
 use noirc_frontend::monomorphization::ast::InlineType;
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
-use acvm::acir::circuit::{AssertionPayload, OpcodeLocation};
+use acvm::acir::circuit::{AssertionPayload, ErrorSelector, OpcodeLocation};
 use acvm::acir::native_types::Witness;
 use acvm::acir::BlackBoxFunc;
 use acvm::{
@@ -639,7 +639,7 @@ impl<'a> Context<'a> {
                                     self.acir_context.vars_to_expressions_or_memory(&acir_vars)?;
 
                                 Some(AssertionPayload::Dynamic(
-                                    error_selector.to_u64(),
+                                    error_selector.as_u64(),
                                     expressions_or_memory,
                                 ))
                             }

noir/noir-repo/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs

@@ -2,14 +2,14 @@ pub(crate) mod data_bus;
 
 use std::{borrow::Cow, collections::BTreeMap, rc::Rc};
 
-use acvm::FieldElement;
+use acvm::{acir::circuit::ErrorSelector, FieldElement};
 use noirc_errors::Location;
 use noirc_frontend::monomorphization::ast::InlineType;
 
 use crate::ssa::ir::{
     basic_block::BasicBlockId,
     function::{Function, FunctionId},
-    instruction::{Binary, BinaryOp, ErrorSelector, Instruction, TerminatorInstruction},
+    instruction::{Binary, BinaryOp, Instruction, TerminatorInstruction},
     types::Type,
     value::{Value, ValueId},
 };

noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction.rs

@@ -1,7 +1,10 @@
 use std::hash::{Hash, Hasher};
 
 use acvm::{
-    acir::{circuit::STRING_ERROR_SELECTOR, BlackBoxFunc},
+    acir::{
+        circuit::{ErrorSelector, STRING_ERROR_SELECTOR},
+        BlackBoxFunc,
+    },
     FieldElement,
 };
 use fxhash::FxHasher;
@@ -605,26 +608,17 @@ impl Instruction {
 
 pub(crate) type ErrorType = HirType;
 
-#[derive(Debug, Copy, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
-pub(crate) struct ErrorSelector(u64);
-
-impl ErrorSelector {
-    pub(crate) fn new(typ: &ErrorType) -> Self {
-        match typ {
-            ErrorType::String(_) => Self(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);
-                Self(hash)
-            }
+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)
         }
     }
-
-    pub(crate) fn to_u64(self) -> u64 {
-        self.0
-    }
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]