gas.py (in diffs/bpo5/amsterdam/vm)

ethereum.forks.bpo5.vm.gasethereum.forks.amsterdam.vm.gas

Ethereum Virtual Machine (EVM) Gas.

.. contents:: Table of Contents :backlinks: none :local:

Introduction

EVM gas constants and calculators.

StateGasCosts ¶

EIP-8037 state-gas constants.

Kept separate from GasCosts because these carry a different unit: state-byte counts that convert into gas via COST_PER_STATE_BYTE.

class StateGasCosts:

COST_PER_STATE_BYTE ¶

57	COST_PER_STATE_BYTE: Final[StateGasPerByte] = StateGasPerByte(Uint(1530))

STATE_BYTES_PER_NEW_ACCOUNT ¶

58	STATE_BYTES_PER_NEW_ACCOUNT: Final[Uint] = Uint(120)

STATE_BYTES_PER_STORAGE_SET ¶

59	STATE_BYTES_PER_STORAGE_SET: Final[Uint] = Uint(64)

STATE_BYTES_PER_AUTH_BASE ¶

60	STATE_BYTES_PER_AUTH_BASE: Final[Uint] = Uint(23)

STORAGE_SET ¶

61	STORAGE_SET: Final[StateGas] = (
62	STATE_BYTES_PER_STORAGE_SET * COST_PER_STATE_BYTE
63	)

NEW_ACCOUNT ¶

64	NEW_ACCOUNT: Final[StateGas] = (
65	STATE_BYTES_PER_NEW_ACCOUNT * COST_PER_STATE_BYTE
66	)

AUTH_BASE ¶

67	AUTH_BASE: Final[StateGas] = (
68	STATE_BYTES_PER_AUTH_BASE * COST_PER_STATE_BYTE
69	)

GasCosts ¶

Constant gas values for the EVM.

class GasCosts:

BASE ¶

36	BASE: Final[Uint] = Uint(2)
79	BASE: Final[ExecutionGas] = ExecutionGas(Uint(2))

VERY_LOW ¶

37	VERY_LOW: Final[Uint] = Uint(3)
80	VERY_LOW: Final[ExecutionGas] = ExecutionGas(Uint(3))

LOW ¶

38	LOW: Final[Uint] = Uint(5)
81	LOW: Final[ExecutionGas] = ExecutionGas(Uint(5))

MID ¶

39	MID: Final[Uint] = Uint(8)
82	MID: Final[ExecutionGas] = ExecutionGas(Uint(8))

HIGH ¶

40	HIGH: Final[Uint] = Uint(10)
83	HIGH: Final[ExecutionGas] = ExecutionGas(Uint(10))

WARM_ACCESS ¶

43	WARM_ACCESS: Final[Uint] = Uint(100)
86	WARM_ACCESS: Final[ExecutionGas] = ExecutionGas(Uint(100))

COLD_ACCOUNT_ACCESS ¶

44	COLD_ACCOUNT_ACCESS: Final[Uint] = Uint(2600)
87	COLD_ACCOUNT_ACCESS: Final[ExecutionGas] = ExecutionGas(Uint(3000))

COLD_STORAGE_ACCESS ¶

45	COLD_STORAGE_ACCESS: Final[Uint] = Uint(2100)
88	COLD_STORAGE_ACCESS: Final[ExecutionGas] = ExecutionGas(Uint(2100))

48	STORAGE_SET: Final[Uint] = Uint(20000)

49	COLD_STORAGE_WRITE: Final[Uint] = Uint(5000)

STORAGE_SET ¶

48
STORAGE_SET: Final[Uint] = Uint(20000)

COLD_STORAGE_WRITE ¶

49
COLD_STORAGE_WRITE: Final[Uint] = Uint(5000)

STORAGE_WRITE ¶

91	STORAGE_WRITE: Final[ExecutionGas] = ExecutionGas(Uint(10000))

CALL_STIPEND ¶

52	CALL_STIPEND: Final[Uint] = Uint(2300)
94	CALL_STIPEND: Final[ExecutionGas] = ExecutionGas(Uint(2300))

ACCOUNT_WRITE ¶

95	ACCOUNT_WRITE: Final[ExecutionGas] = ExecutionGas(Uint(9000))

CALL_VALUE ¶

53	CALL_VALUE: Final[Uint] = Uint(9000)
96	CALL_VALUE: Final[ExecutionGas] = ACCOUNT_WRITE + CALL_STIPEND

54	NEW_ACCOUNT: Final[Uint] = Uint(25000)

NEW_ACCOUNT ¶

54
NEW_ACCOUNT: Final[Uint] = Uint(25000)

CODE_DEPOSIT_PER_BYTE ¶

57	CODE_DEPOSIT_PER_BYTE: Final[Uint] = Uint(200)
99	CODE_DEPOSIT_PER_BYTE: Final[ExecutionGas] = ExecutionGas(Uint(200))

CODE_INIT_PER_WORD ¶

58	CODE_INIT_PER_WORD: Final[Uint] = Uint(2)
100	CODE_INIT_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(2))

61	AUTH_PER_EMPTY_ACCOUNT: Final[int] = 25000

AUTH_PER_EMPTY_ACCOUNT ¶

61
AUTH_PER_EMPTY_ACCOUNT: Final[int] = 25000

CREATE_ACCESS ¶

101	CREATE_ACCESS: Final[ExecutionGas] = ACCOUNT_WRITE + COLD_ACCOUNT_ACCESS

ZERO ¶

64	ZERO: Final[Uint] = Uint(0)
104	ZERO: Final[ExecutionGas] = ExecutionGas(Uint(0))

MEMORY_PER_WORD ¶

65	MEMORY_PER_WORD: Final[Uint] = Uint(3)
105	MEMORY_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(3))

FAST_STEP ¶

66	FAST_STEP: Final[Uint] = Uint(5)
106	FAST_STEP: Final[ExecutionGas] = ExecutionGas(Uint(5))

REFUND_STORAGE_CLEAR ¶

69	REFUND_STORAGE_CLEAR: Final[int] = 4800
109	REFUND_STORAGE_CLEAR: Final[int] = int(
110	(STORAGE_WRITE + COLD_STORAGE_ACCESS) * Uint(4800) // Uint(5000)
111	)

PRECOMPILE_ECRECOVER ¶

72	PRECOMPILE_ECRECOVER: Final[Uint] = Uint(3000)
114	PRECOMPILE_ECRECOVER: Final[ExecutionGas] = ExecutionGas(Uint(3000))

PRECOMPILE_P256VERIFY ¶

73	PRECOMPILE_P256VERIFY: Final[Uint] = Uint(6900)
115	PRECOMPILE_P256VERIFY: Final[ExecutionGas] = ExecutionGas(Uint(6900))

PRECOMPILE_SHA256_BASE ¶

74	PRECOMPILE_SHA256_BASE: Final[Uint] = Uint(60)
116	PRECOMPILE_SHA256_BASE: Final[ExecutionGas] = ExecutionGas(Uint(60))

PRECOMPILE_SHA256_PER_WORD ¶

75	PRECOMPILE_SHA256_PER_WORD: Final[Uint] = Uint(12)
117	PRECOMPILE_SHA256_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(12))

PRECOMPILE_RIPEMD160_BASE ¶

