What Happens If a Rollup Sequencer Lies?
A Rollup can process many transactions without putting every transaction directly on Ethereum.
But there is a problem.
Someone still has to decide the order of those transactions and process them.
That person, or more precisely, that system component, is called a sequencer.
So here is a simple question:
What happens if the sequencer lies?
Can it change your transaction?
Can it steal your money?
Can it create a false result and make Ethereum accept it?
To answer these questions, we first need to understand what a Rollup and a sequencer actually do.
What Is a Rollup?
Ethereum can be expensive and slow when many people use it at the same time.
A Rollup tries to solve this problem.
Instead of processing every transaction directly on the Ethereum mainnet, a Rollup processes many transactions outside the main chain.
It then posts important information back to Ethereum.
The basic idea is simple:
Do more work outside Ethereum, while still using Ethereum as an important part of the security model.
But this creates another question.
If the transactions are being processed somewhere else, who is doing the work?
What Is a Sequencer?
This is where the sequencer comes in.
A sequencer receives transactions from users and determines their order.
For example, imagine three people send transactions:
- Alice sends 1 ETH to Bob.
- Bob sends 1 ETH to Carol.
- David sends 2 ETH to Emma.
The sequencer can put these transactions into a specific order and help produce the next state of the Rollup.
So the sequencer has an important position in the system.
It sees transactions.
It orders them.
It helps produce the next state of the Rollup.
And this creates an obvious concern:
What if the sequencer is dishonest?
What Does It Mean for a Sequencer to Lie?
“Lie” can mean several different things.
For example, a sequencer might:
- try to submit an invalid state transition,
- put transactions in an unfair order,
- refuse to include a transaction,
- delay transactions,
- or attempt to manipulate the transaction flow.
These are not all the same problem.
And this distinction is important.
We often hear that a sequencer can “lie.”
But what kind of lie are we talking about?
That is a much better question.
Can a Sequencer Simply Change the Result?
Suppose you have 10 ETH.
You send 5 ETH to Alice.
The sequencer decides to say:
“Actually, you sent 10 ETH.”
Can it simply change the transaction?
Not necessarily.
A Rollup is not supposed to accept every statement made by the sequencer as automatically valid.
The protocol has mechanisms for determining whether a proposed state follows the rules of the Rollup.
This means there is an important difference between:
A sequencer saying something is true
and
the system accepting that statement as true.
Those are not the same thing.
And this distinction is at the heart of Rollup security.
Then What Can a Sequencer Actually Do?
A sequencer may still have meaningful power.
For example, it may be able to decide which transactions are processed first.
This can matter.
Imagine two people are trying to buy the same NFT.
Alice submits her transaction first.
But the sequencer puts Bob's transaction before Alice's.
The final outcome may change.
The sequencer may also delay or refuse to process a transaction.
This means that even if a sequencer cannot simply create an invalid state and make Ethereum accept it, it may still have important control over transaction ordering, inclusion, and timing.
These issues can be important even when the underlying state transition rules are working correctly.
So we get a more precise picture.
The sequencer may not have unlimited power.
But it does not mean that the sequencer has no power.
Can a Sequencer Steal Your Funds?
This is one of the most important questions.
In a properly designed Rollup, a sequencer should not be able to simply change a valid transaction into an arbitrary transaction and have the resulting invalid state accepted by the protocol.
However, that does not mean the sequencer has no ability to affect users.
Transaction ordering, censorship, delays, and other forms of transaction manipulation can still create problems.
So the answer depends on what “steal” means.
A sequencer's ability to control transaction ordering is very different from having unrestricted control over users' balances.
This is why it is important to separate state validity from transaction ordering and inclusion.
Who Catches the Lie?
This is where things become interesting.
If a sequencer proposes an invalid result, another part of the Rollup system needs to detect or prevent it.
Exactly how this works depends on the Rollup's design.
Some systems use fraud-proof or fault-proof mechanisms.
Others use validity proofs.
The details are different, but the basic idea is similar:
The sequencer's proposed result is not supposed to have unlimited authority simply because the sequencer produced it.
Ethereum and the Rollup's verification mechanism can enforce the rules that determine whether a proposed result is acceptable.
But how does this verification actually work?
That is where Optimistic Rollups and ZK Rollups become important.
내부링크: How Does a Rollup Prove That It Is Correct?
Does That Mean We Don't Need to Trust the Sequencer?
At first, the answer seems obvious.
If the protocol can reject an invalid result, perhaps we do not need to trust the sequencer.
But this is where the question becomes more interesting.
The sequencer may not be able to make an invalid state valid.
But it can still control ordering, inclusion, and timing in ways that matter.
So saying:
“We don't need to trust the sequencer.”
may be too simple.
A better question is:
What exactly do we need to trust the sequencer to do?
And perhaps even more importantly:
What happens when we don't trust it?
What Does a Rollup Actually Change?
This is one of the reasons Rollups are interesting.
They do not necessarily make trust disappear.
Instead, they can change where trust is placed and how it is enforced.
We may not need to trust a sequencer to tell the truth about everything.
Instead, the protocol can limit what the sequencer is able to get away with when it behaves incorrectly.
That is a very different idea from simply removing trust.
The Real Question
So, what happens if a Rollup sequencer lies?
The answer is not simply:
“Nothing.”
And it is not:
“The sequencer can steal everything.”
The more useful answer is:
It depends on what the sequencer is trying to lie about.
Some invalid state transitions can be detected or rejected by the Rollup's verification system.
Other forms of control, such as transaction ordering, censorship, and delays, can still create problems.
That distinction matters.
Because when we ask whether a blockchain system is “trustless,” we should probably ask a more precise question:
Which parts of the system do we trust, and which parts are forced to follow rules even when we do not trust them?
That may be a better way to think about Rollups.
And it leads to the next question:
How does a Rollup actually prove that its result is correct?
