November 17, 2026

Native Rollups and Shared Sequencing Networks

Sagar Prasad
Portfolio Manager
Copper hexagon-grid header with line-art icons of stacked layers, a shared sequencer node, and a gear
In This Article
Share
Questions? Speak to our Team

EIP-8079, which describes the EXECUTE precompile that native rollups depend on, remains a draft with major sections marked TBD, and L2BEAT's tracker is explicit that native rollup work is not part of any scheduled hard fork. Based sequencing is live with evolving preconfirmation stacks. Conventional rollups remain the mature production default. Any brief on this subject has to start there, because the architecture being discussed is research and the question it raises for a deployed system is already live.

Verification Moves Into the L1

The proposal is narrow and its consequences are not. A conventional rollup proves its state transitions to an L1 contract that reimplements EVM semantics in a fraud-proof or validity-proof system, which is thousands of lines of custom code plus a centralized fallback for when that code is wrong. A native rollup instead calls an EXECUTE precompile and has the L1's own execution engine verify the transition directly.

So the verifier stops being a contract the rollup team wrote and audited, and becomes the L1 client software everyone already runs. The rollup automatically tracks L1 changes rather than porting them, which removes a large category of divergence bugs and, with them, a large category of governance.

What the rollup keeps is worth listing precisely, because the word native invites overreach. Sequencing, fee policy, gas token, chain governance and cross-chain messaging all remain the rollup's own. Only the execution rule is shared. A native rollup is a chain that has outsourced one specific function to L1 consensus and retained everything else.

The Examiner's Question Is Change Control

Here is what a banking examiner asks about a deployed system, and it is not about decentralization. Who can change the rules this system runs under, how will you learn about it, and can you decline?

On a conventional rollup those questions have uncomfortable but answerable answers. The verifier is governed by an identifiable party, usually a security council with a timelock, which is a genuine centralization weakness and simultaneously an excellent change-control posture. There is someone with a name, a published upgrade process, a delay before it takes effect, and an address to send an objection to. A firm can diary the timelock and test against the pending version.

On a native rollup the answer changes shape. Execution semantics are whatever the L1 says they are, so they change when the L1 changes, automatically, with no rollup-level timelock, no notice and no ability to decline. Inheriting upgrades automatically is the headline benefit, and it is the same sentence as losing the notice period: the architecture that removes the multisig also removes the party who would have told you. That is a trade rather than a flaw, and one a technical owner should make explicitly, because a conventional rollup gives you a governed counterparty you may not trust while a native rollup gives you no counterparty and no warning.

Shared Sequencing Adds a Third Process

Shared sequencing does two separable things: proposer assignment, meaning who gets to propose the next block across a set of chains, and a finality gadget, meaning a shared economically secured confirmation layer. Espresso's HotShot is the worked example, providing Byzantine fault tolerant confirmation within seconds for integrated rollups.

Note what that implies for the question above. A firm on a native rollup using a shared sequencer now depends on three independently governed upgrade processes: the L1's hard-fork process for execution semantics, the rollup's own governance for fee and messaging policy, and the sequencing network's consensus and operator set for ordering. None of the three publishes a coordinated change calendar, and none is obliged to consider the other two.

Value flows along the same three seams. Sequencing revenue and ordering value accrue to whoever holds proposer rights, which is the sequencing network's operators rather than the rollup team under this model. The rollup earns on fee policy it still controls. The L1 earns on data and verification. A rollup adopting both designs has given away the two revenue lines that were historically its own and kept the one that is easiest to compete away.

Adoption Metrics That Mean Something

Throughput and total value locked say nothing useful here, because neither design claims to change either. Three measures do.

The first is whether a chain's state transitions are checked by a custom verifier contract or by a precompile call, which is a binary fact readable from the deployment and the only honest native-rollup adoption number that exists today. On that measure adoption is zero, and will stay zero until a hard fork names the precompile.

The second is shared sequencer integration count, meaning how many distinct chains draw ordering from one network, since the cross-chain properties being sold scale with that number and with nothing else. The third is whether a chain publishes an upgrade calendar at all. A chain that cannot tell a firm when its execution rules next change is not ready to hold that firm's positions, whichever architecture it runs.

Failure Modes, and What Is Improving

The distinctive failure mode is not an outage. It is a semantics change the firm did not model: an L1 upgrade alters execution behavior, the native rollup inherits it in the same block as the L1, and a deployed contract that depended on the prior behavior now does something else. The mitigation is unglamorous and entirely available today, which is to track L1 hard-fork specifications as a production dependency with the same discipline applied to a vendor release, and to maintain a test suite that runs against devnets of the next fork rather than the current one.

A second mode is the composability claim running ahead of the plumbing. Native rollups can verify each other's state using the same precompile without additional trust assumptions, which is a genuinely strong property for read-only cross-rollup reads. It is also unbuilt, and a design that depends on two chains both being native is a design that depends on an unscheduled hard fork.

What is improving is the honesty of the status reporting, which matters more than it sounds. A draft EIP with sections openly marked TBD, a public tracker stating the work is not in a scheduled fork, and a clear distinction between what is live and what is research together let a technical owner make a dated decision rather than a directional one. The instruction follows: evaluate based sequencing now against a latency and neutrality requirement, write the change-control policy for native rollups before adopting rather than after, and treat any roadmap item requiring a hard fork as unscheduled until a fork names it.

For informational purposes only. Not an offer to buy or sell any security. Available only to accredited investors who meet regulatory requirements.

‍

Recommended blog posts