76	PRECOMPILE_RIPEMD160_BASE: Final[Uint] = Uint(600)
118	PRECOMPILE_RIPEMD160_BASE: Final[ExecutionGas] = ExecutionGas(Uint(600))

PRECOMPILE_RIPEMD160_PER_WORD ¶

77	PRECOMPILE_RIPEMD160_PER_WORD: Final[Uint] = Uint(120)
119	PRECOMPILE_RIPEMD160_PER_WORD: Final[ExecutionGas] = ExecutionGas(
120	Uint(120)
121	)

PRECOMPILE_IDENTITY_BASE ¶

78	PRECOMPILE_IDENTITY_BASE: Final[Uint] = Uint(15)
122	PRECOMPILE_IDENTITY_BASE: Final[ExecutionGas] = ExecutionGas(Uint(15))

PRECOMPILE_IDENTITY_PER_WORD ¶

79	PRECOMPILE_IDENTITY_PER_WORD: Final[Uint] = Uint(3)
123	PRECOMPILE_IDENTITY_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(3))

PRECOMPILE_BLAKE2F_PER_ROUND ¶

80	PRECOMPILE_BLAKE2F_PER_ROUND: Final[Uint] = Uint(1)
124	PRECOMPILE_BLAKE2F_PER_ROUND: Final[ExecutionGas] = ExecutionGas(Uint(1))

PRECOMPILE_POINT_EVALUATION ¶

81	PRECOMPILE_POINT_EVALUATION: Final[Uint] = Uint(50000)
125	PRECOMPILE_POINT_EVALUATION: Final[ExecutionGas] = ExecutionGas(
126	Uint(50000)
127	)

PRECOMPILE_BLS_G1ADD ¶

82	PRECOMPILE_BLS_G1ADD: Final[Uint] = Uint(375)
128	PRECOMPILE_BLS_G1ADD: Final[ExecutionGas] = ExecutionGas(Uint(375))

PRECOMPILE_BLS_G1MUL ¶

83	PRECOMPILE_BLS_G1MUL: Final[Uint] = Uint(12000)
129	PRECOMPILE_BLS_G1MUL: Final[ExecutionGas] = ExecutionGas(Uint(12000))

PRECOMPILE_BLS_G1MAP ¶

84	PRECOMPILE_BLS_G1MAP: Final[Uint] = Uint(5500)
130	PRECOMPILE_BLS_G1MAP: Final[ExecutionGas] = ExecutionGas(Uint(5500))

PRECOMPILE_BLS_G2ADD ¶

85	PRECOMPILE_BLS_G2ADD: Final[Uint] = Uint(600)
131	PRECOMPILE_BLS_G2ADD: Final[ExecutionGas] = ExecutionGas(Uint(600))

PRECOMPILE_BLS_G2MUL ¶

86	PRECOMPILE_BLS_G2MUL: Final[Uint] = Uint(22500)
132	PRECOMPILE_BLS_G2MUL: Final[ExecutionGas] = ExecutionGas(Uint(22500))

PRECOMPILE_BLS_G2MAP ¶

87	PRECOMPILE_BLS_G2MAP: Final[Uint] = Uint(23800)
133	PRECOMPILE_BLS_G2MAP: Final[ExecutionGas] = ExecutionGas(Uint(23800))

PRECOMPILE_ECADD ¶

88	PRECOMPILE_ECADD: Final[Uint] = Uint(150)
134	PRECOMPILE_ECADD: Final[ExecutionGas] = ExecutionGas(Uint(150))

PRECOMPILE_ECMUL ¶

89	PRECOMPILE_ECMUL: Final[Uint] = Uint(6000)
135	PRECOMPILE_ECMUL: Final[ExecutionGas] = ExecutionGas(Uint(6000))

PRECOMPILE_ECPAIRING_BASE ¶

90	PRECOMPILE_ECPAIRING_BASE: Final[Uint] = Uint(45000)
136	PRECOMPILE_ECPAIRING_BASE: Final[ExecutionGas] = ExecutionGas(Uint(45000))

PRECOMPILE_ECPAIRING_PER_POINT ¶

91	PRECOMPILE_ECPAIRING_PER_POINT: Final[Uint] = Uint(34000)
137	PRECOMPILE_ECPAIRING_PER_POINT: Final[ExecutionGas] = ExecutionGas(
138	Uint(34000)
139	)

PER_BLOB ¶

142	PER_BLOB: Final[U64] = U64(2**17)

BLOB_SCHEDULE_TARGET ¶

143	BLOB_SCHEDULE_TARGET: Final[U64] = U64(14)

BLOB_TARGET_GAS_PER_BLOCK ¶

144	BLOB_TARGET_GAS_PER_BLOCK: Final[U64] = PER_BLOB * BLOB_SCHEDULE_TARGET

BLOB_BASE_COST ¶

145	BLOB_BASE_COST: Final[Uint] = Uint(2**13)

BLOB_SCHEDULE_MAX ¶

146	BLOB_SCHEDULE_MAX: Final[U64] = U64(21)

BLOB_MIN_GASPRICE ¶

147	BLOB_MIN_GASPRICE: Final[Uint] = Uint(1)

BLOB_BASE_FEE_UPDATE_FRACTION ¶

148	BLOB_BASE_FEE_UPDATE_FRACTION: Final[Uint] = Uint(11684671)

BLOCK_ACCESS_LIST_ITEM ¶

151	BLOCK_ACCESS_LIST_ITEM: Final[ExecutionGas] = ExecutionGas(Uint(2000))

TX_BASE ¶

103	TX_BASE: Final[Uint] = Uint(21000)
154	TX_BASE: Final[ExecutionGas] = ExecutionGas(Uint(12000))

TX_CREATE ¶

104	TX_CREATE: Final[Uint] = Uint(32000)
155	TX_CREATE: Final[ExecutionGas] = ExecutionGas(Uint(32000))

TX_VALUE_COST ¶

156	TX_VALUE_COST: Final[ExecutionGas] = ExecutionGas(Uint(6000))

TX_DATA_TOKEN_STANDARD ¶

105	TX_DATA_TOKEN_STANDARD: Final[Uint] = Uint(4)
157	TX_DATA_TOKEN_STANDARD: Final[ExecutionGas] = ExecutionGas(Uint(4))

TX_DATA_TOKEN_FLOOR ¶

106	TX_DATA_TOKEN_FLOOR: Final[Uint] = Uint(10)
158	TX_DATA_TOKEN_FLOOR: Final[ExecutionGas] = ExecutionGas(Uint(16))

TX_ACCESS_LIST_ADDRESS ¶

107	TX_ACCESS_LIST_ADDRESS: Final[Uint] = Uint(2400)
159	TX_ACCESS_LIST_ADDRESS: Final[ExecutionGas] = (
160	COLD_ACCOUNT_ACCESS - WARM_ACCESS
161	)

TX_ACCESS_LIST_STORAGE_KEY ¶

108	TX_ACCESS_LIST_STORAGE_KEY: Final[Uint] = Uint(1900)
162	TX_ACCESS_LIST_STORAGE_KEY: Final[ExecutionGas] = (
163	COLD_STORAGE_ACCESS - WARM_ACCESS
164	)

AUTH_TUPLE_BYTES ¶

167	AUTH_TUPLE_BYTES: Final[Uint] = Uint(101)

EXECUTION_PER_AUTH_BASE_COST ¶

