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 ¶

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

STATE_BYTES_PER_NEW_ACCOUNT ¶

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

STATE_BYTES_PER_STORAGE_SET ¶

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

STATE_BYTES_PER_AUTH_BASE ¶

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

STORAGE_SET ¶

51	STORAGE_SET: Final[StateGas] = (
52	STATE_BYTES_PER_STORAGE_SET * COST_PER_STATE_BYTE
53	)

NEW_ACCOUNT ¶

54	NEW_ACCOUNT: Final[StateGas] = (
55	STATE_BYTES_PER_NEW_ACCOUNT * COST_PER_STATE_BYTE
56	)

AUTH_BASE ¶

57	AUTH_BASE: Final[StateGas] = (
58	STATE_BYTES_PER_AUTH_BASE * COST_PER_STATE_BYTE
59	)

GasCosts ¶

Constant gas values for the EVM.

class GasCosts:

BASE ¶

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

VERY_LOW ¶

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

LOW ¶

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

MID ¶

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

HIGH ¶

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

WARM_ACCESS ¶

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

COLD_ACCOUNT_ACCESS ¶

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

COLD_STORAGE_ACCESS ¶

45	COLD_STORAGE_ACCESS: Final[Uint] = Uint(2100)
78	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 ¶

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

CALL_STIPEND ¶

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

ACCOUNT_WRITE ¶

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

CALL_VALUE ¶

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

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

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

NEW_ACCOUNT ¶

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

CODE_DEPOSIT_PER_BYTE ¶

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

CODE_INIT_PER_WORD ¶

58	CODE_INIT_PER_WORD: Final[Uint] = Uint(2)
89	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 ¶

90	CREATE_ACCESS: Final[ExecutionGas] = ACCOUNT_WRITE + COLD_ACCOUNT_ACCESS

ZERO ¶

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

MEMORY_PER_WORD ¶

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

FAST_STEP ¶

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

REFUND_STORAGE_CLEAR ¶

69	REFUND_STORAGE_CLEAR: Final[int] = 4800
98	REFUND_STORAGE_CLEAR: Final[int] = int(
99	(STORAGE_WRITE + COLD_STORAGE_ACCESS) * Uint(4800) // Uint(5000)
100	)

70	REFUND_AUTH_PER_EXISTING_ACCOUNT: Final[int] = 12500

REFUND_AUTH_PER_EXISTING_ACCOUNT ¶

70
REFUND_AUTH_PER_EXISTING_ACCOUNT: Final[int] = 12500

PRECOMPILE_ECRECOVER ¶

73	PRECOMPILE_ECRECOVER: Final[Uint] = Uint(3000)
103	PRECOMPILE_ECRECOVER: Final[ExecutionGas] = ExecutionGas(Uint(3000))

PRECOMPILE_P256VERIFY ¶

74	PRECOMPILE_P256VERIFY: Final[Uint] = Uint(6900)
104	PRECOMPILE_P256VERIFY: Final[ExecutionGas] = ExecutionGas(Uint(6900))

PRECOMPILE_SHA256_BASE ¶

75	PRECOMPILE_SHA256_BASE: Final[Uint] = Uint(60)
105	PRECOMPILE_SHA256_BASE: Final[ExecutionGas] = ExecutionGas(Uint(60))

PRECOMPILE_SHA256_PER_WORD ¶

76	PRECOMPILE_SHA256_PER_WORD: Final[Uint] = Uint(12)
106	PRECOMPILE_SHA256_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(12))

PRECOMPILE_RIPEMD160_BASE ¶

77	PRECOMPILE_RIPEMD160_BASE: Final[Uint] = Uint(600)
107	PRECOMPILE_RIPEMD160_BASE: Final[ExecutionGas] = ExecutionGas(Uint(600))

PRECOMPILE_RIPEMD160_PER_WORD ¶

78	PRECOMPILE_RIPEMD160_PER_WORD: Final[Uint] = Uint(120)
108	PRECOMPILE_RIPEMD160_PER_WORD: Final[ExecutionGas] = ExecutionGas(
109	Uint(120)
110	)

PRECOMPILE_IDENTITY_BASE ¶

79	PRECOMPILE_IDENTITY_BASE: Final[Uint] = Uint(15)
111	PRECOMPILE_IDENTITY_BASE: Final[ExecutionGas] = ExecutionGas(Uint(15))

PRECOMPILE_IDENTITY_PER_WORD ¶

80	PRECOMPILE_IDENTITY_PER_WORD: Final[Uint] = Uint(3)
112	PRECOMPILE_IDENTITY_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(3))

PRECOMPILE_BLAKE2F_PER_ROUND ¶

81	PRECOMPILE_BLAKE2F_PER_ROUND: Final[Uint] = Uint(1)
113	PRECOMPILE_BLAKE2F_PER_ROUND: Final[ExecutionGas] = ExecutionGas(Uint(1))

