Glossary

Execution Pre-Confirmation

An execution pre-confirmation guarantees both transaction inclusion and its specific execution result before final settlement.

Key Takeaways

  • An execution pre-confirmation is a signed commitment from a block proposer guaranteeing not only that a transaction will appear in an upcoming block but also that it will produce a specific post-execution state, providing a stronger assurance than an inclusion preconfirmation.
  • Issuing execution preconfs requires the proposer to simulate the transaction and account for ordering dependencies, which makes them computationally expensive and limits how many can be issued per slot compared to inclusion-only preconfirmations.
  • Execution preconfs unlock use cases where inclusion alone is insufficient: DEX trades that need a guaranteed price, lending liquidations that must execute at a known collateral ratio, and any state-dependent operation where a reverted transaction is as bad as no transaction at all.

What Is an Execution Pre-Confirmation?

An execution pre-confirmation (execution preconf) is a cryptographically signed promise from a block proposer or sequencer that a transaction will be included in a future block and will produce a specific execution outcome. The commitment covers the resulting state changes: storage updates, token transfers, return values, and event emissions. If the proposer fails to deliver the promised result, their posted collateral is slashed.

This distinguishes execution preconfs from their simpler counterpart, the inclusion preconfirmation. An inclusion preconf only guarantees that a transaction will appear in the block: the transaction could still revert during execution. An execution preconf eliminates that uncertainty by pinning down the exact outcome. For a user swapping tokens on a DEX, the difference is between knowing the trade will be attempted versus knowing the trade will execute at a specific price.

The concept was formalized as part of the broader preconfirmation research initiated by Justin Drake of the Ethereum Foundation in late 2023. While inclusion preconfs reached mainnet first (Taiko deployed based preconfirmations on Ethereum in August 2025), execution preconfs remain an active area of research and early deployment, primarily on based rollups and L2 networks where the preconfer controls transaction ordering.

How It Works

The lifecycle of an execution preconfirmation follows the same six-stage pattern as other preconf types (registration, election, request, response, fulfillment, enforcement), but with significantly more work in the response stage. The proposer cannot simply check basic validity and sign: they must simulate the transaction against the current state to determine and commit to the exact outcome.

  1. A proposer registers by depositing slashable collateral into a registry contract and signals willingness to issue execution preconfirmations
  2. A user submits a preconf request containing their signed transaction, a tip, and a flag indicating they want an execution guarantee (not just inclusion)
  3. The proposer simulates the transaction against the current pending state, accounting for all previously preconfirmed transactions and their state changes
  4. If the simulation succeeds, the proposer signs a commitment binding their validator key to both the transaction hash and the resulting state diff (or state root)
  5. When the proposer's slot arrives, they include the transaction in the block at the committed position, producing the promised state result
  6. If the published block contradicts the commitment (the transaction is missing, reverted, or produced a different state), the proposer's collateral is forfeited

Sequential Processing Constraint

The critical difference from inclusion preconfs is that execution preconfs must be processed sequentially. Each preconfirmed transaction changes the state that subsequent transactions depend on. If a proposer preconfirms a swap that moves a DEX pool's price, every later preconf against that pool must account for the new price.

This creates a fundamental throughput bottleneck. An inclusion preconfer can issue hundreds of preconfs in parallel because they only check signatures and nonces. An execution preconfer must simulate each transaction in order, maintaining a running state image. The more preconfs requested, the larger the state tree the proposer must track and the slower each subsequent preconf becomes.

// Simplified execution preconf pipeline
// Each preconf depends on the state left by the previous one

let state = currentChainState;

for (const request of preconfRequests) {
  const result = simulate(request.tx, state);

  if (result.success) {
    state = result.postState;
    const commitment = sign({
      txHash: request.tx.hash,
      stateRoot: result.postState.root,
      slot: targetSlot,
    });
    respond(request.user, commitment);
  } else {
    reject(request, "simulation reverted");
  }
}

The Signed Commitment

