ethereum.frontier.fork

Ethereum Specification ^^^^^^^^^^^^^^^^^^^^^^

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

Introduction

Entry point for the Ethereum specification.

BLOCK_REWARD

55
BLOCK_REWARD = U256(5 * 10**18)

GAS_LIMIT_ADJUSTMENT_FACTOR

56
GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)

GAS_LIMIT_MINIMUM

57
GAS_LIMIT_MINIMUM = Uint(5000)

MINIMUM_DIFFICULTY

58
MINIMUM_DIFFICULTY = Uint(131072)

MAX_OMMER_DEPTH

59
MAX_OMMER_DEPTH = Uint(6)

BlockChain

History and current state of the block chain.

62
@dataclass
class BlockChain:

blocks

68
    blocks: List[Block]

state

69
    state: State

chain_id

70
    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:
74
    """
75
    Transforms the state from the previous hard fork (`old`) into the block
76
    chain object for this hard fork and returns it.
77
78
    When forks need to implement an irregular state transition, this function
79
    is used to handle the irregularity. See the :ref:`DAO Fork <dao-fork>` for
80
    an example.
81
82
    Parameters
83
    ----------
84
    old :
85
        Previous block chain object.
86
87
    Returns
88
    -------
89
    new : `BlockChain`
90
        Upgraded block chain object for this hard fork.
91
    """
92
    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]:
96
    """
97
    Obtain the list of hashes of the previous 256 blocks in order of
98
    increasing block number.
99
100
    This function will return less hashes for the first 256 blocks.
101
102
    The ``BLOCKHASH`` opcode needs to access the latest hashes on the chain,
103
    therefore this function retrieves them.
104
105
    Parameters
106
    ----------
107
    chain :
108
        History and current state.
109
110
    Returns
111
    -------
112
    recent_block_hashes : `List[Hash32]`
113
        Hashes of the recent 256 blocks in order of increasing block number.
114
    """
115
    recent_blocks = chain.blocks[-255:]
116
    # TODO: This function has not been tested rigorously
117
    if len(recent_blocks) == 0:
118
        return []
119
120
    recent_block_hashes = []
121
122
    for block in recent_blocks:
123
        prev_block_hash = block.header.parent_hash
124
        recent_block_hashes.append(prev_block_hash)
125
126
    # We are computing the hash only for the most recent block and not for
127
    # the rest of the blocks as they have successors which have the hash of
128
    # the current block as parent hash.
129
    most_recent_block_hash = keccak256(rlp.encode(recent_blocks[-1].header))
130
    recent_block_hashes.append(most_recent_block_hash)
131
132
    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:
136
    """
137
    Attempts to apply a block to an existing block chain.
138
139
    All parts of the block's contents need to be verified before being added
140
    to the chain. Blocks are verified by ensuring that the contents of the
141
    block make logical sense with the contents of the parent block. The
142
    information in the block's header must also match the corresponding
143
    information in the block.
144
145
    To implement Ethereum, in theory clients are only required to store the
146
    most recent 255 blocks of the chain since as far as execution is
147
    concerned, only those blocks are accessed. Practically, however, clients
148
    should store more blocks to handle reorgs.
149
150
    Parameters
151
    ----------
152
    chain :
153
        History and current state.
154
    block :
155
        Block to apply to `chain`.
156
    """
157
    validate_header(chain, block.header)
158
    validate_ommers(block.ommers, block.header, chain)
159
160
    block_env = vm.BlockEnvironment(
161
        chain_id=chain.chain_id,
162
        state=chain.state,
163
        block_gas_limit=block.header.gas_limit,
164
        block_hashes=get_last_256_block_hashes(chain),
165
        coinbase=block.header.coinbase,
166
        number=block.header.number,
167
        time=block.header.timestamp,
168
        difficulty=block.header.difficulty,
169
    )
170
171
    block_output = apply_body(
172
        block_env=block_env,
173
        transactions=block.transactions,
174
        ommers=block.ommers,
175
    )
176
    block_state_root = state_root(block_env.state)
177
    transactions_root = root(block_output.transactions_trie)
178
    receipt_root = root(block_output.receipts_trie)
179
    block_logs_bloom = logs_bloom(block_output.block_logs)
180
181
    if block_output.block_gas_used != block.header.gas_used:
182
        raise InvalidBlock(
183
            f"{block_output.block_gas_used} != {block.header.gas_used}"
184
        )
185
    if transactions_root != block.header.transactions_root:
186
        raise InvalidBlock
187
    if block_state_root != block.header.state_root:
188
        raise InvalidBlock
189
    if receipt_root != block.header.receipt_root:
190
        raise InvalidBlock
191
    if block_logs_bloom != block.header.bloom:
192
        raise InvalidBlock
193
194
    chain.blocks.append(block)
195
    if len(chain.blocks) > 255:
196
        # Real clients have to store more blocks to deal with reorgs, but the
197
        # protocol only requires the last 255
198
        chain.blocks = chain.blocks[-255:]

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:
202
    """
203
    Verifies a block header.
204
205
    In order to consider a block's header valid, the logic for the
206
    quantities in the header should match the logic for the block itself.
207
    For example the header timestamp should be greater than the block's parent
208
    timestamp because the block was created *after* the parent block.
209
    Additionally, the block's number should be directly following the parent
210
    block's number since it is the next block in the sequence.
211
212
    Parameters
213
    ----------
214
    chain :
215
        History and current state.
216
    header :
217
        Header to check for correctness.
218
    """
219
    if header.number < Uint(1):
220
        raise InvalidBlock
221
    parent_header_number = header.number - Uint(1)
222
    first_block_number = chain.blocks[0].header.number
223
    last_block_number = chain.blocks[-1].header.number
224
225
    if (
226
        parent_header_number < first_block_number
227
        or parent_header_number > last_block_number
228
    ):
229
        raise InvalidBlock
230
231
    parent_header = chain.blocks[
232
        parent_header_number - first_block_number
233
    ].header
234
235
    if header.gas_used > header.gas_limit:
236
        raise InvalidBlock
237
238
    if header.timestamp <= parent_header.timestamp:
239
        raise InvalidBlock
240
    if header.number != parent_header.number + Uint(1):
241
        raise InvalidBlock
242
    if not check_gas_limit(header.gas_limit, parent_header.gas_limit):
243
        raise InvalidBlock
244
    if len(header.extra_data) > 32:
245
        raise InvalidBlock
246
247
    block_difficulty = calculate_block_difficulty(
248
        header.number,
249
        header.timestamp,
250
        parent_header.timestamp,
251
        parent_header.difficulty,
252
    )
253
    if header.difficulty != block_difficulty:
254
        raise InvalidBlock
255
256
    block_parent_hash = keccak256(rlp.encode(parent_header))
257
    if header.parent_hash != block_parent_hash:
258
        raise InvalidBlock
259
260
    validate_proof_of_work(header)

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:
264
    """
265
    Generate rlp hash of the header which is to be used for Proof-of-Work
266
    verification.
267
268
    In other words, the PoW artefacts `mix_digest` and `nonce` are ignored
269
    while calculating this hash.
270
271
    A particular PoW is valid for a single hash, that hash is computed by
272
    this function. The `nonce` and `mix_digest` are omitted from this hash
273
    because they are being changed by miners in their search for a sufficient
274
    proof-of-work.
275
276
    Parameters
277
    ----------
278
    header :
279
        The header object for which the hash is to be generated.
280
281
    Returns
282
    -------
283
    hash : `Hash32`
284
        The PoW valid rlp hash of the passed in header.
285
    """
286
    header_data_without_pow_artefacts = (
287
        header.parent_hash,
288
        header.ommers_hash,
289
        header.coinbase,
290
        header.state_root,
291
        header.transactions_root,
292
        header.receipt_root,
293
        header.bloom,
294
        header.difficulty,
295
        header.number,
296
        header.gas_limit,
297
        header.gas_used,
298
        header.timestamp,
299
        header.extra_data,
300
    )
301
302
    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:
306
    """
307
    Validates the Proof of Work constraints.
308
309
    In order to verify that a miner's proof-of-work is valid for a block, a
310
    ``mix-digest`` and ``result`` are calculated using the ``hashimoto_light``
311
    hash function. The mix digest is a hash of the header and the nonce that
312
    is passed through and it confirms whether or not proof-of-work was done
313
    on the correct block. The result is the actual hash value of the block.
314
315
    Parameters
316
    ----------
317
    header :
318
        Header of interest.
319
    """