PRECOMPILE_POINT_EVALUATION ¶

82	PRECOMPILE_POINT_EVALUATION: Final[Uint] = Uint(50000)
114	PRECOMPILE_POINT_EVALUATION: Final[ExecutionGas] = ExecutionGas(
115	Uint(50000)
116	)

PRECOMPILE_BLS_G1ADD ¶

83	PRECOMPILE_BLS_G1ADD: Final[Uint] = Uint(375)
117	PRECOMPILE_BLS_G1ADD: Final[ExecutionGas] = ExecutionGas(Uint(375))

PRECOMPILE_BLS_G1MUL ¶

84	PRECOMPILE_BLS_G1MUL: Final[Uint] = Uint(12000)
118	PRECOMPILE_BLS_G1MUL: Final[ExecutionGas] = ExecutionGas(Uint(12000))

PRECOMPILE_BLS_G1MAP ¶

85	PRECOMPILE_BLS_G1MAP: Final[Uint] = Uint(5500)
119	PRECOMPILE_BLS_G1MAP: Final[ExecutionGas] = ExecutionGas(Uint(5500))

PRECOMPILE_BLS_G2ADD ¶

86	PRECOMPILE_BLS_G2ADD: Final[Uint] = Uint(600)
120	PRECOMPILE_BLS_G2ADD: Final[ExecutionGas] = ExecutionGas(Uint(600))

PRECOMPILE_BLS_G2MUL ¶

87	PRECOMPILE_BLS_G2MUL: Final[Uint] = Uint(22500)
121	PRECOMPILE_BLS_G2MUL: Final[ExecutionGas] = ExecutionGas(Uint(22500))

PRECOMPILE_BLS_G2MAP ¶

88	PRECOMPILE_BLS_G2MAP: Final[Uint] = Uint(23800)
122	PRECOMPILE_BLS_G2MAP: Final[ExecutionGas] = ExecutionGas(Uint(23800))

PRECOMPILE_ECADD ¶

89	PRECOMPILE_ECADD: Final[Uint] = Uint(150)
123	PRECOMPILE_ECADD: Final[ExecutionGas] = ExecutionGas(Uint(150))

PRECOMPILE_ECMUL ¶

90	PRECOMPILE_ECMUL: Final[Uint] = Uint(6000)
124	PRECOMPILE_ECMUL: Final[ExecutionGas] = ExecutionGas(Uint(6000))

PRECOMPILE_ECPAIRING_BASE ¶

91	PRECOMPILE_ECPAIRING_BASE: Final[Uint] = Uint(45000)
125	PRECOMPILE_ECPAIRING_BASE: Final[ExecutionGas] = ExecutionGas(Uint(45000))

PRECOMPILE_ECPAIRING_PER_POINT ¶

92	PRECOMPILE_ECPAIRING_PER_POINT: Final[Uint] = Uint(34000)
126	PRECOMPILE_ECPAIRING_PER_POINT: Final[ExecutionGas] = ExecutionGas(
127	Uint(34000)
128	)

PER_BLOB ¶

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

BLOB_SCHEDULE_TARGET ¶

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

BLOB_TARGET_GAS_PER_BLOCK ¶

133	BLOB_TARGET_GAS_PER_BLOCK: Final[U64] = PER_BLOB * BLOB_SCHEDULE_TARGET

BLOB_BASE_COST ¶

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

BLOB_SCHEDULE_MAX ¶

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

BLOB_MIN_GASPRICE ¶

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

BLOB_BASE_FEE_UPDATE_FRACTION ¶

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

BLOCK_ACCESS_LIST_ITEM ¶

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

TX_BASE ¶

104	TX_BASE: Final[Uint] = Uint(21000)
143	TX_BASE: Final[ExecutionGas] = ExecutionGas(Uint(12000))

TX_CREATE ¶

105
TX_CREATE: Final[Uint] = Uint(32000)

TX_VALUE_COST ¶

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

TX_DATA_TOKEN_STANDARD ¶

106	TX_DATA_TOKEN_STANDARD: Final[Uint] = Uint(4)
145	TX_DATA_TOKEN_STANDARD: Final[ExecutionGas] = ExecutionGas(Uint(4))

TX_DATA_TOKEN_FLOOR ¶

107	TX_DATA_TOKEN_FLOOR: Final[Uint] = Uint(10)
146	TX_DATA_TOKEN_FLOOR: Final[ExecutionGas] = ExecutionGas(Uint(16))

TX_ACCESS_LIST_ADDRESS ¶

108	TX_ACCESS_LIST_ADDRESS: Final[Uint] = Uint(2400)
147	TX_ACCESS_LIST_ADDRESS: Final[ExecutionGas] = (
148	COLD_ACCOUNT_ACCESS - WARM_ACCESS
149	)

