revm-inspector 19.0.0

Revm inspector interface
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

//! Inspector is a crate that provides a set of traits that allow inspecting the EVM execution.
//!
//! It is used to implement tracers that can be used to inspect the EVM execution.
//! Implementing inspection is optional and it does not effect the core execution.
#![cfg_attr(not(test), warn(unused_crate_dependencies))]
#![cfg_attr(not(feature = "std"), no_std)]

mod count_inspector;
#[cfg(feature = "tracer")]
mod eip3155;
mod either;
mod gas;
/// Handler implementations for inspector integration.
pub mod handler;
mod inspect;
mod inspector;
mod mainnet_inspect;
mod noop;
/// Test inspector for testing EVM execution.
pub mod test_inspector;
mod traits;

#[cfg(test)]
mod inspector_tests;

/// Inspector implementations.
pub mod inspectors {
    #[cfg(feature = "tracer")]
    pub use super::eip3155::TracerEip3155;
    pub use super::gas::GasInspector;
}

pub use context;
pub use database_interface;
pub use handler as evm_handler;
pub use interpreter;
pub use primitives;
pub use state;

pub use count_inspector::CountInspector;
pub use handler::{inspect_instructions, InspectorHandler};
pub use inspect::{InspectCommitEvm, InspectEvm, InspectSystemCallEvm};
pub use inspector::*;
pub use noop::NoOpInspector;
pub use test_inspector::{InspectorEvent, InterpreterState, StepRecord, TestInspector};
pub use traits::*;

#[cfg(test)]
mod tests {
    use super::*;
    use ::handler::{MainBuilder, MainContext};
    use context::{BlockEnv, CfgEnv, Context, Journal, TxEnv};
    use database::{BenchmarkDB, BENCH_CALLER, BENCH_TARGET};
    use interpreter::{interpreter::EthInterpreter, InstructionResult, InterpreterTypes};
    use primitives::TxKind;
    use state::{bytecode::opcode, Bytecode};

    struct HaltInspector;
    impl<CTX, INTR: InterpreterTypes> Inspector<CTX, INTR> for HaltInspector {
        fn step(&mut self, interp: &mut interpreter::Interpreter<INTR>, _context: &mut CTX) {
            interp.halt(InstructionResult::Stop);
        }
    }

    #[test]
    fn test_step_halt() {
        let bytecode = [opcode::INVALID];
        let r = run(&bytecode, HaltInspector);
        assert!(r.is_success());
    }

    fn run(
        bytecode: &[u8],
        inspector: impl Inspector<
            Context<BlockEnv, TxEnv, CfgEnv, BenchmarkDB, Journal<BenchmarkDB>, ()>,
            EthInterpreter,
        >,
    ) -> context::result::ExecutionResult {
        let bytecode = Bytecode::new_raw(bytecode.to_vec().into());
        let ctx = Context::mainnet().with_db(BenchmarkDB::new_bytecode(bytecode));
        let mut evm = ctx.build_mainnet_with_inspector(inspector);
        evm.inspect_one_tx(
            TxEnv::builder()
                .caller(BENCH_CALLER)
                .kind(TxKind::Call(BENCH_TARGET))
                .gas_limit(21100)
                .build()
                .unwrap(),
        )
        .unwrap()
    }
}