zksync_error/
serialized.rs1use crate::{
5 error::{IError, IUnifiedError},
6 identifier::{Identifier, StructuredErrorCode},
7 kind::Kind,
8 packed::PackedError,
9 untyped::UntypedErrorObject,
10};
11use std::error::Error;
12use std::fmt::Debug;
13pub type ErrorCode = u32;
14#[derive(Clone, Debug, Eq, PartialEq, serde :: Serialize, serde :: Deserialize)]
15pub struct SerializedError {
16 pub code: ErrorCode,
17 pub message: String,
18 pub data: serde_json::Value,
19}
20impl SerializedError {
21 pub fn new_custom(
22 kind: Kind,
23 code: ErrorCode,
24 message: impl Into<String>,
25 unified_error_json: serde_json::Value,
26 ) -> Self {
27 SerializedError {
28 code: Identifier::new(kind, code).encode(),
29 message: message.into(),
30 data: unified_error_json,
31 }
32 }
33}
34impl std::fmt::Display for SerializedError {
35 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
36 f.write_fmt(format_args!(
37 "{{ code: {}; message: \"{}\"; data: \"{}\"}}",
38 self.code, self.message, self.data
39 ))
40 }
41}
42pub fn serialize<U>(error: PackedError<U>) -> Result<SerializedError, serde_json::Error>
43where
44 U: serde::Serialize + Clone + Debug,
45{
46 Ok(SerializedError {
47 code: error.identifier.encode(),
48 message: error.message,
49 data: serde_json::value::to_value(&error.data)?,
50 })
51}
52pub fn serialize_ref<U>(error: &PackedError<U>) -> Result<SerializedError, serde_json::Error>
53where
54 U: serde::Serialize + Clone + Debug,
55{
56 Ok(SerializedError {
57 code: error.identifier.encode(),
58 message: error.message.clone(),
59 data: serde_json::value::to_value(&error.data)?,
60 })
61}
62pub fn unpack_untyped(se: &SerializedError) -> Result<UntypedErrorObject, serde_json::Error> {
63 let identifier = Identifier::decode(StructuredErrorCode::decode(se.code)).unwrap();
64 let skip_domain = se.data.as_object().unwrap().values().next().unwrap();
65 let skip_subdomain = skip_domain.as_object().unwrap().values().next().unwrap();
66 let (name, value) = skip_subdomain.as_object().unwrap().iter().next().unwrap();
67 let fields: serde_json::Map<String, serde_json::Value> = value.as_object().unwrap().clone();
68 Ok(UntypedErrorObject {
69 identifier,
70 name: name.clone(),
71 fields,
72 raw: se.data.clone(),
73 })
74}
75pub fn unpack_typed<T>(se: &SerializedError) -> Result<T, serde_json::Error>
76where
77 T: IUnifiedError<T> + serde::Serialize + for<'de> serde::Deserialize<'de> + Clone,
78{
79 serde_json::value::from_value(se.data.clone())
80}
81impl Error for SerializedError {}
82impl IError<UntypedErrorObject> for SerializedError {
83 fn get_identifier(&self) -> Identifier {
84 Identifier::decode(StructuredErrorCode::decode(self.code)).unwrap()
85 }
86 fn get_message(&self) -> String {
87 self.message.clone()
88 }
89 fn get_data(&self) -> UntypedErrorObject {
90 unpack_untyped(self).expect("Internal error")
91 }
92}