168	EXECUTION_PER_AUTH_BASE_COST: Final[ExecutionGas] = ExecutionGas(
169	AUTH_TUPLE_BYTES * TX_DATA_TOKEN_FLOOR
170	+ PRECOMPILE_ECRECOVER
171	+ COLD_ACCOUNT_ACCESS
172	+ Uint(2) * WARM_ACCESS
173	)

LIMIT_ADJUSTMENT_FACTOR ¶

176	LIMIT_ADJUSTMENT_FACTOR: Final[Uint] = Uint(1024)

LIMIT_MINIMUM ¶

177	LIMIT_MINIMUM: Final[Uint] = Uint(5000)

OPCODE_ADD ¶

115	OPCODE_ADD: Final[Uint] = VERY_LOW
180	OPCODE_ADD: Final[ExecutionGas] = VERY_LOW

OPCODE_SUB ¶

116	OPCODE_SUB: Final[Uint] = VERY_LOW
181	OPCODE_SUB: Final[ExecutionGas] = VERY_LOW

OPCODE_MUL ¶

117	OPCODE_MUL: Final[Uint] = LOW
182	OPCODE_MUL: Final[ExecutionGas] = LOW

OPCODE_DIV ¶

118	OPCODE_DIV: Final[Uint] = LOW
183	OPCODE_DIV: Final[ExecutionGas] = LOW

OPCODE_SDIV ¶

119	OPCODE_SDIV: Final[Uint] = LOW
184	OPCODE_SDIV: Final[ExecutionGas] = LOW

OPCODE_MOD ¶

120	OPCODE_MOD: Final[Uint] = LOW
185	OPCODE_MOD: Final[ExecutionGas] = LOW

OPCODE_SMOD ¶

121	OPCODE_SMOD: Final[Uint] = LOW
186	OPCODE_SMOD: Final[ExecutionGas] = LOW

OPCODE_ADDMOD ¶

122	OPCODE_ADDMOD: Final[Uint] = MID
187	OPCODE_ADDMOD: Final[ExecutionGas] = MID

OPCODE_MULMOD ¶

123	OPCODE_MULMOD: Final[Uint] = MID
188	OPCODE_MULMOD: Final[ExecutionGas] = MID

OPCODE_SIGNEXTEND ¶

124	OPCODE_SIGNEXTEND: Final[Uint] = LOW
189	OPCODE_SIGNEXTEND: Final[ExecutionGas] = LOW

OPCODE_LT ¶

125	OPCODE_LT: Final[Uint] = VERY_LOW
190	OPCODE_LT: Final[ExecutionGas] = VERY_LOW

OPCODE_GT ¶

126	OPCODE_GT: Final[Uint] = VERY_LOW
191	OPCODE_GT: Final[ExecutionGas] = VERY_LOW

OPCODE_SLT ¶

127	OPCODE_SLT: Final[Uint] = VERY_LOW
192	OPCODE_SLT: Final[ExecutionGas] = VERY_LOW

OPCODE_SGT ¶

128	OPCODE_SGT: Final[Uint] = VERY_LOW
193	OPCODE_SGT: Final[ExecutionGas] = VERY_LOW

OPCODE_EQ ¶

129	OPCODE_EQ: Final[Uint] = VERY_LOW
194	OPCODE_EQ: Final[ExecutionGas] = VERY_LOW

OPCODE_ISZERO ¶

130	OPCODE_ISZERO: Final[Uint] = VERY_LOW
195	OPCODE_ISZERO: Final[ExecutionGas] = VERY_LOW

OPCODE_AND ¶

131	OPCODE_AND: Final[Uint] = VERY_LOW
196	OPCODE_AND: Final[ExecutionGas] = VERY_LOW

OPCODE_OR ¶

132	OPCODE_OR: Final[Uint] = VERY_LOW
197	OPCODE_OR: Final[ExecutionGas] = VERY_LOW

OPCODE_XOR ¶

133	OPCODE_XOR: Final[Uint] = VERY_LOW
198	OPCODE_XOR: Final[ExecutionGas] = VERY_LOW

OPCODE_NOT ¶

134	OPCODE_NOT: Final[Uint] = VERY_LOW
199	OPCODE_NOT: Final[ExecutionGas] = VERY_LOW

OPCODE_BYTE ¶

135	OPCODE_BYTE: Final[Uint] = VERY_LOW
200	OPCODE_BYTE: Final[ExecutionGas] = VERY_LOW

OPCODE_SHL ¶

136	OPCODE_SHL: Final[Uint] = VERY_LOW
201	OPCODE_SHL: Final[ExecutionGas] = VERY_LOW

OPCODE_SHR ¶

137	OPCODE_SHR: Final[Uint] = VERY_LOW
202	OPCODE_SHR: Final[ExecutionGas] = VERY_LOW

OPCODE_SAR ¶

138	OPCODE_SAR: Final[Uint] = VERY_LOW
203	OPCODE_SAR: Final[ExecutionGas] = VERY_LOW

OPCODE_CLZ ¶

139	OPCODE_CLZ: Final[Uint] = LOW
204	OPCODE_CLZ: Final[ExecutionGas] = LOW

OPCODE_JUMP ¶

140	OPCODE_JUMP: Final[Uint] = MID
205	OPCODE_JUMP: Final[ExecutionGas] = MID

OPCODE_JUMPI ¶

141	OPCODE_JUMPI: Final[Uint] = HIGH
206	OPCODE_JUMPI: Final[ExecutionGas] = HIGH

OPCODE_JUMPDEST ¶

142	OPCODE_JUMPDEST: Final[Uint] = Uint(1)
207	OPCODE_JUMPDEST: Final[ExecutionGas] = ExecutionGas(Uint(1))

OPCODE_CALLDATALOAD ¶

143	OPCODE_CALLDATALOAD: Final[Uint] = VERY_LOW
208	OPCODE_CALLDATALOAD: Final[ExecutionGas] = VERY_LOW

OPCODE_BLOCKHASH ¶

144	OPCODE_BLOCKHASH: Final[Uint] = Uint(20)
209	OPCODE_BLOCKHASH: Final[ExecutionGas] = ExecutionGas(Uint(20))

OPCODE_COINBASE ¶

145	OPCODE_COINBASE: Final[Uint] = BASE
210	OPCODE_COINBASE: Final[ExecutionGas] = BASE

OPCODE_POP ¶

146	OPCODE_POP: Final[Uint] = BASE
211	OPCODE_POP: Final[ExecutionGas] = BASE

OPCODE_MSIZE ¶

147	OPCODE_MSIZE: Final[Uint] = BASE
212	OPCODE_MSIZE: Final[ExecutionGas] = BASE

OPCODE_PC ¶

148	OPCODE_PC: Final[Uint] = BASE
213	OPCODE_PC: Final[ExecutionGas] = BASE

OPCODE_GAS ¶

149	OPCODE_GAS: Final[Uint] = BASE
214	OPCODE_GAS: Final[ExecutionGas] = BASE

OPCODE_ADDRESS ¶

150	OPCODE_ADDRESS: Final[Uint] = BASE
215	OPCODE_ADDRESS: Final[ExecutionGas] = BASE

OPCODE_ORIGIN ¶

151	OPCODE_ORIGIN: Final[Uint] = BASE
216	OPCODE_ORIGIN: Final[ExecutionGas] = BASE

OPCODE_CALLER ¶

152	OPCODE_CALLER: Final[Uint] = BASE
217	OPCODE_CALLER: Final[ExecutionGas] = BASE

