ethereum.constantinople.fork

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

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

Introduction

Entry point for the Ethereum specification.

BLOCK_REWARD

56
BLOCK_REWARD = U256(2 * 10**18)

GAS_LIMIT_ADJUSTMENT_FACTOR

57
GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)

GAS_LIMIT_MINIMUM

58
GAS_LIMIT_MINIMUM = Uint(5000)

MINIMUM_DIFFICULTY

59
MINIMUM_DIFFICULTY = Uint(131072)

MAX_OMMER_DEPTH

60
MAX_OMMER_DEPTH = Uint(6)

BOMB_DELAY_BLOCKS

61
BOMB_DELAY_BLOCKS = 5000000

EMPTY_OMMER_HASH

62
EMPTY_OMMER_HASH = keccak256(rlp.encode([]))

BlockChain

History and current state of the block chain.

65
@dataclass
class BlockChain:

blocks

71
    blocks: List[Block]

state

72
    state: State

chain_id

73
    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:
77
    """
78
    Transforms the state from the previous hard fork (`old`) into the block
79
    chain object for this hard fork and returns it.
80
81
    When forks need to implement an irregular state transition, this function
82
    is used to handle the irregularity. See the :ref:`DAO Fork <dao-fork>` for
83
    an example.
84
85
    Parameters
86
    ----------
87
    old :
88
        Previous block chain object.
89
90
    Returns
91
    -------
92
    new : `BlockChain`
93
        Upgraded block chain object for this hard fork.
94
    """
95
    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]:
99
    """
100
    Obtain the list of hashes of the previous 256 blocks in order of
101
    increasing block number.
102
103
    This function will return less hashes for the first 256 blocks.
104
105
    The ``BLOCKHASH`` opcode needs to access the latest hashes on the chain,
106
    therefore this function retrieves them.
107
108
    Parameters
109
    ----------
110
    chain :
111
        History and current state.
112
113
    Returns
114
    -------
115
    recent_block_hashes : `List[Hash32]`
116
        Hashes of the recent 256 blocks in order of increasing block number.
117
    """
118
    recent_blocks = chain.blocks[-255:]
119
    # TODO: This function has not been tested rigorously
120
    if len(recent_blocks) == 0:
121
        return []
122
123
    recent_block_hashes = []
124
125
    for block in recent_blocks:
126
        prev_block_hash = block.header.parent_hash
127
        recent_block_hashes.append(prev_block_hash)
128
129
    # We are computing the hash only for the most recent block and not for
130
    # the rest of the blocks as they have successors which have the hash of
131
    # the current block as parent hash.
132
    most_recent_block_hash = keccak256(rlp.encode(recent_blocks[-1].header))
133
    recent_block_hashes.append(most_recent_block_hash)
134
135
    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:
139
    """
140
    Attempts to apply a block to an existing block chain.
141
142
    All parts of the block's contents need to be verified before being added
143
    to the chain. Blocks are verified by ensuring that the contents of the
144
    block make logical sense with the contents of the parent block. The
145
    information in the block's header must also match the corresponding
146
    information in the block.
147
148
    To implement Ethereum, in theory clients are only required to store the
149
    most recent 255 blocks of the chain since as far as execution is
150
    concerned, only those blocks are accessed. Practically, however, clients
151
    should store more blocks to handle reorgs.
152
153
    Parameters
154
    ----------
155
    chain :
156
        History and current state.
157
    block :
158
        Block to apply to `chain`.
159
    """
160
    validate_header(chain, block.header)
161
    validate_ommers(block.ommers, block.header, chain)
162
163
    block_env = vm.BlockEnvironment(
164
        chain_id=chain.chain_id,
165
        state=chain.state,
166
        block_gas_limit=block.header.gas_limit,
167
        block_hashes=get_last_256_block_hashes(chain),
168
        coinbase=block.header.coinbase,
169
        number=block.header.number,
170
        time=block.header.timestamp,
171
        difficulty=block.header.difficulty,
172
    )
173
174
    block_output = apply_body(
175
        block_env=block_env,
176
        transactions=block.transactions,
177
        ommers=block.ommers,
178
    )
179
    block_state_root = state_root(block_env.state)
180
    transactions_root = root(block_output.transactions_trie)
181
    receipt_root = root(block_output.receipts_trie)
