From 2073518f0ff03a86a6fc948bf1ff4deda24cf9c5 Mon Sep 17 00:00:00 2001
From: Michael Sproul <michael@sigmaprime.io>
Date: Tue, 7 Feb 2023 11:23:36 +1100
Subject: [PATCH] Remove unused `u256_hex_be_opt` (#3942)

---
 consensus/serde_utils/src/lib.rs             |   1 -
 consensus/serde_utils/src/u256_hex_be_opt.rs | 169 -------------------
 2 files changed, 170 deletions(-)
 delete mode 100644 consensus/serde_utils/src/u256_hex_be_opt.rs

diff --git a/consensus/serde_utils/src/lib.rs b/consensus/serde_utils/src/lib.rs
index 75fd6009b..92b5966c9 100644
--- a/consensus/serde_utils/src/lib.rs
+++ b/consensus/serde_utils/src/lib.rs
@@ -7,7 +7,6 @@ pub mod json_str;
 pub mod list_of_bytes_lists;
 pub mod quoted_u64_vec;
 pub mod u256_hex_be;
-pub mod u256_hex_be_opt;
 pub mod u32_hex;
 pub mod u64_hex_be;
 pub mod u8_hex;
diff --git a/consensus/serde_utils/src/u256_hex_be_opt.rs b/consensus/serde_utils/src/u256_hex_be_opt.rs
deleted file mode 100644
index 8eadbf024..000000000
--- a/consensus/serde_utils/src/u256_hex_be_opt.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-use ethereum_types::U256;
-
-use serde::de::Visitor;
-use serde::{de, Deserializer, Serialize, Serializer};
-use std::fmt;
-use std::str::FromStr;
-
-pub fn serialize<S>(num: &Option<U256>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    num.serialize(serializer)
-}
-
-pub struct U256Visitor;
-
-impl<'de> Visitor<'de> for U256Visitor {
-    type Value = String;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a well formatted hex string")
-    }
-
-    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        if !value.starts_with("0x") {
-            return Err(de::Error::custom("must start with 0x"));
-        }
-        let stripped = &value[2..];
-        if stripped.is_empty() {
-            Err(de::Error::custom(format!(
-                "quantity cannot be {:?}",
-                stripped
-            )))
-        } else if stripped == "0" {
-            Ok(value.to_string())
-        } else if stripped.starts_with('0') {
-            Err(de::Error::custom("cannot have leading zero"))
-        } else {
-            Ok(value.to_string())
-        }
-    }
-}
-
-pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<U256>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let decoded = deserializer.deserialize_string(U256Visitor)?;
-
-    Some(
-        U256::from_str(&decoded)
-            .map_err(|e| de::Error::custom(format!("Invalid U256 string: {}", e))),
-    )
-    .transpose()
-}
-
-#[cfg(test)]
-mod test {
-    use ethereum_types::U256;
-    use serde::{Deserialize, Serialize};
-    use serde_json;
-
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(transparent)]
-    struct Wrapper {
-        #[serde(with = "super")]
-        val: Option<U256>,
-    }
-
-    #[test]
-    fn encoding() {
-        assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: Some(0.into())
-            })
-            .unwrap(),
-            "\"0x0\""
-        );
-        assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: Some(1.into())
-            })
-            .unwrap(),
-            "\"0x1\""
-        );
-        assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: Some(256.into())
-            })
-            .unwrap(),
-            "\"0x100\""
-        );
-        assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: Some(65.into())
-            })
-            .unwrap(),
-            "\"0x41\""
-        );
-        assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: Some(1024.into())
-            })
-            .unwrap(),
-            "\"0x400\""
-        );
-        assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: Some(U256::max_value() - 1)
-            })
-            .unwrap(),
-            "\"0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe\""
-        );
-        assert_eq!(
-            &serde_json::to_string(&Wrapper {
-                val: Some(U256::max_value())
-            })
-            .unwrap(),
-            "\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
-        );
-    }
-
-    #[test]
-    fn decoding() {
-        assert_eq!(
-            serde_json::from_str::<Wrapper>("\"0x0\"").unwrap(),
-            Wrapper {
-                val: Some(0.into())
-            },
-        );
-        assert_eq!(
-            serde_json::from_str::<Wrapper>("\"0x41\"").unwrap(),
-            Wrapper {
-                val: Some(65.into())
-            },
-        );
-        assert_eq!(
-            serde_json::from_str::<Wrapper>("\"0x400\"").unwrap(),
-            Wrapper {
-                val: Some(1024.into())
-            },
-        );
-        assert_eq!(
-            serde_json::from_str::<Wrapper>(
-                "\"0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe\""
-            )
-            .unwrap(),
-            Wrapper {
-                val: Some(U256::max_value() - 1)
-            },
-        );
-        assert_eq!(
-            serde_json::from_str::<Wrapper>(
-                "\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
-            )
-            .unwrap(),
-            Wrapper {
-                val: Some(U256::max_value())
-            },
-        );
-        serde_json::from_str::<Wrapper>("\"0x\"").unwrap_err();
-        serde_json::from_str::<Wrapper>("\"0x0400\"").unwrap_err();
-        serde_json::from_str::<Wrapper>("\"400\"").unwrap_err();
-        serde_json::from_str::<Wrapper>("\"ff\"").unwrap_err();
-    }
-}