Glossary

Inclusion Preconfirmation

An inclusion preconfirmation is a cryptographic commitment from a block proposer guaranteeing a transaction will appear in their upcoming block.

Key Takeaways

  • An inclusion preconfirmation is a signed promise from a block proposer that a transaction will appear in their upcoming block, giving users near-instant assurance before the block is finalized on-chain. It is the simpler of two preconfirmation types.
  • Unlike an execution preconfirmation, an inclusion preconf makes no guarantee about the transaction's outcome: the transaction is promised a spot in the block but could still revert during execution. This makes inclusion preconfs cheaper to issue and easier to scale.
  • Proposers back their commitments with slashable collateral deposited into a registry contract. If the promised transaction does not appear in the block, the proposer's stake is forfeited, making broken promises economically costly.

What Is an Inclusion Preconfirmation?

An inclusion preconfirmation (inclusion preconf) is a cryptographically signed commitment from an upcoming block proposer guaranteeing that a specific transaction will appear in the block they produce. The user receives this signed message within roughly 100 to 250 milliseconds of submitting their transaction, well before the block itself is published to the network.

The concept sits within the broader family of preconfirmations, which come in two flavors. Inclusion preconfs promise only that the transaction will be present in the block. Execution preconfs go further by also committing to the transaction's post-execution state (the exact output, storage changes, or return values). Because inclusion preconfs skip state simulation entirely, they require far less computational overhead and can be issued in bulk without the proposer needing to process transactions sequentially.

The distinction matters for practical reasons. A simple ETH transfer or rollup batch posting does not depend on the state of other transactions in the same block: it either succeeds or fails based on the sender's balance and nonce. For these cases, an inclusion guarantee is sufficient. State-dependent operations like DEX swaps, where the execution price changes based on transaction ordering, need the stronger execution preconf.

How It Works

The lifecycle of an inclusion preconfirmation involves four participants: the user, the preconf gateway, the proposer (preconfer), and the enforcement contract.

  1. The proposer registers by depositing slashable collateral into a registry smart contract (such as the Universal Registry Contract) and signals willingness to issue preconfirmations
  2. The protocol's proposer schedule determines which validator will produce the next block: only that validator has authority to issue a credible inclusion preconf for their upcoming slot
  3. A user submits a preconf request containing their signed transaction, a tip (preconf fee), and the target slot number
  4. The proposer validates the request with lightweight checks: valid signature, sufficient sender balance, correct nonce, and acceptable fee
  5. If the checks pass, the proposer signs a commitment message binding their validator key to the transaction hash and target slot, then returns this signed preconf to the user
  6. When the proposer's slot arrives, they include all preconfirmed transactions in the block they propose
  7. If the proposer publishes a block that omits a preconfirmed transaction, anyone can submit a fraud proof to the registry contract, triggering slashing of the proposer's collateral

Validation Requirements

