mega-evm 1.5.1

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

use crate::MegaSpecId;

/// Runtime limits for a single transaction.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct EvmTxRuntimeLimits {
    // ====== Limits enforced during transaction execution ======
    /// Maximum data size for a single transaction.
    pub tx_data_size_limit: u64,
    /// Maximum key-value updates for a single transaction.
    pub tx_kv_updates_limit: u64,
    /// Maximum compute gas limit for a single transaction.
    pub tx_compute_gas_limit: u64,
    /// Maximum state growth limit for a single transaction.
    pub tx_state_growth_limit: u64,
    /// Compute gas limit when accessing block environment data.
    pub block_env_access_compute_gas_limit: u64,
    /// Compute gas limit when accessing oracle data.
    pub oracle_access_compute_gas_limit: u64,
}

impl EvmTxRuntimeLimits {
    /// Creates a new `TxLimits` instance from the given `MegaSpecId`.
    pub fn from_spec(spec: MegaSpecId) -> Self {
        match spec {
            MegaSpecId::EQUIVALENCE => Self::equivalence(),
            MegaSpecId::MINI_REX => Self::mini_rex(),
            MegaSpecId::REX | MegaSpecId::REX1 | MegaSpecId::REX2 => Self::rex(),
            MegaSpecId::REX3 => Self::rex3(),
            MegaSpecId::REX4 => Self::rex4(),
        }
    }

    /// No limits.
    pub fn no_limits() -> Self {
        Self {
            tx_data_size_limit: u64::MAX,
            tx_kv_updates_limit: u64::MAX,
            tx_compute_gas_limit: u64::MAX,
            tx_state_growth_limit: u64::MAX,
            block_env_access_compute_gas_limit: u64::MAX,
            oracle_access_compute_gas_limit: u64::MAX,
        }
    }

    /// Limits for the `EQUIVALENCE` spec.
    pub fn equivalence() -> Self {
        Self::no_limits()
    }

    /// Limits for the `MINI_REX` spec.
    pub fn mini_rex() -> Self {
        Self {
            tx_data_size_limit: crate::constants::mini_rex::TX_DATA_LIMIT,
            tx_kv_updates_limit: crate::constants::mini_rex::TX_KV_UPDATE_LIMIT,
            tx_compute_gas_limit: crate::constants::mini_rex::TX_COMPUTE_GAS_LIMIT,
            block_env_access_compute_gas_limit:
                crate::constants::mini_rex::BLOCK_ENV_ACCESS_COMPUTE_GAS,
            oracle_access_compute_gas_limit: crate::constants::mini_rex::ORACLE_ACCESS_COMPUTE_GAS,
            ..Self::equivalence()
        }
    }

    /// Limits for the `REX` spec.
    pub fn rex() -> Self {
        Self {
            tx_data_size_limit: crate::constants::rex::TX_DATA_LIMIT,
            tx_kv_updates_limit: crate::constants::rex::TX_KV_UPDATE_LIMIT,
            tx_compute_gas_limit: crate::constants::rex::TX_COMPUTE_GAS_LIMIT,
            tx_state_growth_limit: crate::constants::rex::TX_STATE_GROWTH_LIMIT,
            block_env_access_compute_gas_limit:
                crate::constants::mini_rex::BLOCK_ENV_ACCESS_COMPUTE_GAS,
            oracle_access_compute_gas_limit: crate::constants::mini_rex::ORACLE_ACCESS_COMPUTE_GAS,
        }
    }

    /// Limits for the `REX3` spec.
    fn rex3() -> Self {
        Self {
            oracle_access_compute_gas_limit: crate::constants::rex3::ORACLE_ACCESS_COMPUTE_GAS,
            ..Self::rex()
        }
    }

    /// Limits for the `REX4` spec.
    ///
    /// Currently identical to Rex3 limits.
    /// Per-frame state growth budgets are handled by `FrameLimitTracker`.
    fn rex4() -> Self {
        Self::rex3()
    }
}

impl EvmTxRuntimeLimits {
    /// Sets the maximum data size for a single transaction.
    pub fn with_tx_data_size_limit(mut self, tx_data_size_limit: u64) -> Self {
        self.tx_data_size_limit = tx_data_size_limit;
        self
    }

    /// Sets the maximum key-value updates for a single transaction.
    pub fn with_tx_kv_updates_limit(mut self, tx_kv_updates_limit: u64) -> Self {
        self.tx_kv_updates_limit = tx_kv_updates_limit;
        self
    }

    /// Sets the maximum compute gas limit for a single transaction.
    pub fn with_tx_compute_gas_limit(mut self, tx_compute_gas_limit: u64) -> Self {
        self.tx_compute_gas_limit = tx_compute_gas_limit;
        self
    }

    /// Sets the maximum state growth limit for a single transaction.
    pub fn with_tx_state_growth_limit(mut self, tx_state_growth_limit: u64) -> Self {
        self.tx_state_growth_limit = tx_state_growth_limit;
        self
    }

    /// Sets the compute gas limit when accessing block environment data.
    pub fn with_block_env_access_compute_gas_limit(
        mut self,
        block_env_access_compute_gas_limit: u64,
    ) -> Self {
        self.block_env_access_compute_gas_limit = block_env_access_compute_gas_limit;
        self
    }

    /// Sets the compute gas limit when accessing oracle data.
    pub fn with_oracle_access_compute_gas_limit(
        mut self,
        oracle_access_compute_gas_limit: u64,
    ) -> Self {
        self.oracle_access_compute_gas_limit = oracle_access_compute_gas_limit;
        self
    }
}