ethereum.paris.fork

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

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

Introduction

Entry point for the Ethereum specification.

BASE_FEE_MAX_CHANGE_DENOMINATOR

64
BASE_FEE_MAX_CHANGE_DENOMINATOR = Uint(8)

ELASTICITY_MULTIPLIER

65
ELASTICITY_MULTIPLIER = Uint(2)

GAS_LIMIT_ADJUSTMENT_FACTOR

66
GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)

GAS_LIMIT_MINIMUM

67
GAS_LIMIT_MINIMUM = Uint(5000)

EMPTY_OMMER_HASH

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

BlockChain

History and current state of the block chain.

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
    """
84
    Transforms the state from the previous hard fork (`old`) into the block
85
    chain object for this hard fork and returns it.
86
87
    When forks need to implement an irregular state transition, this function
88
    is used to handle the irregularity. See the :ref:`DAO Fork <dao-fork>` for
89
    an example.
90
91
    Parameters
92
    ----------
93
    old :
94
        Previous block chain object.
95
96
    Returns
97
    -------
98
    new : `BlockChain`
99
        Upgraded block chain object for this hard fork.
100
    """
101
    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]:
105
    """
106
    Obtain the list of hashes of the previous 256 blocks in order of
107
    increasing block number.
108
109
    This function will return less hashes for the first 256 blocks.
110
111
    The ``BLOCKHASH`` opcode needs to access the latest hashes on the chain,
112
    therefore this function retrieves them.
113
114
    Parameters
115
    ----------
116
    chain :
117
        History and current state.
118
119
    Returns
120
    -------
121
    recent_block_hashes : `List[Hash32]`
122
        Hashes of the recent 256 blocks in order of increasing block number.
123
    """
124
    recent_blocks = chain.blocks[-255:]
125
    # TODO: This function has not been tested rigorously
126
    if len(recent_blocks) == 0:
127
        return []
128
129
    recent_block_hashes = []
130
131
    for block in recent_blocks:
132
        prev_block_hash = block.header.parent_hash
133
        recent_block_hashes.append(prev_block_hash)
134
135
    # We are computing the hash only for the most recent block and not for
136
    # the rest of the blocks as they have successors which have the hash of
137
    # the current block as parent hash.
138
    most_recent_block_hash = keccak256(rlp.encode(recent_blocks[-1].header))
139
    recent_block_hashes.append(most_recent_block_hash)
140
141
    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:
145
    """
146
    Attempts to apply a block to an existing block chain.
147
148
    All parts of the block's contents need to be verified before being added
149
    to the chain. Blocks are verified by ensuring that the contents of the
150
    block make logical sense with the contents of the parent block. The
151
    information in the block's header must also match the corresponding
152
    information in the block.
153
154
    To implement Ethereum, in theory clients are only required to store the
155
    most recent 255 blocks of the chain since as far as execution is
156
    concerned, only those blocks are accessed. Practically, however, clients
157
    should store more blocks to handle reorgs.
158
159
    Parameters
160
    ----------
161
    chain :
162
        History and current state.
163
    block :
164
        Block to apply to `chain`.
165
    """
166
    validate_header(chain, block.header)
167
    if block.ommers != ():
168
        raise InvalidBlock
169
170
    block_env = vm.BlockEnvironment(
171
        chain_id=chain.chain_id,
172
        state=chain.state,
173
        block_gas_limit=block.header.gas_limit,
174
        block_hashes=get_last_256_block_hashes(chain),
175
        coinbase=block.header.coinbase,
176
        number=block.header.number,
177
        base_fee_per_gas=block.header.base_fee_per_gas,
178
        time=block.header.timestamp,
179
        prev_randao=block.header.prev_randao,
180
    )
181
182
    block_output = apply_body(
183
        block_env=block_env,
184
        transactions=block.transactions,
185
    )
186
    block_state_root = state_root(block_env.state)
187
    transactions_root = root(block_output.transactions_trie)