320
    header_hash = generate_header_hash_for_pow(header)
321
    # TODO: Memoize this somewhere and read from that data instead of
322
    # calculating cache for every block validation.
323
    cache = generate_cache(header.number)
324
    mix_digest, result = hashimoto_light(
325
        header_hash, header.nonce, cache, dataset_size(header.number)
326
    )
327
    if mix_digest != header.mix_digest:
328
        raise InvalidBlock
329
330
    limit = Uint(U256.MAX_VALUE) + Uint(1)
331
    if Uint.from_be_bytes(result) > (limit // header.difficulty):
332
        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.

Returns

sender_address : The sender of the transaction.

Raises

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.

def check_transaction(block_env: ethereum.frontier.vm.BlockEnvironment, ​​block_output: ethereum.frontier.vm.BlockOutput, ​​tx: Transaction) -> Address:
340
    """
341
    Check if the transaction is includable in the block.
342
343
    Parameters
344
    ----------
345
    block_env :
346
        The block scoped environment.
347
    block_output :
348
        The block output for the current block.
349
    tx :
350
        The transaction.
351
352
    Returns
353
    -------
354
    sender_address :
355
        The sender of the transaction.
356
357
    Raises
358
    ------
359
    GasUsedExceedsLimitError :
360
        If the gas used by the transaction exceeds the block's gas limit.
361
    NonceMismatchError :
362
        If the nonce of the transaction is not equal to the sender's nonce.
363
    InsufficientBalanceError :
364
        If the sender's balance is not enough to pay for the transaction.
365
    InvalidSenderError :
366
        If the transaction is from an address that does not exist anymore.
367
    """
368
    gas_available = block_env.block_gas_limit - block_output.block_gas_used
369
    if tx.gas > gas_available:
370
        raise GasUsedExceedsLimitError("gas used exceeds limit")
371
    sender_address = recover_sender(tx)
372
    sender_account = get_account(block_env.state, sender_address)
373
374
    max_gas_fee = tx.gas * tx.gas_price
375
376
    if sender_account.nonce > Uint(tx.nonce):
377
        raise NonceMismatchError("nonce too low")
378
    elif sender_account.nonce < Uint(tx.nonce):
379
        raise NonceMismatchError("nonce too high")
380
    if Uint(sender_account.balance) < max_gas_fee + Uint(tx.value):
381
        raise InsufficientBalanceError("insufficient sender balance")
382
    if sender_account.code:
383
        raise InvalidSenderError("not EOA")
384
385
    return sender_address

make_receipt

Make the receipt for a transaction that was executed.

Parameters

post_state : The state root immediately after this transaction. 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(post_state: Bytes32, ​​cumulative_gas_used: Uint, ​​logs: Tuple[Log, ...]) -> Receipt:
393
    """
394
    Make the receipt for a transaction that was executed.
395
396
    Parameters
397
    ----------
398
    post_state :
399
        The state root immediately after this transaction.
400
    cumulative_gas_used :
401
        The total gas used so far in the block after the transaction was
402
        executed.
403
    logs :
404
        The logs produced by the transaction.
405
406
    Returns
407
    -------
408
    receipt :
409
        The receipt for the transaction.
410
    """
411
    receipt = Receipt(
412
        post_state=post_state,
413
        cumulative_gas_used=cumulative_gas_used,
414
        bloom=logs_bloom(logs),
415
        logs=logs,
416
    )
417
418
    return 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.frontier.vm.BlockEnvironment, ​​transactions: Tuple[Transaction, ...], ​​ommers: Tuple[Header, ...]) -> ethereum.frontier.vm.BlockOutput:
426
    """
427
    Executes a block.
428
429
    Many of the contents of a block are stored in data structures called
430
    tries. There is a transactions trie which is similar to a ledger of the
431
    transactions stored in the current block. There is also a receipts trie
432
    which stores the results of executing a transaction, like the post state
433
    and gas used. This function creates and executes the block that is to be
434
    added to the chain.
435
436
    Parameters
437
    ----------
438
    block_env :
439
        The block scoped environment.
440
    transactions :
441
        Transactions included in the block.
442
    ommers :
443
        Headers of ancestor blocks which are not direct parents (formerly
444
        uncles.)
445
446
    Returns
447
    -------
448
    block_output :
449
        The block output for the current block.
450
    """