An execution preconf commitment contains more data than an inclusion preconf. Beyond the transaction hash and slot number, it includes a state commitment that proves the proposer simulated the transaction and is binding themselves to the result:

{
  "slot": 9847201,
  "txHash": "0xabc123...def456",
  "txIndex": 42,
  "postStateRoot": "0xdef789...abc012",
  "proposerPubkey": "0x9182...fa03",
  "chainId": 1,
  "tip": "150000000000000",
  "type": "execution",
  "signature": "0xsig..."
}

The txIndex field commits to the transaction's position within the block, and the postStateRoot commits to the resulting state. Both are verifiable: anyone can re-execute the block and check whether the committed state matches. If it does not, the signed commitment serves as a fraud proof for the slashing contract.

Inclusion vs. Execution: Why the Difference Matters

The gap between inclusion and execution preconfs is not just a matter of degree: it determines which applications can rely on preconfirmations at all.

PropertyInclusion PreconfExecution Preconf
GuaranteeTransaction appears in the blockTransaction appears and produces a committed state result
Revert riskTransaction may revertProposer is slashed if the promised outcome does not hold
Proposer burdenLightweight validity checksFull state simulation with ordering constraints
ThroughputHundreds per slot (parallelizable)Tens per slot (sequential processing)
Collateral riskLower (simpler fault conditions)Higher (must cover state mismatches)
Typical useETH transfers, rollup batch postingsDEX swaps, liquidations, arbitrage

For a simple ETH transfer, an inclusion preconf is sufficient because the transaction either succeeds or fails based on the sender's balance and nonce, neither of which typically depends on other transactions in the same block. But for a DEX swap where the output amount depends on the pool's reserves at execution time, inclusion alone tells the user nothing about the price they will receive.

Use Cases

DEX Trading with Price Certainty

Decentralized exchange trades are the canonical use case for execution preconfs. On a constant-product AMM, the output of a swap depends on the pool's reserve ratio at the moment of execution. Other transactions in the same block (arbitrage, other swaps, liquidity additions) can shift those reserves before the user's trade executes.

With an execution preconf, the proposer simulates the swap at a specific position in the block and commits to the resulting output amount. The user knows before settlement exactly how many tokens they will receive, eliminating slippage uncertainty. This matters most in volatile markets where pool reserves can shift significantly within a single block.

Lending Liquidations

In lending protocols, a liquidation must execute when a borrower's collateral ratio falls below the protocol's threshold. Liquidators submit transactions to claim the discounted collateral, but the collateral ratio can change between submission and execution due to price oracle updates or other liquidators acting first.

An execution preconf guarantees the liquidator that their transaction will execute successfully at the expected collateral ratio. Without this guarantee, a liquidator risks submitting a transaction that reverts because another liquidator acted first or because the oracle price shifted during the slot. Reverted liquidation attempts waste gas and leave the protocol exposed to bad debt.

Cross-Chain Atomic Operations

Cross-chain bridges and atomic swaps can use execution preconfs to strengthen the guarantee on the source chain side. An inclusion preconf tells a bridge relayer that the deposit transaction will appear in the block, but if the deposit reverts (due to insufficient token approval, for example), the relayer has already released funds on the destination chain. An execution preconf ensures the deposit actually succeeded before the relayer commits.

MEV Strategy Execution

MEV searchers benefit from execution preconfs because their strategies are inherently state-dependent. An arbitrage opportunity exists only at a specific price level. A sandwich requires precise ordering. With an execution preconf, a searcher receives a binding guarantee that their bundle will execute at the expected state, reducing the risk of wasted gas on reverted transactions.

Why Execution Preconfs Are Harder

Several factors make execution preconfirmations significantly more difficult to implement and operate than their inclusion-only counterparts.

State Simulation Overhead

The proposer must maintain a full execution environment capable of simulating transactions against the latest state. This is functionally equivalent to running a block builder: the proposer needs access to the full state trie, an EVM execution engine, and enough compute to process transactions within the tight latency window that preconfirmations demand (typically under 250 milliseconds).

