EIP-7623: Fix linter issues

EIPS/eip-7886.md

@@ -3,26 +3,24 @@ eip: 7886
 title: Delayed execution
 description: Make blocks statically verifiable by charging coinbase for inclusion costs upfront
 author: Francesco D`Amato (@fradamt), Toni Wahrstätter (@nerolation)
-discussions-to: https://ethereum-magicians.org/t/eip-xxxx-delayed-execution/22890
+discussions-to: https://ethereum-magicians.org/t/eip-7886-delayed-execution/22890
 status: Draft
 type: Standards Track
 category: Core
 created: 2025-02-18
 ---
 
-
 ## Abstract
 
 This proposal makes (execution) blocks statically verifiable through minimal checks that only require the previous state, but no execution of the block's transactions, allowing validators attest to a block's validity without completing its execution. We allow transactions to be skipped when invalid at execution time, without invalidating the whole block. To ensure that even skipped transactions pay for their resources, the `COINBASE` pays for all inclusion costs upfront (base cost, calldata and blobs), and recovers the costs only when transactions are successfully executed.
 
 ## Motivation
 
-A key advantage of the skipping mechanism is that it enables **asynchronous block validation**: a block can be considered valid even if it contains invalid transactions, because those transactions end up skipping execution without invalidating the entire block. 
+A key advantage of the skipping mechanism is that it enables **asynchronous block validation**: a block can be considered valid even if it contains invalid transactions, because those transactions end up skipping execution without invalidating the entire block. As a result, execution is no longer a bottleneck in the validation process, enabling an earlier attestation deadline and an increase in the block gas limit.
 
 ## Overview
 
 Enabling delayed execution by making the block's validity statically verifiable requires two things:
-
 1. **Deferred execution outputs**: all header fields that commit to execution outputs are deferred by one slot. For example `state_root` and `receipt_root` become `pre_state_root` (similarly to [EIP-7862](./eip-7862.md)) and `parent_receipt_root`, the root of the state and receipt trie obtained after executing the block's parent. The same applies to the General Purpose Execution Layer Requests from [EIP-7685](./eip-7685.md): the requests are deferred by one slot and the requests in the CL must correspond to the `parent_requests_hash` in the EL header. However, this alone would only defer the computation of these execution outputs (mainly of the state root) rather than the actual execution, because verifying transaction validity would still require executing. 
 2. **Upfront payment of inclusion costs by `COINBASE`**: in addition, we need to be able to skip (no-op) invalid transactions without invalidating the whole block. Right now, this is not possible because of the free-DA problem: as soon as we include a transaction into a block, it must pay for its data footprint. By charging the inclusion cost of all transactions upfront from the block's `COINBASE`, it is possible to skip transactions that are found to be invalid at execution time, because the protocol has already been compensated for the inclusion.
 
@@ -247,8 +245,8 @@ This logic is implemented into the ethereum/execution-specs, in `apply_body`.
 
 #### Coinbase Pays Inclusion Cost Upfront
 
-   - The block's `COINBASE` is charged `inclusion_cost = 21000 + max_calldata_fee + blob_fee` for each transaction at the start of block execution. The `inclusion_cost` is determined by adding up the blob fee and the floor cost of [EIP-7623](./eip-7623.md), itself comprising the 21k base cost and the calldata cost charged at `TOTAL_COST_FLOOR_PER_TOKEN`.
-   - If the transaction is skipped, **the `COINBASE` loses** these inclusion fees and thereby pays for DA and other base costs like signature verification.
+   * The block's `COINBASE` is charged `inclusion_cost = 21000 + max_calldata_fee + blob_fee` for each transaction at the start of block execution. The `inclusion_cost` is determined by adding up the blob fee and the floor cost of [EIP-7623](./eip-7623.md), itself comprising the 21k base cost and the calldata cost charged at `TOTAL_COST_FLOOR_PER_TOKEN`.
+   * If the transaction is skipped, **the `COINBASE` loses** these inclusion fees and thereby pays for DA and other base costs like signature verification.
 
 ```python
 # The inclusion gas consists of the base cost + the calldata cost
@@ -331,10 +329,9 @@ def apply_body(
 #### Skipped Transactions
 
 **Definition**: A "skipped transaction" is a transaction that:
-
-- Is included in the block (part of the transactions list)
-- Is not executed during block execution
-- Consumes no gas beyond its inclusion cost, which the block's `COINBASE` pays and **does not get refunded** if the transaction is ultimately skipped.
+* Is included in the block (part of the transactions list)
+* Is not executed during block execution
+* Consumes no gas beyond its inclusion cost, which the block's `COINBASE` pays and **does not get refunded** if the transaction is ultimately skipped.
 
 Skipping might occur because: