A rollup transaction lifecycle involves users submitting transactions to a sequencer, which collects and batches them (every 12 seconds) before publishing to Ethereum L1 with soft finality; rollup nodes then independently verify these batches using derivation logic to reconstruct the L2 chain and achieve hard finality, ensuring transaction irreversibility while maintaining Ethereum's security guarantees.
Rollup Transaction Lifecycle: A Visual Technical Guide
Added:You click send on a rollup, but what actually happens next? Where does your transaction go? Who processes it? And how does it end up on Ethereum? Hey everyone, welcome to this video. I'm Rohan and in this video I'm going to walk you through the complete life cycle of a transaction on a rollup in the simplest way possible. So let's get into it.
Uh this is our illustration here. You can see the Ethereum L1 chain and the rollup L2 chain.
Now in step one user submit transaction to a rollup.
Basically submitting a transaction to a rollup means that user performs certain actions that could be swapping tokens or you know sending ETH or even interacting with the smart contract through a decentralized application.
Now if you don't know what a rollup is, I'll explain it to you briefly. The concept of rollup came into existence to address the scalability constraints in Ethereum L1. By constraints, I mean the Ethereum not being able to have higher transaction throughput, cheaper transaction cost and faster finality. A rollup is a layer 2 scaling solution on top of Ethereum layer 1 chain which processes the transactions offchain. So in that way it scales Ethereum and addresses the constraints of Ethereum scalability. Right now just so you know and have more context on rollup you need to know that the blockchain architecture for instance the Ethereum architecture has three layers. One is the execution layer, the consensus layer and the data availability layer. Now what the rollup does is it outsources the consensus layer and the data availability layer to Ethereum right and it inherits Ethereum security and the ordering and finality while the execution layer here is offchain. So in that way it scales the Ethereum.
Coming back to the point, the transactions are submitted to a actor in rollup called sequencer. The job of sequencer is to collect transactions, order them and publish the transactions to the Ethereum layer 1 chain. As soon as the sequencer receives the transactions, it sends the user with something called a preconfirmation.
Now preconfirmation is nothing but a soft guarantee of execution. So it's the sequence is saying that hey I've received your transactions and this is what will happen. But that doesn't mean that the transactions are finalized yet.
So they send a preconfirmation to the user. For instance, you can consider this to an example of you going to a restaurant. You order something and the waiter says that hey your order is received and the food is being prepared.
We will deliver it to you after it's done. So the kitchen in this sense is the Ethereum layer one. Right? So that's the step two. Now after sending the preconfirmation of the transactions to the user, the sequencer forms a transaction batch here. The transaction batch is the collection of transactions sequencer received from the users in the step earlier. Now it does that because posting an L1 transaction is quite expensive. And to address that issue and make it cheaper, the sequencer collects transactions, orders them and posts them to the Ethereum layer 1 as a single transaction batch. These transaction batches are formed every 12 seconds. Why it's done? Because every 12 seconds uh there's a Ethereum block produced on Ethereum. So just to align with that, it's done. In step four, they submit and publish the transaction batch as one L1 transaction.
Here you can see something called soft finality. Soft finality means that the rollup data is now available to the Ethereum layer 1. It's called soft finality cuz the Ethereum can still reorg the blocks or reorder the batches.
So it's not final yet. That comes in the later part called hard finality.
Now in step five, you can see the validators include the transactions in the blocks like any other transactions uh through the consensus process. In step six, you here you can see the rollup nodes. The rollup nodes parallelly watch the Ethereum layer 1.
So they scan the Ethereum layer 1 chain to see if the sequencer has posted the transaction batches or not. Now a question should cross your mind. Why do rollup nodes exist at all? Aren't Ethereum nodes enough? Don't they have the DA and consensus responsibilities?
Well, they do have that responsibilities, but you need to know that Ethereum doesn't do the execution part. What Ethereum does is it accepts the data uh the transaction data from the rollup which is the data availability. Then it orders the batches which is the consensus process and finalizes the order ordering or the transaction.
The main thing here is that it doesn't execute the transactions. It doesn't know the correctness of the execution of these transactions which the sequencer does. It just stores the data, accepts it and orders the orders the transaction. All the execution part the rollup correctness part the transaction part is outsourced to the execution of layer of the rollup. The question again arises that if Ethereum does the DA and consensus part and the rollup does the execution of the transaction part who actually verifies this correctness of the transactions? That's where the roll of nodes come in that's what their role is. Now that we know why roll-up nodes exist, let's come back to step six. In step six, what happens is the rollup nodes read the rollup batches and download them. Now, how do they download that? So, they use the something called derivation logic. Derivation logic is a set of rules through which they roll up nodes, retrieve the batch data, download them and they play the transactions locally. Why do they do that? They do that to reconstruct the chain history, the L2 chain history and see what actually happened on L2. So this is done because they don't trust the sequencer.
So they rebuilt the L2 chain from the data they downloaded from the Ethereum L1 through the derivation logic. Now after producing the data uh what they do is they produce a set of new L2 blocks.
These L2 blocks are then appended to the new chain. Now in the last step which is step nine you can see that after the L1 block containing the batches rollup batches get finalized on L1 further they are finalized on L2 as well. So now finalization means that it's the hard finality.
That means the transactions are irreversible. Now anyone can't make any change to the transactions.
Well, that's a wrap. If you understood this video, you now understand how most rollups work under the hood. If you want more breakdowns like this, uh do like the video, follow, subscribe, do share, and I'll see you in the next
Up Next

Build a Rollup with OP Stack: Full Technical Tutorial
@ETHGlobal
4.7K views•2023-05-24

Hybrid Key Establishment in Production: Post-Quantum Cryptography
@durumcrustulum
14.7K views•2025-08-27

Operational Security Essentials: A Guide for Hacktivists (OPSEC)
@hitbsecconf
157.4K views•2012-11-26

Understanding Ethereum: A Comprehensive Beginner's Overview
@99Bitcoins
3.1M views•2018-06-26
Related Study Plans & Knowledge Roadmaps
Structured learning paths in Blockchain & Crypto






































![[Panel] Beyond TPS: The Modular Road to Scale](https://i.ytimg.com/vi_webp/wcYQdgOupL0/maxresdefault.webp)