cast/
rlp_converter.rs

1use alloy_primitives::{U256, hex};
2use alloy_rlp::{Decodable, Encodable, Header, PayloadView};
3use eyre::Context;
4use serde_json::Value;
5use std::fmt;
6
7/// Arbitrary nested data.
8///
9/// - `Item::Array(vec![])` is equivalent to `[]`.
10/// - `Item::Array(vec![Item::Data(vec![])])` is equivalent to `[""]` or `[null]`.
11#[derive(Clone, Debug, PartialEq, Eq)]
12pub enum Item {
13    Data(Vec<u8>),
14    Array(Vec<Self>),
15}
16
17impl Encodable for Item {
18    fn encode(&self, out: &mut dyn alloy_rlp::BufMut) {
19        match self {
20            Self::Array(arr) => arr.encode(out),
21            Self::Data(data) => <[u8]>::encode(data, out),
22        }
23    }
24}
25
26impl Decodable for Item {
27    fn decode(buf: &mut &[u8]) -> alloy_rlp::Result<Self> {
28        struct ListFrame<'a> {
29            remaining: std::vec::IntoIter<&'a [u8]>,
30            items: Vec<Item>,
31        }
32
33        let items = match Header::decode_raw(buf)? {
34            PayloadView::String(data) => return Ok(Self::Data(data.to_vec())),
35            PayloadView::List(items) => items,
36        };
37
38        let mut frames = vec![ListFrame { remaining: items.into_iter(), items: Vec::new() }];
39        loop {
40            let Some(encoded) = frames.last_mut().unwrap().remaining.next() else {
41                let frame = frames.pop().unwrap();
42                let item = Self::Array(frame.items);
43                if let Some(parent) = frames.last_mut() {
44                    parent.items.push(item);
45                    continue;
46                }
47                return Ok(item);
48            };
49
50            match Header::decode_raw(&mut &encoded[..])? {
51                PayloadView::String(data) => {
52                    frames.last_mut().unwrap().items.push(Self::Data(data.to_vec()));
53                }
54                PayloadView::List(items) => {
55                    frames.push(ListFrame { remaining: items.into_iter(), items: Vec::new() });
56                }
57            }
58        }
59    }
60}
61
62impl Drop for Item {
63    fn drop(&mut self) {
64        // The default recursive drop can overflow after successfully decoding deeply nested RLP.
65        let Self::Array(items) = self else { return };
66        let mut pending = std::mem::take(items);
67        while let Some(mut item) = pending.pop() {
68            if let Self::Array(children) = &mut item {
69                pending.append(children);
70            }
71        }
72    }
73}
74
75impl Item {
76    pub(crate) fn value_to_item(value: &Value) -> eyre::Result<Self> {
77        match value {
78            Value::Null => Ok(Self::Data(vec![])),
79            Value::Bool(_) => eyre::bail!("RLP input can not contain booleans"),
80            Value::Number(n) => {
81                Ok(Self::Data(n.to_string().parse::<U256>()?.to_be_bytes_trimmed_vec()))
82            }
83            Value::String(s) => Ok(Self::Data(hex::decode(s).wrap_err("Could not decode hex")?)),
84            Value::Array(values) => {
85                values.iter().map(Self::value_to_item).collect::<Result<_, _>>().map(Self::Array)
86            }
87            Value::Object(_) => eyre::bail!("RLP input can not contain objects"),
88        }
89    }
90}
91
92/// Displays the items as nested JSON arrays of hex strings.
93impl fmt::Display for Item {
94    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
95        enum Task<'a> {
96            Item(&'a Item),
97            Comma,
98            Close,
99        }
100
101        let mut tasks = vec![Task::Item(self)];
102        while let Some(task) = tasks.pop() {
103            match task {
104                Task::Item(Self::Data(data)) => write!(f, "\"0x{}\"", hex::encode(data))?,
105                Task::Item(Self::Array(items)) => {
106                    f.write_str("[")?;
107                    tasks.push(Task::Close);
108                    for (i, item) in items.iter().enumerate().rev() {
109                        tasks.push(Task::Item(item));
110                        if i > 0 {
111                            tasks.push(Task::Comma);
112                        }
113                    }
114                }
115                Task::Comma => f.write_str(",")?,
116                Task::Close => f.write_str("]")?,
117            }
118        }
119        Ok(())
120    }
121}
122
123#[cfg(test)]
124mod test {
125    use crate::rlp_converter::Item;
126    use alloy_primitives::hex;
127    use alloy_rlp::{Bytes, Decodable};
128    use serde_json::Result as JsonResult;
129
130    // https://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers
131    fn array_von_neuman() -> Item {
132        Item::Array(vec![
133            Item::Array(vec![]),
134            Item::Array(vec![Item::Array(vec![])]),
135            Item::Array(vec![Item::Array(vec![]), Item::Array(vec![Item::Array(vec![])])]),
136        ])
137    }
138
139    #[test]
140    fn encode_decode_test() -> alloy_rlp::Result<()> {
141        let parameters = vec![
142            (1, b"\xc0".to_vec(), Item::Array(vec![])),
143            (2, b"\xc1\x80".to_vec(), Item::Array(vec![Item::Data(vec![])])),
144            (3, b"\xc4\x83dog".to_vec(), Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])),
145            (
146                4,
147                b"\xc5\xc4\x83dog".to_vec(),
148                Item::Array(vec![Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])]),
149            ),
150            (
151                5,
152                b"\xc8\x83dog\x83cat".to_vec(),
153                Item::Array(vec![
154                    Item::Data(vec![0x64, 0x6f, 0x67]),
155                    Item::Data(vec![0x63, 0x61, 0x74]),
156                ]),
157            ),
158            (6, b"\xc7\xc0\xc1\xc0\xc3\xc0\xc1\xc0".to_vec(), array_von_neuman()),
159            (
160                7,
161                b"\xcd\x83\x6c\x6f\x6c\xc3\xc2\xc1\xc0\xc4\x83\x6f\x6c\x6f".to_vec(),
162                Item::Array(vec![
163                    Item::Data(vec![b'\x6c', b'\x6f', b'\x6c']),
164                    Item::Array(vec![Item::Array(vec![Item::Array(vec![Item::Array(vec![])])])]),
165                    Item::Array(vec![Item::Data(vec![b'\x6f', b'\x6c', b'\x6f'])]),
166                ]),
167            ),
168        ];
169        for params in parameters {
170            let encoded = alloy_rlp::encode(&params.2);
171            assert_eq!(Item::decode(&mut &encoded[..])?, params.2);
172            let decoded = Item::decode(&mut &params.1[..])?;
173            assert_eq!(alloy_rlp::encode(&decoded), params.1);
174        }
175
176        Ok(())
177    }
178
179    #[test]
180    fn deserialize_from_str_test_hex() -> JsonResult<()> {
181        let parameters = vec![
182            (1, "[\"\"]", Item::Array(vec![Item::Data(vec![])])),
183            (2, "[\"0x646f67\"]", Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])),
184            (
185                3,
186                "[[\"646f67\"]]",
187                Item::Array(vec![Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])]),
188            ),
189            (
190                4,
191                "[\"646f67\",\"0x636174\"]",
192                Item::Array(vec![
193                    Item::Data(vec![0x64, 0x6f, 0x67]),
194                    Item::Data(vec![0x63, 0x61, 0x74]),
195                ]),
196            ),
197            (6, "[[],[[]],[[],[[]]]]", array_von_neuman()),
198        ];
199        for params in parameters {
200            let val = serde_json::from_str(params.1)?;
201            let item = Item::value_to_item(&val).unwrap();
202            assert_eq!(item, params.2);
203        }
204
205        Ok(())
206    }
207
208    #[test]
209    fn rlp_data() {
210        // <https://github.com/foundry-rs/foundry/issues/9197>
211        let hex_val_rlp = hex!("820002");
212        let item = Item::decode(&mut &hex_val_rlp[..]).unwrap();
213
214        let data = hex!("0002");
215        let encoded = alloy_rlp::encode(&data[..]);
216        let decoded: Bytes = alloy_rlp::decode_exact(&encoded[..]).unwrap();
217        assert_eq!(Item::Data(decoded.to_vec()), item);
218
219        let hex_val_rlp = hex!("00");
220        let item = Item::decode(&mut &hex_val_rlp[..]).unwrap();
221
222        let data = hex!("00");
223        let encoded = alloy_rlp::encode(&data[..]);
224        let decoded: Bytes = alloy_rlp::decode_exact(&encoded[..]).unwrap();
225        assert_eq!(Item::Data(decoded.to_vec()), item);
226    }
227}
cast/rlp_converter.rs

cast/
rlp_converter.rs
