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, "\"{}\"", hex::encode_prefixed(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 foundry_cli::utils::parse_json;
129    use serde_json::Result as JsonResult;
130
131    // https://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers
132    fn array_von_neuman() -> Item {
133        Item::Array(vec![
134            Item::Array(vec![]),
135            Item::Array(vec![Item::Array(vec![])]),
136            Item::Array(vec![Item::Array(vec![]), Item::Array(vec![Item::Array(vec![])])]),
137        ])
138    }
139
140    #[test]
141    fn encode_decode_test() -> alloy_rlp::Result<()> {
142        let parameters = vec![
143            (1, b"\xc0".to_vec(), Item::Array(vec![])),
144            (2, b"\xc1\x80".to_vec(), Item::Array(vec![Item::Data(vec![])])),
145            (3, b"\xc4\x83dog".to_vec(), Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])),
146            (
147                4,
148                b"\xc5\xc4\x83dog".to_vec(),
149                Item::Array(vec![Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])]),
150            ),
151            (
152                5,
153                b"\xc8\x83dog\x83cat".to_vec(),
154                Item::Array(vec![
155                    Item::Data(vec![0x64, 0x6f, 0x67]),
156                    Item::Data(vec![0x63, 0x61, 0x74]),
157                ]),
158            ),
159            (6, b"\xc7\xc0\xc1\xc0\xc3\xc0\xc1\xc0".to_vec(), array_von_neuman()),
160            (
161                7,
162                b"\xcd\x83\x6c\x6f\x6c\xc3\xc2\xc1\xc0\xc4\x83\x6f\x6c\x6f".to_vec(),
163                Item::Array(vec![
164                    Item::Data(vec![b'\x6c', b'\x6f', b'\x6c']),
165                    Item::Array(vec![Item::Array(vec![Item::Array(vec![Item::Array(vec![])])])]),
166                    Item::Array(vec![Item::Data(vec![b'\x6f', b'\x6c', b'\x6f'])]),
167                ]),
168            ),
169        ];
170        for params in parameters {
171            let encoded = alloy_rlp::encode(&params.2);
172            assert_eq!(Item::decode(&mut &encoded[..])?, params.2);
173            let decoded = Item::decode(&mut &params.1[..])?;
174            assert_eq!(alloy_rlp::encode(&decoded), params.1);
175        }
176
177        Ok(())
178    }
179
180    #[test]
181    fn deserialize_from_str_test_hex() -> JsonResult<()> {
182        let parameters = vec![
183            (1, "[\"\"]", Item::Array(vec![Item::Data(vec![])])),
184            (2, "[\"0x646f67\"]", Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])),
185            (
186                3,
187                "[[\"646f67\"]]",
188                Item::Array(vec![Item::Array(vec![Item::Data(vec![0x64, 0x6f, 0x67])])]),
189            ),
190            (
191                4,
192                "[\"646f67\",\"0x636174\"]",
193                Item::Array(vec![
194                    Item::Data(vec![0x64, 0x6f, 0x67]),
195                    Item::Data(vec![0x63, 0x61, 0x74]),
196                ]),
197            ),
198            (6, "[[],[[]],[[],[[]]]]", array_von_neuman()),
199        ];
200        for params in parameters {
201            let val = parse_json(params.1)?;
202            let item = Item::value_to_item(&val).unwrap();
203            assert_eq!(item, params.2);
204        }
205
206        Ok(())
207    }
208
209    #[test]
210    fn rlp_data() {
211        // <https://github.com/foundry-rs/foundry/issues/9197>
212        let hex_val_rlp = hex!("820002");
213        let item = Item::decode(&mut &hex_val_rlp[..]).unwrap();
214
215        let data = hex!("0002");
216        let encoded = alloy_rlp::encode(&data[..]);
217        let decoded: Bytes = alloy_rlp::decode_exact(&encoded[..]).unwrap();
218        assert_eq!(Item::Data(decoded.to_vec()), item);
219
220        let hex_val_rlp = hex!("00");
221        let item = Item::decode(&mut &hex_val_rlp[..]).unwrap();
222
223        let data = hex!("00");
224        let encoded = alloy_rlp::encode(&data[..]);
225        let decoded: Bytes = alloy_rlp::decode_exact(&encoded[..]).unwrap();
226        assert_eq!(Item::Data(decoded.to_vec()), item);
227    }
228}
cast/rlp_converter.rs

cast/
rlp_converter.rs