451
    block_output = vm.BlockOutput()
452
453
    for i, tx in enumerate(transactions):
454
        process_transaction(block_env, block_output, tx, Uint(i))
455
456
    pay_rewards(block_env.state, block_env.number, block_env.coinbase, ommers)
457
458
    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:
464
    """
465
    Validates the ommers mentioned in the block.
466
467
    An ommer block is a block that wasn't canonically added to the
468
    blockchain because it wasn't validated as fast as the canonical block
469
    but was mined at the same time.
470
471
    To be considered valid, the ommers must adhere to the rules defined in
472
    the Ethereum protocol. The maximum amount of ommers is 2 per block and
473
    there cannot be duplicate ommers in a block. Many of the other ommer
474
    constraints are listed in the in-line comments of this function.
475
476
    Parameters
477
    ----------
478
    ommers :
479
        List of ommers mentioned in the current block.
480
    block_header:
481
        The header of current block.
482
    chain :
483
        History and current state.
484
    """
485
    block_hash = keccak256(rlp.encode(block_header))
486
    if keccak256(rlp.encode(ommers)) != block_header.ommers_hash:
487
        raise InvalidBlock
488
489
    if len(ommers) == 0:
490
        # Nothing to validate
491
        return
492
493
    # Check that each ommer satisfies the constraints of a header
494
    for ommer in ommers:
495
        if Uint(1) > ommer.number or ommer.number >= block_header.number:
496
            raise InvalidBlock
497
        validate_header(chain, ommer)
498
    if len(ommers) > 2:
499
        raise InvalidBlock
500
501
    ommers_hashes = [keccak256(rlp.encode(ommer)) for ommer in ommers]
502
    if len(ommers_hashes) != len(set(ommers_hashes)):
503
        raise InvalidBlock
504
505
    recent_canonical_blocks = chain.blocks[-(MAX_OMMER_DEPTH + Uint(1)) :]
506
    recent_canonical_block_hashes = {
507
        keccak256(rlp.encode(block.header))
508
        for block in recent_canonical_blocks
509
    }
510
    recent_ommers_hashes: Set[Hash32] = set()
511
    for block in recent_canonical_blocks:
512
        recent_ommers_hashes = recent_ommers_hashes.union(
513
            {keccak256(rlp.encode(ommer)) for ommer in block.ommers}
514
        )
515
516
    for ommer_index, ommer in enumerate(ommers):
517
        ommer_hash = ommers_hashes[ommer_index]
518
        if ommer_hash == block_hash:
519
            raise InvalidBlock
520
        if ommer_hash in recent_canonical_block_hashes:
521
            raise InvalidBlock
522
        if ommer_hash in recent_ommers_hashes:
523
            raise InvalidBlock
524
525
        # Ommer age with respect to the current block. For example, an age of
526
        # 1 indicates that the ommer is a sibling of previous block.
527
        ommer_age = block_header.number - ommer.number
528
        if Uint(1) > ommer_age or ommer_age > MAX_OMMER_DEPTH:
529
            raise InvalidBlock
530
        if ommer.parent_hash not in recent_canonical_block_hashes:
531
            raise InvalidBlock
532
        if ommer.parent_hash == block_header.parent_hash:
533
            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

state : Current account state. block_number : Position of the block within the chain. coinbase : Address of account which receives block reward and transaction fees. ommers : List of ommers mentioned in the current block.

def pay_rewards(state: State, ​​block_number: Uint, ​​coinbase: Address, ​​ommers: Tuple[Header, ...]) -> None:
542
    """
543
    Pay rewards to the block miner as well as the ommers miners.
544
545
    The miner of the canonical block is rewarded with the predetermined
546
    block reward, ``BLOCK_REWARD``, plus a variable award based off of the
547
    number of ommer blocks that were mined around the same time, and included
548
    in the canonical block's header. An ommer block is a block that wasn't
549
    added to the canonical blockchain because it wasn't validated as fast as
550
    the accepted block but was mined at the same time. Although not all blocks
551
    that are mined are added to the canonical chain, miners are still paid a
552
    reward for their efforts. This reward is called an ommer reward and is
553
    calculated based on the number associated with the ommer block that they
554
    mined.
555
556
    Parameters
557
    ----------
558
    state :
559
        Current account state.
560
    block_number :
561
        Position of the block within the chain.
562
    coinbase :
563
        Address of account which receives block reward and transaction fees.
564
    ommers :
565
        List of ommers mentioned in the current block.
566
    """