The validation a proposer performs before issuing an inclusion preconf is intentionally minimal. Because no state outcome is promised, the proposer only needs to verify:

  • The transaction signature is valid
  • The sender's account balance can cover the gas cost
  • The nonce is correct (no gaps in the sender's transaction sequence)
  • The transaction fits within the block's remaining gas limit
  • The preconf tip meets the proposer's minimum threshold

This simplicity is a core advantage. A proposer can issue hundreds of inclusion preconfs per slot without maintaining a simulation environment or worrying about state conflicts between preconfirmed transactions. Execution preconfs, by contrast, must be processed one at a time because each transaction can change the state that subsequent transactions depend on.

The Signed Commitment

The preconf message itself is a structured data object signed with the proposer's validator key. A simplified representation:

{
  "slot": 9847201,
  "txHash": "0xabc123...def456",
  "proposerPubkey": "0x9182...fa03",
  "chainId": 1,
  "tip": "50000000000000",
  "signature": "0xsig..."
}

This signature is the user's receipt. If the transaction does not appear in block 9847201, the user (or any observer) can present the signed commitment and the published block as a fraud proof to the slashing contract.

Inclusion vs. Execution Preconfirmations

The two preconf types serve different needs and impose different requirements on the proposer:

PropertyInclusion PreconfExecution Preconf
GuaranteeTransaction appears in the blockTransaction appears and produces a specific state result
Revert riskTransaction may revertProposer is slashed if the promised outcome does not hold
Proposer burdenLightweight validity checks onlyFull state simulation required
ParallelismMany preconfs can be issued concurrentlyMust be processed sequentially to avoid state conflicts
Typical useTransfers, rollup batch postings, simple contract callsDEX swaps, arbitrage, state-dependent DeFi operations

In practice, most early preconfirmation deployments focus on inclusion preconfs because they are simpler to implement, easier to price, and less risky for proposers. Execution preconfs require the proposer to build or simulate the full block in advance, which introduces complexity comparable to running a block builder.

Role in Based Rollups

Inclusion preconfirmations are especially important for based rollups: layer-2 networks that rely on Ethereum L1 validators for transaction sequencing instead of running a centralized sequencer. Based rollups inherit Ethereum's censorship resistance and security, but they also inherit its 12-second slot time.

Without preconfs, a based rollup user submits a transaction and waits up to 12 seconds for the next L1 slot. With inclusion preconfs, the upcoming L1 proposer signs a commitment within milliseconds, giving the user (and the rollup's application layer) immediate confidence that the transaction will land. This closes the speed gap with centralized sequencers while preserving decentralization.

Taiko, the first based rollup to deploy preconfirmations on Ethereum mainnet, demonstrated roughly 2-second transaction latency in its initial August 2025 rollout, with targets of sub-1-second latency in subsequent phases.

Interaction with Proposer-Builder Separation

Most Ethereum blocks today are constructed under proposer-builder separation (PBS), where specialized builders assemble blocks and proposers simply attest. This creates a challenge: the proposer signs an inclusion preconf, but a builder assembles the actual block contents.

Several mechanisms address this tension. Inclusion lists (EIP-7547) let proposers mandate that specific transactions must appear in the block. The Constraints API extends the builder auction so proposers can express preconf obligations as block-building constraints. Sidecars like Chainbound's Bolt and Commit-Boost let validators participate in preconf protocols without disrupting the existing MEV-Boost auction. For more on how PBS and MEV interact with validator economics, see the Ethereum MEV, PBS, and validator economics research article.

Use Cases

Rollup Transaction Speed

The primary use case is accelerating based rollup transactions. Users of rollups like Taiko receive sub-second soft confirmation instead of waiting a full L1 slot, making the experience comparable to centralized rollup sequencers.

Cross-Chain Bridge Acceleration

Bridge relayers can treat a signed inclusion preconf as early evidence that a source-chain deposit will land. Rather than waiting for full finality on the source chain, the relayer can begin releasing funds on the destination chain as soon as the preconf is received, cutting bridge latency from minutes to seconds.

Batch Posting Guarantees

Rollup sequencers that post batches to L1 can request inclusion preconfs for their batch transactions. This gives the sequencer early certainty that the batch will be included, allowing it to advance its local state without waiting for L1 confirmation.

MEV Supply Chain Coordination

Searchers in the MEV supply chain can request inclusion preconfs to reduce uncertainty about whether their bundles will make it into the next block. This is particularly valuable for time-sensitive arbitrage where missing a single block renders the opportunity worthless.

Risks and Considerations

No Execution Guarantee

The fundamental limitation of an inclusion preconf is that the transaction may still revert. A user who receives an inclusion preconf for a swap has assurance the transaction will be in the block, but the swap could fail due to slippage, insufficient liquidity, or state changes from earlier transactions in the same block. Applications that need outcome certainty must use execution preconfirmations instead.

Collateral and Slashing Risk

Proposers must lock collateral that can be slashed if they fail to honor a commitment. This creates risk for validators: a missed slot due to network issues, client bugs, or connectivity problems triggers slashing even if the failure was unintentional. Most current slashing designs assume all deposited collateral is available for forfeiture, which can make the penalty disproportionate to the tip earned.

Proposer Centralization

Running preconf infrastructure requires maintaining low-latency API endpoints, monitoring incoming requests, and managing collateral. These operational demands favor large, professional node operators over solo stakers. If preconf tips become a significant revenue source, validators who cannot offer preconfs may become economically disadvantaged, potentially concentrating the validator set among fewer operators.

Lookahead Dependency

Inclusion preconfs require knowing which proposer controls the next slot. Ethereum's proposer schedule is determined per epoch (roughly 6.4 minutes), which provides a lookahead window. EIP-7917 (Deterministic Proposer Lookahead) aims to make this schedule fully predictable, but until it is finalized, edge cases around reorgs and missed slots can invalidate preconfs issued during schedule transitions.

Not Yet Enshrined in Protocol

Inclusion preconfirmations are currently enforced via smart contracts and economic incentives rather than consensus rules. A proposer who violates a preconf loses collateral but does not produce an invalid block. Future Ethereum upgrades may enshrine preconf enforcement at the protocol level, but no such proposal has been finalized. Until then, the guarantee is economic, not cryptographic at the consensus layer.

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.