OPCODE_CALLVALUE ¶

153	OPCODE_CALLVALUE: Final[Uint] = BASE
218	OPCODE_CALLVALUE: Final[ExecutionGas] = BASE

OPCODE_CALLDATASIZE ¶

154	OPCODE_CALLDATASIZE: Final[Uint] = BASE
219	OPCODE_CALLDATASIZE: Final[ExecutionGas] = BASE

OPCODE_CODESIZE ¶

155	OPCODE_CODESIZE: Final[Uint] = BASE
220	OPCODE_CODESIZE: Final[ExecutionGas] = BASE

OPCODE_GASPRICE ¶

156	OPCODE_GASPRICE: Final[Uint] = BASE
221	OPCODE_GASPRICE: Final[ExecutionGas] = BASE

OPCODE_TIMESTAMP ¶

157	OPCODE_TIMESTAMP: Final[Uint] = BASE
222	OPCODE_TIMESTAMP: Final[ExecutionGas] = BASE

OPCODE_NUMBER ¶

158	OPCODE_NUMBER: Final[Uint] = BASE
223	OPCODE_NUMBER: Final[ExecutionGas] = BASE

OPCODE_GASLIMIT ¶

159	OPCODE_GASLIMIT: Final[Uint] = BASE
224	OPCODE_GASLIMIT: Final[ExecutionGas] = BASE

OPCODE_PREVRANDAO ¶

160	OPCODE_PREVRANDAO: Final[Uint] = BASE
225	OPCODE_PREVRANDAO: Final[ExecutionGas] = BASE

OPCODE_RETURNDATASIZE ¶

161	OPCODE_RETURNDATASIZE: Final[Uint] = BASE
226	OPCODE_RETURNDATASIZE: Final[ExecutionGas] = BASE

OPCODE_CHAINID ¶

162	OPCODE_CHAINID: Final[Uint] = BASE
227	OPCODE_CHAINID: Final[ExecutionGas] = BASE

OPCODE_SELFBALANCE ¶

163	OPCODE_SELFBALANCE: Final[Uint] = FAST_STEP
228	OPCODE_SELFBALANCE: Final[ExecutionGas] = FAST_STEP

OPCODE_BASEFEE ¶

164	OPCODE_BASEFEE: Final[Uint] = BASE
229	OPCODE_BASEFEE: Final[ExecutionGas] = BASE

OPCODE_BLOBBASEFEE ¶

165	OPCODE_BLOBBASEFEE: Final[Uint] = BASE
230	OPCODE_BLOBBASEFEE: Final[ExecutionGas] = BASE

OPCODE_SLOTNUM ¶

231	OPCODE_SLOTNUM: Final[ExecutionGas] = BASE

OPCODE_BLOBHASH ¶

166	OPCODE_BLOBHASH: Final[Uint] = Uint(3)
232	OPCODE_BLOBHASH: Final[ExecutionGas] = ExecutionGas(Uint(3))

OPCODE_PUSH ¶

167	OPCODE_PUSH: Final[Uint] = VERY_LOW
233	OPCODE_PUSH: Final[ExecutionGas] = VERY_LOW

OPCODE_PUSH0 ¶

168	OPCODE_PUSH0: Final[Uint] = BASE
234	OPCODE_PUSH0: Final[ExecutionGas] = BASE

OPCODE_DUP ¶

169	OPCODE_DUP: Final[Uint] = VERY_LOW
235	OPCODE_DUP: Final[ExecutionGas] = VERY_LOW

OPCODE_SWAP ¶

170	OPCODE_SWAP: Final[Uint] = VERY_LOW
236	OPCODE_SWAP: Final[ExecutionGas] = VERY_LOW

OPCODE_DUPN ¶

237	OPCODE_DUPN: Final[ExecutionGas] = VERY_LOW

OPCODE_SWAPN ¶

238	OPCODE_SWAPN: Final[ExecutionGas] = VERY_LOW

OPCODE_EXCHANGE ¶

239	OPCODE_EXCHANGE: Final[ExecutionGas] = VERY_LOW

OPCODE_TLOAD ¶

171	OPCODE_TLOAD: Final[Uint] = WARM_ACCESS
240	OPCODE_TLOAD: Final[ExecutionGas] = ExecutionGas(Uint(100))

OPCODE_TSTORE ¶

172	OPCODE_TSTORE: Final[Uint] = WARM_ACCESS
241	OPCODE_TSTORE: Final[ExecutionGas] = ExecutionGas(Uint(100))

OPCODE_RETURNDATACOPY_BASE ¶

175	OPCODE_RETURNDATACOPY_BASE: Final[Uint] = VERY_LOW
244	OPCODE_RETURNDATACOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_RETURNDATACOPY_PER_WORD ¶

176	OPCODE_RETURNDATACOPY_PER_WORD: Final[Uint] = Uint(3)
245	OPCODE_RETURNDATACOPY_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(3))

OPCODE_CALLDATACOPY_BASE ¶

177	OPCODE_CALLDATACOPY_BASE: Final[Uint] = VERY_LOW
246	OPCODE_CALLDATACOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_CODECOPY_BASE ¶

178	OPCODE_CODECOPY_BASE: Final[Uint] = VERY_LOW
247	OPCODE_CODECOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MCOPY_BASE ¶

179	OPCODE_MCOPY_BASE: Final[Uint] = VERY_LOW
248	OPCODE_MCOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MLOAD_BASE ¶

180	OPCODE_MLOAD_BASE: Final[Uint] = VERY_LOW
249	OPCODE_MLOAD_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MSTORE_BASE ¶

181	OPCODE_MSTORE_BASE: Final[Uint] = VERY_LOW
250	OPCODE_MSTORE_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MSTORE8_BASE ¶

182	OPCODE_MSTORE8_BASE: Final[Uint] = VERY_LOW
251	OPCODE_MSTORE8_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_COPY_PER_WORD ¶

183	OPCODE_COPY_PER_WORD: Final[Uint] = Uint(3)
252	OPCODE_COPY_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(3))

OPCODE_CREATE_BASE ¶

184
OPCODE_CREATE_BASE: Final[Uint] = Uint(32000)

OPCODE_EXP_BASE ¶

185	OPCODE_EXP_BASE: Final[Uint] = Uint(10)
253	OPCODE_EXP_BASE: Final[ExecutionGas] = ExecutionGas(Uint(10))

OPCODE_EXP_PER_BYTE ¶

186	OPCODE_EXP_PER_BYTE: Final[Uint] = Uint(50)
254	OPCODE_EXP_PER_BYTE: Final[ExecutionGas] = ExecutionGas(Uint(50))

OPCODE_KECCAK256_BASE ¶

187	OPCODE_KECCAK256_BASE: Final[Uint] = Uint(30)
255	OPCODE_KECCAK256_BASE: Final[ExecutionGas] = ExecutionGas(Uint(30))

OPCODE_KECCAK256_PER_WORD ¶

188	OPCODE_KECCAK256_PER_WORD: Final[Uint] = Uint(6)
256	OPCODE_KECCAK256_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(6))

OPCODE_LOG_BASE ¶

189	OPCODE_LOG_BASE: Final[Uint] = Uint(375)
257	OPCODE_LOG_BASE: Final[ExecutionGas] = ExecutionGas(Uint(375))

