Force inclusion is a protocol-level mechanism, most notably implemented in Ethereum via EIP-1559, that allows a transaction to be included in a block even if its attached fee is below the current prevailing market rate. Its primary purpose is to guarantee censorship resistance by preventing block producers from indefinitely ignoring valid transactions for economic or political reasons. A user can invoke this mechanism by submitting a transaction with a maxPriorityFee and maxFeePerGas of zero, signaling to the network that it must be included in a future block, typically within a predefined maximum delay.
Force Inclusion
What is Force Inclusion?
A protocol-level mechanism that allows a transaction to be included in a block even if its fee is below the current market rate, ensuring censorship resistance.
The mechanism operates by leveraging the concept of a base fee. Under EIP-1559, each block has a dynamically calculated base fee that is burned. Transactions must pay at least this base fee. Force inclusion transactions pay only this mandatory base fee, offering no priority fee (tip) to the block producer. Validators are protocol-bound to include these transactions when the block's gas target is not full, ensuring the network's promise of credible neutrality. This creates a base fee auction for block space, where regular transactions compete with tips, while force inclusion transactions rely on protocol guarantees.
A critical technical requirement for force inclusion is that the transaction must be mempool-eligible and submitted from an Externally Owned Account (EOA). It cannot be a contract creation transaction. Furthermore, the mechanism includes a maximum wait time; on Ethereum, this is defined as 25 * MAX_BLOCK_GAS / GAS_LIMIT_PER_TX blocks, which translates to roughly 100 blocks or ~20 minutes under normal conditions. This prevents the mechanism from being abused to spam the network with zero-fee transactions indefinitely, as they are processed in a first-in-first-out queue within the constraint of the block gas limit.
The primary use case for force inclusion is censorship-resistant transactions, such as voting in decentralized governance, submitting fraud proofs in optimistic rollups, or executing critical smart contract functions during network stress. For example, in a Layer 2 rollup, a user can force-include a transaction to withdraw assets if the sequencer is maliciously censoring their requests. This makes force inclusion a foundational component for trust-minimized systems, ensuring that users always have a guaranteed, albeit slower, exit path that does not rely on the goodwill of block producers.
It is important to distinguish force inclusion from related concepts like fee bumping (RBF) or private transaction pools. While RBF allows a user to replace a pending transaction with a higher-fee one, force inclusion mandates inclusion at the base fee. Private pools allow transactions to bypass the public mempool but do not provide protocol-level inclusion guarantees. Force inclusion is thus a stronger, cryptoeconomic guarantee embedded in the consensus rules, making it a vital tool for maintaining the liveness and neutrality of decentralized networks.
How Force Inclusion Works
Force Inclusion is a critical mechanism in blockchain transaction processing that ensures censorship resistance by guaranteeing a transaction's inclusion in a block after a set time.
Force Inclusion is a protocol-level guarantee that a valid transaction submitted to a sequencer or mempool will be included in a block within a specified time window, typically enforced by a challenge period or direct on-chain proof. This mechanism is a foundational component of censorship resistance, preventing centralized operators from indefinitely delaying or censoring user transactions. In systems like optimistic rollups, users can submit a transaction directly to the Layer 1 (L1) chain if the rollup's sequencer fails to include it, forcing its processing and ensuring the network's liveness guarantees are upheld.
The process is often triggered by a force inclusion transaction or a direct L1 submission. A user constructs a proof that their transaction is valid and was submitted to the sequencer but not included. They then pay the necessary L1 gas fees to post this transaction and its proof directly to the underlying blockchain's mempool. The L1 network's validators will then process it, effectively bypassing the potentially malicious or faulty sequencer. This acts as a powerful economic and cryptographic disincentive against censorship, as sequencers are compelled to include transactions promptly to avoid losing fee revenue to the more expensive L1.
Key parameters governing force inclusion include the maximum sequencing delay (the time a sequencer can delay a transaction) and the challenge period (the window for users to force inclusion). These are set by the protocol's governance or hardcoded rules. For example, a rollup might specify that any transaction not included within 24 hours can be forced onto L1. This creates a clear, predictable safety net for users and applications, ensuring state finality and operational reliability even if a primary processing layer behaves adversarially.
In practice, force inclusion interacts with other scaling mechanisms. In a validium (a zero-knowledge rollup using off-chain data availability), force inclusion may require proving data availability to the L1, which is more complex. Its implementation requires careful economic design to prevent spam attacks where users might force-include transactions to disrupt sequencing order. Despite this, it remains an essential cryptoeconomic tool, balancing scalability with the decentralized, permissionless ethos of blockchain technology by ensuring no single entity has absolute control over transaction ordering.
Key Features of Force Inclusion
Force Inclusion is a protocol-level mechanism that guarantees transaction processing by forcing a sequencer to include specific transactions in the next batch submitted to the base layer (L1).
Guaranteed Transaction Inclusion
The core function of Force Inclusion is to provide users with a cryptographic guarantee that their transaction will be processed. If a sequencer is unresponsive or censoring, users can submit their transaction directly to the L1 inbox contract. After a predefined challenge period (e.g., 24 hours), the protocol forces the sequencer to include it in the next batch, preventing censorship and ensuring liveness.
Direct L1 Submission Path
Force Inclusion operates via a designated L1 smart contract (often called the Inbox or Delayed Inbox). This contract acts as a canonical, permissionless entry point. Users submit their signed L2 transactions to this contract, where they are queued. This creates an on-chain record that the sequencer is obligated to honor, establishing a verifiable fallback mechanism independent of the sequencer's centralized gateway.
Enforced Sequencer Obligation
The protocol's consensus rules mandate that the sequencer must process transactions from the L1 queue in the order they were submitted, after the delay period expires. Failure to do so would result in the sequencer producing an invalid state root, causing the network to reject its batch. This makes Force Inclusion a cryptoeconomic security feature, aligning the sequencer's incentives with protocol rules.
Fixed Delay Period
A critical parameter of Force Inclusion is the delay window (or challenge period). This is the mandatory waiting time between a transaction being posted to L1 and when the sequencer must include it. This delay:
- Allows the sequencer time to include the transaction voluntarily via its fast lane.
- Provides a safety buffer for system synchronization.
- Represents a trade-off between censorship resistance and optimal user experience for non-censored transactions.
Censorship Resistance
Force Inclusion is the primary technical mechanism ensuring permissionless access and anti-censorship in optimistic rollups and validiums. It prevents a malicious or malfunctioning sequencer from selectively excluding transactions based on their content, sender, or destination. This property is essential for maintaining the decentralized and neutral value proposition of the underlying blockchain.
Economic Cost & UX Trade-off
Using Force Inclusion has practical implications:
- Higher Cost: Submitting to L1 requires paying L1 gas fees, which are significantly more expensive than standard L2 fees.
- Slower Finality: Transactions are subject to the full delay period, taking hours instead of seconds.
- Self-Enforcement: Users must actively monitor the sequencer and manually trigger the L1 submission if needed. This creates a user-operated safety net rather than a seamless experience.
Security Considerations & Limitations
Force inclusion is a mechanism that allows a transaction to be included in a block even if the current block proposer is censoring it. While it enhances censorship resistance, it introduces unique security trade-offs and operational constraints.
Guaranteed Liveness vs. Economic Security
Force inclusion ensures liveness by guaranteeing transaction processing, but it can bypass the fee market and block builder incentives. This creates a potential attack vector where malicious actors can spam the network with low-fee transactions that must be included, potentially degrading performance or increasing costs for honest users without paying the prevailing market rate.
Relayer Centralization Risk
The mechanism typically relies on a relayer to submit force-inclusion transactions. This creates a centralization point:
- If the relayer is offline or malicious, the guarantee fails.
- Users must trust the relayer not to front-run or censor the force-inclusion requests themselves.
- Relayer infrastructure must be highly available and resistant to DoS attacks.
Temporal Constraints and Delays
Force inclusion is not instantaneous. Transactions are often subject to a delay period (e.g., one or more blocks) before they can be forced. This limitation means:
- It is unsuitable for time-sensitive transactions (e.g., arbitrage, liquidations).
- Attackers have a window to censor transactions before the force-inclusion window opens.
- The security guarantee is probabilistic over time, not absolute.
Resource Exhaustion Attacks
By mandating inclusion, the protocol can be forced to process computationally expensive or data-heavy transactions. An attacker could:
- Fill blocks with complex smart contract executions to slow down the network.
- Exhaust block gas limits with spam, crowding out legitimate transactions.
- This makes careful design of gas metering and block resource limits critical.
Implementation Complexity and Audit Surface
Adding force inclusion logic increases protocol complexity and the attack surface. Key areas requiring rigorous audit include:
- The state transition function for handling forced transactions.
- Mempool logic and transaction ordering rules.
- Interactions with other mechanisms like MEV auction or proposer-builder separation (PBS). Bugs here could compromise chain safety.
Dependence on Underlying Chain Finality
Force inclusion's effectiveness is ultimately bounded by the security of the underlying consensus mechanism. If an attacker gains the ability to reorg the chain (temporarily reverse blocks), they could undo a forced inclusion. Therefore, the strength of the guarantee is only as strong as the finality of the chain it operates on.
Ecosystem Usage & Implementations
Force inclusion is a critical mechanism for transaction censorship resistance, primarily implemented within rollup architectures to ensure user transactions are processed.
L1-L2 Bridge Guarantee
Force inclusion acts as the ultimate guarantee for users bridging assets from a Layer 2 (L2) back to the underlying Layer 1 (L1). If an L2 sequencer is maliciously censoring a user's withdrawal transaction, the user can submit a force inclusion transaction directly to the L1 rollup contract. This bypasses the sequencer, forcing the L2 to process the withdrawal within a predefined time window, ensuring users can always reclaim their funds.
Optimistic Rollup Implementation
In Optimistic Rollups like Arbitrum and Optimism, force inclusion is a foundational safety mechanism. It is invoked by submitting a transaction to a special inbox contract on L1. The system's challenge period or dispute window defines the maximum delay before a force-included transaction must be processed. This design ensures liveness even if the sole sequencer fails or acts maliciously, making censorship economically irrational.
zk-Rollup Variations
zk-Rollups like zkSync Era and StarkNet implement force inclusion with key differences due to their validity-proof architecture. Users submit forced transactions via L1 contracts, but processing only occurs upon the submission of the next validity proof. While this can introduce a delay tied to the proof submission interval, it maintains the system's security by ensuring all forced transactions are verified before finalization on L1.
Economic & Game-Theoretic Role
Force inclusion is designed as a credible threat that shapes sequencer behavior. The economic cost for a sequencer to censor is high, as users can easily trigger the mechanism, costing the sequencer potential revenue and reputation. This game-theoretic design makes proactive censorship economically non-viable, ensuring the rollup's liveness property is maintained in a decentralized manner without constant user intervention.
User-Operated Security Fallback
For end-users, force inclusion is a manual security tool of last resort. The process typically involves:
- Constructing a properly formatted L2 transaction.
- Paying the L1 gas fee to submit it to the rollup's inbox or priority queue contract.
- Waiting for the enforced delay period to expire. Wallets and block explorers are increasingly integrating this functionality to make it accessible, turning a complex protocol feature into a usable safety net.
Contrast with Escalation & Proposer-Builder Separation
Force inclusion is often confused with related concepts. It is distinct from:
- Escalation Games: Used in Optimistic Rollup fraud proofs, a multi-round challenge process for invalid state transitions.
- Proposer-Builder Separation (PBS): An Ethereum consensus-layer design to separate block building from proposing. Force inclusion is specifically a liveness mechanism for transaction ordering, not a safety mechanism for correcting invalid state.
Force Inclusion vs. Other Censorship Solutions
A technical comparison of mechanisms designed to counter transaction censorship on blockchains.
| Feature / Mechanism | Force Inclusion | Proposer-Builder Separation (PBS) | Permissioned Relays |
|---|---|---|---|
Core Principle | Guarantees transaction inclusion via a direct protocol-level rule | Separates block building from proposing to reduce centralization | Relies on trusted, whitelisted relay operators |
Censorship Resistance | |||
Decentralization | High (enforced by consensus) | Medium (depends on builder market) | Low (centralized relay set) |
Protocol Layer | L1 Consensus | L1/L2 Execution | Infrastructure (off-chain) |
Implementation Complexity | High (requires hard fork) | Medium (complex auction design) | Low (off-chain service) |
User Cost Impact | Minimal (standard gas) | Variable (builder fees) | Variable (relay fees) |
Example Implementation | Ethereum EIP-7266 (blob fee mechanism) | Ethereum PBS with MEV-Boost | Flashbots SUAVE (concept) |
Common Misconceptions About Force Inclusion
Force inclusion is a critical but often misunderstood mechanism in Ethereum's transaction ordering. This section clarifies its precise function, limitations, and relationship to other concepts like MEV and censorship resistance.
Force inclusion is a mechanism that allows a transaction to bypass the standard mempool and be included directly in an Ethereum block by submitting it to a block builder via a trusted relay. It works by leveraging the builder's pre-confirmation, where the builder cryptographically commits to including the transaction in the next block they produce, typically for a fee. This process is distinct from regular transaction submission as it involves a direct, prioritized agreement with a specific block-building entity, ensuring execution unless the builder acts maliciously and forfeits their bond or reputation.
Frequently Asked Questions (FAQ)
Force inclusion is a critical mechanism in blockchain transaction processing, particularly within rollup architectures. These questions address its purpose, mechanics, and implications for users and developers.
Force inclusion is a mechanism that allows a transaction to bypass the standard mempool and be guaranteed inclusion in the next block or batch, typically by paying a premium fee. It works by submitting the transaction directly to a privileged component of the network, such as a sequencer in an Optimistic Rollup or a proposer in certain L1 protocols, which is contractually or protocol-bound to include it. This is crucial for time-sensitive operations like withdrawing funds from an L2 during a sequencer outage or executing critical smart contract logic that cannot afford delays. The transaction is often submitted to a special precompile or smart contract function (e.g., the GasPriceOracle contract) that forces it into the subsequent block construction.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.