mega-evm 1.6.0

The evm tailored for the MegaETH
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

//! This example demonstrates the block environment access tracking in the EVM.
//! It creates three contracts that use different block environment accesses and
//! tests the tracking functionality.
//!
//! The contracts are:
//! 1. Contract 1: Uses single block environment access (NUMBER opcode)
//! 2. Contract 2: Uses multiple block environment accesses (NUMBER, TIMESTAMP, BASEFEE opcodes)
//! 3. Contract 3: Does NOT use block environment (CALLER opcode)

use alloy_primitives::{address, Bytes, U256};
use mega_evm::{MegaContext, MegaEvm, MegaSpecId, MegaTransaction, VolatileDataAccess};
use revm::{
    bytecode::opcode::{BASEFEE, CALLER, NUMBER, POP, STOP, TIMESTAMP},
    context::{ContextTr, TxEnv},
    database::{CacheDB, EmptyDB},
    primitives::TxKind,
    state::{AccountInfo, Bytecode},
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create database and EVM context
    let mut db = CacheDB::<EmptyDB>::default();
    let spec = MegaSpecId::MINI_REX;

    // Contract 1: Uses single block environment access (NUMBER opcode)
    let contract1_address = address!("0000000000000000000000000000000000100001");
    let contract1_code = vec![NUMBER, STOP]; // Read block number then stop
    set_account_code(&mut db, contract1_address, contract1_code.into());

    // Contract 2: Uses multiple block environment accesses
    let contract2_address = address!("0000000000000000000000000000000000100002");
    let contract2_code = vec![
        NUMBER, POP, // Read block number
        TIMESTAMP, POP, // Read timestamp
        BASEFEE, POP, // Read base fee
        STOP,
    ];
    set_account_code(&mut db, contract2_address, contract2_code.into());

    // Contract 3: Does NOT use block environment (CALLER opcode)
    let contract3_address = address!("0000000000000000000000000000000000100003");
    let contract3_code = vec![CALLER, STOP]; // Read caller then stop
    set_account_code(&mut db, contract3_address, contract3_code.into());

    // Create EVM instance with properly configured L1BlockInfo
    let mut context = MegaContext::new(db, spec);
    // Set operator fee fields to zero to avoid panic in MINI_REX (ISTHMUS) spec
    context.chain_mut().operator_fee_scalar = Some(U256::from(0));
    context.chain_mut().operator_fee_constant = Some(U256::from(0));
    let mut evm = MegaEvm::new(context);

    let caller = address!("0000000000000000000000000000000000100000");

    println!("=== Block Environment Access Tracking Demo ===\n");

    // Test Contract 1 (single block env access)
    println!("Testing Contract 1 (uses NUMBER opcode):");

    // Ensure clean state
    assert!(evm.get_block_env_accesses().is_empty(), "Should start with no block env access");
    println!("  Initial state: no block env access");

    // Create and execute transaction for contract 1
    let tx1 = MegaTransaction {
        base: TxEnv {
            caller,
            kind: TxKind::Call(contract1_address),
            data: Bytes::default(),
            value: U256::ZERO,
            gas_limit: 1000000,
            ..Default::default()
        },
        ..Default::default()
    };

    let result1 = alloy_evm::Evm::transact_raw(&mut evm, tx1)?;
    println!("  Transaction result: {:?}", result1.result.is_success());

    let accesses1 = evm.get_block_env_accesses();
    println!("  Block env accessed: {}", !accesses1.is_empty());

    // Show detailed access information
    println!("  Access count: {}", accesses1.count_block_env_accessed());
    println!(
        "  Has accessed BlockNumber: {}",
        accesses1.contains(VolatileDataAccess::BLOCK_NUMBER)
    );

    assert_eq!(accesses1.count_block_env_accessed(), 1);
    assert!(accesses1.contains(VolatileDataAccess::BLOCK_NUMBER));
    assert!(!accesses1.is_empty(), "Contract 1 should have accessed block env");

    // Reset for next transaction
    evm.reset_volatile_data_access();
    println!("  After reset: {}\n", evm.get_block_env_accesses().is_empty());

    // Test Contract 2 (multiple block env accesses)
    println!("Testing Contract 2 (uses NUMBER, TIMESTAMP, BASEFEE opcodes):");

    assert!(evm.get_block_env_accesses().is_empty(), "Should start with no block env access");
    println!("  Initial state: no block env access");

    // Create and execute transaction for contract 2
    let tx2 = MegaTransaction {
        base: TxEnv {
            caller,
            kind: TxKind::Call(contract2_address),
            data: Bytes::default(),
            value: U256::ZERO,
            gas_limit: 1000000,
            nonce: 0, // Reset nonce for new transaction
            ..Default::default()
        },
        ..Default::default()
    };

    let result2 = alloy_evm::Evm::transact_raw(&mut evm, tx2)?;
    println!("  Transaction result: {:?}", result2.result.is_success());

    let accesses2 = evm.get_block_env_accesses();
    println!("  Block env accessed: {}", !accesses2.is_empty());

    // Show detailed access information
    println!("  Access count: {}", accesses2.count_block_env_accessed());
    println!(
        "  Has accessed BlockNumber: {}",
        accesses2.contains(VolatileDataAccess::BLOCK_NUMBER)
    );
    println!("  Has accessed Timestamp: {}", accesses2.contains(VolatileDataAccess::TIMESTAMP));
    println!("  Has accessed BaseFee: {}", accesses2.contains(VolatileDataAccess::BASE_FEE));

    assert_eq!(accesses2.count_block_env_accessed(), 3);
    assert!(accesses2.contains(VolatileDataAccess::BLOCK_NUMBER));
    assert!(accesses2.contains(VolatileDataAccess::TIMESTAMP));
    assert!(accesses2.contains(VolatileDataAccess::BASE_FEE));
    assert!(!accesses2.is_empty(), "Contract 2 should have accessed block env");

    // Reset for next transaction
    evm.reset_volatile_data_access();
    println!("  After reset: {}\n", evm.get_block_env_accesses().is_empty());

    // Test Contract 3 (does NOT access block env)
    println!("Testing Contract 3 (uses CALLER opcode):");

    assert!(evm.get_block_env_accesses().is_empty(), "Should start with no block env access");
    println!("  Initial state: no block env access");

    // Create and execute transaction for contract 3
    let tx3 = MegaTransaction {
        base: TxEnv {
            caller,
            kind: TxKind::Call(contract3_address),
            data: Bytes::default(),
            value: U256::ZERO,
            gas_limit: 1000000,
            nonce: 0, // Reset nonce for new transaction
            ..Default::default()
        },
        ..Default::default()
    };

    let result3 = alloy_evm::Evm::transact_raw(&mut evm, tx3)?;
    println!("  Transaction result: {:?}", result3.result.is_success());

    let accesses3 = evm.get_block_env_accesses();
    println!("  Block env accessed: {}", !accesses3.is_empty());

    println!("  Access count: {}", accesses3.count_block_env_accessed());

    assert_eq!(accesses3.count_block_env_accessed(), 0);
    assert!(accesses3.is_empty(), "Contract 3 should NOT have accessed block env");

    println!("  Demo finished");

    Ok(())
}

/// Helper function to set account code
fn set_account_code(db: &mut CacheDB<EmptyDB>, address: alloy_primitives::Address, code: Bytes) {
    let bytecode = Bytecode::new_legacy(code);
    let code_hash = bytecode.hash_slow();
    let account_info = AccountInfo { code: Some(bytecode), code_hash, ..Default::default() };
    db.insert_account_info(address, account_info);
}