188
    receipt_root = root(block_output.receipts_trie)
189
    block_logs_bloom = logs_bloom(block_output.block_logs)
190
191
    if block_output.block_gas_used != block.header.gas_used:
192
        raise InvalidBlock(
193
            f"{block_output.block_gas_used} != {block.header.gas_used}"
194
        )
195
    if transactions_root != block.header.transactions_root:
196
        raise InvalidBlock
197
    if block_state_root != block.header.state_root:
198
        raise InvalidBlock
199
    if receipt_root != block.header.receipt_root:
200
        raise InvalidBlock
201
    if block_logs_bloom != block.header.bloom:
202
        raise InvalidBlock
203
204
    chain.blocks.append(block)
205
    if len(chain.blocks) > 255:
206
        # Real clients have to store more blocks to deal with reorgs, but the
207
        # protocol only requires the last 255
208
        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:
217
    """
218
    Calculates the base fee per gas for the block.
219
220
    Parameters
221
    ----------
222
    block_gas_limit :
223
        Gas limit of the block for which the base fee is being calculated.
224
    parent_gas_limit :
225
        Gas limit of the parent block.
226
    parent_gas_used :
227
        Gas used in the parent block.
228
    parent_base_fee_per_gas :
229
        Base fee per gas of the parent block.
230
231
    Returns
232
    -------
233
    base_fee_per_gas : `Uint`
234
        Base fee per gas for the block.
235
    """
236
    parent_gas_target = parent_gas_limit // ELASTICITY_MULTIPLIER
237
    if not check_gas_limit(block_gas_limit, parent_gas_limit):
238
        raise InvalidBlock
239
240
    if parent_gas_used == parent_gas_target:
241
        expected_base_fee_per_gas = parent_base_fee_per_gas
242
    elif parent_gas_used > parent_gas_target:
243
        gas_used_delta = parent_gas_used - parent_gas_target
244
245
        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta
246
        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target
247
248
        base_fee_per_gas_delta = max(
249
            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR,
250
            Uint(1),
251
        )
252
253
        expected_base_fee_per_gas = (
254
            parent_base_fee_per_gas + base_fee_per_gas_delta
255
        )
256
    else:
257
        gas_used_delta = parent_gas_target - parent_gas_used
258
259
        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta
260
        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target
261
262
        base_fee_per_gas_delta = (
263
            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR
264
        )
265
266
        expected_base_fee_per_gas = (
267
            parent_base_fee_per_gas - base_fee_per_gas_delta
268
        )
269
270
    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:
274
    """
275
    Verifies a block header.
276
277
    In order to consider a block's header valid, the logic for the
278
    quantities in the header should match the logic for the block itself.
279
    For example the header timestamp should be greater than the block's parent
280
    timestamp because the block was created *after* the parent block.
281
    Additionally, the block's number should be directly following the parent
282
    block's number since it is the next block in the sequence.
283
284
    Parameters
285
    ----------
286
    chain :
287
        History and current state.
288
    header :
289
        Header to check for correctness.
290
    """
291
    if header.number < Uint(1):
292
        raise InvalidBlock
293
294
    parent_header = chain.blocks[-1].header
295
296
    if header.gas_used > header.gas_limit:
297
        raise InvalidBlock
298
299
    expected_base_fee_per_gas = calculate_base_fee_per_gas(
300
        header.gas_limit,
301
        parent_header.gas_limit,
302
        parent_header.gas_used,
303
        parent_header.base_fee_per_gas,
304
    )
305
    if expected_base_fee_per_gas != header.base_fee_per_gas:
306
        raise InvalidBlock
307
    if header.timestamp <= parent_header.timestamp:
308
        raise InvalidBlock
309
    if header.number != parent_header.number + Uint(1):
310
        raise InvalidBlock
311
    if len(header.extra_data) > 32:
312
        raise InvalidBlock
313
    if header.difficulty != 0:
314
        raise InvalidBlock
315
    if header.nonce != b"\x00\x00\x00\x00\x00\x00\x00\x00":
316
        raise InvalidBlock
317
    if header.ommers_hash != EMPTY_OMMER_HASH:
318
        raise InvalidBlock
319
320
    block_parent_hash = keccak256(rlp.encode(parent_header))
321
    if header.parent_hash != block_parent_hash:
322
        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. 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. PriorityFeeGreaterThanMaxFeeError : If the priority fee is greater than the maximum fee per gas. InsufficientMaxFeePerGasError : If the maximum fee per gas is insufficient for the transaction.

def check_transaction(block_env: ethereum.paris.vm.BlockEnvironment, ​​block_output: ethereum.paris.vm.BlockOutput, ​​tx: Transaction) -> Tuple[Address, Uint]:
330
    """
331
    Check if the transaction is includable in the block.
332
333
    Parameters
334
    ----------
335
    block_env :
336
        The block scoped environment.
337
    block_output :
338
        The block output for the current block.
339
    tx :
340
        The transaction.
341
342
    Returns
343
    -------
344
    sender_address :
345
        The sender of the transaction.
346
    effective_gas_price :
347
        The price to charge for gas when the transaction is executed.
348
349
    Raises
350
    ------
351
    InvalidBlock :
352
        If the transaction is not includable.
353
    GasUsedExceedsLimitError :
354
        If the gas used by the transaction exceeds the block's gas limit.
355
    NonceMismatchError :
356
        If the nonce of the transaction is not equal to the sender's nonce.
357
    InsufficientBalanceError :
358
        If the sender's balance is not enough to pay for the transaction.
359
    InvalidSenderError :
360
        If the transaction is from an address that does not exist anymore.
361
    PriorityFeeGreaterThanMaxFeeError :
362
        If the priority fee is greater than the maximum fee per gas.
363
    InsufficientMaxFeePerGasError :
364
        If the maximum fee per gas is insufficient for the transaction.
365
    """
366
    gas_available = block_env.block_gas_limit - block_output.block_gas_used
367
    if tx.gas > gas_available:
368
        raise GasUsedExceedsLimitError("gas used exceeds limit")
369
    sender_address = recover_sender(block_env.chain_id, tx)
370
    sender_account = get_account(block_env.state, sender_address)
371
372
    if isinstance(tx, FeeMarketTransaction):
373
        if tx.max_fee_per_gas < tx.max_priority_fee_per_gas:
374
            raise PriorityFeeGreaterThanMaxFeeError(
375
                "priority fee greater than max fee"
376
            )
377
        if tx.max_fee_per_gas < block_env.base_fee_per_gas:
378
            raise InsufficientMaxFeePerGasError(
379
                tx.max_fee_per_gas, block_env.base_fee_per_gas
380
            )
381
382
        priority_fee_per_gas = min(
383
            tx.max_priority_fee_per_gas,
384
            tx.max_fee_per_gas - block_env.base_fee_per_gas,
385
        )
386
        effective_gas_price = priority_fee_per_gas + block_env.base_fee_per_gas
387
        max_gas_fee = tx.gas * tx.max_fee_per_gas
388
    else:
389
        if tx.gas_price < block_env.base_fee_per_gas:
390
            raise InvalidBlock
391
        effective_gas_price = tx.gas_price
392
        max_gas_fee = tx.gas * tx.gas_price
393
394
    if sender_account.nonce > Uint(tx.nonce):
395
        raise NonceMismatchError("nonce too low")
396
    elif sender_account.nonce < Uint(tx.nonce):
397
        raise NonceMismatchError("nonce too high")
398
    if Uint(sender_account.balance) < max_gas_fee + Uint(tx.value):
399
        raise InsufficientBalanceError("insufficient sender balance")
400
    if sender_account.code:
401
        raise InvalidSenderError("not EOA")
402
403
    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:
412
    """
413
    Make the receipt for a transaction that was executed.
414
415
    Parameters
416
    ----------
417
    tx :
418
        The executed transaction.
419
    error :
420
        Error in the top level frame of the transaction, if any.
421
    cumulative_gas_used :
422
        The total gas used so far in the block after the transaction was
423
        executed.
424
    logs :
425
        The logs produced by the transaction.
426
427
    Returns
428
    -------
429
    receipt :
430
        The receipt for the transaction.
431
    """
432
    receipt = Receipt(
433
        succeeded=error is None,
434
        cumulative_gas_used=cumulative_gas_used,
435
        bloom=logs_bloom(logs),
436
        logs=logs,
437
    )
438
439
    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.

Returns

block_output : The block output for the current block.

def apply_body(block_env: ethereum.paris.vm.BlockEnvironment, ​​transactions: Tuple[LegacyTransaction | Bytes, ...]) -> ethereum.paris.vm.BlockOutput:
446
    """
447
    Executes a block.
448
449
    Many of the contents of a block are stored in data structures called
450
    tries. There is a transactions trie which is similar to a ledger of the
451
    transactions stored in the current block. There is also a receipts trie
452
    which stores the results of executing a transaction, like the post state
453
    and gas used. This function creates and executes the block that is to be
454
    added to the chain.
455
456
    Parameters
457
    ----------
458
    block_env :
459
        The block scoped environment.
460
    transactions :
461
        Transactions included in the block.
462
463
    Returns
464
    -------
465
    block_output :
466
        The block output for the current block.
467
    """
468
    block_output = vm.BlockOutput()
469
470
    for i, tx in enumerate(map(decode_transaction, transactions)):
471
        process_transaction(block_env, block_output, tx, Uint(i))
472
473
    return block_output

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.paris.vm.BlockEnvironment, ​​block_output: ethereum.paris.vm.BlockOutput, ​​tx: Transaction, ​​index: Uint) -> None:
482
    """
483
    Execute a transaction against the provided environment.
484
485
    This function processes the actions needed to execute a transaction.
486
    It decrements the sender's account after calculating the gas fee and
487
    refunds them the proper amount after execution. Calling contracts,
488
    deploying code, and incrementing nonces are all examples of actions that
489
    happen within this function or from a call made within this function.
490
491
    Accounts that are marked for deletion are processed and destroyed after
492
    execution.
493
494
    Parameters
495
    ----------
496
    block_env :
497
        Environment for the Ethereum Virtual Machine.
498
    block_output :
499
        The block output for the current block.
500
    tx :
501
        Transaction to execute.
502
    index:
503
        Index of the transaction in the block.
504
    """
505
    trie_set(
506
        block_output.transactions_trie,
507
        rlp.encode(index),
508
        encode_transaction(tx),
509
    )
510
511
    intrinsic_gas = validate_transaction(tx)
512
513
    (
514
        sender,
515
        effective_gas_price,
516
    ) = check_transaction(
517
        block_env=block_env,
518
        block_output=block_output,
519
        tx=tx,
520
    )
521
522
    sender_account = get_account(block_env.state, sender)
523
524
    effective_gas_fee = tx.gas * effective_gas_price
525
526
    gas = tx.gas - intrinsic_gas
527
    increment_nonce(block_env.state, sender)
528
529
    sender_balance_after_gas_fee = (
530
        Uint(sender_account.balance) - effective_gas_fee
531
    )
532
    set_account_balance(
533
        block_env.state, sender, U256(sender_balance_after_gas_fee)
534
    )
535
536
    access_list_addresses = set()
537
    access_list_storage_keys = set()
538
    if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)):
539
        for access in tx.access_list:
540
            access_list_addresses.add(access.account)
541
            for slot in access.slots:
542
                access_list_storage_keys.add((access.account, slot))
