L2s Go Permissionless: BoLD, Base Proofs, Neutral Sequencing

The year L2s changed their trust model

Two switches flipped in 2025 that fundamentally changed how users withdraw and how builders think about safety on Ethereum rollups.

On February 12, 2025, Arbitrum turned on BoLD. It is a redesigned dispute protocol that brings permissionless validation and bounded resolution to Arbitrum One and Nova. You can confirm timing and guidance in the official docs: BoLD activation details and rollout.
On April 29, 2025, Base announced it had reached Stage 1 decentralization in Vitalik Buterin’s framework. The key step was enabling permissionless fault proofs, so withdrawals no longer rely on a trusted operator to publish outputs. Read the team’s post: Base Stage 1 fault proofs.

Those two milestones did not immediately make every rollup perfect. They did something more practical. They moved withdrawal security and censorship resistance beyond goodwill and toward rules any honest participant can enforce.

Why BoLD and fault proofs are different in kind

Think about a bank vault with two features: a door with a timer and a public alarm. Before 2025, most optimistic rollups had a timer, but only a small, permissioned group held the keys to raise the alarm. If the operators delayed or failed, withdrawals could be stalled or misled. BoLD and permissionless fault proofs hand the alarm to everyone.

BoLD sets a firm upper bound on dispute time, so a withdrawal cannot be delayed indefinitely by stalling tactics. It also introduces a censorship timeout. If a sequencer refuses to include a transaction, the system can be advanced by others.
The OP Stack’s permissionless fault proofs let any participant propose or challenge the state used to prove withdrawals. That breaks the special dependence on a privileged proposer and aligns Base and other OP Stack chains with Stage 1 expectations.

For users, the practical change is simple. You can withdraw without trusting a single operator. For teams, the change is operational. You must assume there will be public challengers, that upgrade windows will interact with challenge periods, and that bridges and apps must handle reproving and reorg-like UX around withdrawals.

Permissionless validation is the floor, not the ceiling

Security parity for withdrawals is important, but the next competition is already underway. It is the race to neutral sequencing and MEV-aware orderflow.

Neutral sequencing means the actors who order transactions do not favor themselves or their partners. MEV, or maximal extractable value, is the set of profits that arise from reordering, inserting, or censoring transactions. If sequencing is centralized, MEV extraction tends to concentrate and policy is whatever the operator says it is. If sequencing is decentralized, with verifiable rules, the platform can commit to fairness and predictable behavior.

In 2025, three threads converged:

Shared, decentralized sequencing moved from paper to production, with early adopters like Forma migrating to Astria’s shared sequencer in June. Shared sequencing gives rollups fast preconfirmations, stronger censorship resistance, and a common temporal domain that makes cross-rollup atomic actions practical.
A MEV-aware execution stack began to take shape outside of any single rollup, with projects that aim to provide a privacy-preserving, programmable orderflow layer and a path to decentralized block building across chains. For context on modular stacks landing on Base, see EigenLayer goes multichain on Base.
New data questioned auction designs that privilege speed. A September study of Timeboost on Arbitrum reported that a tiny set of actors captured the vast majority of express lane auctions and that the design did not reduce spam effectively. That is a warning. Race-based ordering can harden into centralized control if left unchecked.

The result is a new frontier. If 2025 was the year withdrawals went permissionless, 2026 is set to be the year sequencing gets shared, auditable, and neutral by default.

What shared and neutral sequencing actually unlocks

Builders often ask for specific benefits beyond principles. Here is what shared, neutral sequencing can deliver in practice when paired with robust data availability and proof systems:

Cross-rollup atomicity. Two transactions on different rollups can be included in the same temporal frame. If one fails, both fail. That makes multi-market strategies, cross-chain swaps, and complex intents safer to execute. For DEX-led designs, compare with Uniswap v4 and Unichain design.
Predictable preconfirmations. A decentralized sequencer set can provide fast, soft confirmations with clear, auditable rules. Apps can display reliable status to users without leaning on opaque operator promises.
Censorship resistance with recourse. If a single operator refuses to include certain transactions, shared sequencers make it hard to sustain that policy. Others can step in. That reduces the business risk of becoming dependent on an unaccountable mempool policy. Teams operating in the U.S. should also align with a U.S. onchain compliance playbook.
MEV policy you can reason about. When ordering rules are verifiable, and when the orderflow pipeline is open to competition, the distribution of MEV becomes a system parameter rather than a backroom deal.

Builders’ brief for Q4 2025 to 2026

You do not need to rebuild your stack from scratch. You should make targeted upgrades in four areas: watchers, bridges, orderflow, and UX.

1) Stand up watchdog validators and challengers

Move from a passive reliance on operators to an active posture.

Arbitrum chains: run a Nitro node configured for BoLD monitoring and challenge participation. Budget a bond to challenge incorrect state roots and set alerting on dispute windows. Assign on-call ownership, the same way you would for exchange wallets.
OP Stack chains like Base: run challenger software that can both propose and dispute outputs. Instrument it with metrics for proposal latency, challenge success, and finalization lag. Store proofs and logs for auditability.
Fund watchdogs sustainably. Use a small, ring-fenced treasury allocation or restaked yields to cover bonds and operational costs. Publish a runbook for incident response. If your app secures user funds, treat watchdogs like critical infrastructure.

