ethereum.forks.gray_glacier.forkethereum.forks.paris.fork
Ethereum Specification.
.. contents:: Table of Contents :backlinks: none :local:
Introduction
Entry point for the Ethereum specification.
BLOCK_REWARD¶
| 68 | BLOCK_REWARD = U256(2 * 10**18) |
|---|
BASE_FEE_MAX_CHANGE_DENOMINATOR¶
| 65 | BASE_FEE_MAX_CHANGE_DENOMINATOR = Uint(8) |
|---|
ELASTICITY_MULTIPLIER¶
| 66 | ELASTICITY_MULTIPLIER = Uint(2) |
|---|
MINIMUM_DIFFICULTY¶
| 71 | MINIMUM_DIFFICULTY = Uint(131072) |
|---|
MAX_OMMER_DEPTH¶
| 72 | MAX_OMMER_DEPTH = Uint(6) |
|---|
BOMB_DELAY_BLOCKS¶
| 73 | BOMB_DELAY_BLOCKS = 11400000 |
|---|
EMPTY_OMMER_HASH¶
| 67 | EMPTY_OMMER_HASH = keccak256(rlp.encode([])) |
|---|
BlockChain ¶
History and current state of the block chain.
| 70 | @final |
|---|
| 71 | @dataclass |
|---|
class BlockChain:
blocks¶
| 77 | blocks: List[Block] |
|---|
state¶
| 78 | state: State |
|---|
chain_id¶
| 79 | chain_id: U64 |
|---|
apply_fork ¶
Transforms the state from the previous hard fork (old) into the block
chain object for this hard fork and returns it.
When forks need to implement an irregular state transition, this function
is used to handle the irregularity. See the :ref:DAO Fork <dao-fork> for
an example.
Parameters
old : Previous block chain object.
Returns
new : BlockChain
Upgraded block chain object for this hard fork.
def apply_fork(old: BlockChain) -> BlockChain:
| 83 | <snip> |
|---|---|
| 102 | return old |
get_last_256_block_hashes ¶
Obtain the list of hashes of the previous 256 blocks in order of increasing block number.
This function will return less hashes for the first 256 blocks.
The BLOCKHASH opcode needs to access the latest hashes on the chain,
therefore this function retrieves them.
Parameters
chain : History and current state.
Returns
recent_block_hashes : List[Hash32]
Hashes of the recent 256 blocks in order of increasing block number.
def get_last_256_block_hashes(chain: BlockChain) -> List[Hash32]:
| 106 | <snip> |
|---|---|
| 126 | recent_blocks = chain.blocks[-255:] |
| 127 | if len(recent_blocks) == 0: |
| 128 | return [] |
| 129 | |
| 130 | recent_block_hashes = [] |
| 131 | |
| 132 | for block in recent_blocks: |
| 133 | prev_block_hash = block.header.parent_hash |
| 134 | recent_block_hashes.append(prev_block_hash) |
| 135 | |
| 136 | # We are computing the hash only for the most recent block and not for |
| 137 | # the rest of the blocks as they have successors which have the hash of |
| 138 | # the current block as parent hash. |
| 139 | most_recent_block_hash = keccak256(rlp.encode(recent_blocks[-1].header)) |
| 140 | recent_block_hashes.append(most_recent_block_hash) |
| 141 | |
| 142 | return recent_block_hashes |
state_transition ¶
Attempts to apply a block to an existing block chain.
All parts of the block's contents need to be verified before being added to the chain. Blocks are verified by ensuring that the contents of the block make logical sense with the contents of the parent block. The information in the block's header must also match the corresponding information in the block.
To implement Ethereum, in theory clients are only required to store the most recent 255 blocks of the chain since as far as execution is concerned, only those blocks are accessed. Practically, however, clients should store more blocks to handle reorgs.
Parameters
chain :
History and current state.
block :
Block to apply to chain.
def state_transition(chain: BlockChain, block: Block) -> None:
| 146 | <snip> |
|---|---|
| 168 | validate_header(chain, block.header) |
| 176 | validate_ommers(block.ommers, block.header, chain) |
| 169 | if block.ommers != (): |
| 170 | raise InvalidBlock |
| 171 | |
| 172 | block_state = BlockState(pre_state=chain.state) |
| 173 | |
| 174 | block_env = vm.BlockEnvironment( |
| 175 | chain_id=chain.chain_id, |
| 176 | state=block_state, |
| 177 | block_gas_limit=block.header.gas_limit, |
| 178 | block_hashes=get_last_256_block_hashes(chain), |
| 179 | coinbase=block.header.coinbase, |
| 180 | number=block.header.number, |
| 181 | base_fee_per_gas=block.header.base_fee_per_gas, |
| 182 | time=block.header.timestamp, |
| 189 | difficulty=block.header.difficulty, |
| 183 | prev_randao=block.header.prev_randao, |
| 184 | ) |
| 185 | |
| 186 | block_output = apply_body( |
| 187 | block_env=block_env, |
| 188 | transactions=block.transactions, |
| 195 | ommers=block.ommers, |
| 189 | ) |
| 190 | block_diff = extract_block_diff(block_state) |
| 191 | block_state_root = chain.state.compute_state_root(block_diff) |
| 192 | transactions_root = root(block_output.transactions_trie) |
| 193 | receipt_root = root(block_output.receipts_trie) |
| 194 | block_logs_bloom = logs_bloom(block_output.block_logs) |
| 195 | |
| 196 | if block_output.block_gas_used != block.header.gas_used: |
| 197 | raise InvalidBlock( |
| 198 | f"{block_output.block_gas_used} != {block.header.gas_used}" |
| 199 | ) |
| 200 | if transactions_root != block.header.transactions_root: |
| 201 | raise InvalidBlock |
| 202 | if block_state_root != block.header.state_root: |
| 203 | raise InvalidBlock |
| 204 | if receipt_root != block.header.receipt_root: |
| 205 | raise InvalidBlock |
| 206 | if block_logs_bloom != block.header.bloom: |
| 207 | raise InvalidBlock |
| 208 | |
| 209 | apply_changes_to_state(chain.state, block_diff) |
| 210 | chain.blocks.append(block) |
| 211 | if len(chain.blocks) > 255: |
| 212 | # Real clients have to store more blocks to deal with reorgs, but the |
| 213 | # protocol only requires the last 255 |
| 214 | chain.blocks = chain.blocks[-255:] |
calculate_base_fee_per_gas ¶
Calculates the base fee per gas for the block.
Parameters
block_gas_limit : Gas limit of the block for which the base fee is being calculated. parent_gas_limit : Gas limit of the parent block. parent_gas_used : Gas used in the parent block. parent_base_fee_per_gas : Base fee per gas of the parent block.
Returns
base_fee_per_gas : Uint
Base fee per gas for the block.
def calculate_base_fee_per_gas(block_gas_limit: Uint, parent_gas_limit: Uint, parent_gas_used: Uint, parent_base_fee_per_gas: Uint) -> Uint:
| 223 | <snip> |
|---|---|
| 243 | parent_gas_target = parent_gas_limit // ELASTICITY_MULTIPLIER |
| 244 | if not check_gas_limit(block_gas_limit, parent_gas_limit): |
| 245 | raise InvalidBlock |
| 246 | |
| 247 | if parent_gas_used == parent_gas_target: |
| 248 | expected_base_fee_per_gas = parent_base_fee_per_gas |
| 249 | elif parent_gas_used > parent_gas_target: |
| 250 | gas_used_delta = parent_gas_used - parent_gas_target |
| 251 | |
| 252 | parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta |
| 253 | target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target |
| 254 | |
| 255 | base_fee_per_gas_delta = max( |
| 256 | target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR, |
| 257 | Uint(1), |
| 258 | ) |
| 259 | |
| 260 | expected_base_fee_per_gas = ( |
| 261 | parent_base_fee_per_gas + base_fee_per_gas_delta |
| 262 | ) |
| 263 | else: |
| 264 | gas_used_delta = parent_gas_target - parent_gas_used |
| 265 | |
| 266 | parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta |
| 267 | target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target |
| 268 | |
| 269 | base_fee_per_gas_delta = ( |
| 270 | target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR |
| 271 | ) |
| 272 | |
| 273 | expected_base_fee_per_gas = ( |
| 274 | parent_base_fee_per_gas - base_fee_per_gas_delta |
| 275 | ) |
| 276 | |
| 277 | return Uint(expected_base_fee_per_gas) |
validate_header ¶
Verifies a block header.
In order to consider a block's header valid, the logic for the quantities in the header should match the logic for the block itself. For example the header timestamp should be greater than the block's parent timestamp because the block was created after the parent block. Additionally, the block's number should be directly following the parent block's number since it is the next block in the sequence.
Parameters
chain : History and current state. header : Header to check for correctness.
def validate_header(chain: BlockChain, header: Header) -> None:
| 281 | <snip> |
|---|---|
| 299 | if header.number < Uint(1): |
| 300 | raise InvalidBlock |
| 308 | parent_header_number = header.number - Uint(1) |
| 309 | first_block_number = chain.blocks[0].header.number |
| 310 | last_block_number = chain.blocks[-1].header.number |
| 301 | |
| 312 | if ( |
| 313 | parent_header_number < first_block_number |
| 314 | or parent_header_number > last_block_number |
| 315 | ): |
| 316 | raise InvalidBlock |
| 317 | |
| 318 | parent_header = chain.blocks[ |
| 319 | parent_header_number - first_block_number |
| 320 | ].header |
| 302 | parent_header = chain.blocks[-1].header |
| 303 | |
| 304 | if header.gas_used > header.gas_limit: |
| 305 | raise InvalidBlock |
| 306 | |
| 307 | expected_base_fee_per_gas = calculate_base_fee_per_gas( |
| 308 | header.gas_limit, |
| 309 | parent_header.gas_limit, |
| 310 | parent_header.gas_used, |
| 311 | parent_header.base_fee_per_gas, |
| 312 | ) |
| 313 | if expected_base_fee_per_gas != header.base_fee_per_gas: |
| 314 | raise InvalidBlock |
| 333 | |
| 334 | parent_has_ommers = parent_header.ommers_hash != EMPTY_OMMER_HASH |
| 315 | if header.timestamp <= parent_header.timestamp: |
| 316 | raise InvalidBlock |
| 317 | if header.number != parent_header.number + Uint(1): |
| 318 | raise InvalidBlock |
| 319 | if len(header.extra_data) > 32: |
| 320 | raise InvalidBlock |
| 341 | |
| 342 | block_difficulty = calculate_block_difficulty( |
| 343 | header.number, |
| 344 | header.timestamp, |
| 345 | parent_header.timestamp, |
| 346 | parent_header.difficulty, |
| 347 | parent_has_ommers, |
| 348 | ) |
| 349 | if header.difficulty != block_difficulty: |
| 321 | if header.difficulty != 0: |
| 322 | raise InvalidBlock |
| 323 | if header.nonce != b"\x00\x00\x00\x00\x00\x00\x00\x00": |
| 324 | raise InvalidBlock |
| 325 | if header.ommers_hash != EMPTY_OMMER_HASH: |
| 326 | raise InvalidBlock |
| 327 | |
| 328 | block_parent_hash = keccak256(rlp.encode(parent_header)) |
| 329 | if header.parent_hash != block_parent_hash: |
| 354 | raise InvalidBlock |
| 355 | |
| 356 | validate_proof_of_work(header) |
| 330 | raise InvalidBlock |
generate_header_hash_for_pow ¶
Generate rlp hash of the header which is to be used for Proof-of-Work verification.
In other words, the PoW artefacts mix_digest and nonce are ignored
while calculating this hash.
A particular PoW is valid for a single hash, that hash is computed by
this function. The nonce and mix_digest are omitted from this hash
because they are being changed by miners in their search for a sufficient
proof-of-work.
Parameters
header : The header object for which the hash is to be generated.
Returns
hash : Hash32
The PoW valid rlp hash of the passed in header.
def generate_header_hash_for_pow(header: Header) -> Hash32:
| 360 | <snip> |
|---|---|
| 383 | header_data_without_pow_artefacts = ( |
| 384 | header.parent_hash, |
| 385 | header.ommers_hash, |
| 386 | header.coinbase, |
| 387 | header.state_root, |
| 388 | header.transactions_root, |
| 389 | header.receipt_root, |
| 390 | header.bloom, |
| 391 | header.difficulty, |
| 392 | header.number, |
| 393 | header.gas_limit, |
| 394 | header.gas_used, |
| 395 | header.timestamp, |
| 396 | header.extra_data, |
| 397 | header.base_fee_per_gas, |
| 398 | ) |
| 399 | |
| 400 | return keccak256(rlp.encode(header_data_without_pow_artefacts)) |
validate_proof_of_work ¶
Validates the Proof of Work constraints.
In order to verify that a miner's proof-of-work is valid for a block, a
mix-digest and result are calculated using the hashimoto_light
hash function. The mix digest is a hash of the header and the nonce that
is passed through and it confirms whether or not proof-of-work was done
on the correct block. The result is the actual hash value of the block.
Parameters
header : Header of interest.
def validate_proof_of_work(header: Header) -> None:
| 404 | <snip> |
|---|---|
| 419 | header_hash = generate_header_hash_for_pow(header) |
| 420 | # TODO: Memoize this somewhere and read from that data instead of |
| 421 | # calculating cache for every block validation. |
| 422 | cache = generate_cache(header.number) |
| 423 | mix_digest, result = hashimoto_light( |
| 424 | header_hash, header.nonce, cache, dataset_size(header.number) |
| 425 | ) |
| 426 | if mix_digest != header.mix_digest: |
| 427 | raise InvalidBlock |
| 428 | |
| 429 | limit = Uint(U256.MAX_VALUE) + Uint(1) |
| 430 | if Uint.from_be_bytes(result) > (limit // header.difficulty): |
| 431 | raise InvalidBlock |
check_transaction ¶
Check if the transaction is includable in the block.
Parameters
block_env : The block scoped environment. block_output : The block output for the current block. tx : The transaction. tx_state : The transaction state tracker.
Returns
sender_address : The sender of the transaction. effective_gas_price : The price to charge for gas when the transaction is executed.
Raises
InvalidBlock : If the transaction is not includable. GasUsedExceedsLimitError : If the gas used by the transaction exceeds the block's gas limit. NonceMismatchError : If the nonce of the transaction is not equal to the sender's nonce. InsufficientBalanceError : If the sender's balance is not enough to pay for the transaction. InvalidSenderError : If the transaction is from an address that does not exist anymore. InsufficientMaxFeePerGasError : If the maximum fee per gas is insufficient for the transaction.
def check_transaction(block_env: ethereum.forks.gray_glacier.vm.BlockEnvironmentethereum.forks.paris.vm.BlockEnvironment, block_output: ethereum.forks.gray_glacier.vm.BlockOutputethereum.forks.paris.vm.BlockOutput, tx: Transaction, tx_state: TransactionState) -> Tuple[Address, Uint]:
| 339 | <snip> |
|---|---|
| 376 | gas_available = block_env.block_gas_limit - block_output.block_gas_used |
| 377 | if tx.gas > gas_available: |
| 378 | raise GasUsedExceedsLimitError("gas used exceeds limit") |
| 379 | tx_chain_id = chain_id(tx) |
| 380 | if tx_chain_id is not None and tx_chain_id != block_env.chain_id: |
| 381 | raise WrongChainIdError( |
| 382 | expected=block_env.chain_id, |
| 383 | actual=tx_chain_id, |
| 384 | ) |
| 385 | |
| 386 | sender_address = recover_sender(tx) |
| 387 | sender_account = get_account(tx_state, sender_address) |
| 388 | |
| 389 | if isinstance(tx, FeeMarketTransaction): |
| 390 | if tx.max_fee_per_gas < block_env.base_fee_per_gas: |
| 391 | raise InsufficientMaxFeePerGasError( |
| 392 | tx.max_fee_per_gas, block_env.base_fee_per_gas |
| 393 | ) |
| 394 | |
| 395 | priority_fee_per_gas = min( |
| 396 | tx.max_priority_fee_per_gas, |
| 397 | tx.max_fee_per_gas - block_env.base_fee_per_gas, |
| 398 | ) |
| 399 | effective_gas_price = priority_fee_per_gas + block_env.base_fee_per_gas |
| 400 | max_gas_fee = tx.gas * tx.max_fee_per_gas |
| 401 | else: |
| 402 | if tx.gas_price < block_env.base_fee_per_gas: |
| 403 | raise InvalidBlock |
| 404 | effective_gas_price = tx.gas_price |
| 405 | max_gas_fee = tx.gas * tx.gas_price |
| 406 | |
| 407 | if sender_account.nonce > Uint(tx.nonce): |
| 408 | raise NonceMismatchError("nonce too low") |
| 409 | elif sender_account.nonce < Uint(tx.nonce): |
| 410 | raise NonceMismatchError("nonce too high") |
| 411 | if Uint(sender_account.balance) < max_gas_fee + Uint(tx.value): |
| 412 | raise InsufficientBalanceError("insufficient sender balance") |
| 413 | if sender_account.code_hash != EMPTY_CODE_HASH: |
| 414 | raise InvalidSenderError("not EOA") |
| 415 | |
| 416 | return sender_address, effective_gas_price |
make_receipt ¶
Make the receipt for a transaction that was executed.
Parameters
tx : The executed transaction. error : Error in the top level frame of the transaction, if any. cumulative_gas_used : The total gas used so far in the block after the transaction was executed. logs : The logs produced by the transaction.
Returns
receipt : The receipt for the transaction.
def make_receipt(tx: Transaction, error: Optional[EthereumException], cumulative_gas_used: Uint, logs: Tuple[Log, ...]) -> Bytes | Receipt:
| 425 | <snip> |
|---|---|
| 446 | receipt = Receipt( |
| 447 | succeeded=error is None, |
| 448 | cumulative_gas_used=cumulative_gas_used, |
| 449 | bloom=logs_bloom(logs), |
| 450 | logs=logs, |
| 451 | ) |
| 452 | |
| 453 | return encode_receipt(tx, receipt) |
apply_body ¶
Executes a block.
Many of the contents of a block are stored in data structures called tries. There is a transactions trie which is similar to a ledger of the transactions stored in the current block. There is also a receipts trie which stores the results of executing a transaction, like the post state and gas used. This function creates and executes the block that is to be added to the chain.
Parameters
block_env :
The block scoped environment.
transactions :
Transactions included in the block.
ommers :
Headers of ancestor blocks which are not direct parents (formerly
uncles.)
Returns
block_output : The block output for the current block.
def apply_body(block_env: ethereum.forks.gray_glacier.vm.BlockEnvironmentethereum.forks.paris.vm.BlockEnvironment, transactions: Tuple[LegacyTransaction | Bytes, ...], ommers: Tuple[Header, ...]) -> ethereum.forks.gray_glacier.vm.BlockOutputethereum.forks.paris.vm.BlockOutput:
| 460 | <snip> |
|---|---|
| 483 | block_output = vm.BlockOutput() |
| 484 | |
| 485 | for i, tx in enumerate(map(decode_transaction, transactions)): |
| 486 | process_transaction(block_env, block_output, tx, Uint(i)) |
| 487 | |
| 593 | pay_rewards(block_env, ommers) |
| 594 | |
| 488 | return block_output |
validate_ommers ¶
Validates the ommers mentioned in the block.
An ommer block is a block that wasn't canonically added to the blockchain because it wasn't validated as fast as the canonical block but was mined at the same time.
To be considered valid, the ommers must adhere to the rules defined in the Ethereum protocol. The maximum amount of ommers is 2 per block and there cannot be duplicate ommers in a block. Many of the other ommer constraints are listed in the in-line comments of this function.
Parameters
ommers : List of ommers mentioned in the current block. block_header: The header of current block. chain : History and current state.
def validate_ommers(ommers: Tuple[Header, ...], block_header: Header, chain: BlockChain) -> None:
| 601 | <snip> |
|---|---|
| 623 | block_hash = keccak256(rlp.encode(block_header)) |
| 624 | if keccak256(rlp.encode(ommers)) != block_header.ommers_hash: |
| 625 | raise InvalidBlock |
| 626 | |
| 627 | if len(ommers) == 0: |
| 628 | # Nothing to validate |
| 629 | return |
| 630 | |
| 631 | # Check that each ommer satisfies the constraints of a header |
| 632 | for ommer in ommers: |
| 633 | if Uint(1) > ommer.number or ommer.number >= block_header.number: |
| 634 | raise InvalidBlock |
| 635 | validate_header(chain, ommer) |
| 636 | if len(ommers) > 2: |
| 637 | raise InvalidBlock |
| 638 | |
| 639 | ommers_hashes = [keccak256(rlp.encode(ommer)) for ommer in ommers] |
| 640 | if len(ommers_hashes) != len(set(ommers_hashes)): |
| 641 | raise InvalidBlock |
| 642 | |
| 643 | recent_canonical_blocks = chain.blocks[-(MAX_OMMER_DEPTH + Uint(1)) :] |
| 644 | recent_canonical_block_hashes = { |
| 645 | keccak256(rlp.encode(block.header)) |
| 646 | for block in recent_canonical_blocks |
| 647 | } |
| 648 | recent_ommers_hashes: Set[Hash32] = set() |
| 649 | for block in recent_canonical_blocks: |
| 650 | recent_ommers_hashes = recent_ommers_hashes.union( |
| 651 | {keccak256(rlp.encode(ommer)) for ommer in block.ommers} |
| 652 | ) |
| 653 | |
| 654 | for ommer_index, ommer in enumerate(ommers): |
| 655 | ommer_hash = ommers_hashes[ommer_index] |
| 656 | if ommer_hash == block_hash: |
| 657 | raise InvalidBlock |
| 658 | if ommer_hash in recent_canonical_block_hashes: |
| 659 | raise InvalidBlock |
| 660 | if ommer_hash in recent_ommers_hashes: |
| 661 | raise InvalidBlock |
| 662 | |
| 663 | # Ommer age with respect to the current block. For example, an age of |
| 664 | # 1 indicates that the ommer is a sibling of previous block. |
| 665 | ommer_age = block_header.number - ommer.number |
| 666 | if Uint(1) > ommer_age or ommer_age > MAX_OMMER_DEPTH: |
| 667 | raise InvalidBlock |
| 668 | if ommer.parent_hash not in recent_canonical_block_hashes: |
| 669 | raise InvalidBlock |
| 670 | if ommer.parent_hash == block_header.parent_hash: |
| 671 | raise InvalidBlock |
pay_rewards ¶
Pay rewards to the block miner as well as the ommers miners.
The miner of the canonical block is rewarded with the predetermined
block reward, BLOCK_REWARD, plus a variable award based off of the
number of ommer blocks that were mined around the same time, and included
in the canonical block's header. An ommer block is a block that wasn't
added to the canonical blockchain because it wasn't validated as fast as
the accepted block but was mined at the same time. Although not all blocks
that are mined are added to the canonical chain, miners are still paid a
reward for their efforts. This reward is called an ommer reward and is
calculated based on the number associated with the ommer block that they
mined.
Parameters
block_env : The block scoped environment. ommers : List of ommers mentioned in the current block.
def pay_rewards(block_env: ethereum.forks.gray_glacier.vm.BlockEnvironment, ommers: Tuple[Header, ...]) -> None:
| 678 | <snip> |
|---|---|
| 700 | rewards_state = TransactionState(parent=block_env.state) |
| 701 | ommer_count = U256(len(ommers)) |
| 702 | miner_reward = BLOCK_REWARD + (ommer_count * (BLOCK_REWARD // U256(32))) |
| 703 | create_ether(rewards_state, block_env.coinbase, miner_reward) |
| 704 | |
| 705 | for ommer in ommers: |
| 706 | # Ommer age with respect to the current block. |
| 707 | ommer_age = U256(block_env.number - ommer.number) |
| 708 | ommer_miner_reward = ((U256(8) - ommer_age) * BLOCK_REWARD) // U256(8) |
| 709 | create_ether(rewards_state, ommer.coinbase, ommer_miner_reward) |
| 710 | |
| 711 | incorporate_tx_into_block(rewards_state) |
process_transaction ¶
Execute a transaction against the provided environment.
This function processes the actions needed to execute a transaction. It decrements the sender's account balance after calculating the gas fee and refunds them the proper amount after execution. Calling contracts, deploying code, and incrementing nonces are all examples of actions that happen within this function or from a call made within this function.
Accounts that are marked for deletion are processed and destroyed after execution.
Parameters
block_env : Environment for the Ethereum Virtual Machine. block_output : The block output for the current block. tx : Transaction to execute. index: Index of the transaction in the block.
def process_transaction(block_env: ethereum.forks.gray_glacier.vm.BlockEnvironmentethereum.forks.paris.vm.BlockEnvironment, block_output: ethereum.forks.gray_glacier.vm.BlockOutputethereum.forks.paris.vm.BlockOutput, tx: Transaction, index: Uint) -> None:
| 497 | <snip> |
|---|---|
| 521 | tx_state = TransactionState(parent=block_env.state) |
| 522 | |
| 523 | trie_set( |
| 524 | block_output.transactions_trie, |
| 525 | rlp.encode(index), |
| 526 | encode_transaction(tx), |
| 527 | ) |
| 528 | |
| 529 | intrinsic_gas = validate_transaction(tx) |
| 530 | |
| 531 | ( |
| 532 | sender, |
| 533 | effective_gas_price, |
| 534 | ) = check_transaction( |
| 535 | block_env=block_env, |
| 536 | block_output=block_output, |
| 537 | tx=tx, |
| 538 | tx_state=tx_state, |
| 539 | ) |
| 540 | |
| 541 | sender_account = get_account(tx_state, sender) |
| 542 | |
| 543 | effective_gas_fee = tx.gas * effective_gas_price |
| 544 | |
| 545 | gas = tx.gas - intrinsic_gas |
| 546 | increment_nonce(tx_state, sender) |
| 547 | |
| 548 | sender_balance_after_gas_fee = ( |
| 549 | Uint(sender_account.balance) - effective_gas_fee |
| 550 | ) |
| 551 | set_account_balance(tx_state, sender, U256(sender_balance_after_gas_fee)) |
| 552 | |
| 553 | access_list_addresses = set() |
| 554 | access_list_storage_keys = set() |
| 555 | if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)): |
| 556 | for access in tx.access_list: |
| 557 | access_list_addresses.add(access.account) |
| 558 | for slot in access.slots: |
| 559 | access_list_storage_keys.add((access.account, slot)) |
| 560 | |
| 561 | tx_env = vm.TransactionEnvironment( |
| 562 | origin=sender, |
| 563 | gas_price=effective_gas_price, |
| 564 | gas=gas, |
| 565 | access_list_addresses=access_list_addresses, |
| 566 | access_list_storage_keys=access_list_storage_keys, |
| 567 | state=tx_state, |
| 568 | index_in_block=index, |
| 569 | tx_hash=get_transaction_hash(encode_transaction(tx)), |
| 570 | ) |
| 571 | |
| 572 | message = prepare_message(block_env, tx_env, tx) |
| 573 | |
| 574 | tx_output = process_message_call(message) |
| 575 | |
| 576 | tx_gas_used_before_refund = tx.gas - tx_output.gas_left |
| 577 | tx_gas_refund = min( |
| 578 | tx_gas_used_before_refund // Uint(5), Uint(tx_output.refund_counter) |
| 579 | ) |
| 580 | tx_gas_used_after_refund = tx_gas_used_before_refund - tx_gas_refund |
| 581 | tx_gas_left = tx.gas - tx_gas_used_after_refund |
| 582 | gas_refund_amount = tx_gas_left * effective_gas_price |
| 583 | |
| 584 | # For non-1559 transactions effective_gas_price == tx.gas_price |
| 585 | priority_fee_per_gas = effective_gas_price - block_env.base_fee_per_gas |
| 586 | transaction_fee = tx_gas_used_after_refund * priority_fee_per_gas |
| 587 | |
| 588 | # refund gas |
| 589 | create_ether(tx_state, sender, U256(gas_refund_amount)) |
| 590 | |
| 591 | # transfer miner fees |
| 815 | coinbase_balance_after_mining_fee = get_account( |
| 816 | tx_state, block_env.coinbase |
| 817 | ).balance + U256(transaction_fee) |
| 818 | if coinbase_balance_after_mining_fee != 0: |
| 819 | set_account_balance( |
| 820 | tx_state, |
| 821 | block_env.coinbase, |
| 822 | coinbase_balance_after_mining_fee, |
| 823 | ) |
| 824 | elif account_exists_and_is_empty(tx_state, block_env.coinbase): |
| 825 | destroy_account(tx_state, block_env.coinbase) |
| 592 | create_ether(tx_state, block_env.coinbase, U256(transaction_fee)) |
| 593 | |
| 594 | for address in tx_output.accounts_to_delete: |
| 595 | destroy_account(tx_state, address) |
| 829 | |
| 830 | destroy_touched_empty_accounts(tx_state, tx_output.touched_accounts) |
| 596 | |
| 597 | block_output.block_gas_used += tx_gas_used_after_refund |
| 598 | |
| 599 | receipt = make_receipt( |
| 600 | tx, tx_output.error, block_output.block_gas_used, tx_output.logs |
| 601 | ) |
| 602 | |
| 603 | receipt_key = rlp.encode(Uint(index)) |
| 604 | block_output.receipt_keys += (receipt_key,) |
| 605 | |
| 606 | trie_set( |
| 607 | block_output.receipts_trie, |
| 608 | receipt_key, |
| 609 | receipt, |
| 610 | ) |
| 611 | |
| 612 | block_output.block_logs += tx_output.logs |
| 613 | |
| 614 | incorporate_tx_into_block(tx_state) |
check_gas_limit ¶
Validates the gas limit for a block.
The bounds of the gas limit, max_adjustment_delta, is set as the
quotient of the parent block's gas limit and the
LIMIT_ADJUSTMENT_FACTOR. Therefore, if the gas limit that is passed
through as a parameter is greater than or equal to the sum of the
parent's gas and the adjustment delta then the limit for gas is too high
and fails this function's check. Similarly, if the limit is less than or
equal to the difference of the parent's gas and the adjustment delta or
the predefined LIMIT_MINIMUM then this function's check fails because
the gas limit doesn't allow for a sufficient or reasonable amount of gas to
be used on a block.
Parameters
gas_limit : Gas limit to validate.
parent_gas_limit : Gas limit of the parent block.
Returns
check : bool
True if gas limit constraints are satisfied, False otherwise.
def check_gas_limit(gas_limit: Uint, parent_gas_limit: Uint) -> bool:
| 618 | <snip> |
|---|---|
| 646 | max_adjustment_delta = parent_gas_limit // GasCosts.LIMIT_ADJUSTMENT_FACTOR |
| 647 | if gas_limit >= parent_gas_limit + max_adjustment_delta: |
| 648 | return False |
| 649 | if gas_limit <= parent_gas_limit - max_adjustment_delta: |
| 650 | return False |
| 651 | if gas_limit < GasCosts.LIMIT_MINIMUM: |
| 652 | return False |
| 653 | |
| 654 | return True |
calculate_block_difficulty ¶
Computes difficulty of a block using its header and parent header.
The difficulty is determined by the time the block was created after its
parent. The offset is calculated using the parent block's difficulty,
parent_difficulty, and the timestamp between blocks. This offset is
then added to the parent difficulty and is stored as the difficulty
variable. If the time between the block and its parent is too short, the
offset will result in a positive number thus making the sum of
parent_difficulty and offset to be a greater value in order to
avoid mass forking. But, if the time is long enough, then the offset
results in a negative value making the block less difficult than
its parent.
The base standard for a block's difficulty is the predefined value
set for the genesis block since it has no parent. So, a block
can't be less difficult than the genesis block, therefore each block's
difficulty is set to the maximum value between the calculated
difficulty and the MINIMUM_DIFFICULTY.
Parameters
block_number : Block number of the block. block_timestamp : Timestamp of the block. parent_timestamp : Timestamp of the parent block. parent_difficulty : difficulty of the parent block. parent_has_ommers: does the parent have ommers.
Returns
difficulty : ethereum.base_types.Uint
Computed difficulty for a block.
def calculate_block_difficulty(block_number: Uint, block_timestamp: U256, parent_timestamp: U256, parent_difficulty: Uint, parent_has_ommers: bool) -> Uint:
| 899 | <snip> |
|---|---|
| 938 | offset = ( |
| 939 | int(parent_difficulty) |
| 940 | // 2048 |
| 941 | * max( |
| 942 | (2 if parent_has_ommers else 1) |
| 943 | - int(block_timestamp - parent_timestamp) // 9, |
| 944 | -99, |
| 945 | ) |
| 946 | ) |
| 947 | difficulty = int(parent_difficulty) + offset |
| 948 | # Historical Note: The difficulty bomb was not present in Ethereum at the |
| 949 | # start of Frontier, but was added shortly after launch. However since the |
| 950 | # bomb has no effect prior to block 200000 we pretend it existed from |
| 951 | # genesis. |
| 952 | # See https://github.com/ethereum/go-ethereum/pull/1588 |
| 953 | num_bomb_periods = ((int(block_number) - BOMB_DELAY_BLOCKS) // 100000) - 2 |
| 954 | if num_bomb_periods >= 0: |
| 955 | difficulty += 2**num_bomb_periods |
| 956 | |
| 957 | # Some clients raise the difficulty to `MINIMUM_DIFFICULTY` prior to adding |
| 958 | # the bomb. This bug does not matter because the difficulty is always much |
| 959 | # greater than `MINIMUM_DIFFICULTY` on Mainnet. |
| 960 | return Uint(max(difficulty, int(MINIMUM_DIFFICULTY))) |