182
    block_logs_bloom = logs_bloom(block_output.block_logs)
183
184
    if block_output.block_gas_used != block.header.gas_used:
185
        raise InvalidBlock(
186
            f"{block_output.block_gas_used} != {block.header.gas_used}"
187
        )
188
    if transactions_root != block.header.transactions_root:
189
        raise InvalidBlock
190
    if block_state_root != block.header.state_root:
191
        raise InvalidBlock
192
    if receipt_root != block.header.receipt_root:
193
        raise InvalidBlock
194
    if block_logs_bloom != block.header.bloom:
195
        raise InvalidBlock
196
197
    chain.blocks.append(block)
198
    if len(chain.blocks) > 255:
199
        # Real clients have to store more blocks to deal with reorgs, but the
200
        # protocol only requires the last 255
201
        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:
205
    """
206
    Verifies a block header.
207
208
    In order to consider a block's header valid, the logic for the
209
    quantities in the header should match the logic for the block itself.
210
    For example the header timestamp should be greater than the block's parent
211
    timestamp because the block was created *after* the parent block.
212
    Additionally, the block's number should be directly following the parent
213
    block's number since it is the next block in the sequence.
214
215
    Parameters
216
    ----------
217
    chain :
218
        History and current state.
219
    header :
220
        Header to check for correctness.
221
    """
222
    if header.number < Uint(1):
223
        raise InvalidBlock
224
    parent_header_number = header.number - Uint(1)
225
    first_block_number = chain.blocks[0].header.number
226
    last_block_number = chain.blocks[-1].header.number
227
228
    if (
229
        parent_header_number < first_block_number
230
        or parent_header_number > last_block_number
231
    ):
232
        raise InvalidBlock
233
234
    parent_header = chain.blocks[
235
        parent_header_number - first_block_number
236
    ].header
237
238
    if header.gas_used > header.gas_limit:
239
        raise InvalidBlock
240
241
    parent_has_ommers = parent_header.ommers_hash != EMPTY_OMMER_HASH
242
    if header.timestamp <= parent_header.timestamp:
243
        raise InvalidBlock
244
    if header.number != parent_header.number + Uint(1):
245
        raise InvalidBlock
246
    if not check_gas_limit(header.gas_limit, parent_header.gas_limit):
247
        raise InvalidBlock
248
    if len(header.extra_data) > 32:
249
        raise InvalidBlock
250
251
    block_difficulty = calculate_block_difficulty(
252
        header.number,
253
        header.timestamp,
254
        parent_header.timestamp,
255
        parent_header.difficulty,
256
        parent_has_ommers,
257
    )
258
    if header.difficulty != block_difficulty:
259
        raise InvalidBlock
260
261
    block_parent_hash = keccak256(rlp.encode(parent_header))
262
    if header.parent_hash != block_parent_hash:
263
        raise InvalidBlock
264
265
    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:
269
    """
270
    Generate rlp hash of the header which is to be used for Proof-of-Work
271
    verification.
272
273
    In other words, the PoW artefacts `mix_digest` and `nonce` are ignored
274
    while calculating this hash.
275
276
    A particular PoW is valid for a single hash, that hash is computed by
277
    this function. The `nonce` and `mix_digest` are omitted from this hash
278
    because they are being changed by miners in their search for a sufficient
279
    proof-of-work.
280
281
    Parameters
282
    ----------
283
    header :
284
        The header object for which the hash is to be generated.
285
286
    Returns
287
    -------
288
    hash : `Hash32`
289
        The PoW valid rlp hash of the passed in header.
290
    """
291
    header_data_without_pow_artefacts = (
292
        header.parent_hash,
293
        header.ommers_hash,
294
        header.coinbase,
295
        header.state_root,
296
        header.transactions_root,
297
        header.receipt_root,
298
        header.bloom,
299
        header.difficulty,
300
        header.number,
301
        header.gas_limit,
302
        header.gas_used,
303
        header.timestamp,
304
        header.extra_data,
305
    )
306
307
    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:
311
    """
312
    Validates the Proof of Work constraints.
313
314
    In order to verify that a miner's proof-of-work is valid for a block, a
315
    ``mix-digest`` and ``result`` are calculated using the ``hashimoto_light``
316
    hash function. The mix digest is a hash of the header and the nonce that
317
    is passed through and it confirms whether or not proof-of-work was done
318
    on the correct block. The result is the actual hash value of the block.
319
320
    Parameters
321
    ----------
322
    header :
323
        Header of interest.
324
    """
