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        alloy_serde::quantity::serialize(&(self.0 as u64), serializer)
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_serialization() {
106        let index = Index::from(0);
107        assert_eq!(serde_json::to_string(&index).unwrap(), "\"0x0\"");
108
109        let index = Index::from(42);
110        assert_eq!(serde_json::to_string(&index).unwrap(), "\"0x2a\"");
111    }
112
113    #[test]
114    #[cfg(feature = "serde")]
115    fn test_serde_index_deserialization() {
116        // Test decimal index
117        let json_data = json!(42);
118        let index: Index =
119            serde_json::from_value(json_data).expect("Failed to deserialize decimal index");
120        assert_eq!(index, Index::from(42));
121
122        // Test hex index
123        let json_data = json!("0x2A");
124        let index: Index =
125            serde_json::from_value(json_data).expect("Failed to deserialize hex index");
126        assert_eq!(index, Index::from(42));
127
128        // Test invalid hex index
129        let json_data = json!("0xGHI");
130        let result: Result<Index, _> = serde_json::from_value(json_data);
131        assert!(result.is_err());
132
133        // Test invalid decimal index
134        let json_data = json!("abc");
135        let result: Result<Index, _> = serde_json::from_value(json_data);
136        assert!(result.is_err());
137
138        // Test string decimal index
139        let json_data = json!("123");
140        let index: Index =
141            serde_json::from_value(json_data).expect("Failed to deserialize string decimal index");
142        assert_eq!(index, Index::from(123));
143
144        // Test invalid numeric string
145        let json_data = json!("123abc");
146        let result: Result<Index, _> = serde_json::from_value(json_data);
147        assert!(result.is_err());
148
149        // Test negative index
150        let json_data = json!(-1);
151        let result: Result<Index, _> = serde_json::from_value(json_data);
152        assert!(result.is_err());
153
154        // Test large index
155        let json_data = json!(u64::MAX);
156        let index: Index =
157            serde_json::from_value(json_data).expect("Failed to deserialize large index");
158        assert_eq!(index, Index::from(u64::MAX as usize));
159    }
160}
alloy_rpc_types_eth/index.rs

alloy_rpc_types_eth/
index.rs
