Move HexBinary

Author: aumetra

Cargo.lock

@@ -12,6 +12,7 @@ base64 = { version = "0.21.0", default-features = false, features = ["alloc"] }
 bnum = "0.10.0"
 crc32fast = { version = "1.4.0", optional = true, default-features = false }
 derive_more = { version = "1.0.0-beta.6", default-features = false, features = ["display", "from"] }
+hex = { version = "0.4.3", default-features = false, features = ["alloc"] }
 schemars = { version = "0.8.16", optional = true }
 serde = { version = "1.0.197", default-features = false, features = ["derive"] }
 serde-json-wasm = { version = "1.0.1", default-features = false }

contracts/burner/Cargo.lock

@@ -17,20 +17,8 @@ pub enum CoreError {
         actual: u64,
         backtrace: BT,
     },
-    #[display("Error parsing into type {target_type}: {msg}")]
-    ParseErr {
-        /// the target type that was attempted
-        target_type: String,
-        msg: String,
-        backtrace: BT,
-    },
-    #[display("Error serializing type {source_type}: {msg}")]
-    SerializeErr {
-        /// the source type that was attempted
-        source_type: String,
-        msg: String,
-        backtrace: BT,
-    },
+    #[display("Invalid hex string: {msg}")]
+    InvalidHex { msg: String, backtrace: BT },
     #[display("Overflow: {source}")]
     Overflow {
         source: OverflowError,
@@ -81,17 +69,8 @@ impl CoreError {
         }
     }
 
-    pub fn parse_err(target: impl Into<String>, msg: impl ToString) -> Self {
-        CoreError::ParseErr {
-            target_type: target.into(),
-            msg: msg.to_string(),
-            backtrace: BT::capture(),
-        }
-    }
-
-    pub fn serialize_err(source: impl Into<String>, msg: impl ToString) -> Self {
-        CoreError::SerializeErr {
-            source_type: source.into(),
+    pub fn invalid_hex(msg: impl ToString) -> Self {
+        CoreError::InvalidHex {
             msg: msg.to_string(),
             backtrace: BT::capture(),
         }
@@ -153,34 +132,13 @@ impl PartialEq<CoreError> for CoreError {
                     false
                 }
             }
-            CoreError::ParseErr {
-                target_type,
-                msg,
-                backtrace: _,
-            } => {
-                if let CoreError::ParseErr {
-                    target_type: rhs_target_type,
-                    msg: rhs_msg,
-                    backtrace: _,
-                } = rhs
-                {
-                    target_type == rhs_target_type && msg == rhs_msg
-                } else {
-                    false
-                }
-            }
-            CoreError::SerializeErr {
-                source_type,
-                msg,
-                backtrace: _,
-            } => {
-                if let CoreError::SerializeErr {
-                    source_type: rhs_source_type,
+            CoreError::InvalidHex { msg, backtrace: _ } => {
+                if let CoreError::InvalidHex {
                     msg: rhs_msg,
                     backtrace: _,
                 } = rhs
                 {
-                    source_type == rhs_source_type && msg == rhs_msg
+                    msg == rhs_msg
                 } else {
                     false
                 }