TX_ACCESS_LIST_STORAGE_KEY ¶

109	TX_ACCESS_LIST_STORAGE_KEY: Final[Uint] = Uint(1900)
150	TX_ACCESS_LIST_STORAGE_KEY: Final[ExecutionGas] = (
151	COLD_STORAGE_ACCESS - WARM_ACCESS
152	)

TX_MAX_GAS_LIMIT ¶

153	TX_MAX_GAS_LIMIT: Final[Uint] = Uint(16_777_216)

TX_MAX_TOTAL_GAS_LIMIT ¶

154	TX_MAX_TOTAL_GAS_LIMIT: Final[Uint] = Uint(4_294_967_295)

AUTH_TUPLE_BYTES ¶

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

EXECUTION_PER_AUTH_BASE_COST ¶

158	EXECUTION_PER_AUTH_BASE_COST: Final[ExecutionGas] = ExecutionGas(
159	AUTH_TUPLE_BYTES * TX_DATA_TOKEN_FLOOR
160	+ PRECOMPILE_ECRECOVER
161	+ COLD_ACCOUNT_ACCESS
162	+ Uint(2) * WARM_ACCESS
163	)

LIMIT_ADJUSTMENT_FACTOR ¶

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

LIMIT_MINIMUM ¶

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

OPCODE_ADD ¶

117	OPCODE_ADD: Final[Uint] = VERY_LOW
170	OPCODE_ADD: Final[ExecutionGas] = VERY_LOW

OPCODE_SUB ¶

118	OPCODE_SUB: Final[Uint] = VERY_LOW
171	OPCODE_SUB: Final[ExecutionGas] = VERY_LOW

OPCODE_MUL ¶

119	OPCODE_MUL: Final[Uint] = LOW
172	OPCODE_MUL: Final[ExecutionGas] = LOW

OPCODE_DIV ¶

120	OPCODE_DIV: Final[Uint] = LOW
173	OPCODE_DIV: Final[ExecutionGas] = LOW

OPCODE_SDIV ¶

121	OPCODE_SDIV: Final[Uint] = LOW
174	OPCODE_SDIV: Final[ExecutionGas] = LOW

OPCODE_MOD ¶

122	OPCODE_MOD: Final[Uint] = LOW
175	OPCODE_MOD: Final[ExecutionGas] = LOW

OPCODE_SMOD ¶

123	OPCODE_SMOD: Final[Uint] = LOW
176	OPCODE_SMOD: Final[ExecutionGas] = LOW

OPCODE_ADDMOD ¶

124	OPCODE_ADDMOD: Final[Uint] = MID
177	OPCODE_ADDMOD: Final[ExecutionGas] = MID

OPCODE_MULMOD ¶

125	OPCODE_MULMOD: Final[Uint] = MID
178	OPCODE_MULMOD: Final[ExecutionGas] = MID

OPCODE_SIGNEXTEND ¶

126	OPCODE_SIGNEXTEND: Final[Uint] = LOW
179	OPCODE_SIGNEXTEND: Final[ExecutionGas] = LOW

OPCODE_LT ¶

127	OPCODE_LT: Final[Uint] = VERY_LOW
180	OPCODE_LT: Final[ExecutionGas] = VERY_LOW

OPCODE_GT ¶

128	OPCODE_GT: Final[Uint] = VERY_LOW
181	OPCODE_GT: Final[ExecutionGas] = VERY_LOW

OPCODE_SLT ¶

129	OPCODE_SLT: Final[Uint] = VERY_LOW
182	OPCODE_SLT: Final[ExecutionGas] = VERY_LOW

OPCODE_SGT ¶

130	OPCODE_SGT: Final[Uint] = VERY_LOW
183	OPCODE_SGT: Final[ExecutionGas] = VERY_LOW

OPCODE_EQ ¶

131	OPCODE_EQ: Final[Uint] = VERY_LOW
184	OPCODE_EQ: Final[ExecutionGas] = VERY_LOW

OPCODE_ISZERO ¶

132	OPCODE_ISZERO: Final[Uint] = VERY_LOW
185	OPCODE_ISZERO: Final[ExecutionGas] = VERY_LOW

OPCODE_AND ¶

133	OPCODE_AND: Final[Uint] = VERY_LOW
186	OPCODE_AND: Final[ExecutionGas] = VERY_LOW

OPCODE_OR ¶

134	OPCODE_OR: Final[Uint] = VERY_LOW
187	OPCODE_OR: Final[ExecutionGas] = VERY_LOW

OPCODE_XOR ¶

135	OPCODE_XOR: Final[Uint] = VERY_LOW
188	OPCODE_XOR: Final[ExecutionGas] = VERY_LOW

OPCODE_NOT ¶

136	OPCODE_NOT: Final[Uint] = VERY_LOW
189	OPCODE_NOT: Final[ExecutionGas] = VERY_LOW