567
    ommer_count = U256(len(ommers))
568
    miner_reward = BLOCK_REWARD + (ommer_count * (BLOCK_REWARD // U256(32)))
569
    create_ether(state, coinbase, miner_reward)
570
571
    for ommer in ommers:
572
        # Ommer age with respect to the current block.
573
        ommer_age = U256(block_number - ommer.number)
574
        ommer_miner_reward = ((U256(8) - ommer_age) * BLOCK_REWARD) // U256(8)
575
        create_ether(state, ommer.coinbase, ommer_miner_reward)

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 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.frontier.vm.BlockEnvironment, ​​block_output: ethereum.frontier.vm.BlockOutput, ​​tx: Transaction, ​​index: Uint) -> None:
584
    """
585
    Execute a transaction against the provided environment.
586
587
    This function processes the actions needed to execute a transaction.
588
    It decrements the sender's account after calculating the gas fee and
589
    refunds them the proper amount after execution. Calling contracts,
590
    deploying code, and incrementing nonces are all examples of actions that
591
    happen within this function or from a call made within this function.
592
593
    Accounts that are marked for deletion are processed and destroyed after
594
    execution.
595
596
    Parameters
597
    ----------
598
    block_env :
599
        Environment for the Ethereum Virtual Machine.
600
    block_output :
601
        The block output for the current block.
602
    tx :
603
        Transaction to execute.
604
    index:
605
        Index of the transaction in the block.
606
    """
607
    trie_set(block_output.transactions_trie, rlp.encode(Uint(index)), tx)
608
    intrinsic_gas = validate_transaction(tx)
609
610
    sender = check_transaction(
611
        block_env=block_env,
612
        block_output=block_output,
613
        tx=tx,
614
    )
615
616
    sender_account = get_account(block_env.state, sender)
617
618
    gas = tx.gas - intrinsic_gas
619
    increment_nonce(block_env.state, sender)
620
621
    gas_fee = tx.gas * tx.gas_price
622
    sender_balance_after_gas_fee = Uint(sender_account.balance) - gas_fee
623
    set_account_balance(
624
        block_env.state, sender, U256(sender_balance_after_gas_fee)
625
    )
626
627
    tx_env = vm.TransactionEnvironment(
628
        origin=sender,
629
        gas_price=tx.gas_price,
630
        gas=gas,
631
        index_in_block=index,
632
        tx_hash=get_transaction_hash(tx),
633
        traces=[],
634
    )
635
636
    message = prepare_message(block_env, tx_env, tx)
637
638
    tx_output = process_message_call(message)
639
640
    tx_gas_used_before_refund = tx.gas - tx_output.gas_left
641
    tx_gas_refund = min(
642
        tx_gas_used_before_refund // Uint(2), Uint(tx_output.refund_counter)
643
    )
644
    tx_gas_used_after_refund = tx_gas_used_before_refund - tx_gas_refund
645
    tx_gas_left = tx.gas - tx_gas_used_after_refund
646
    gas_refund_amount = tx_gas_left * tx.gas_price
647
648
    transaction_fee = tx_gas_used_after_refund * tx.gas_price
649
650
    # refund gas
651
    sender_balance_after_refund = get_account(
652
        block_env.state, sender
653
    ).balance + U256(gas_refund_amount)
654
    set_account_balance(block_env.state, sender, sender_balance_after_refund)
655
656
    # transfer miner fees
657
    coinbase_balance_after_mining_fee = get_account(
658
        block_env.state, block_env.coinbase
659
    ).balance + U256(transaction_fee)
660
    set_account_balance(
661
        block_env.state, block_env.coinbase, coinbase_balance_after_mining_fee
662
    )
663
664
    for address in tx_output.accounts_to_delete:
665
        destroy_account(block_env.state, address)
666
667
    block_output.block_gas_used += tx_gas_used_after_refund
668
669
    receipt = make_receipt(
670
        state_root(block_env.state),
671
        block_output.block_gas_used,
672
        tx_output.logs,
673
    )
674
675
    receipt_key = rlp.encode(Uint(index))
676
    block_output.receipt_keys += (receipt_key,)
677
678
    trie_set(
679
        block_output.receipts_trie,
680
        receipt_key,
681
        receipt,
682
    )
683
684
    block_output.block_logs += tx_output.logs

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 GAS_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 GAS_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:
688
    """
689
    Validates the gas limit for a block.
690
691
    The bounds of the gas limit, ``max_adjustment_delta``, is set as the
692
    quotient of the parent block's gas limit and the
693
    ``GAS_LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is
694
    passed through as a parameter is greater than or equal to the *sum* of
695
    the parent's gas and the adjustment delta then the limit for gas is too
696
    high and fails this function's check. Similarly, if the limit is less
697
    than or equal to the *difference* of the parent's gas and the adjustment
698
    delta *or* the predefined ``GAS_LIMIT_MINIMUM`` then this function's
699
    check fails because the gas limit doesn't allow for a sufficient or
700
    reasonable amount of gas to be used on a block.
701
702
    Parameters
703
    ----------
704
    gas_limit :
705
        Gas limit to validate.
706
707
    parent_gas_limit :
708
        Gas limit of the parent block.
709
710
    Returns
711
    -------
712
    check : `bool`
713
        True if gas limit constraints are satisfied, False otherwise.
714
    """
715
    max_adjustment_delta = parent_gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
716
    if gas_limit >= parent_gas_limit + max_adjustment_delta:
717
        return False
718
    if gas_limit <= parent_gas_limit - max_adjustment_delta:
719
        return False
720
    if gas_limit < GAS_LIMIT_MINIMUM:
721
        return False
722
723
    return True

calculate_block_difficulty

Computes difficulty of a block using its header and parent header.

The difficulty of a block is determined by the time the block was created after its parent. If a block's timestamp is more than 13 seconds after its parent block then its difficulty is set as the difference between the parent's difficulty and the max_adjustment_delta. Otherwise, if the time between parent and child blocks is too small (under 13 seconds) then, to avoid mass forking, the block's difficulty is set to the sum of the delta and the parent's 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.

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) -> Uint:
732
    """
733
    Computes difficulty of a block using its header and parent header.
734
735
    The difficulty of a block is determined by the time the block was created
736
    after its parent. If a block's timestamp is more than 13 seconds after its
737
    parent block then its difficulty is set as the difference between the
738
    parent's difficulty and the ``max_adjustment_delta``. Otherwise, if the
739
    time between parent and child blocks is too small (under 13 seconds) then,
740
    to avoid mass forking, the block's difficulty is set to the sum of the
741
    delta and the parent's difficulty.
742
743
    Parameters
744
    ----------
745
    block_number :
746
        Block number of the block.
747
    block_timestamp :
748
        Timestamp of the block.
749
    parent_timestamp :
750
        Timestamp of the parent block.
751
    parent_difficulty :
752
        difficulty of the parent block.
753
754
    Returns
755
    -------
756
    difficulty : `ethereum.base_types.Uint`
757
        Computed difficulty for a block.
758
    """
759
    max_adjustment_delta = parent_difficulty // Uint(2048)
760
    if block_timestamp < parent_timestamp + U256(13):
761
        difficulty = parent_difficulty + max_adjustment_delta
762
    else:  # block_timestamp >= parent_timestamp + 13
763
        difficulty = parent_difficulty - max_adjustment_delta
764
765
    # Historical Note: The difficulty bomb was not present in Ethereum at the
766
    # start of Frontier, but was added shortly after launch. However since the
767
    # bomb has no effect prior to block 200000 we pretend it existed from
768
    # genesis.
769
    # See https://github.com/ethereum/go-ethereum/pull/1588
770
    num_bomb_periods = (int(block_number) // 100000) - 2
771
    if num_bomb_periods >= 0:
772
        difficulty += 2**num_bomb_periods
773
774
    # Some clients raise the difficulty to `MINIMUM_DIFFICULTY` prior to adding
775
    # the bomb. This bug does not matter because the difficulty is always much
776
    # greater than `MINIMUM_DIFFICULTY` on Mainnet.
777
    return max(difficulty, MINIMUM_DIFFICULTY)