OPCODE_LOG_DATA_PER_BYTE ¶

190	OPCODE_LOG_DATA_PER_BYTE: Final[Uint] = Uint(8)
258	OPCODE_LOG_DATA_PER_BYTE: Final[ExecutionGas] = ExecutionGas(Uint(8))

OPCODE_LOG_TOPIC ¶

191	OPCODE_LOG_TOPIC: Final[Uint] = Uint(375)
259	OPCODE_LOG_TOPIC: Final[ExecutionGas] = ExecutionGas(Uint(375))

OPCODE_SELFDESTRUCT_BASE ¶

192	OPCODE_SELFDESTRUCT_BASE: Final[Uint] = Uint(5000)
260	OPCODE_SELFDESTRUCT_BASE: Final[ExecutionGas] = ExecutionGas(Uint(5000))

OPCODE_SELFDESTRUCT_NEW_ACCOUNT ¶

193
OPCODE_SELFDESTRUCT_NEW_ACCOUNT: Final[Uint] = Uint(25000)

MAX_BLOB_GAS_PER_BLOCK ¶

263	MAX_BLOB_GAS_PER_BLOCK: Final[U64] = (
264	GasCosts.BLOB_SCHEDULE_MAX * GasCosts.PER_BLOB
265	)

GasMeter ¶

Track a frame's gas consumption across both gas dimensions.

Bundle every mutable gas quantity a frame maintains, so the frame and its settlement work against one object instead of a scatter of fields on the Evm.

268	@final

269	@dataclass

class GasMeter:

gas_left ¶

Gas still available from the frame's execution-gas grant. Pays execution-gas charges, and state charges as spill once the reservoir empties.

281	gas_left: ExecutionGas

state_gas_left ¶

State gas still available in the frame's reservoir. Charges draw from here first and spill into gas_left once it is empty.

290	state_gas_left: StateGas

state_gas_baseline ¶

Reservoir level a rollback refills to: the frame's grant at entry, moved down by commit_state_gas when charges become non-refillable.

296	state_gas_baseline: StateGas

refund_counter ¶

Gas eligible for refund at the end of the transaction.

305	refund_counter: int = 0

Execution gas spent covering state charges after the reservoir emptied, not yet credited back. Credited back to gas_left first, in LIFO order, on a refund or failure, and repaid from the reservoir when a successful child merges (repay_state_gas_spill). EIP-8037 names this quantity state_gas_from_gas_left.

308	state_gas_spilled: StateGas = StateGas(Uint(0))

state_gas_committed_spill ¶

Spill that commit_state_gas marked non-refillable. It outlives the rollbacks restore_state_gas performs; only restore_state_gas_to_entry credits it back to gas_left. Committed reservoir draw needs no counter of its own: each commit lowers the baseline, so it is the frame's grant minus state_gas_baseline.

321	state_gas_committed_spill: StateGas = StateGas(Uint(0))

ExtendMemory ¶

Define the parameters for memory extension in opcodes.

cost: ethereum.base_types.UintExecutionGas The gas required to perform the extension expand_by: ethereum.base_types.Uint The size by which the memory will be extended

337	@final

338	@dataclass

class ExtendMemory:

cost ¶

208	cost: Uint
349	cost: ExecutionGas

expand_by ¶

350	expand_by: Uint

MessageCallGas ¶

Define the gas cost and gas given to the sub-call for executing the call opcodes.

cost: ethereum.base_types.UintExecutionGas The gas required to execute the call opcode, excludes memory expansion costs. sub_call: ethereum.base_types.UintExecutionGas The portion of gas available to sub-calls that is refundable if not consumed.

353	@final

354	@dataclass

class MessageCallGas:

cost ¶

227	cost: Uint
368	cost: ExecutionGas

sub_call ¶

228	sub_call: Uint
369	sub_call: ExecutionGas

check_gas ¶

Checks if amount gas is available without charging it. Raises OutOfGasError if insufficient gas.

Parameters

evm : The current EVM. amount : The amount of execution gas to check.

def check_gas(evm: "Evm", amount: ExecutionGas) -> None:

373	<snip>
385	if evm.gas_meter.gas_left < amount:
386	raise OutOfGasError

charge_gas_from_meter ¶

Subtracts amount from gas_left (execution gas).

Parameters

gas_meter : The gas meter. amount : The amount of execution gas the current operation requires.

def charge_gas_from_meter(gas_meter: GasMeter, amount: ExecutionGas) -> None:

390	<snip>
401	if gas_meter.gas_left < amount:
402	raise OutOfGasError
403	gas_meter.gas_left -= amount

charge_gas ¶

Subtracts amount from evm.gas_leftgas_left. (execution gas).

Parameters

evm : The current EVM. amount : ~~The amount of gas the current operation requires.~~The amount of execution gas the current operation requires.

def charge_gas(evm: Evm"Evm", amount: UintExecutionGas) -> None:

407	<snip>
418	evm_trace(evm, GasAndRefund(int(amount)))
419
245	if evm.gas_left < amount:
246	raise OutOfGasError
247	else:
248	evm.gas_left -= amount
420	charge_gas_from_meter(evm.gas_meter, amount)

charge_state_gas_from_meter ¶

Subtracts amount from the state gas reservoir, then from gas_left when the reservoir is empty, tracking any spill.

Parameters

gas_meter : The gas meter. amount : The amount of state gas the current operation requires.

def charge_state_gas_from_meter(gas_meter: GasMeter, amount: StateGas) -> None:

424	<snip>
438	if gas_meter.state_gas_left >= amount:
439	gas_meter.state_gas_left -= amount
440	elif Uint(gas_meter.state_gas_left) + Uint(gas_meter.gas_left) >= amount:
441	remainder = amount - gas_meter.state_gas_left
442	gas_meter.state_gas_left = StateGas(Uint(0))
443	gas_meter.gas_left = ExecutionGas(gas_meter.gas_left - Uint(remainder))
444	gas_meter.state_gas_spilled += remainder
445	else:
446	raise OutOfGasError

charge_state_gas ¶

Subtracts amount from the state gas reservoir, then from gas_left when the reservoir is empty, tracking any spill.

Parameters

evm : The current EVM. amount : The amount of state gas the current operation requires.

def charge_state_gas(evm: "Evm", amount: StateGas) -> None:

450	<snip>
464	evm_trace(evm, StateGasAndRefund(int(amount)))
465
466	charge_state_gas_from_meter(evm.gas_meter, amount)

commit_state_gas ¶

Mark the state gas spent so far as non-refillable.

A later rollback via restore_state_gas leaves the state bought so far in place, so it must not credit this gas back. In the top frame that protects the delegations applied by set_delegation, which survive a failure of the dispatched code. A failure that reverts the committed state as well -- one raised before dispatch -- must instead undo the commit with restore_state_gas_to_entry.

Move the baseline down to the current reservoir level and fold the spill into state_gas_committed_spill, so later refunds route to the reservoir instead of back into gas_left.

Parameters

gas_meter : The frame's gas meter.

def commit_state_gas(gas_meter: GasMeter) -> None:

470	<snip>
495	# Only charges precede a commit, so no refund has pushed the
496	# reservoir above the baseline: a commit only ever lowers it.
497	assert gas_meter.state_gas_left <= gas_meter.state_gas_baseline
498	gas_meter.state_gas_committed_spill += gas_meter.state_gas_spilled
499	gas_meter.state_gas_baseline = gas_meter.state_gas_left
500	gas_meter.state_gas_spilled = StateGas(Uint(0))

restore_state_gas ¶

Roll the frame's state gas back to the baseline on revert or halt.

The frame's state changes are undone, so the state gas consumed since the baseline is credited back in LIFO order: the spill returns to gas_left first, then the reservoir resets to the baseline. The refunds accrued on the undone changes are discarded with them. State gas committed as non-refillable stays charged.

Parameters

gas_meter : The frame's gas meter.

def restore_state_gas(gas_meter: GasMeter) -> None:

504	<snip> # noqa: E501
522	gas_meter.gas_left = ExecutionGas(
523	gas_meter.gas_left + Uint(gas_meter.state_gas_spilled)
524	)
525	gas_meter.state_gas_spilled = StateGas(Uint(0))
526	gas_meter.state_gas_left = gas_meter.state_gas_baseline
527	gas_meter.refund_counter = 0

restore_state_gas_to_entry ¶

Roll the frame's state gas back to frame entry, undoing any commit.

Used when the transaction-state rollback also reverts the applied delegations a commit_state_gas protected: every state charge refills -- all spill, committed or not, returns to gas_left -- and the baseline resets to the frame's grant.

Parameters

gas_meter : The frame's gas meter. state_gas_reservoir : The frame's immutable state gas grant.

def restore_state_gas_to_entry(gas_meter: GasMeter, state_gas_reservoir: StateGas) -> None:

533	<snip> # noqa: E501
552	# The baseline starts at the grant and only ever moves down.
553	assert gas_meter.state_gas_baseline <= state_gas_reservoir
554	# Only pre-dispatch failures roll back to entry, and no refund
555	# accrues before dispatch.
556	assert gas_meter.refund_counter == 0
557	gas_meter.gas_left = ExecutionGas(
558	gas_meter.gas_left
559	+ Uint(gas_meter.state_gas_spilled)
560	+ Uint(gas_meter.state_gas_committed_spill)
561	)
562	gas_meter.state_gas_spilled = StateGas(Uint(0))
563	gas_meter.state_gas_committed_spill = StateGas(Uint(0))
564	gas_meter.state_gas_left = state_gas_reservoir
565	gas_meter.state_gas_baseline = state_gas_reservoir

tx_state_gas_used ¶

Return the net state gas a transaction's execution consumed.

Measured off the top frame's finished gas meter: the reservoir drawn down since the transaction's grant plus the spill, outstanding or committed. May be negative when refunds exceed charges.

Parameters

gas_meter : The top frame's finished gas meter. state_gas_reservoir : The transaction's immutable state gas grant.

Returns

state_gas_used : int The net state gas consumed.

def tx_state_gas_used(gas_meter: GasMeter, state_gas_reservoir: StateGas) -> int:

571	<snip>
594	# The baseline starts at the grant and only ever moves down.
595	assert gas_meter.state_gas_baseline <= state_gas_reservoir
596	return (
597	int(state_gas_reservoir)
598	- int(gas_meter.state_gas_left)
599	+ int(gas_meter.state_gas_spilled)
600	+ int(gas_meter.state_gas_committed_spill)
601	)

credit_state_gas_refund ¶

Credit a state gas refund to the local frame, in LIFO order.

State-gas charges draw from the reservoir first and from gas_left last, so refunds credit the pool charged last first: gas_left up to the spill, then the reservoir. This restores the exact pools the charge drew from, so the two never drift.

Parameters

gas_meter : The gas meter crediting the refund. amount : The refund amount to credit.

def credit_state_gas_refund(gas_meter: GasMeter, amount: StateGas) -> None:

605	<snip>
623	from_gas_left = min(amount, gas_meter.state_gas_spilled)
624	gas_meter.gas_left = ExecutionGas(gas_meter.gas_left + Uint(from_gas_left))
625	gas_meter.state_gas_spilled -= from_gas_left
626	gas_meter.state_gas_left += amount - from_gas_left

repay_state_gas_spill ¶

Repay outstanding spill from the reservoir after a child merges.

A refund may land in a different frame than the charge it undoes: the refunding frame's spill can be smaller than the refund, so the excess credits the reservoir even though the charge drew from gas_left. Once a successful child's meter is absorbed, the claim and the credit sit in one meter, and the reservoir repays gas_left up to the spill still outstanding. No state creation is undone, so the used counters do not move; gas only crosses back between the two pools it drifted across.

Parameters

gas_meter : The merged gas meter.

def repay_state_gas_spill(gas_meter: GasMeter) -> None:

630	<snip> # noqa: E501
650	repayment = min(gas_meter.state_gas_left, gas_meter.state_gas_spilled)
651	gas_meter.gas_left = ExecutionGas(gas_meter.gas_left + Uint(repayment))
652	gas_meter.state_gas_left -= repayment
653	gas_meter.state_gas_spilled -= repayment
654	# The claim and the credit cannot both survive a repayment.
655	assert gas_meter.state_gas_left == Uint(0) or (
656	gas_meter.state_gas_spilled == Uint(0)
657	)

forfeit_remaining_gas ¶

Consume all remaining execution gas on an exceptional halt.

Parameters

gas_meter : The halted frame's gas meter.

def forfeit_remaining_gas(gas_meter: GasMeter) -> None:

661	<snip>
670	# A rollback owes any outstanding spill back to `gas_left`; it
671	# must be restored before the remainder burns.
672	assert gas_meter.state_gas_spilled == Uint(0)
673	gas_meter.gas_left = ExecutionGas(Uint(0))

withhold_create_gas ¶

Withhold and return the gas made available to a CREATE* child.

Deduct the all-but-one-64th share from the frame's gas_left and return it as the child frame's execution-gas grant.

Parameters

gas_meter : The creating frame's gas meter.

Returns

child_gas : ExecutionGas The execution gas granted to the child frame.

def withhold_create_gas(gas_meter: GasMeter) -> ExecutionGas:

677	<snip>
694	child_gas = max_message_call_gas(gas_meter.gas_left)
695	gas_meter.gas_left -= child_gas
696	return child_gas

drain_state_gas_reservoir ¶

Empty the frame's state gas reservoir for a child frame.

A child frame receives the parent's entire reservoir; there is no all-but-one-64th rule for state gas. The parent's reservoir is restored when the child returns.

Parameters

gas_meter : The parent frame's gas meter.

Returns

reservoir : StateGas The state gas granted to the child frame.

def drain_state_gas_reservoir(gas_meter: GasMeter) -> StateGas:

700	<snip>
718	reservoir = gas_meter.state_gas_left
719	gas_meter.state_gas_left = StateGas(Uint(0))
720	return reservoir

restore_child_gas ¶

Return a child frame's unused gas grant to the parent.

Used when the child frame is never entered (for example, a stack depth or balance check fails): the withheld execution gas and drained reservoir are returned untouched.

Parameters

gas_meter : The parent frame's gas meter. gas : The execution gas grant to return. state_gas_reservoir : The state gas reservoir to return.

def restore_child_gas(gas_meter: GasMeter, gas: ExecutionGas, state_gas_reservoir: StateGas) -> None:

726	<snip>
743	gas_meter.gas_left += gas
744	gas_meter.state_gas_left += state_gas_reservoir

calculate_memory_gas_cost ¶

Calculates the gas cost for allocating memory to the smallest multiple of 32 bytes, such that the allocated size is at least as big as the given size.

