alloy_rpc_types_eth/
index.rs

1use alloy_primitives::U256;
2
3/// A hex encoded or decimal index that's intended to be used as a rust index, hence it's
4/// deserialized into a `usize`.
5#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
6pub struct Index(pub usize);
7
8impl From<Index> for usize {
9    fn from(idx: Index) -> Self {
10        idx.0
11    }
12}
13
14impl From<Index> for U256 {
15    fn from(idx: Index) -> Self {
16        Self::from(idx.0)
17    }
18}
19
20impl From<usize> for Index {
21    fn from(idx: usize) -> Self {
22        Self(idx)
23    }
24}
25
26#[cfg(feature = "serde")]
27impl serde::Serialize for Index {
28    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
29    where
30        S: serde::Serializer,
31    {
32        serializer.serialize_str(&format!("0x{:x}", self.0))
33    }
34}
35
36#[cfg(feature = "serde")]
37impl<'a> serde::Deserialize<'a> for Index {
38    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
39    where
40        D: serde::Deserializer<'a>,
41    {
42        struct IndexVisitor;
43
44        impl serde::de::Visitor<'_> for IndexVisitor {
45            type Value = Index;
46
47            fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
48                write!(formatter, "hex-encoded or decimal index")
49            }
50
51            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
52            where
53                E: serde::de::Error,
54            {
55                Ok(Index(value as usize))
56            }
57
58            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
59            where
60                E: serde::de::Error,
61            {
62                value.strip_prefix("0x").map_or_else(
63                    || {
64                        value.parse::<usize>().map(Index).map_err(|e| {
65                            serde::de::Error::custom(format!("Failed to parse numeric index: {e}"))
66                        })
67                    },
68                    |val| {
69                        usize::from_str_radix(val, 16).map(Index).map_err(|e| {
70                            serde::de::Error::custom(format!(
71                                "Failed to parse hex encoded index value: {e}"
72                            ))
73                        })
74                    },
75                )
76            }
77        }
78
79        deserializer.deserialize_any(IndexVisitor)
80    }
81}
82
83#[cfg(test)]
84mod tests {
85    use super::*;
86    use rand::{thread_rng, Rng};
87    #[cfg(feature = "serde")]
88    use serde_json::json;
89    use similar_asserts::assert_eq;
90
91    #[test]
92    #[cfg(feature = "serde")]
93    fn test_serde_index_rand() {
94        let mut rng = thread_rng();
95        for _ in 0..100 {
96            let index = Index(rng.gen());
97            let val = serde_json::to_string(&index).unwrap();
98            let de: Index = serde_json::from_str(&val).unwrap();
99            assert_eq!(index, de);
100        }
101    }
102
103    #[test]
104    #[cfg(feature = "serde")]
105    fn test_serde_index_deserialization() {
106        // Test decimal index
107        let json_data = json!(42);
108        let index: Index =
109            serde_json::from_value(json_data).expect("Failed to deserialize decimal index");
110        assert_eq!(index, Index::from(42));
111
112        // Test hex index
113        let json_data = json!("0x2A");
114        let index: Index =
115            serde_json::from_value(json_data).expect("Failed to deserialize hex index");
116        assert_eq!(index, Index::from(42));
117
118        // Test invalid hex index
119        let json_data = json!("0xGHI");
120        let result: Result<Index, _> = serde_json::from_value(json_data);
121        assert!(result.is_err());
122
123        // Test invalid decimal index
124        let json_data = json!("abc");
125        let result: Result<Index, _> = serde_json::from_value(json_data);
126        assert!(result.is_err());
127
128        // Test string decimal index
129        let json_data = json!("123");
130        let index: Index =
131            serde_json::from_value(json_data).expect("Failed to deserialize string decimal index");
132        assert_eq!(index, Index::from(123));
133
134        // Test invalid numeric string
135        let json_data = json!("123abc");
136        let result: Result<Index, _> = serde_json::from_value(json_data);
137        assert!(result.is_err());
138
139        // Test negative index
140        let json_data = json!(-1);
141        let result: Result<Index, _> = serde_json::from_value(json_data);
142        assert!(result.is_err());
143
144        // Test large index
145        let json_data = json!(u64::MAX);
146        let index: Index =
147            serde_json::from_value(json_data).expect("Failed to deserialize large index");
148        assert_eq!(index, Index::from(u64::MAX as usize));
149    }
150}
alloy_rpc_types_eth/index.rs

alloy_rpc_types_eth/
index.rs
