Bundle Propagation

After a block builder constructs a bundle, it must be broadcast to the network's validators. This is done via a specialized P2P network (e.g., the builder's own relay network or a public mempool). Efficient propagation minimizes latency, increasing the bundle's chance of being included in the next block. Key mechanisms include:

• Gossip protocols for rapid, decentralized dissemination.
• Direct connections to trusted validator nodes for priority submission.
• Redundancy to ensure delivery even if some network paths fail.

Propagation involves cryptographic commitments to ensure fairness and execution. The builder submits a header with a commitment to the bundle's hash and fee. The proposer (validator) signs a commitment to include that header if it's the most profitable. Only after these commitments are exchanged is the full bundle content revealed and executed. This commit-reveal scheme prevents front-running and ensures the builder's transaction order is preserved.

Propagation can fail, leading to bundle non-inclusion. Common causes:

• Network Latency: The bundle arrives after the validator's cutoff time.
• Relay Downtime: The chosen relay is offline or slow.
• Censorship: A relay or validator may censor specific transactions or addresses. To mitigate this, builders often use multiple propagation paths (e.g., submitting to several relays simultaneously) to maximize redundancy and resist censorship.

Searchers (who find profitable MEV opportunities) rely on builders for propagation. They send their transaction bundles to builders via private RPC endpoints or public channels. The builder then aggregates, simulates, and propagates the final bundle. This relationship is governed by:

• Submission APIs (e.g., eth_sendBundle).
• Simulation checks to ensure bundle validity and profitability.
• Payment flows where searchers include tips for both the builder and the validator.

Propagation mechanics differ across ecosystems. On Ethereum, it's heavily reliant on the proposer-builder separation (PBS) model and relays. On Solana, bundles are called "packets" and are propagated directly to leaders via the Gulf Stream protocol. For Layer 2s (Rollups), bundles are often propagated to the sequencer, which is responsible for ordering and posting data to L1. Understanding the target chain's architecture is essential for effective propagation.

A user submitting a transaction to a searcher or builder must trust that entity to faithfully propagate the bundle. This creates a trusted third-party dependency outside the core protocol. Malicious actors could:

• Censor the transaction.
• Front-run or sandwich the user's trade.
• Withhold the bundle to exploit private information.

Bundles are often propagated via peer-to-peer (P2P) networks separate from the standard transaction mempool. This introduces risks:

• Eclipse Attacks: A malicious node could isolate a builder to manipulate bundle visibility.
• Propagation Delays: Slow or incomplete propagation can lead to bundles arriving too late, causing failed transactions and lost fees.
• Network Partitioning: Faulty or malicious gossip can prevent bundles from reaching critical validators.

The economic efficiency of bundle propagation favors large, well-connected block builders. This can lead to:

• Centralization Pressure: A small set of dominant builders control bundle inclusion.
• Protocol-Level Censorship: Builders could systematically exclude transactions from certain addresses or protocols (e.g., OFAC-sanctioned addresses).
• MEV Extraction Monopolies: Concentrated control over bundle ordering maximizes extractable value for the builder, not the user.

A critical security risk is data withholding, where a builder creates a block containing a bundle but only reveals it after the block is proposed. This can be used for:

• Time-Bandit Attacks: Attempting to reorg the chain based on newly revealed information.
• Adversarial MEV: Extracting value in ways that are impossible if the bundle were public. Solutions like commit-reveal schemes and encrypted mempools aim to mitigate this.

The entity that constructs and signs the bundle (bundler) becomes a single point of failure for the entire operation. Compromise of the bundler's private key allows an attacker to:

• Steal all assets within the bundle's smart contracts.
• Rug pull users by submitting malicious transactions.
• Damage reputation of the associated application or service.

Unlike a single transaction, a bundle's atomic execution is only guaranteed if all constituent transactions succeed. This creates complex failure states:

• Partial Failure: One failed transaction can revert the entire bundle, wasting gas on prior successful ones.
• State Contention: Bundles are vulnerable to nonce conflicts and state changes from other blocks during propagation.
• Simulation Accuracy: Users rely on the bundler's pre-execution simulation, which may not perfectly match live chain state.

A mempool (memory pool) is a node's temporary storage for pending, unconfirmed transactions broadcast to the network. It is the source from which searchers and builders select transactions to include in bundles and blocks. Key characteristics include:

• Dynamic State: Transactions are added upon broadcast and removed upon block inclusion.
• Local View: Each node maintains its own mempool, leading to slight variations across the network.
• Priority: Transactions are often ordered by fee rate, influencing bundle construction strategies.

A block builder is a specialized network participant responsible for constructing a full block candidate. They receive bundles from searchers, aggregate them with other transactions, and optimize the block's content for maximum value (e.g., MEV extraction). Builders then submit their proposed block to validators or proposers for inclusion in the blockchain. This role is central to proposer-builder separation (PBS) architectures.

A searcher is an entity (often a bot or automated system) that scans the mempool and blockchain state to identify profitable opportunities, such as arbitrage or liquidations. They create bundles containing the transactions necessary to capture this value and submit them to block builders or relay networks. Searchers compete based on the sophistication of their algorithms and the speed of their bundle propagation.

A relay network is a trusted intermediary that facilitates communication between searchers and block builders. It receives bundles, validates them, and forwards the most profitable ones to builders. Relays provide critical infrastructure for fair and efficient bundle propagation by:

• Guaranteeing Privacy: Preventing frontrunning by hiding bundle content until a block is built.
• Ensuring Delivery: Providing a reliable channel for bundle submission.
• Enabling PBS: Acting as a neutral party in proposer-builder separation.

Maximum Extractable Value (MEV) is the total value that can be extracted from block production beyond standard block rewards and gas fees, by including, excluding, or reordering transactions. Bundle propagation is the primary mechanism for capturing MEV. Searchers create bundles to execute strategies like:

• Arbitrage: Exploiting price differences across DEXs.
• Liquidations: Triggering and capturing liquidation penalties in lending protocols.
• Sandwich Attacks: Profiting from predictable trades.

Transaction ordering refers to the sequence in which transactions are executed within a block. It is a critical and contested resource because it determines the outcome of dependent transactions and the distribution of MEV. Bundles are atomic units that enforce a specific, non-interleavable order for a set of transactions. The competition to influence ordering drives the need for fast, private bundle propagation to builders and relays.