This hardware and infrastructure requirement far exceeds what an inclusion preconfer needs, where basic signature verification and nonce checking suffice. The gap creates a natural barrier to entry that favors well-resourced operators.

Ordering Commitment

An execution preconf implicitly commits to transaction ordering. If a proposer preconfirms transaction A with a specific state result at position 42 in the block, inserting another transaction before position 42 could invalidate A's committed state. This means the proposer must either commit to the full block order upfront or refuse to accept new preconfs that would conflict with existing ones.

The ordering constraint also interacts with the proposer-builder separation pipeline. If a builder constructs the block, the proposer must ensure the builder honors all execution preconf commitments, including their exact positions. This requires tighter integration between proposer and builder than inclusion preconfs demand.

Conflict Resolution

Two preconf requests that touch the same state (for example, two swaps against the same liquidity pool) cannot both be preconfirmed independently. The second request's outcome depends on whether the first executes before it. The proposer must serialize these requests and either reject the second or simulate it against the post-state of the first.

In high-demand scenarios like popular trading pairs or token launches, this serialization creates contention. Many users request execution preconfs simultaneously, but only a few can be granted because the state changes are mutually dependent.

L1 vs. L2 Execution Preconfs

Execution preconfirmations are significantly easier to offer on L2 networks than on Ethereum L1. The fundamental reason is control over transaction ordering.

On Ethereum L1, the proposer does not necessarily control the final block contents. Under PBS, builders assemble the block, and the proposer selects the highest-bid block header without seeing its contents. This makes it extremely difficult for the proposer to guarantee a specific execution outcome, since they cannot control what other transactions appear in the block or in what order.

On an L2 network, the sequencer (or preconfer in a based rollup) has full authority over transaction ordering. This means they can simulate the transaction, commit to its execution result, and guarantee that no conflicting transactions will be inserted before it. This is why early execution preconf deployments focus on L2 environments, where the preconfer has the ordering control necessary to deliver on execution guarantees.

For a deeper comparison of rollup and state channel approaches to scaling, see the rollup vs. state channel scaling tradeoffs research article.

Risks and Considerations

Centralization of Preconfers

The computational requirements for execution preconfs (full state simulation, low-latency response, sequential processing) favor large, professional operators. If execution preconf tips become a significant revenue source, validators who cannot afford the infrastructure may be economically disadvantaged, concentrating the network among fewer operators. This directly undermines the decentralization that based rollups and preconfirmations are designed to preserve.

Collateral Sizing

Execution preconfs expose proposers to larger potential losses than inclusion preconfs. If a proposer commits to a state result and fails to deliver, the economic damage to the user could be substantial (a missed arbitrage opportunity worth thousands of dollars, for example). The slashable collateral must be large enough to cover these potential losses, but setting the collateral too high excludes smaller validators from participating. Research suggests that 1 ETH of collateral covers approximately 99% of preconfirmation values under current network conditions, with insurance pools proposed for the remainder.

Revenue Impact on Proposers

Issuing execution preconfs can reduce a proposer's MEV revenue. By committing to a specific execution outcome (such as a swap at a particular price), the proposer may foreclose their own arbitrage opportunities against that transaction. Research indicates that splitting a slot into sub-slot preconf auctions can reduce expected proposer revenue by 50 to 74% compared to a standard MEV-Boost auction. Preconf tips must compensate for this reduction, or validators will not opt in.

State Conflict Denial of Service

An attacker could flood a proposer with execution preconf requests that all touch the same state, forcing the proposer to simulate each one sequentially. Even if most requests are rejected (because they conflict with earlier preconfs), the simulation cost is borne by the proposer. Rate limiting and minimum tip requirements are the primary mitigations, but they reduce accessibility for legitimate users.

Rollup Finality Interaction

An execution preconf provides early assurance, but it does not substitute for rollup finality or deterministic finality. The preconf is only as strong as the proposer's collateral and willingness to honor it. Until the transaction is included in a finalized L1 block, there remains a window (however small) where the guarantee is economic rather than cryptographic. Applications that require absolute settlement finality must still wait for on-chain confirmation.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.