Parameters

size_in_bytes : The size of the data in bytes.

Returns

total_gas_cost : ethereum.base_types.UintExecutionGas The gas cost for storing data in memory.

def calculate_memory_gas_cost(size_in_bytes: Uint) -> UintExecutionGas:

748	<snip>
764	size_in_words = ceil32(size_in_bytes) // Uint(32)
765	linear_cost = size_in_words * GasCosts.MEMORY_PER_WORD
766	quadratic_cost = size_in_words ** Uint(2) // Uint(512)
767	total_gas_cost = linear_cost + quadratic_cost
768	try:
273	return total_gas_cost
769	return ExecutionGas(total_gas_cost)
770	except ValueError as e:
771	raise OutOfGasError from e

calculate_gas_extend_memory ¶

Calculates the gas amount to extend memory.

Parameters

memory : Memory contents of the EVM. extensions: List of extensions to be made to the memory. Consists of a tuple of start position and size.

Returns

extend_memory: ExtendMemory

def calculate_gas_extend_memory(memory: bytearray, extensions: List[Tuple[U256, U256]]) -> ExtendMemory:

777	<snip>
793	size_to_extend = Uint(0)
298	to_be_paid = Uint(0)
794	to_be_paid = GasCosts.ZERO
795	current_size = ulen(memory)
796	for start_position, size in extensions:
797	if size == 0:
798	continue
799	before_size = ceil32(current_size)
800	after_size = ceil32(Uint(start_position) + Uint(size))
801	if after_size <= before_size:
802	continue
803
804	size_to_extend += after_size - before_size
805	already_paid = calculate_memory_gas_cost(before_size)
806	total_cost = calculate_memory_gas_cost(after_size)
807	to_be_paid += total_cost - already_paid
808
809	current_size = after_size
810
811	return ExtendMemory(to_be_paid, size_to_extend)

calculate_message_call_gas ¶

Calculates the MessageCallGas (cost and gas made available to the sub-call) for executing call Opcodes.

Parameters

value: The amount of ETH that needs to be transferred. gas : The amount of gas provided to the message-call. gas_left : The amount of gas left in the current frame. memory_cost : The amount needed to extend the memory in the current frame. extra_gas : The amount of gas needed for transferring value + creating a new account inside a message call. call_stipend : The amount of stipend provided to a message call to execute code while transferring value (ETH).

Returns

message_call_gas: MessageCallGas

def calculate_message_call_gas(value: U256, gas: UintExecutionGas, gas_left: UintExecutionGas, memory_cost: UintExecutionGas, extra_gas: UintExecutionGas, call_stipend: UintExecutionGas) -> MessageCallGas:

822	<snip>
352	call_stipend = Uint(0) if value == 0 else call_stipend
848	call_stipend = GasCosts.ZERO if value == 0 else call_stipend
849	if gas_left < extra_gas + memory_cost:
850	return MessageCallGas(gas + extra_gas, gas + call_stipend)
851
852	gas = min(gas, max_message_call_gas(gas_left - memory_cost - extra_gas))
853
854	return MessageCallGas(gas + extra_gas, gas + call_stipend)

max_message_call_gas ¶

Calculates the maximum gas that is allowed for making a message call.

Parameters

gas : The amount of gas provided to the message-call.

Returns

max_allowed_message_call_gas: ethereum.base_types.UintExecutionGas The maximum gas allowed for making the message-call.

def max_message_call_gas(gas: UintExecutionGas) -> UintExecutionGas:

