revm-primitives 43.0.0

Revm primitives types
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
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

//! EIP-8038: State-Access Gas Cost Update
//!
//! Increases the gas cost of state-access operations to reflect Ethereum's
//! larger state. The values below match the glamsterdam devnet-8 numbers in
//! execution-specs `forks/amsterdam` (`vm/gas.py::GasCosts`).
//!
//! Active alongside EIP-7904 and EIP-8037 starting at the Amsterdam hardfork.

/// Cold touch of an account (was 2,600 pre-EIP-8038).
pub const COLD_ACCOUNT_ACCESS: u64 = 3_000;

/// Surcharge for writing to an account that changes one account leaf value for
/// the first time (was 6,700 pre-EIP-8038).
pub const ACCOUNT_WRITE: u64 = 9_000;

/// Cold touch of a storage slot. Unchanged from the pre-EIP-8038 cost, but
/// under EIP-8038 it is the *total* cold charge (the warm base is folded in).
pub const COLD_STORAGE_ACCESS: u64 = 2_100;

/// Surcharge for writing to a storage slot that changes its value for the
/// first time (was 2,800 pre-EIP-8038).
pub const STORAGE_WRITE: u64 = 10_000;

/// Touch of an already-warm account or storage slot. Unchanged by EIP-8038.
pub const WARM_ACCESS: u64 = 100;

/// Refund for clearing a storage slot (was 4,800 pre-EIP-8038).
///
/// Derived per the spec as `(STORAGE_WRITE + COLD_STORAGE_ACCESS) * 4800 / 5000`.
pub const STORAGE_CLEAR_REFUND: u64 = (STORAGE_WRITE + COLD_STORAGE_ACCESS) * 4_800 / 5_000;

/// State access cost for contract deployment (was 7,000 pre-EIP-8038).
///
/// Per the spec, `CREATE_ACCESS = ACCOUNT_WRITE + COLD_ACCOUNT_ACCESS`. This does
/// not match the legacy decomposition (`GAS_CREATE - GAS_NEW_ACCOUNT = 7,000`); the
/// EIP keeps that discrepancy rather than reconciling it.
pub const CREATE_ACCESS: u64 = ACCOUNT_WRITE + COLD_ACCOUNT_ACCESS;

/// Gas charged per storage key included in a transaction's access list
/// (was 1,900 pre-EIP-8038). Derived per the spec as
/// `COLD_STORAGE_ACCESS - WARM_ACCESS`: the access list pre-pays only the cold
/// premium, the warm base is still charged at first use.
pub const ACCESS_LIST_STORAGE_KEY_COST: u64 = COLD_STORAGE_ACCESS - WARM_ACCESS;

/// Gas charged per address included in a transaction's access list
/// (was 2,400 pre-EIP-8038). Derived per the spec as
/// `COLD_ACCOUNT_ACCESS - WARM_ACCESS`.
pub const ACCESS_LIST_ADDRESS_COST: u64 = COLD_ACCOUNT_ACCESS - WARM_ACCESS;

/// Cold premium on top of `WARM_ACCESS` for account access.
pub const COLD_ACCOUNT_ACCESS_ADDITIONAL: u64 = COLD_ACCOUNT_ACCESS - WARM_ACCESS;

/// Cold premium on top of `WARM_ACCESS` for storage access.
pub const COLD_STORAGE_ACCESS_ADDITIONAL: u64 = COLD_STORAGE_ACCESS - WARM_ACCESS;

/// CALL value transfer cost: `ACCOUNT_WRITE + CALL_STIPEND` per the EIP.
pub const CALL_VALUE: u64 = ACCOUNT_WRITE + 2_300;

/// Calldata bytes charged for one EIP-7702 authorization tuple (execution-specs
/// `AUTH_TUPLE_BYTES`): chain id, authority address, nonce, signature parity, and
/// the two signature scalars. Charged at the calldata floor rate.
pub const EIP7702_AUTH_TUPLE_BYTES: u64 = 101;

/// ecRecover precompile base cost, charged once per EIP-7702 authorization to
/// recover the authority.
pub const EIP7702_ECRECOVER_COST: u64 = 3_000;

/// Calldata floor rate per token under EIP-7976 (Amsterdam).
pub const TX_DATA_TOKEN_FLOOR: u64 = 16;

/// `REGULAR_PER_AUTH_BASE_COST`: the state-independent regular-gas base charged
/// per EIP-7702 authorization at the intrinsic phase under EIP-2780
/// (ethereum/EIPs#11844).
///
/// `AUTH_TUPLE_BYTES * TX_DATA_TOKEN_FLOOR + PRECOMPILE_ECRECOVER + COLD_ACCOUNT_ACCESS + 2 * WARM_ACCESS`
/// = `101*16 + 3,000 + 3,000 + 200 = 7,816`. Covers the authorization's calldata,
/// the ECDSA recovery, the authority's cold access, and the warm writes every
/// authorization performs. The state-dependent remainder (`ACCOUNT_WRITE` and the
/// new-account / delegation-bytes state gas) is charged at runtime, only for the
/// authorities that incur it.
pub const EIP7702_PER_AUTH_BASE_REGULAR: u64 = EIP7702_AUTH_TUPLE_BYTES * TX_DATA_TOKEN_FLOOR
    + EIP7702_ECRECOVER_COST
    + COLD_ACCOUNT_ACCESS
    + 2 * WARM_ACCESS;

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

    /// Values must match execution-specs `forks/amsterdam` (glamsterdam devnet-8).
    #[test]
    fn constants_match_spec() {
        assert_eq!(WARM_ACCESS, 100); // unchanged by EIP-8038
        assert_eq!(COLD_ACCOUNT_ACCESS, 3_000);
        assert_eq!(ACCOUNT_WRITE, 9_000);
        assert_eq!(COLD_STORAGE_ACCESS, 2_100);
        assert_eq!(STORAGE_WRITE, 10_000);
        assert_eq!(STORAGE_CLEAR_REFUND, 11_616);
        assert_eq!(CREATE_ACCESS, 12_000);
        assert_eq!(ACCESS_LIST_ADDRESS_COST, 2_900);
        assert_eq!(ACCESS_LIST_STORAGE_KEY_COST, 2_000);
        assert_eq!(CALL_VALUE, 11_300);
        assert_eq!(EIP7702_PER_AUTH_BASE_REGULAR, 7_816);
    }

    /// Spec-defined relationships between the parameters (kept as derivations so a
    /// renumber of one base value propagates correctly).
    #[test]
    fn derived_relations() {
        assert_eq!(CREATE_ACCESS, ACCOUNT_WRITE + COLD_ACCOUNT_ACCESS);
        assert_eq!(CALL_VALUE, ACCOUNT_WRITE + 2_300);
        assert_eq!(ACCESS_LIST_ADDRESS_COST, COLD_ACCOUNT_ACCESS - WARM_ACCESS);
        assert_eq!(
            ACCESS_LIST_STORAGE_KEY_COST,
            COLD_STORAGE_ACCESS - WARM_ACCESS
        );
        assert_eq!(
            STORAGE_CLEAR_REFUND,
            (STORAGE_WRITE + COLD_STORAGE_ACCESS) * 4_800 / 5_000
        );
        assert_eq!(
            COLD_ACCOUNT_ACCESS_ADDITIONAL,
            COLD_ACCOUNT_ACCESS - WARM_ACCESS
        );
        assert_eq!(
            COLD_STORAGE_ACCESS_ADDITIONAL,
            COLD_STORAGE_ACCESS - WARM_ACCESS
        );
    }
}