ethereum.paris.fork

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

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

Introduction

Entry point for the Ethereum specification.

BASE_FEE_MAX_CHANGE_DENOMINATOR

63
BASE_FEE_MAX_CHANGE_DENOMINATOR = Uint(8)

ELASTICITY_MULTIPLIER

64
ELASTICITY_MULTIPLIER = Uint(2)

GAS_LIMIT_ADJUSTMENT_FACTOR

65
GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)

GAS_LIMIT_MINIMUM

66
GAS_LIMIT_MINIMUM = Uint(5000)

EMPTY_OMMER_HASH

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

BlockChain

History and current state of the block chain.

70
@dataclass
class BlockChain:

blocks

76
    blocks: List[Block]

state

77
    state: State

chain_id

78
    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:
82
    """
83
    Transforms the state from the previous hard fork (`old`) into the block
84
    chain object for this hard fork and returns it.
85
86
    When forks need to implement an irregular state transition, this function
87
    is used to handle the irregularity. See the :ref:`DAO Fork <dao-fork>` for
88
    an example.
89
90
    Parameters
91
    ----------
92
    old :
93
        Previous block chain object.
94
95
    Returns
96
    -------
97
    new : `BlockChain`
98
        Upgraded block chain object for this hard fork.
99
    """
100
    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]:
104
    """
105
    Obtain the list of hashes of the previous 256 blocks in order of
106
    increasing block number.
107
108
    This function will return less hashes for the first 256 blocks.
109
110
    The ``BLOCKHASH`` opcode needs to access the latest hashes on the chain,
111
    therefore this function retrieves them.
112
113
    Parameters
114
    ----------
115
    chain :
116
        History and current state.
117
118
    Returns
119
    -------
120
    recent_block_hashes : `List[Hash32]`
121
        Hashes of the recent 256 blocks in order of increasing block number.
122
    """
123
    recent_blocks = chain.blocks[-255:]
124
    # TODO: This function has not been tested rigorously
125
    if len(recent_blocks) == 0:
126
        return []
127
128
    recent_block_hashes = []
129
130
    for block in recent_blocks:
131
        prev_block_hash = block.header.parent_hash
132
        recent_block_hashes.append(prev_block_hash)
133
134
    # We are computing the hash only for the most recent block and not for
135
    # the rest of the blocks as they have successors which have the hash of
136
    # the current block as parent hash.
137
    most_recent_block_hash = keccak256(rlp.encode(recent_blocks[-1].header))
138
    recent_block_hashes.append(most_recent_block_hash)
139
140
    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:
144
    """
145
    Attempts to apply a block to an existing block chain.
146
147
    All parts of the block's contents need to be verified before being added
148
    to the chain. Blocks are verified by ensuring that the contents of the
149
    block make logical sense with the contents of the parent block. The
150
    information in the block's header must also match the corresponding
151
    information in the block.
152
153
    To implement Ethereum, in theory clients are only required to store the
154
    most recent 255 blocks of the chain since as far as execution is
155
    concerned, only those blocks are accessed. Practically, however, clients
156
    should store more blocks to handle reorgs.
157
158
    Parameters
159
    ----------
160
    chain :
161
        History and current state.
162
    block :
163
        Block to apply to `chain`.
164
    """
165
    validate_header(chain, block.header)
166
    if block.ommers != ():
167
        raise InvalidBlock
168
169
    block_env = vm.BlockEnvironment(
170
        chain_id=chain.chain_id,
171
        state=chain.state,
172
        block_gas_limit=block.header.gas_limit,
173
        block_hashes=get_last_256_block_hashes(chain),
174
        coinbase=block.header.coinbase,
175
        number=block.header.number,
176
        base_fee_per_gas=block.header.base_fee_per_gas,
177
        time=block.header.timestamp,
178
        prev_randao=block.header.prev_randao,
179
    )
180
181
    block_output = apply_body(
182
        block_env=block_env,
183
        transactions=block.transactions,
184
    )
185
    block_state_root = state_root(block_env.state)
186
    transactions_root = root(block_output.transactions_trie)
187
    receipt_root = root(block_output.receipts_trie)
188
    block_logs_bloom = logs_bloom(block_output.block_logs)
189
190
    if block_output.block_gas_used != block.header.gas_used:
191
        raise InvalidBlock(
192
            f"{block_output.block_gas_used} != {block.header.gas_used}"
193
        )
194
    if transactions_root != block.header.transactions_root:
195
        raise InvalidBlock
196
    if block_state_root != block.header.state_root:
197
        raise InvalidBlock
198
    if receipt_root != block.header.receipt_root:
199
        raise InvalidBlock
200
    if block_logs_bloom != block.header.bloom:
201
        raise InvalidBlock
202
203
    chain.blocks.append(block)
204
    if len(chain.blocks) > 255:
205
        # Real clients have to store more blocks to deal with reorgs, but the
206
        # protocol only requires the last 255
207
        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:
216
    """
217
    Calculates the base fee per gas for the block.
218
219
    Parameters
220
    ----------
221
    block_gas_limit :
222
        Gas limit of the block for which the base fee is being calculated.
223
    parent_gas_limit :
224
        Gas limit of the parent block.
225
    parent_gas_used :
226
        Gas used in the parent block.
227
    parent_base_fee_per_gas :
228
        Base fee per gas of the parent block.
229
230
    Returns
231
    -------
232
    base_fee_per_gas : `Uint`
233
        Base fee per gas for the block.
234
    """
235
    parent_gas_target = parent_gas_limit // ELASTICITY_MULTIPLIER
236
    if not check_gas_limit(block_gas_limit, parent_gas_limit):
237
        raise InvalidBlock
238
239
    if parent_gas_used == parent_gas_target:
240
        expected_base_fee_per_gas = parent_base_fee_per_gas
241
    elif parent_gas_used > parent_gas_target:
242
        gas_used_delta = parent_gas_used - parent_gas_target
243
244
        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta
245
        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target
246
247
        base_fee_per_gas_delta = max(
248
            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR,
249
            Uint(1),
250
        )
251
252
        expected_base_fee_per_gas = (
253
            parent_base_fee_per_gas + base_fee_per_gas_delta
254
        )
255
    else:
256
        gas_used_delta = parent_gas_target - parent_gas_used
257
258
        parent_fee_gas_delta = parent_base_fee_per_gas * gas_used_delta
259
        target_fee_gas_delta = parent_fee_gas_delta // parent_gas_target
260
261
        base_fee_per_gas_delta = (
262
            target_fee_gas_delta // BASE_FEE_MAX_CHANGE_DENOMINATOR
263
        )
264
265
        expected_base_fee_per_gas = (
266
            parent_base_fee_per_gas - base_fee_per_gas_delta
267
        )
268
269
    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:
273
    """
274
    Verifies a block header.
275
276
    In order to consider a block's header valid, the logic for the
277
    quantities in the header should match the logic for the block itself.
278
    For example the header timestamp should be greater than the block's parent
279
    timestamp because the block was created *after* the parent block.
280
    Additionally, the block's number should be directly following the parent
281
    block's number since it is the next block in the sequence.
282
283
    Parameters
284
    ----------
285
    chain :
286
        History and current state.
287
    header :
288
        Header to check for correctness.
289
    """
290
    if header.number < Uint(1):
291
        raise InvalidBlock
292
293
    parent_header = chain.blocks[-1].header
294
295
    if header.gas_used > header.gas_limit:
296
        raise InvalidBlock
297
298
    expected_base_fee_per_gas = calculate_base_fee_per_gas(
299
        header.gas_limit,
300
        parent_header.gas_limit,
301
        parent_header.gas_used,
302
        parent_header.base_fee_per_gas,
303
    )
304
    if expected_base_fee_per_gas != header.base_fee_per_gas:
305
        raise InvalidBlock
306
    if header.timestamp <= parent_header.timestamp:
307
        raise InvalidBlock
308
    if header.number != parent_header.number + Uint(1):
309
        raise InvalidBlock
310
    if len(header.extra_data) > 32:
311
        raise InvalidBlock
312
    if header.difficulty != 0:
313
        raise InvalidBlock
314
    if header.nonce != b"\x00\x00\x00\x00\x00\x00\x00\x00":
315
        raise InvalidBlock
316
    if header.ommers_hash != EMPTY_OMMER_HASH:
317
        raise InvalidBlock
318
319
    block_parent_hash = keccak256(rlp.encode(parent_header))
320
    if header.parent_hash != block_parent_hash:
321
        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]:
329
    """
330
    Check if the transaction is includable in the block.
331
332
    Parameters
333
    ----------
334
    block_env :
335
        The block scoped environment.
336
    block_output :
337
        The block output for the current block.
338
    tx :
339
        The transaction.
340
341
    Returns
342
    -------
343
    sender_address :
344
        The sender of the transaction.
345
    effective_gas_price :
346
        The price to charge for gas when the transaction is executed.
347
348
    Raises
349
    ------
350
    InvalidBlock :
351
        If the transaction is not includable.
352
    GasUsedExceedsLimitError :
353
        If the gas used by the transaction exceeds the block's gas limit.
354
    NonceMismatchError :
355
        If the nonce of the transaction is not equal to the sender's nonce.
356
    InsufficientBalanceError :
357
        If the sender's balance is not enough to pay for the transaction.
358
    InvalidSenderError :
359
        If the transaction is from an address that does not exist anymore.
360
    PriorityFeeGreaterThanMaxFeeError :
361
        If the priority fee is greater than the maximum fee per gas.
362
    InsufficientMaxFeePerGasError :
363
        If the maximum fee per gas is insufficient for the transaction.
364
    """
365
    gas_available = block_env.block_gas_limit - block_output.block_gas_used
366
    if tx.gas > gas_available:
367
        raise GasUsedExceedsLimitError("gas used exceeds limit")
368
    sender_address = recover_sender(block_env.chain_id, tx)
369
    sender_account = get_account(block_env.state, sender_address)
370
371
    if isinstance(tx, FeeMarketTransaction):
372
        if tx.max_fee_per_gas < tx.max_priority_fee_per_gas:
373
            raise PriorityFeeGreaterThanMaxFeeError(
374
                "priority fee greater than max fee"
375
            )
376
        if tx.max_fee_per_gas < block_env.base_fee_per_gas:
377
            raise InsufficientMaxFeePerGasError(
378
                tx.max_fee_per_gas, block_env.base_fee_per_gas
379
            )
380
381
        priority_fee_per_gas = min(
382
            tx.max_priority_fee_per_gas,
383
            tx.max_fee_per_gas - block_env.base_fee_per_gas,
384
        )
385
        effective_gas_price = priority_fee_per_gas + block_env.base_fee_per_gas
386
        max_gas_fee = tx.gas * tx.max_fee_per_gas
387
    else:
388
        if tx.gas_price < block_env.base_fee_per_gas:
389
            raise InvalidBlock
390
        effective_gas_price = tx.gas_price
391
        max_gas_fee = tx.gas * tx.gas_price
392
393
    if sender_account.nonce > Uint(tx.nonce):
394
        raise NonceMismatchError("nonce too low")
395
    elif sender_account.nonce < Uint(tx.nonce):
396
        raise NonceMismatchError("nonce too high")
397
    if Uint(sender_account.balance) < max_gas_fee + Uint(tx.value):
398
        raise InsufficientBalanceError("insufficient sender balance")
399
    if sender_account.code:
400
        raise InvalidSenderError("not EOA")
401
402
    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:
411
    """
412
    Make the receipt for a transaction that was executed.
413
414
    Parameters
415
    ----------
416
    tx :
417
        The executed transaction.
418
    error :
419
        Error in the top level frame of the transaction, if any.
420
    cumulative_gas_used :
421
        The total gas used so far in the block after the transaction was
422
        executed.
423
    logs :
424
        The logs produced by the transaction.
425
426
    Returns
427
    -------
428
    receipt :
429
        The receipt for the transaction.
430
    """
431
    receipt = Receipt(
432
        succeeded=error is None,
433
        cumulative_gas_used=cumulative_gas_used,
434
        bloom=logs_bloom(logs),
435
        logs=logs,
436
    )
437
438
    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:
445
    """
446
    Executes a block.
447
448
    Many of the contents of a block are stored in data structures called
449
    tries. There is a transactions trie which is similar to a ledger of the
450
    transactions stored in the current block. There is also a receipts trie
451
    which stores the results of executing a transaction, like the post state
452
    and gas used. This function creates and executes the block that is to be
453
    added to the chain.
454
455
    Parameters
456
    ----------
457
    block_env :
458
        The block scoped environment.
459
    transactions :
460
        Transactions included in the block.
461
462
    Returns
463
    -------
464
    block_output :
465
        The block output for the current block.
466
    """
467
    block_output = vm.BlockOutput()
468
469
    for i, tx in enumerate(map(decode_transaction, transactions)):
470
        process_transaction(block_env, block_output, tx, Uint(i))
471
472
    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 balance after calculating the gas fee and refunds them the proper amount after execution. Calling contracts, deploying code, and incrementing nonces are all examples of actions that happen within this function or from a call made within this function.

Accounts that are marked for deletion are processed and destroyed after execution.

Parameters

block_env : Environment for the Ethereum Virtual Machine. block_output : The block output for the current block. tx : Transaction to execute. index: Index of the transaction in the block.

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