Switch to alloy (#8)

* chore(deps): change ethereum-types to alloy-primitives (#7) f f * Add additional utils (#9) * add bytes_20_hex * add bytes_20_hex * add bytes_20_hex * add address utils * add address utils * add b256 utils * remove ssz feature flag * Add tests for B256 --------- Co-authored-by: Kolby Moroz Liebl <31669092+KolbyML@users.noreply.github.com> Co-authored-by: Eitan Seri-Levi <eserilev@gmail.com>
sigp · Aug 15, 2024 · c74ceb5 · c74ceb5
1 parent 9dbafae
commit c74ceb5
Show file tree

Hide file tree

Showing 7 changed files with 196 additions and 43 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -14,8 +14,8 @@ categories = ["cryptography::cryptocurrencies"]
 name = "serde_utils"
 
 [dependencies]
+alloy-primitives = { version = "0.7.7", features = ["serde"] }
 serde = { version = "1.0.0", features = ["derive"] }
 serde_derive = "1.0.0"
 serde_json = "1.0.0"
 hex = "0.4.3"
-ethereum-types = "0.14.1"
diff --git a/src/address_hex.rs b/src/address_hex.rs
@@ -0,0 +1,34 @@
+use alloy_primitives::Address;
+use serde::de::Error;
+use serde::{Deserializer, Serializer};
+
+use crate::hex::PrefixedHexVisitor;
+
+pub fn serialize<S>(address: &Address, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut hex_string: String = "0x".to_string();
+    hex_string.push_str(&hex::encode(&address));
+
+    serializer.serialize_str(&hex_string)
+}
+
+pub fn deserialize<'de, D>(deserializer: D) -> Result<Address, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let decoded = deserializer.deserialize_str(PrefixedHexVisitor)?;
+
+    if decoded.len() != 20 {
+        return Err(D::Error::custom(format!(
+            "expected {} bytes for array, got {}",
+            20,
+            decoded.len()
+        )));
+    }
+
+    let mut array = [0; 20];
+    array.copy_from_slice(&decoded);
+    Ok(array.into())
+}
diff --git a/src/b256_hex.rs b/src/b256_hex.rs
@@ -0,0 +1,100 @@
+use alloy_primitives::B256;
+use serde::de::Error;
+use serde::{Deserializer, Serializer};
+
+use crate::hex::PrefixedHexVisitor;
+
+pub fn serialize<S>(hash: &B256, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut hex_string: String = "0x".to_string();
+    hex_string.push_str(&hex::encode(&hash));
+
+    serializer.serialize_str(&hex_string)
+}
+
+pub fn deserialize<'de, D>(deserializer: D) -> Result<B256, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let decoded = deserializer.deserialize_str(PrefixedHexVisitor)?;
+
+    if decoded.len() != 32 {
+        return Err(D::Error::custom(format!(
+            "expected {} bytes for array, got {}",
+            32,
+            decoded.len()
+        )));
+    }
+
+    let mut array = [0; 32];
+    array.copy_from_slice(&decoded);
+    Ok(array.into())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(transparent)]
+    struct Wrapper {
+        #[serde(with = "super")]
+        val: B256,
+    }
+
+    #[test]
+    fn encoding() {
+        assert_eq!(
+            &serde_json::to_string(&Wrapper { val: B256::ZERO }).unwrap(),
+            "\"0x0000000000000000000000000000000000000000000000000000000000000000\""
+        );
+        assert_eq!(
+            &serde_json::to_string(&Wrapper {
+                val: B256::with_last_byte(0x03)
+            })
+            .unwrap(),
+            "\"0x0000000000000000000000000000000000000000000000000000000000000003\""
+        );
+        assert_eq!(
+            &serde_json::to_string(&Wrapper {
+                val: B256::repeat_byte(0x03)
+            })
+            .unwrap(),
+            "\"0x0303030303030303030303030303030303030303030303030303030303030303\""
+        );
+    }
+
+    #[test]
+    fn decoding() {
+        assert_eq!(
+            serde_json::from_str::<Wrapper>(
+                "\"0x0000000000000000000000000000000000000000000000000000000000000000\""
+            )
+            .unwrap(),
+            Wrapper { val: B256::ZERO },
+        );
+        assert_eq!(
+            serde_json::from_str::<Wrapper>(
+                "\"0x0000000000000000000000000000000000000000000000000000000000000003\""
+            )
+            .unwrap(),
+            Wrapper {
+                val: B256::with_last_byte(0x03)
+            },
+        );
+
+        // Require 0x.
+        serde_json::from_str::<Wrapper>(
+            "\"0000000000000000000000000000000000000000000000000000000000000000\"",
+        )
+        .unwrap_err();
+        // Wrong length.
+        serde_json::from_str::<Wrapper>(
+            "\"0x00000000000000000000000000000000000000000000000000000000000000\"",
+        )
+        .unwrap_err();
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,5 +1,7 @@
 mod quoted_int;
 
+pub mod address_hex;
+pub mod b256_hex;
 pub mod fixed_bytes_hex;
 pub mod hex;
 pub mod hex_vec;

diff --git a/src/quoted_int.rs b/src/quoted_int.rs
@@ -4,7 +4,7 @@
 //!
 //! Quotes can be optional during decoding.
 
-use ethereum_types::U256;
+use alloy_primitives::U256;
 use serde::{Deserializer, Serializer};
 use serde_derive::{Deserialize, Serialize};
 use std::convert::TryFrom;
@@ -177,7 +177,7 @@ pub mod quoted_u256 {
         where
             E: serde::de::Error,
         {
-            U256::from_dec_str(v).map_err(serde::de::Error::custom)
+            U256::from_str_radix(v, 10).map_err(serde::de::Error::custom)
         }
     }
 
@@ -209,12 +209,12 @@ mod test {
     #[test]
     fn u256_with_quotes() {
         assert_eq!(
-            &serde_json::to_string(&WrappedU256(U256::one())).unwrap(),
+            &serde_json::to_string(&WrappedU256(U256::from(1))).unwrap(),
             "\"1\""
         );
         assert_eq!(
             serde_json::from_str::<WrappedU256>("\"1\"").unwrap(),
-            WrappedU256(U256::one())
+            WrappedU256(U256::from(1))
         );
     }
 

diff --git a/src/u256_dec.rs b/src/u256_dec.rs
@@ -1,4 +1,4 @@
-use ethereum_types::U256;
+use alloy_primitives::U256;
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 
 pub fn serialize<S>(num: &U256, serializer: S) -> Result<S::Ok, S::Error>
@@ -13,12 +13,12 @@ where
     D: Deserializer<'de>,
 {
     let s = String::deserialize(deserializer)?;
-    U256::from_dec_str(&s).map_err(|e| de::Error::custom(format!("Invalid U256 string: {e}")))
+    U256::from_str_radix(&s, 10).map_err(|e| de::Error::custom(format!("Invalid U256 string: {e}")))
 }
 
 #[cfg(test)]
 mod test {
-    use ethereum_types::U256;
+    use alloy_primitives::U256;
     use serde::{Deserialize, Serialize};
     use serde_json;
 
@@ -32,37 +32,43 @@ mod test {
     #[test]
     fn encoding() {
         assert_eq!(
-            &serde_json::to_string(&Wrapper { val: 0.into() }).unwrap(),
+            &serde_json::to_string(&Wrapper { val: U256::from(0) }).unwrap(),
             "\"0\""
         );
         assert_eq!(
-            &serde_json::to_string(&Wrapper { val: 1.into() }).unwrap(),
+            &serde_json::to_string(&Wrapper { val: U256::from(1) }).unwrap(),
             "\"1\""
         );
         assert_eq!(
-            &serde_json::to_string(&Wrapper { val: 256.into() }).unwrap(),
+            &serde_json::to_string(&Wrapper {
+                val: U256::from(256)
+            })
+            .unwrap(),
             "\"256\""
         );
         assert_eq!(
-            &serde_json::to_string(&Wrapper { val: 65.into() }).unwrap(),
+            &serde_json::to_string(&Wrapper {
+                val: U256::from(65)
+            })
+            .unwrap(),
             "\"65\""
         );
         assert_eq!(
-            &serde_json::to_string(&Wrapper { val: 1024.into() }).unwrap(),
+            &serde_json::to_string(&Wrapper {
+                val: U256::from(1024)
+            })
+            .unwrap(),
             "\"1024\""
         );
         assert_eq!(
             &serde_json::to_string(&Wrapper {
-                val: U256::max_value() - 1
+                val: U256::MAX - U256::from(1)
             })
             .unwrap(),
             "\"115792089237316195423570985008687907853269984665640564039457584007913129639934\""
         );
         assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: U256::max_value()
-            })
-            .unwrap(),
+            &serde_json::to_string(&Wrapper { val: U256::MAX }).unwrap(),
             "\"115792089237316195423570985008687907853269984665640564039457584007913129639935\""
         );
     }
@@ -71,23 +77,27 @@ mod test {
     fn decoding() {
         assert_eq!(
             serde_json::from_str::<Wrapper>("\"0\"").unwrap(),
-            Wrapper { val: 0.into() },
+            Wrapper { val: U256::from(0) },
         );
         assert_eq!(
             serde_json::from_str::<Wrapper>("\"65\"").unwrap(),
-            Wrapper { val: 65.into() },
+            Wrapper {
+                val: U256::from(65)
+            },
         );
         assert_eq!(
             serde_json::from_str::<Wrapper>("\"1024\"").unwrap(),
-            Wrapper { val: 1024.into() },
+            Wrapper {
+                val: U256::from(1024)
+            },
         );
         assert_eq!(
             serde_json::from_str::<Wrapper>(
                 "\"115792089237316195423570985008687907853269984665640564039457584007913129639934\""
             )
             .unwrap(),
             Wrapper {
-                val: U256::max_value() - 1
+                val: U256::MAX - U256::from(1)
             },
         );
         assert_eq!(
@@ -96,7 +106,7 @@ mod test {
             )
             .unwrap(),
             Wrapper {
-                val: U256::max_value()
+                val: U256::MAX
             },
         );
         serde_json::from_str::<Wrapper>("\"0x0\"").unwrap_err();