evmole 0.8.4

Extracts function selectors and arguments from EVM bytecode
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use super::Label;
use crate::evm::{U256, VAL_4, calldata::CallData, element::Element};
use std::error;

pub(super) struct CallDataImpl {}

impl CallData<Label> for CallDataImpl {
    fn load32(&self, offset: U256) -> Element<Label> {
        let mut data = [0; 32];
        if offset < VAL_4 {
            let off = usize::try_from(offset).expect("len checked");
            data[..4 - off].copy_from_slice(&self.selector()[off..]);
        }
        Element {
            data,
            label: Some(Label::CallData),
        }
    }

    fn load(
        &self,
        offset: U256,
        size: U256,
    ) -> Result<(Vec<u8>, Option<Label>), Box<dyn error::Error>> {
        let mut data = vec![0; u8::try_from(size)? as usize]; // max len limited to max_u8
        if offset < VAL_4 {
            let off = usize::try_from(offset).expect("len checked");
            let nlen = std::cmp::min(data.len(), 4 - off);
            data[..nlen].copy_from_slice(&self.selector()[off..off + nlen]);
        }
        Ok((data, Some(Label::CallData)))
    }

    fn selector(&self) -> [u8; 4] {
        [0xaa, 0xbb, 0xcc, 0xdd]
    }

    fn len(&self) -> U256 {
        VAL_4
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_calldata_load32() {
        let cd = CallDataImpl {};

        let mut x = cd.load32(U256::ZERO);
        assert_eq!(x.label, Some(Label::CallData));
        assert!(x.data.starts_with(&[0xaa, 0xbb, 0xcc, 0xdd, 0x00, 0x00]));

        x = cd.load32(U256::from(1));
        assert_eq!(x.label, Some(Label::CallData));
        assert!(x.data.starts_with(&[0xbb, 0xcc, 0xdd, 0x00, 0x00]));

        x = cd.load32(U256::from(2));
        assert_eq!(x.label, Some(Label::CallData));
        assert!(x.data.starts_with(&[0xcc, 0xdd, 0x00, 0x00]));

        x = cd.load32(U256::from(3));
        assert_eq!(x.label, Some(Label::CallData));
        assert!(x.data.starts_with(&[0xdd, 0x00, 0x00]));

        x = cd.load32(U256::from(4));
        assert_eq!(x.label, Some(Label::CallData));
        assert!(x.data.starts_with(&[0x00, 0x00]));

        x = cd.load32(U256::from(64));
        assert_eq!(x.label, Some(Label::CallData));
        assert!(x.data.starts_with(&[0x00, 0x00]));
    }

    #[test]
    fn test_calldata_load() {
        let cd = CallDataImpl {};

        let (mut data, mut label) = cd.load(U256::ZERO, U256::from(5)).unwrap();
        assert_eq!(label, Some(Label::CallData));
        assert_eq!(data, [0xaa, 0xbb, 0xcc, 0xdd, 0x00]);

        (data, label) = cd.load(U256::ZERO, U256::from(3)).unwrap();
        assert_eq!(label, Some(Label::CallData));
        assert_eq!(data, [0xaa, 0xbb, 0xcc]);

        (data, label) = cd.load(U256::from(2), U256::from(4)).unwrap();
        assert_eq!(label, Some(Label::CallData));
        assert_eq!(data, [0xcc, 0xdd, 0x00, 0x00]);

        (data, label) = cd.load(U256::from(2), U256::from(1)).unwrap();
        assert_eq!(label, Some(Label::CallData));
        assert_eq!(data, [0xcc]);

        (data, label) = cd.load(U256::from(4), U256::from(2)).unwrap();
        assert_eq!(label, Some(Label::CallData));
        assert_eq!(data, [0x00, 0x00]);

        (data, label) = cd.load(U256::from(4), U256::from(0)).unwrap();
        assert_eq!(label, Some(Label::CallData));
        assert!(data.is_empty());
    }
}