Concrete target: by the end of Q1 2026, your team can programmatically detect an incorrect output, submit a challenge within minutes, and track the dispute to resolution with automated alerts.

2) Make bridges safer by design

Bridging logic is where permissionless validation meets user funds. The failure mode is silent loss.

Adopt withdrawal state machines that cover both legacy and post-upgrade paths. Many networks invalidated in-flight proofs during upgrades in 2025. Your code should detect the upgrade epoch and auto-reprove if necessary.
For OP Stack withdrawals, integrate the dispute game contracts. Treat the challenge period as a live state, not a constant. Surface status in-app with plain language, including expected finalization time and any ongoing disputes.
For Arbitrum, account for BoLD’s impact on withdrawal timing. Communicate delays at initiation and provide a recheck function rather than forcing users to poll Etherscan.
Add two invariants to monitoring: L2 to L1 message replay rate and invalidation rate during upgrades. Alert when either deviates from baseline.

Concrete target: by Q2 2026, your bridge handles chain upgrades without manual operator intervention and can resume pending withdrawals automatically with clear user messaging.

3) Prepare for neutral sequencing endpoints

Design your rollup or app to treat sequencing as a pluggable service.

Abstract your mempool connection. Support a neutral endpoint in addition to the default rollup sequencer. This could be a shared sequencer or a MEV-aware orderflow network. Put the routing decision behind a policy flag so you can switch gradually.
Verify ordering rules on the client. When a preconfirmation arrives, check that it conforms to the advertised policy. If a block claims to be fair-ordered or follows an inclusion list, verify the proof or attestation.
Use batch-friendly execution paths. Many neutral designs prefer frequent batch auctions over first-come-first-served. Make sure your contracts and offchain components handle batched fills and consistent pricing across inputs.
Publish an inclusion policy. If your app relies on private orderflow for user protection, define and document the policy scope. If you accept public orderflow, make explicit how users can opt in, how fees are charged, and how protection is enforced.

Concrete target: by mid 2026, your app can route transactions through a shared sequencer or MEV-aware network, verify preconfirmations, and fall back to the default sequencer without user confusion.

4) Upgrade UX to intents, not clicks

As ordering and proving get more complex, the path to a good user experience is intent-based design.

Move from single raw transactions to signed intents with constraints. Let users specify goals like swap X to Y at or better than a quoted rate, fill before a time bound, and do not leak balance deltas across chains. Treat solvers as replaceable modules.
Show verifiable status. Present both the soft preconfirmation and the firm finality checkpoint. Let users drill into disputes when they exist. Make the challenge window a first-class element in your UI.
Respect privacy and fairness by default. If you route to a private enclave or batch auction, say so. If the route is public, give users a one-click protection toggle with clear trade-offs.

Concrete target: by the end of 2026, your primary flows are intent-based, solver-pluggable, and sequencing-agnostic, with clear status and recovery paths.

The research that should shape your roadmap

Not every fairness mechanism ages well. The 2025 Timeboost analysis reported that two entities captured the vast majority of express lane auctions and that many boosted transactions reverted. The lesson is not that auctions are bad, but that speed-based priority can converge to centralization.

Prefer mechanisms with verifiable rules and limited room for latency games:

Frequent batch auctions over micro time races
Inclusion lists or allow-anyone submission windows with forced inclusion after a timeout
Refund and rebate rules that are transparent and provable
Multi-operator committees for ordering, ideally with rotating leadership and attestations

Fold these preferences into your procurement checklists. When a vendor sells a faster lane, ask for decentralization metrics. Who can win and how often. What proof can your team or your users verify on every block.

How to decide: shared sequencer vs rollup-local

A simple decision guide for 2026 planning:

Choose a shared sequencer if you need reliable cross-rollup atomicity, if your app is often censored by centralized mempools, or if you want out-of-the-box preconfirmations with diverse operators.
Stay rollup-local if your app relies on highly specialized ordering, if you require custom auction designs that the shared layer does not support, or if you are still in controlled beta with a narrow user set. In that case, commit to a roadmap that adds an opt-in neutral endpoint and verifiable ordering proofs.

In both cases, make watchdogs and bridges first-class concerns. Neutral sequencing without good challengers is a half-upgrade. Fast preconfirmations without safe reproving is a trap.

What this means for teams by role

Protocol engineers: modularize sequencing, implement ordering proof checks, and ship challenger tooling with budgets and on-call support.
Product managers: set explicit service levels for preconfirmation, finality, and withdrawal clarity. Track them like uptime.
Security and ops: run challengers, fuzz the dispute paths in staging, and simulate upgrade invalidations. Treat bridge incidents as Sev 1.
BD and partnerships: negotiate MEV policy and inclusion rules, not only fee splits. Ask for verifiable attestations and weekly decentralization metrics.

The takeaway

In 2025, rollups crossed a line. Arbitrum’s BoLD made disputes bounded and open. Base and the OP Stack brought fault proofs and Stage 1 to production. The center of gravity now shifts to how transactions are ordered, who benefits from orderflow, and whether users can verify the rules.

Treat permissionless validation as the new floor. Compete on neutral sequencing and MEV-aware UX. Build watchdogs, fix your bridges, route orderflow through verifiable pipes, and let users express intents instead of wrestling with raw transactions. The next winners will be the teams that make fairness a feature and prove it on every block.