Signet's Fair Block Production

Traditional rollups inherit Ethereum’s block auction model, where builders compete with capital and the highest bidder wins. While the goal of these auctions is decentralization, in practice this creates centralization: two builders control over 80% of Ethereum blocks. Signet replaces block auctions with predictable and equitable builder rotation, assigning block production rights in a round robin. Each builder gets their slot to build and the next builder in the set thereafter.

Auction vs Rotation

Auctions favour capital and complex latency games create barriers only the largest players can overcome. These advantages compound into market dominance by a wealthy few. Builder rotation is simpler: your slot comes, you build a block.

Signet’s SignRequest and SignResponse types enable blind signing—the sequencer validates builder identity and timing without seeing block contents. This design choice prevents content-based censorship while maintaining system integrity.

Block Production Mechanics

Each builder operates within a 12-second window synced with Ethereum blocks:

The 8-second timing of each builder slot enables transaction optimization without the need for pre-confirmations or optimistic assumptions. Transactions either execute atomically across both chains in the same block or don’t execute at all. During a builder’s 8-second window to build their block they will:

• Access the private bundle cache
• Request sequencer signatures
• Submit blocks to Ethereum

Outside a builder’s 8-second window: 403 errors. Signet’s design enforces rotation through the signet-tx-cache authentication layer.

Unlike traditional PBS where builders compete by the millisecond, Signet’s Round-Robin approach with an 8-second window eliminates latency games. The 2-second buffers ensure clean handoffs between builders, preventing slot collisions, race conditions, and auction games.

Performance Comparison

1. Collect Transactions

1# Public transactions (always accessible)
2GET https://transactions.pecorino.signet.sh/get
3
4# Private bundles (only during your slot)
5GET https://transactions.pecorino.signet.sh/get-bundles

The bundle cache checks your authentication and current time. Wrong slot = no access. The TxCache client handles these API interactions:

2. Simulate Execution

Simulation validates conditional transactions through SignetBundleDriver. Orders with host_fills require Ethereum actions to execute atomically with Signet transactions.

3. Request Co-Signature

The sequencer signs a builders block hash without seeing transactions. Blind signing prevents content-based censorship while maintaining builder accountability.

4. Submit to Ethereum

The ZenithBlock type handles transaction encoding for blob submission. Blocks with cross-chain operations use multi-call:

1. submitBlock on Zenith contract
2. fillPermit2 on Orders contract

Use private relays for cross-chain bundles.

Blind Signing Architecture

The sequencer co-signs blocks without visibility into the contents of the block’s transactions. Signet’s design creates censorship resistance through protocol enforcement, not social consensus. MagicSig extends this to L1-driven actions.

Signet’s blind signing mechanism is implemented through the SignRequest structure, which only includes the block hash in the contents field. The sequencer’s SignResponse provides the signature without ever processing transaction data. This separation is enforced at the API level.

Why Builder Rotation Works

Auctions optimize for one thing: extraction. The builder who extracts the most value wins. This naturally concentrates the market. Builder rotation optimizes for participation and performance. Every builder gets an equal opportunity to perform their service. Round-robin assignment removes bidding wars, capital barriers, and auction games.

Builder Economics

Traditional PBS requires builders to optimize two competing constraints:

• Transaction selection: Compute-intensive simulation and MEV extraction
• Auction timing: Millisecond-sensitive bid submission

Time spent on simulation reduces auction competitiveness. Auctions force builders to choose between thorough transaction analysis and timely bid submission. Builder rotation changes the focus where builders are enabled by a full 8-second window for compute optimization over diminishing competition.

Execution Flow

PBS: Simulate → Calculate bid → Submit to relays → Hope to win Round-Robin: Wait for slot → Access bundles → Get signature → Submit block

Resource Allocation:

• More compute focus on transaction selection
• No bid calculation overhead
• No timing optimization required
• Standard infrastructure requirements

Predictable Outcomes:

• Revenue: internalized MEV without bidding costs
• Block allocation: 7,200 daily blocks ÷ number of builders
• Primary optimization: Transaction selection quality
• Infrastructure focus: Compute capacity over network latency and capital requirements

This shift enables builders to address their primary constraint—computational efficiency—without sacrificing block inclusion probability.

Bundle Simulation

The signet-bundle SDK provides efficient bundle simulation:

1// Single call validates entire cross-chain bundle
2let result = driver.simulate_bundle(&bundle).await?;
3// Returns: coinbase_diff, gas_used, validity

Compare with PBS simulation requirements:

• PBS: Simulate each transaction individually, calculate competitive bid, optimize for latency
• Round-Robin: Simulate complete bundles, no bid calculation, optimize for selection

Searchers pre-process orders into valid bundles. The OrderDetector enforces cross-chain atomicity within the EVM, eliminating the need for external coordination protocols. Builders receive structured bundles, not raw transaction pools to sort through.

Builder Benefits

This increase in effective compute time, combined with pre-processed order flow, creates more efficient economic outcomes without requiring capital for auctions or infrastructure for significant latency optimization games.

Integration Path

1. Register: Get in touch to become a builder
2. Authenticate: Set up API credentials with TxCache client
3. Test: Use staging environment with test constants
4. Deploy: Join the rotation on testnet

Extensibility

Builders can implement additional services above the protocol layer:

• Preconfirmation mechanisms
• Application-specific guarantees
• Custom ordering preferences

The base protocol provides atomic execution, fair inclusion, and instant settlement. Additional complexity remains optional.

Build with Us

Signet’s builder set is actively growing and proves that fairer block production doesn’t require complex approaches.

SDK Components for Builders:

• signet-bundle: Bundle simulation and construction
• signet-types: Core types including SignRequest/SignResponse
• signet-tx-cache: Transaction cache
• signet-extract: Block extraction and reorg handling

Additional Resources:

• Execution Engine: Order system architecture
• Builder examples: Reference implementations
• Block submission tests: Integration test patterns