325
    header_hash = generate_header_hash_for_pow(header)
326
    # TODO: Memoize this somewhere and read from that data instead of
327
    # calculating cache for every block validation.
328
    cache = generate_cache(header.number)
329
    mix_digest, result = hashimoto_light(
330
        header_hash, header.nonce, cache, dataset_size(header.number)
331
    )
332
    if mix_digest != header.mix_digest:
333
        raise InvalidBlock
334
335
    limit = Uint(U256.MAX_VALUE) + Uint(1)
336
    if Uint.from_be_bytes(result) > (limit // header.difficulty):
337
        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.constantinople.vm.BlockEnvironment, ​​block_output: ethereum.constantinople.vm.BlockOutput, ​​tx: Transaction) -> Address:
345
    """
346
    Check if the transaction is includable in the block.
347
348
    Parameters
349
    ----------
350
    block_env :
351
        The block scoped environment.
352
    block_output :
353
        The block output for the current block.
354
    tx :
355
        The transaction.
356
357
    Returns
358
    -------
359
    sender_address :
360
        The sender of the transaction.
361
362
    Raises
363
    ------
364
    GasUsedExceedsLimitError :
365
        If the gas used by the transaction exceeds the block's gas limit.
366
    NonceMismatchError :
367
        If the nonce of the transaction is not equal to the sender's nonce.
368
    InsufficientBalanceError :
369
        If the sender's balance is not enough to pay for the transaction.
370
    InvalidSenderError :
371
        If the transaction is from an address that does not exist anymore.
372
    """
373
    gas_available = block_env.block_gas_limit - block_output.block_gas_used
374
    if tx.gas > gas_available:
375
        raise GasUsedExceedsLimitError("gas used exceeds limit")
376
    sender_address = recover_sender(block_env.chain_id, tx)
377
    sender_account = get_account(block_env.state, sender_address)
378
379
    max_gas_fee = tx.gas * tx.gas_price
380
381
    if sender_account.nonce > Uint(tx.nonce):
382
        raise NonceMismatchError("nonce too low")
383
    elif sender_account.nonce < Uint(tx.nonce):
384
        raise NonceMismatchError("nonce too high")
385
    if Uint(sender_account.balance) < max_gas_fee + Uint(tx.value):
386
        raise InsufficientBalanceError("insufficient sender balance")
387
    if sender_account.code:
388
        raise InvalidSenderError("not EOA")
389
390
    return sender_address

make_receipt

Make the receipt for a transaction that was executed.

Parameters

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(error: Optional[EthereumException], ​​cumulative_gas_used: Uint, ​​logs: Tuple[Log, ...]) -> Receipt:
398
    """
399
    Make the receipt for a transaction that was executed.
400
401
    Parameters
402
    ----------
403
    error :
404
        Error in the top level frame of the transaction, if any.
405
    cumulative_gas_used :
406
        The total gas used so far in the block after the transaction was
407
        executed.
408
    logs :
409
        The logs produced by the transaction.
410
411
    Returns
412
    -------
413
    receipt :
414
        The receipt for the transaction.
415
    """
416
    receipt = Receipt(
417
        succeeded=error is None,
418
        cumulative_gas_used=cumulative_gas_used,
419
        bloom=logs_bloom(logs),
420
        logs=logs,
421
    )
422
423
    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.constantinople.vm.BlockEnvironment, ​​transactions: Tuple[Transaction, ...], ​​ommers: Tuple[Header, ...]) -> ethereum.constantinople.vm.BlockOutput:
431
    """
432
    Executes a block.
433
434
    Many of the contents of a block are stored in data structures called
435
    tries. There is a transactions trie which is similar to a ledger of the
436
    transactions stored in the current block. There is also a receipts trie
437
    which stores the results of executing a transaction, like the post state
438
    and gas used. This function creates and executes the block that is to be
439
    added to the chain.
440
441
    Parameters
442
    ----------
443
    block_env :
444
        The block scoped environment.
445
    transactions :
446
        Transactions included in the block.
447
    ommers :
448
        Headers of ancestor blocks which are not direct parents (formerly
449
        uncles.)
450
451
    Returns
452
    -------
453
    block_output :
454
        The block output for the current block.
455
    """
456
    block_output = vm.BlockOutput()
457
458
    for i, tx in enumerate(transactions):
459
        process_transaction(block_env, block_output, tx, Uint(i))
460
461
    pay_rewards(block_env.state, block_env.number, block_env.coinbase, ommers)
462
463
    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:
469
    """
470
    Validates the ommers mentioned in the block.
471
472
    An ommer block is a block that wasn't canonically added to the
473
    blockchain because it wasn't validated as fast as the canonical block
474
    but was mined at the same time.
475
476
    To be considered valid, the ommers must adhere to the rules defined in
477
    the Ethereum protocol. The maximum amount of ommers is 2 per block and
478
    there cannot be duplicate ommers in a block. Many of the other ommer
479
    constraints are listed in the in-line comments of this function.
480
481
    Parameters
482
    ----------
483
    ommers :
484
        List of ommers mentioned in the current block.
485
    block_header:
486
        The header of current block.
487
    chain :
488
        History and current state.
489
    """
490
    block_hash = keccak256(rlp.encode(block_header))
491
    if keccak256(rlp.encode(ommers)) != block_header.ommers_hash:
492
        raise InvalidBlock
493
494
    if len(ommers) == 0:
495
        # Nothing to validate
496
        return
497
498
    # Check that each ommer satisfies the constraints of a header
499
    for ommer in ommers:
500
        if Uint(1) > ommer.number or ommer.number >= block_header.number:
501
            raise InvalidBlock
502
        validate_header(chain, ommer)
503
    if len(ommers) > 2:
504
        raise InvalidBlock
505
506
    ommers_hashes = [keccak256(rlp.encode(ommer)) for ommer in ommers]
507
    if len(ommers_hashes) != len(set(ommers_hashes)):
508
        raise InvalidBlock
509
510
    recent_canonical_blocks = chain.blocks[-(MAX_OMMER_DEPTH + Uint(1)) :]
511
    recent_canonical_block_hashes = {
512
        keccak256(rlp.encode(block.header))
513
        for block in recent_canonical_blocks
514
    }
515
    recent_ommers_hashes: Set[Hash32] = set()
516
    for block in recent_canonical_blocks:
517
        recent_ommers_hashes = recent_ommers_hashes.union(
518
            {keccak256(rlp.encode(ommer)) for ommer in block.ommers}
519
        )
520
521
    for ommer_index, ommer in enumerate(ommers):
522
        ommer_hash = ommers_hashes[ommer_index]
523
        if ommer_hash == block_hash:
524
            raise InvalidBlock
525
        if ommer_hash in recent_canonical_block_hashes:
526
            raise InvalidBlock
527
        if ommer_hash in recent_ommers_hashes:
528
            raise InvalidBlock
529
530
        # Ommer age with respect to the current block. For example, an age of
531
        # 1 indicates that the ommer is a sibling of previous block.
532
        ommer_age = block_header.number - ommer.number
533
        if Uint(1) > ommer_age or ommer_age > MAX_OMMER_DEPTH:
534
            raise InvalidBlock
535
        if ommer.parent_hash not in recent_canonical_block_hashes:
536
            raise InvalidBlock
537
        if ommer.parent_hash == block_header.parent_hash:
538
            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:
547
    """
548
    Pay rewards to the block miner as well as the ommers miners.
549
550
    The miner of the canonical block is rewarded with the predetermined
551
    block reward, ``BLOCK_REWARD``, plus a variable award based off of the
552
    number of ommer blocks that were mined around the same time, and included
553
    in the canonical block's header. An ommer block is a block that wasn't
554
    added to the canonical blockchain because it wasn't validated as fast as
555
    the accepted block but was mined at the same time. Although not all blocks
556
    that are mined are added to the canonical chain, miners are still paid a
557
    reward for their efforts. This reward is called an ommer reward and is
558
    calculated based on the number associated with the ommer block that they
559
    mined.
560
561
    Parameters
562
    ----------
563
    state :
564
        Current account state.
565
    block_number :
566
        Position of the block within the chain.
567
    coinbase :
568
        Address of account which receives block reward and transaction fees.
569
    ommers :
570
        List of ommers mentioned in the current block.
571
    """
