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

use super::op;
use alloy_primitives::hex;

#[derive(Debug)]
pub struct CodeOp<'a> {
    #[allow(dead_code)]
    pub op: op::OpCode,
    pub opi: &'static op::OpCodeInfo,
    pub arg: &'a [u8],
}

pub fn iterate_code(
    code: &'_ [u8],
    start_pc: usize,
    end_pc: Option<usize>, // Start pc of the last instruction to include
) -> impl Iterator<Item = (usize, CodeOp<'_>)> {
    let mut pc = start_pc;
    let code_len = code.len();
    let pc_limit = if let Some(v) = end_pc {
        std::cmp::min(v + 1, code_len)
    } else {
        code_len
    };
    std::iter::from_fn(move || {
        if pc >= pc_limit {
            return None;
        }
        let op = code[pc];
        let opi = op::info(op);
        if pc + opi.size > code_len {
            return None;
        }
        let curpc = pc;
        pc += opi.size;
        Some((
            curpc,
            CodeOp {
                op,
                opi,
                arg: &code[curpc + 1..pc],
            },
        ))
    })
}

pub fn disassemble(code: &[u8]) -> Vec<(usize, String)> {
    iterate_code(code, 0, None)
        .map(|(pc, op)| {
            (
                pc,
                if op.arg.is_empty() {
                    op.opi.name.to_string()
                } else {
                    format!("{} {}", op.opi.name, hex::encode(op.arg))
                },
            )
        })
        .collect()
}

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

    #[test]
    fn test_empty_code_disassemble() {
        let result = disassemble(&[]);
        assert!(result.is_empty());
    }

    #[test]
    fn test_invalid_code_disassemble() {
        let result = disassemble(&[0xb0, 0xb1, 0x01]);
        assert_eq!(
            result,
            vec![
                (0, "?".to_string()),
                (1, "?".to_string()),
                (2, "ADD".to_string())
            ]
        );
    }
}