OPCODE_BYTE ¶

137	OPCODE_BYTE: Final[Uint] = VERY_LOW
190	OPCODE_BYTE: Final[ExecutionGas] = VERY_LOW

OPCODE_SHL ¶

138	OPCODE_SHL: Final[Uint] = VERY_LOW
191	OPCODE_SHL: Final[ExecutionGas] = VERY_LOW

OPCODE_SHR ¶

139	OPCODE_SHR: Final[Uint] = VERY_LOW
192	OPCODE_SHR: Final[ExecutionGas] = VERY_LOW

OPCODE_SAR ¶

140	OPCODE_SAR: Final[Uint] = VERY_LOW
193	OPCODE_SAR: Final[ExecutionGas] = VERY_LOW

OPCODE_CLZ ¶

141	OPCODE_CLZ: Final[Uint] = LOW
194	OPCODE_CLZ: Final[ExecutionGas] = LOW

OPCODE_JUMP ¶

142	OPCODE_JUMP: Final[Uint] = MID
195	OPCODE_JUMP: Final[ExecutionGas] = MID

OPCODE_JUMPI ¶

143	OPCODE_JUMPI: Final[Uint] = HIGH
196	OPCODE_JUMPI: Final[ExecutionGas] = HIGH

OPCODE_JUMPDEST ¶

144	OPCODE_JUMPDEST: Final[Uint] = Uint(1)
197	OPCODE_JUMPDEST: Final[ExecutionGas] = ExecutionGas(Uint(1))

OPCODE_CALLDATALOAD ¶

145	OPCODE_CALLDATALOAD: Final[Uint] = VERY_LOW
198	OPCODE_CALLDATALOAD: Final[ExecutionGas] = VERY_LOW

OPCODE_BLOCKHASH ¶

146	OPCODE_BLOCKHASH: Final[Uint] = Uint(20)
199	OPCODE_BLOCKHASH: Final[ExecutionGas] = ExecutionGas(Uint(20))

OPCODE_COINBASE ¶

147	OPCODE_COINBASE: Final[Uint] = BASE
200	OPCODE_COINBASE: Final[ExecutionGas] = BASE

OPCODE_POP ¶

148	OPCODE_POP: Final[Uint] = BASE
201	OPCODE_POP: Final[ExecutionGas] = BASE

OPCODE_MSIZE ¶

149	OPCODE_MSIZE: Final[Uint] = BASE
202	OPCODE_MSIZE: Final[ExecutionGas] = BASE

OPCODE_PC ¶

150	OPCODE_PC: Final[Uint] = BASE
203	OPCODE_PC: Final[ExecutionGas] = BASE

OPCODE_GAS ¶

151	OPCODE_GAS: Final[Uint] = BASE
204	OPCODE_GAS: Final[ExecutionGas] = BASE

OPCODE_ADDRESS ¶

152	OPCODE_ADDRESS: Final[Uint] = BASE
205	OPCODE_ADDRESS: Final[ExecutionGas] = BASE

OPCODE_ORIGIN ¶

153	OPCODE_ORIGIN: Final[Uint] = BASE
206	OPCODE_ORIGIN: Final[ExecutionGas] = BASE

OPCODE_CALLER ¶

154	OPCODE_CALLER: Final[Uint] = BASE
207	OPCODE_CALLER: Final[ExecutionGas] = BASE

OPCODE_CALLVALUE ¶

155	OPCODE_CALLVALUE: Final[Uint] = BASE
208	OPCODE_CALLVALUE: Final[ExecutionGas] = BASE

OPCODE_CALLDATASIZE ¶

156	OPCODE_CALLDATASIZE: Final[Uint] = BASE
209	OPCODE_CALLDATASIZE: Final[ExecutionGas] = BASE

OPCODE_CODESIZE ¶

157	OPCODE_CODESIZE: Final[Uint] = BASE
210	OPCODE_CODESIZE: Final[ExecutionGas] = BASE

OPCODE_GASPRICE ¶

158	OPCODE_GASPRICE: Final[Uint] = BASE
211	OPCODE_GASPRICE: Final[ExecutionGas] = BASE

OPCODE_TIMESTAMP ¶

159	OPCODE_TIMESTAMP: Final[Uint] = BASE
212	OPCODE_TIMESTAMP: Final[ExecutionGas] = BASE

OPCODE_NUMBER ¶

160	OPCODE_NUMBER: Final[Uint] = BASE
213	OPCODE_NUMBER: Final[ExecutionGas] = BASE

OPCODE_GASLIMIT ¶

161	OPCODE_GASLIMIT: Final[Uint] = BASE
214	OPCODE_GASLIMIT: Final[ExecutionGas] = BASE

OPCODE_PREVRANDAO ¶