572
    ommer_count = U256(len(ommers))
573
    miner_reward = BLOCK_REWARD + (ommer_count * (BLOCK_REWARD // U256(32)))
574
    create_ether(state, coinbase, miner_reward)
575
576
    for ommer in ommers:
577
        # Ommer age with respect to the current block.
578
        ommer_age = U256(block_number - ommer.number)
579
        ommer_miner_reward = ((U256(8) - ommer_age) * BLOCK_REWARD) // U256(8)
580
        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.constantinople.vm.BlockEnvironment, ​​block_output: ethereum.constantinople.vm.BlockOutput, ​​tx: Transaction, ​​index: Uint) -> None:
589
    """
590
    Execute a transaction against the provided environment.
591
592
    This function processes the actions needed to execute a transaction.
593
    It decrements the sender's account after calculating the gas fee and
594
    refunds them the proper amount after execution. Calling contracts,
595
    deploying code, and incrementing nonces are all examples of actions that
596
    happen within this function or from a call made within this function.
597
598
    Accounts that are marked for deletion are processed and destroyed after
599
    execution.
600
601
    Parameters
602
    ----------
603
    block_env :
604
        Environment for the Ethereum Virtual Machine.
605
    block_output :
606
        The block output for the current block.
607
    tx :
608
        Transaction to execute.
609
    index:
610
        Index of the transaction in the block.
611
    """
612
    trie_set(block_output.transactions_trie, rlp.encode(Uint(index)), tx)
613
    intrinsic_gas = validate_transaction(tx)
614
615
    sender = check_transaction(
616
        block_env=block_env,
617
        block_output=block_output,
618
        tx=tx,
619
    )
620
621
    sender_account = get_account(block_env.state, sender)
622
623
    gas = tx.gas - intrinsic_gas
624
    increment_nonce(block_env.state, sender)
625
626
    gas_fee = tx.gas * tx.gas_price
627
    sender_balance_after_gas_fee = Uint(sender_account.balance) - gas_fee
628
    set_account_balance(
629
        block_env.state, sender, U256(sender_balance_after_gas_fee)
630
    )
631
632
    tx_env = vm.TransactionEnvironment(
633
        origin=sender,
634
        gas_price=tx.gas_price,
635
        gas=gas,
636
        index_in_block=index,
637
        tx_hash=get_transaction_hash(tx),
638
        traces=[],
639
    )
640
641
    message = prepare_message(block_env, tx_env, tx)
642
643
    tx_output = process_message_call(message)
644
645
    tx_gas_used_before_refund = tx.gas - tx_output.gas_left
646
    tx_gas_refund = min(
647
        tx_gas_used_before_refund // Uint(2), Uint(tx_output.refund_counter)
648
    )
649
    tx_gas_used_after_refund = tx_gas_used_before_refund - tx_gas_refund
650
    tx_gas_left = tx.gas - tx_gas_used_after_refund
651
    gas_refund_amount = tx_gas_left * tx.gas_price
652
653
    transaction_fee = tx_gas_used_after_refund * tx.gas_price
654
655
    # refund gas
656
    sender_balance_after_refund = get_account(
657
        block_env.state, sender
658
    ).balance + U256(gas_refund_amount)
659
    set_account_balance(block_env.state, sender, sender_balance_after_refund)
660
661
    # transfer miner fees
662
    coinbase_balance_after_mining_fee = get_account(
663
        block_env.state, block_env.coinbase
664
    ).balance + U256(transaction_fee)
665
    if coinbase_balance_after_mining_fee != 0:
666
        set_account_balance(
667
            block_env.state,
668
            block_env.coinbase,
669
            coinbase_balance_after_mining_fee,
670
        )
671
    elif account_exists_and_is_empty(block_env.state, block_env.coinbase):
672
        destroy_account(block_env.state, block_env.coinbase)
673
674
    for address in tx_output.accounts_to_delete:
675
        destroy_account(block_env.state, address)
676
677
    destroy_touched_empty_accounts(block_env.state, tx_output.touched_accounts)
678
679
    block_output.block_gas_used += tx_gas_used_after_refund
680
681
    receipt = make_receipt(
682
        tx_output.error, block_output.block_gas_used, tx_output.logs
683
    )
684
685
    receipt_key = rlp.encode(Uint(index))
686
    block_output.receipt_keys += (receipt_key,)
687
688
    trie_set(
689
        block_output.receipts_trie,
690
        receipt_key,
691
        receipt,
692
    )
693
694
    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:
698
    """
699
    Validates the gas limit for a block.
700
701
    The bounds of the gas limit, ``max_adjustment_delta``, is set as the
702
    quotient of the parent block's gas limit and the
703
    ``GAS_LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is
704
    passed through as a parameter is greater than or equal to the *sum* of
705
    the parent's gas and the adjustment delta then the limit for gas is too
706
    high and fails this function's check. Similarly, if the limit is less
707
    than or equal to the *difference* of the parent's gas and the adjustment
708
    delta *or* the predefined ``GAS_LIMIT_MINIMUM`` then this function's
709
    check fails because the gas limit doesn't allow for a sufficient or
710
    reasonable amount of gas to be used on a block.
711
712
    Parameters
713
    ----------
714
    gas_limit :
715
        Gas limit to validate.
716
717
    parent_gas_limit :
718
        Gas limit of the parent block.
719
720
    Returns
721
    -------
722
    check : `bool`
723
        True if gas limit constraints are satisfied, False otherwise.
724
    """
725
    max_adjustment_delta = parent_gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
726
    if gas_limit >= parent_gas_limit + max_adjustment_delta:
727
        return False
728
    if gas_limit <= parent_gas_limit - max_adjustment_delta:
729
        return False
730
    if gas_limit < GAS_LIMIT_MINIMUM:
731
        return False
732
733
    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 GENESIS_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:
743
    """
744
    Computes difficulty of a block using its header and parent header.
745
746
    The difficulty is determined by the time the block was created after its
747
    parent. The ``offset`` is calculated using the parent block's difficulty,
748
    ``parent_difficulty``, and the timestamp between blocks. This offset is
749
    then added to the parent difficulty and is stored as the ``difficulty``
750
    variable. If the time between the block and its parent is too short, the
751
    offset will result in a positive number thus making the sum of
752
    ``parent_difficulty`` and ``offset`` to be a greater value in order to
753
    avoid mass forking. But, if the time is long enough, then the offset
754
    results in a negative value making the block less difficult than
755
    its parent.
756
757
    The base standard for a block's difficulty is the predefined value
758
    set for the genesis block since it has no parent. So, a block
759
    can't be less difficult than the genesis block, therefore each block's
760
    difficulty is set to the maximum value between the calculated
761
    difficulty and the ``GENESIS_DIFFICULTY``.
762
763
    Parameters
764
    ----------
765
    block_number :
766
        Block number of the block.
767
    block_timestamp :
768
        Timestamp of the block.
769
    parent_timestamp :
770
        Timestamp of the parent block.
771
    parent_difficulty :
772
        difficulty of the parent block.
773
    parent_has_ommers:
774
        does the parent have ommers.
775
776
    Returns
777
    -------
778
    difficulty : `ethereum.base_types.Uint`
779
        Computed difficulty for a block.
780
    """
781
    offset = (
782
        int(parent_difficulty)
783
        // 2048
784
        * max(
785
            (2 if parent_has_ommers else 1)
786
            - int(block_timestamp - parent_timestamp) // 9,
787
            -99,
788
        )
789
    )
790
    difficulty = int(parent_difficulty) + offset
791
    # Historical Note: The difficulty bomb was not present in Ethereum at the
792
    # start of Frontier, but was added shortly after launch. However since the
793
    # bomb has no effect prior to block 200000 we pretend it existed from
794
    # genesis.
795
    # See https://github.com/ethereum/go-ethereum/pull/1588
796
    num_bomb_periods = ((int(block_number) - BOMB_DELAY_BLOCKS) // 100000) - 2
797
    if num_bomb_periods >= 0:
798
        difficulty += 2**num_bomb_periods
799
800
    # Some clients raise the difficulty to `MINIMUM_DIFFICULTY` prior to adding
801
    # the bomb. This bug does not matter because the difficulty is always much
802
    # greater than `MINIMUM_DIFFICULTY` on Mainnet.
803
    return Uint(max(difficulty, int(MINIMUM_DIFFICULTY)))