543
544
    tx_env = vm.TransactionEnvironment(
545
        origin=sender,
546
        gas_price=effective_gas_price,
547
        gas=gas,
548
        access_list_addresses=access_list_addresses,
549
        access_list_storage_keys=access_list_storage_keys,
550
        index_in_block=index,
551
        tx_hash=get_transaction_hash(encode_transaction(tx)),
552
        traces=[],
553
    )
554
555
    message = prepare_message(block_env, tx_env, tx)
556
557
    tx_output = process_message_call(message)
558
559
    tx_gas_used_before_refund = tx.gas - tx_output.gas_left
560
    tx_gas_refund = min(
561
        tx_gas_used_before_refund // Uint(5), Uint(tx_output.refund_counter)
562
    )
563
    tx_gas_used_after_refund = tx_gas_used_before_refund - tx_gas_refund
564
    tx_gas_left = tx.gas - tx_gas_used_after_refund
565
    gas_refund_amount = tx_gas_left * effective_gas_price
566
567
    # For non-1559 transactions effective_gas_price == tx.gas_price
568
    priority_fee_per_gas = effective_gas_price - block_env.base_fee_per_gas
569
    transaction_fee = tx_gas_used_after_refund * priority_fee_per_gas
570
571
    # refund gas
572
    sender_balance_after_refund = get_account(
573
        block_env.state, sender
574
    ).balance + U256(gas_refund_amount)
575
    set_account_balance(block_env.state, sender, sender_balance_after_refund)
576
577
    # transfer miner fees
578
    coinbase_balance_after_mining_fee = get_account(
579
        block_env.state, block_env.coinbase
580
    ).balance + U256(transaction_fee)
581
    if coinbase_balance_after_mining_fee != 0:
582
        set_account_balance(
583
            block_env.state,
584
            block_env.coinbase,
585
            coinbase_balance_after_mining_fee,
586
        )
587
    elif account_exists_and_is_empty(block_env.state, block_env.coinbase):
588
        destroy_account(block_env.state, block_env.coinbase)
589
590
    for address in tx_output.accounts_to_delete:
591
        destroy_account(block_env.state, address)
592
593
    block_output.block_gas_used += tx_gas_used_after_refund
594
595
    receipt = make_receipt(
596
        tx, tx_output.error, block_output.block_gas_used, tx_output.logs
597
    )
598
599
    receipt_key = rlp.encode(Uint(index))
600
    block_output.receipt_keys += (receipt_key,)
601
602
    trie_set(
603
        block_output.receipts_trie,
604
        receipt_key,
605
        receipt,
606
    )
607
608
    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:
612
    """
613
    Validates the gas limit for a block.
614
615
    The bounds of the gas limit, ``max_adjustment_delta``, is set as the
616
    quotient of the parent block's gas limit and the
617
    ``GAS_LIMIT_ADJUSTMENT_FACTOR``. Therefore, if the gas limit that is
618
    passed through as a parameter is greater than or equal to the *sum* of
619
    the parent's gas and the adjustment delta then the limit for gas is too
620
    high and fails this function's check. Similarly, if the limit is less
621
    than or equal to the *difference* of the parent's gas and the adjustment
622
    delta *or* the predefined ``GAS_LIMIT_MINIMUM`` then this function's
623
    check fails because the gas limit doesn't allow for a sufficient or
624
    reasonable amount of gas to be used on a block.
625
626
    Parameters
627
    ----------
628
    gas_limit :
629
        Gas limit to validate.
630
631
    parent_gas_limit :
632
        Gas limit of the parent block.
633
634
    Returns
635
    -------
636
    check : `bool`
637
        True if gas limit constraints are satisfied, False otherwise.
638
    """
639
    max_adjustment_delta = parent_gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
640
    if gas_limit >= parent_gas_limit + max_adjustment_delta:
641
        return False
642
    if gas_limit <= parent_gas_limit - max_adjustment_delta:
643
        return False
644
    if gas_limit < GAS_LIMIT_MINIMUM:
645
        return False
646
647
    return True