162	OPCODE_PREVRANDAO: Final[Uint] = BASE
215	OPCODE_PREVRANDAO: Final[ExecutionGas] = BASE

OPCODE_RETURNDATASIZE ¶

163	OPCODE_RETURNDATASIZE: Final[Uint] = BASE
216	OPCODE_RETURNDATASIZE: Final[ExecutionGas] = BASE

OPCODE_CHAINID ¶

164	OPCODE_CHAINID: Final[Uint] = BASE
217	OPCODE_CHAINID: Final[ExecutionGas] = BASE

OPCODE_SELFBALANCE ¶

165	OPCODE_SELFBALANCE: Final[Uint] = FAST_STEP
218	OPCODE_SELFBALANCE: Final[ExecutionGas] = FAST_STEP

OPCODE_BASEFEE ¶

166	OPCODE_BASEFEE: Final[Uint] = BASE
219	OPCODE_BASEFEE: Final[ExecutionGas] = BASE

OPCODE_BLOBBASEFEE ¶

167	OPCODE_BLOBBASEFEE: Final[Uint] = BASE
220	OPCODE_BLOBBASEFEE: Final[ExecutionGas] = BASE

OPCODE_SLOTNUM ¶

221	OPCODE_SLOTNUM: Final[ExecutionGas] = BASE

OPCODE_BLOBHASH ¶

168	OPCODE_BLOBHASH: Final[Uint] = Uint(3)
222	OPCODE_BLOBHASH: Final[ExecutionGas] = ExecutionGas(Uint(3))

OPCODE_PUSH ¶

169	OPCODE_PUSH: Final[Uint] = VERY_LOW
223	OPCODE_PUSH: Final[ExecutionGas] = VERY_LOW

OPCODE_PUSH0 ¶

170	OPCODE_PUSH0: Final[Uint] = BASE
224	OPCODE_PUSH0: Final[ExecutionGas] = BASE

OPCODE_DUP ¶

171	OPCODE_DUP: Final[Uint] = VERY_LOW
225	OPCODE_DUP: Final[ExecutionGas] = VERY_LOW

OPCODE_SWAP ¶

172	OPCODE_SWAP: Final[Uint] = VERY_LOW
226	OPCODE_SWAP: Final[ExecutionGas] = VERY_LOW

OPCODE_DUPN ¶

227	OPCODE_DUPN: Final[ExecutionGas] = VERY_LOW

OPCODE_SWAPN ¶

228	OPCODE_SWAPN: Final[ExecutionGas] = VERY_LOW

OPCODE_EXCHANGE ¶

229	OPCODE_EXCHANGE: Final[ExecutionGas] = VERY_LOW

OPCODE_TLOAD ¶

173	OPCODE_TLOAD: Final[Uint] = WARM_ACCESS
230	OPCODE_TLOAD: Final[ExecutionGas] = ExecutionGas(Uint(100))

OPCODE_TSTORE ¶

174	OPCODE_TSTORE: Final[Uint] = WARM_ACCESS
231	OPCODE_TSTORE: Final[ExecutionGas] = ExecutionGas(Uint(100))

OPCODE_RETURNDATACOPY_BASE ¶

177	OPCODE_RETURNDATACOPY_BASE: Final[Uint] = VERY_LOW
234	OPCODE_RETURNDATACOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_RETURNDATACOPY_PER_WORD ¶

178	OPCODE_RETURNDATACOPY_PER_WORD: Final[Uint] = Uint(3)
235	OPCODE_RETURNDATACOPY_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(3))

OPCODE_CALLDATACOPY_BASE ¶

179	OPCODE_CALLDATACOPY_BASE: Final[Uint] = VERY_LOW
236	OPCODE_CALLDATACOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_CODECOPY_BASE ¶

180	OPCODE_CODECOPY_BASE: Final[Uint] = VERY_LOW
237	OPCODE_CODECOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MCOPY_BASE ¶

181	OPCODE_MCOPY_BASE: Final[Uint] = VERY_LOW
238	OPCODE_MCOPY_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MLOAD_BASE ¶

182	OPCODE_MLOAD_BASE: Final[Uint] = VERY_LOW
239	OPCODE_MLOAD_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MSTORE_BASE ¶

183	OPCODE_MSTORE_BASE: Final[Uint] = VERY_LOW
240	OPCODE_MSTORE_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_MSTORE8_BASE ¶

184	OPCODE_MSTORE8_BASE: Final[Uint] = VERY_LOW
241	OPCODE_MSTORE8_BASE: Final[ExecutionGas] = VERY_LOW

OPCODE_COPY_PER_WORD ¶

185	OPCODE_COPY_PER_WORD: Final[Uint] = Uint(3)
242	OPCODE_COPY_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(3))

OPCODE_CREATE_BASE ¶

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

OPCODE_EXP_BASE ¶