858	<snip>
376	return gas - (gas // Uint(64))
872	return ExecutionGas(gas - (gas // Uint(64)))

init_code_cost ¶

Calculates the gas to be charged for the init code in CREATE* opcodes as well as create transactions.

Parameters

init_code_length : The length of the init code provided to the opcode or a create transaction

Returns

init_code_gas: ethereum.base_types.UintExecutionGas The gas to be charged for the init code.

def init_code_cost(init_code_length: Uint) -> UintExecutionGas:

876	<snip>
396	return GasCosts.CODE_INIT_PER_WORD * ceil32(init_code_length) // Uint(32)
892	return ExecutionGas(
893	GasCosts.CODE_INIT_PER_WORD * ceil32(init_code_length) // Uint(32)
894	)

calculate_excess_blob_gas ¶

Calculates the excess blob gas for the current block based on the gas used in the parent block.

Parameters

parent_header : The parent block of the current block.

Returns

excess_blob_gas: ethereum.base_types.U64 The excess blob gas for the current block.

def calculate_excess_blob_gas(parent_header: Header | PreviousHeaderPreviousHeader) -> U64:

900	<snip>
915	# Defaults for a parent without blob gas fields.
916	excess_blob_gas = U64(0)
917	blob_gas_used = U64(0)
918	base_fee_per_gas = Uint(0)
919
422	if isinstance(parent_header, (Header, PreviousHeader)):
920	if isinstance(parent_header, (Header, PreviousHeader)):
921	# Read them from any parent that carries the fields, so
922	# accumulated excess blob gas survives a fork transition.
923	excess_blob_gas = parent_header.excess_blob_gas
924	blob_gas_used = parent_header.blob_gas_used
925	base_fee_per_gas = parent_header.base_fee_per_gas
926
927	parent_blob_gas = excess_blob_gas + blob_gas_used
928	if parent_blob_gas < GasCosts.BLOB_TARGET_GAS_PER_BLOCK:
929	return U64(0)
930
931	target_blob_gas_price = Uint(GasCosts.PER_BLOB)
932	target_blob_gas_price *= calculate_blob_gas_price(excess_blob_gas)
933
934	base_blob_tx_price = GasCosts.BLOB_BASE_COST * base_fee_per_gas
935	if base_blob_tx_price > target_blob_gas_price:
936	blob_schedule_delta = (
937	GasCosts.BLOB_SCHEDULE_MAX - GasCosts.BLOB_SCHEDULE_TARGET
938	)
939	return (
940	excess_blob_gas
941	+ blob_gas_used * blob_schedule_delta // GasCosts.BLOB_SCHEDULE_MAX
942	)
943
944	return parent_blob_gas - GasCosts.BLOB_TARGET_GAS_PER_BLOCK

calculate_total_blob_gas ¶

Calculate the total blob gas for a transaction.

Parameters

tx : The transaction for which the blob gas is to be calculated.

Returns

total_blob_gas: ethereum.base_types.Uint The total blob gas for the transaction.

def calculate_total_blob_gas(tx: Transaction) -> U64:

948	<snip>
962	if isinstance(tx, BlobTransaction):
963	return GasCosts.PER_BLOB * U64(len(tx.blob_versioned_hashes))
964	else:
965	return U64(0)

calculate_blob_gas_price ¶

Calculate the blob gasprice for a block.

Parameters

excess_blob_gas : The excess blob gas for the block.

Returns

blob_gasprice: Uint The blob gasprice.

def calculate_blob_gas_price(excess_blob_gas: U64) -> Uint:

969	<snip>
983	return taylor_exponential(
984	GasCosts.BLOB_MIN_GASPRICE,
985	Uint(excess_blob_gas),
986	GasCosts.BLOB_BASE_FEE_UPDATE_FRACTION,
987	)

calculate_data_fee ¶

Calculate the blob data fee for a transaction.

Parameters

excess_blob_gas : The excess_blob_gas for the execution. tx : The transaction for which the blob data fee is to be calculated.

Returns

data_fee: Uint The blob data fee.

def calculate_data_fee(excess_blob_gas: U64, tx: Transaction) -> Uint:

991	<snip>
1007	return Uint(calculate_total_blob_gas(tx)) * calculate_blob_gas_price(
1008	excess_blob_gas
1009	)

check_max_fee_per_blob_gas ¶

Check that a transaction carrying blobs pays at least the blob gas price.

A transaction without blobs pays no blob fee, so its fee cap is not checked.

Parameters

blob_versioned_hashes : The transaction's blob versioned hashes. max_fee_per_blob_gas : The transaction's fee cap per unit of blob gas. excess_blob_gas : The block's excess blob gas.

Raises

InsufficientMaxFeePerBlobGasError : If the fee cap does not cover the blob gas price.

def check_max_fee_per_blob_gas(blob_versioned_hashes: Tuple[VersionedHash, ...], max_fee_per_blob_gas: U256, excess_blob_gas: U64) -> None:

1017	<snip>
1039	if not blob_versioned_hashes:
1040	return
1041
1042	blob_gas_price = calculate_blob_gas_price(excess_blob_gas)
1043	if Uint(max_fee_per_blob_gas) < blob_gas_price:
1044	raise InsufficientMaxFeePerBlobGasError(
1045	"insufficient max fee per blob gas"
1046	)

check_block_gas_capacity ¶

Check that the transaction fits the block's remaining gas capacity.

Each dimension is checked against its own remaining budget: execution gas, where a single transaction can consume at most TX_MAX_GAS_LIMIT; state gas; and blob gas.

Parameters

block_env : The block scoped environment. block_output : The block output for the current block. tx_gas : The transaction's gas limit. tx_blob_gas : The blob gas used by the transaction.

Raises

GasUsedExceedsLimitError : If the transaction exceeds the block's remaining execution or state gas. BlobGasLimitExceededError : If the transaction exceeds the block's remaining blob gas.

def check_block_gas_capacity(block_env: "BlockEnvironment", block_output: "BlockOutput", tx_gas: Uint, tx_blob_gas: U64) -> None:

1055	<snip> # noqa: E501
1084	execution_gas_available = (
1085	block_env.block_gas_limit - block_output.block_gas_used
1086	)
1087	state_gas_available = (
1088	block_env.block_gas_limit - block_output.block_state_gas_used
1089	)
1090	blob_gas_available = MAX_BLOB_GAS_PER_BLOCK - block_output.blob_gas_used
1091
1092	if min(TX_MAX_GAS_LIMIT, tx_gas) > execution_gas_available:
1093	raise GasUsedExceedsLimitError("execution gas used exceeds limit")
1094
1095	if tx_gas > state_gas_available:
1096	raise GasUsedExceedsLimitError("state gas used exceeds limit")
1097
1098	if tx_blob_gas > blob_gas_available:
1099	raise BlobGasLimitExceededError("blob gas limit exceeded")

EvmGasAllocation ¶

Split of a transaction's EVM gas across the two dimensions.

1102	@final

1103	@dataclass

class EvmGasAllocation:

execution_gas ¶

Execution gas granted to the top frame, capped by the budget.

1109	execution_gas: ExecutionGas

state_gas_reservoir ¶

State gas set aside for the top frame's reservoir.

1112	state_gas_reservoir: StateGas

allocate_evm_gas ¶

Split EVM gas into an execution-gas grant and a state reservoir.

After the intrinsic cost is removed, the remaining EVM gas is divided into execution gas -- capped by the execution-gas budget that remains below TX_MAX_GAS_LIMIT -- and a state gas reservoir that holds whatever exceeds that cap.

Only valid once validate_transaction has confirmed the transaction can afford its intrinsic cost, which guarantees the subtractions below do not underflow.

Parameters

tx_gas : The transaction's gas limit. intrinsic : The transaction's intrinsic gas cost.

Returns

allocation : EvmGasAllocation The execution gas grant and state gas reservoir.

def allocate_evm_gas(tx_gas: Uint, intrinsic: IntrinsicGasCost) -> EvmGasAllocation:

1119	<snip>
1144	evm_gas = tx_gas - Uint(intrinsic.execution)
1145	execution_gas_budget = TX_MAX_GAS_LIMIT - intrinsic.execution
1146	execution_gas = ExecutionGas(min(execution_gas_budget, evm_gas))
1147	state_gas_reservoir = StateGas(evm_gas - execution_gas)
1148	return EvmGasAllocation(execution_gas, state_gas_reservoir)

TransactionGasSettlement ¶

Settled gas amounts for a finished transaction.

Hold only gas figures; the caller turns them into fee payments and block-accounting updates.

1151	@final

1152	@dataclass

class TransactionGasSettlement:

gas_used ¶

Total gas charged to the sender, after refund and floor.

1161	gas_used: Uint

gas_left ¶

Gas returned to the sender, priced at the effective gas price.

1164	gas_left: Uint

execution_gas_used ¶

Execution gas the transaction contributes to the block total.

1167	execution_gas_used: ExecutionGas

state_gas_used ¶

State gas the transaction contributes to the block total.

1170	state_gas_used: StateGas

settle_transaction_gas ¶

Settle a transaction's gas after execution.

Compute, in order:

the gas used before refunds, from the gas limit less the execution gas and reservoir the top frame returned;
the refund, capped at one fifth of that pre-refund usage;
the gas used, taken as the larger of the post-refund usage and the calldata floor, so a transaction never pays below the floor; and
the per-dimension block amounts: the state gas used (clamped to zero, since refunds can drive it negative) and the execution gas used, which carries the floor because the floor binds the execution dimension. Unlike the sender-facing gas_used, it ignores refunds: block accounting counts pre-refund gas (EIP-7778).

Parameters

tx_gas : The transaction's gas limit. calldata_floor : The transaction's calldata floor gas. gas_left : Execution gas the top frame returned. state_gas_left : State gas reservoir the top frame returned. refund_counter : The refund the top frame accrued. state_gas_used : Net state gas the top frame consumed, possibly negative.

Returns

settlement : TransactionGasSettlement The settled gas amounts.

def settle_transaction_gas(tx_gas: Uint, calldata_floor: Uint, gas_left: ExecutionGas, state_gas_left: StateGas, refund_counter: U256, state_gas_used: int) -> TransactionGasSettlement:

1182	<snip>
1222	gas_used_before_refund = tx_gas - gas_left - state_gas_left
1223	gas_refund = min(gas_used_before_refund // Uint(5), Uint(refund_counter))
1224	gas_used_after_refund = gas_used_before_refund - gas_refund
1225	gas_used = max(gas_used_after_refund, calldata_floor)
1226
1227	settled_state_gas_used = StateGas(Uint(max(0, state_gas_used)))
1228	execution_gas_used = ExecutionGas(
1229	max(
1230	gas_used_before_refund - settled_state_gas_used,
1231	calldata_floor,
1232	)
1233	)
1234	return TransactionGasSettlement(
1235	gas_used=gas_used,
1236	gas_left=tx_gas - gas_used,
1237	execution_gas_used=execution_gas_used,
1238	state_gas_used=settled_state_gas_used,
1239	)

Search Results

ethereum.forks.bpo5.vm.gasethereum.forks.amsterdam.vm.gas

Introduction