187	OPCODE_EXP_BASE: Final[Uint] = Uint(10)
243	OPCODE_EXP_BASE: Final[ExecutionGas] = ExecutionGas(Uint(10))

OPCODE_EXP_PER_BYTE ¶

188	OPCODE_EXP_PER_BYTE: Final[Uint] = Uint(50)
244	OPCODE_EXP_PER_BYTE: Final[ExecutionGas] = ExecutionGas(Uint(50))

OPCODE_KECCAK256_BASE ¶

189	OPCODE_KECCAK256_BASE: Final[Uint] = Uint(30)
245	OPCODE_KECCAK256_BASE: Final[ExecutionGas] = ExecutionGas(Uint(30))

OPCODE_KECCAK256_PER_WORD ¶

190	OPCODE_KECCAK256_PER_WORD: Final[Uint] = Uint(6)
246	OPCODE_KECCAK256_PER_WORD: Final[ExecutionGas] = ExecutionGas(Uint(6))

OPCODE_LOG_BASE ¶

191	OPCODE_LOG_BASE: Final[Uint] = Uint(375)
247	OPCODE_LOG_BASE: Final[ExecutionGas] = ExecutionGas(Uint(375))

OPCODE_LOG_DATA_PER_BYTE ¶

192	OPCODE_LOG_DATA_PER_BYTE: Final[Uint] = Uint(8)
248	OPCODE_LOG_DATA_PER_BYTE: Final[ExecutionGas] = ExecutionGas(Uint(8))

OPCODE_LOG_TOPIC ¶

193	OPCODE_LOG_TOPIC: Final[Uint] = Uint(375)
249	OPCODE_LOG_TOPIC: Final[ExecutionGas] = ExecutionGas(Uint(375))

OPCODE_SELFDESTRUCT_BASE ¶

194	OPCODE_SELFDESTRUCT_BASE: Final[Uint] = Uint(5000)
250	OPCODE_SELFDESTRUCT_BASE: Final[ExecutionGas] = ExecutionGas(Uint(5000))

OPCODE_SELFDESTRUCT_NEW_ACCOUNT ¶

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

MAX_BLOB_GAS_PER_BLOCK ¶

253	MAX_BLOB_GAS_PER_BLOCK: Final[U64] = (
254	GasCosts.BLOB_SCHEDULE_MAX * GasCosts.PER_BLOB
255	)

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.

258	@final

259	@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.

271	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.

280	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.

286	state_gas_baseline: StateGas

refund_counter ¶

Gas eligible for refund at the end of the transaction.

295	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.

298	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.

311	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

327	@final

328	@dataclass

class ExtendMemory:

cost ¶

210	cost: Uint
339	cost: ExecutionGas

expand_by ¶

340	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.

343	@final

344	@dataclass

class MessageCallGas:

cost ¶

229	cost: Uint
358	cost: ExecutionGas

sub_call ¶

230	sub_call: Uint
359	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:

363	<snip>
375	if evm.gas_meter.gas_left < amount:
376	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:

380	<snip>
391	if gas_meter.gas_left < amount:
392	raise OutOfGasError
393	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:

397	<snip>
408	evm_trace(evm, GasAndRefund(int(amount)))
409
247	if evm.gas_left < amount:
248	raise OutOfGasError
249	else:
250	evm.gas_left -= amount
410	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:

414	<snip>
428	if gas_meter.state_gas_left >= amount:
429	gas_meter.state_gas_left -= amount
430	elif Uint(gas_meter.state_gas_left) + Uint(gas_meter.gas_left) >= amount:
431	remainder = amount - gas_meter.state_gas_left
432	gas_meter.state_gas_left = StateGas(Uint(0))
433	gas_meter.gas_left = ExecutionGas(gas_meter.gas_left - Uint(remainder))
434	gas_meter.state_gas_spilled += remainder
435	else:
436	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:

440	<snip>
454	evm_trace(evm, StateGasAndRefund(int(amount)))
455
456	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:

460	<snip>
485	# Only charges precede a commit, so no refund has pushed the
486	# reservoir above the baseline: a commit only ever lowers it.
487	assert gas_meter.state_gas_left <= gas_meter.state_gas_baseline
488	gas_meter.state_gas_committed_spill += gas_meter.state_gas_spilled
489	gas_meter.state_gas_baseline = gas_meter.state_gas_left
490	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:

494	<snip> # noqa: E501
512	gas_meter.gas_left = ExecutionGas(
513	gas_meter.gas_left + Uint(gas_meter.state_gas_spilled)
514	)
515	gas_meter.state_gas_spilled = StateGas(Uint(0))
516	gas_meter.state_gas_left = gas_meter.state_gas_baseline
517	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:

523	<snip> # noqa: E501
542	# The baseline starts at the grant and only ever moves down.
543	assert gas_meter.state_gas_baseline <= state_gas_reservoir
544	# Only pre-dispatch failures roll back to entry, and no refund
545	# accrues before dispatch.
546	assert gas_meter.refund_counter == 0
547	gas_meter.gas_left = ExecutionGas(
548	gas_meter.gas_left
549	+ Uint(gas_meter.state_gas_spilled)
550	+ Uint(gas_meter.state_gas_committed_spill)
551	)
552	gas_meter.state_gas_spilled = StateGas(Uint(0))
553	gas_meter.state_gas_committed_spill = StateGas(Uint(0))
554	gas_meter.state_gas_left = state_gas_reservoir
555	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:

561	<snip>
584	# The baseline starts at the grant and only ever moves down.
585	assert gas_meter.state_gas_baseline <= state_gas_reservoir
586	return (
587	int(state_gas_reservoir)
588	- int(gas_meter.state_gas_left)
589	+ int(gas_meter.state_gas_spilled)
590	+ int(gas_meter.state_gas_committed_spill)
591	)

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:

595	<snip>
613	from_gas_left = min(amount, gas_meter.state_gas_spilled)
614	gas_meter.gas_left = ExecutionGas(gas_meter.gas_left + Uint(from_gas_left))
615	gas_meter.state_gas_spilled -= from_gas_left
616	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:

620	<snip> # noqa: E501
640	repayment = min(gas_meter.state_gas_left, gas_meter.state_gas_spilled)
641	gas_meter.gas_left = ExecutionGas(gas_meter.gas_left + Uint(repayment))
642	gas_meter.state_gas_left -= repayment
643	gas_meter.state_gas_spilled -= repayment
644	# The claim and the credit cannot both survive a repayment.
645	assert gas_meter.state_gas_left == Uint(0) or (
646	gas_meter.state_gas_spilled == Uint(0)
647	)

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:

651	<snip>
660	# A rollback owes any outstanding spill back to `gas_left`; it
661	# must be restored before the remainder burns.
662	assert gas_meter.state_gas_spilled == Uint(0)
663	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:

667	<snip>
684	child_gas = max_message_call_gas(gas_meter.gas_left)
685	gas_meter.gas_left -= child_gas
686	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:

690	<snip>
708	reservoir = gas_meter.state_gas_left
709	gas_meter.state_gas_left = StateGas(Uint(0))
710	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:

716	<snip>
733	gas_meter.gas_left += gas
734	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:

738	<snip>
754	size_in_words = ceil32(size_in_bytes) // Uint(32)
755	linear_cost = size_in_words * GasCosts.MEMORY_PER_WORD
756	quadratic_cost = size_in_words ** Uint(2) // Uint(512)
757	total_gas_cost = linear_cost + quadratic_cost
274	return total_gas_cost
758	return ExecutionGas(total_gas_cost)

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:

764	<snip>
780	size_to_extend = Uint(0)
297	to_be_paid = Uint(0)
781	to_be_paid = GasCosts.ZERO
782	current_size = ulen(memory)
783	for start_position, size in extensions:
784	if size == 0:
785	continue
786	before_size = ceil32(current_size)
787	after_size = ceil32(Uint(start_position) + Uint(size))
788	if after_size <= before_size:
789	continue
790
791	size_to_extend += after_size - before_size
792	already_paid = calculate_memory_gas_cost(before_size)
793	total_cost = calculate_memory_gas_cost(after_size)
794	to_be_paid += total_cost - already_paid
795
796	current_size = after_size
797
798	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~~The call's own execution charge (access, value transfer and ~~account inside a message call.~~delegation resolution) that the forwarding budget must cover. Account creation is charged in state gas separately; CALL charges this itself and passes zero here. 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:

809	<snip>
351	call_stipend = Uint(0) if value == 0 else call_stipend
837	call_stipend = GasCosts.ZERO if value == 0 else call_stipend
838	if gas_left < extra_gas + memory_cost:
839	return MessageCallGas(gas + extra_gas, gas + call_stipend)
840
841	gas = min(gas, max_message_call_gas(gas_left - memory_cost - extra_gas))
842
843	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:

847	<snip>
375	return gas - (gas // Uint(64))
861	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:

865	<snip>
395	return GasCosts.CODE_INIT_PER_WORD * ceil32(init_code_length) // Uint(32)
881	return ExecutionGas(
882	GasCosts.CODE_INIT_PER_WORD * ceil32(init_code_length) // Uint(32)
883	)

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:

889	<snip>
904	# Defaults for a parent without blob gas fields.
905	excess_blob_gas = U64(0)
906	blob_gas_used = U64(0)
907	base_fee_per_gas = Uint(0)
908
421	if isinstance(parent_header, (Header, PreviousHeader)):
909	if isinstance(parent_header, (Header, PreviousHeader)):
910	# Read them from any parent that carries the fields, so
911	# accumulated excess blob gas survives a fork transition.
912	excess_blob_gas = parent_header.excess_blob_gas
913	blob_gas_used = parent_header.blob_gas_used
914	base_fee_per_gas = parent_header.base_fee_per_gas
915
916	parent_blob_gas = excess_blob_gas + blob_gas_used
917	if parent_blob_gas < GasCosts.BLOB_TARGET_GAS_PER_BLOCK:
918	return U64(0)
919
920	target_blob_gas_price = Uint(GasCosts.PER_BLOB)
921	target_blob_gas_price *= calculate_blob_gas_price(excess_blob_gas)
922
923	base_blob_tx_price = GasCosts.BLOB_BASE_COST * base_fee_per_gas
924	if base_blob_tx_price > target_blob_gas_price:
925	blob_schedule_delta = (
926	GasCosts.BLOB_SCHEDULE_MAX - GasCosts.BLOB_SCHEDULE_TARGET
927	)
928	return (
929	excess_blob_gas
930	+ blob_gas_used * blob_schedule_delta // GasCosts.BLOB_SCHEDULE_MAX
931	)
932
933	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:

937	<snip>
951	if isinstance(tx, BlobTransaction):
952	return GasCosts.PER_BLOB * U64(len(tx.blob_versioned_hashes))
953	else:
954	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:

958	<snip>
972	return taylor_exponential(
973	GasCosts.BLOB_MIN_GASPRICE,
974	Uint(excess_blob_gas),
975	GasCosts.BLOB_BASE_FEE_UPDATE_FRACTION,
976	)

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:

980	<snip>
996	return Uint(calculate_total_blob_gas(tx)) * calculate_blob_gas_price(
997	excess_blob_gas
998	)

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:

1006	<snip>
1028	if not blob_versioned_hashes:
1029	return
1030
1031	blob_gas_price = calculate_blob_gas_price(excess_blob_gas)
1032	if Uint(max_fee_per_blob_gas) < blob_gas_price:
1033	raise InsufficientMaxFeePerBlobGasError(
1034	"insufficient max fee per blob gas"
1035	)

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:

1044	<snip> # noqa: E501
1073	execution_gas_available = (
1074	block_env.block_gas_limit - block_output.block_gas_used
1075	)
1076	state_gas_available = (
1077	block_env.block_gas_limit - block_output.block_state_gas_used
1078	)
1079	blob_gas_available = MAX_BLOB_GAS_PER_BLOCK - block_output.blob_gas_used
1080
1081	if min(GasCosts.TX_MAX_GAS_LIMIT, tx_gas) > execution_gas_available:
1082	raise GasUsedExceedsLimitError("execution gas used exceeds limit")
1083
1084	if tx_gas > state_gas_available:
1085	raise GasUsedExceedsLimitError("state gas used exceeds limit")
1086
1087	if tx_blob_gas > blob_gas_available:
1088	raise BlobGasLimitExceededError("blob gas limit exceeded")

EvmGasAllocation ¶

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

1091	@final

1092	@dataclass

class EvmGasAllocation:

execution_gas ¶

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

1098	execution_gas: ExecutionGas

state_gas_reservoir ¶

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

1101	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:

1108	<snip>
1133	evm_gas = tx_gas - Uint(intrinsic.execution)
1134	execution_gas_budget = GasCosts.TX_MAX_GAS_LIMIT - intrinsic.execution
1135	execution_gas = ExecutionGas(min(execution_gas_budget, evm_gas))
1136	state_gas_reservoir = StateGas(evm_gas - execution_gas)
1137	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.

1140	@final

1141	@dataclass

class TransactionGasSettlement:

gas_used ¶

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

1150	gas_used: Uint

gas_left ¶

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

1153	gas_left: Uint

execution_gas_used ¶

Execution gas the transaction contributes to the block total.

1156	execution_gas_used: ExecutionGas

state_gas_used ¶

State gas the transaction contributes to the block total.

1159	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:

1171	<snip>
1211	gas_used_before_refund = tx_gas - gas_left - state_gas_left
1212	gas_refund = min(gas_used_before_refund // Uint(5), Uint(refund_counter))
1213	gas_used_after_refund = gas_used_before_refund - gas_refund
1214	gas_used = max(gas_used_after_refund, calldata_floor)
1215
1216	settled_state_gas_used = StateGas(Uint(max(0, state_gas_used)))
1217	execution_gas_used = ExecutionGas(
1218	max(
1219	gas_used_before_refund - settled_state_gas_used,
1220	calldata_floor,
1221	)
1222	)
1223	return TransactionGasSettlement(
1224	gas_used=gas_used,
1225	gas_left=tx_gas - gas_used,
1226	execution_gas_used=execution_gas_used,
1227	state_gas_used=settled_state_gas_used,
1228	)

Search Results

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

Introduction