The Ethereum mainnet was once famous for being “absurdly expensive”: a simple transfer could cost tens of dollars during peak times. Many people have heard of names like Arbitrum, Optimism, and Base, and know they are much cheaper, but aren’t quite clear on their relationship with the Ethereum mainnet—are they another new public blockchain, or some kind of extension of the mainnet? This article aims to answer exactly that question: When the Ethereum mainnet becomes expensive and congested, what exactly does L2 solve for it, and what key trade-offs should users understand.

First, understand why Ethereum became expensive and congested

Block space is a scarce resource

Ethereum is a blockchain, and transactions are recorded in “blocks”; only when packaged into a block does a transaction truly go on-chain. The number of transactions each block can hold is limited—because each block has a size and computation limit.

You can think of the mainnet as a highway with only a few lanes: capacity is fixed, and no matter how many cars want to get on, only so many can pass at once. Block space is scarce, and this is the premise for understanding everything that follows.

Why every transaction must be verified by the whole network

Some might ask: if it’s congested, why not just add more lanes and make blocks bigger?

The problem is that Ethereum’s design goal is to balance decentralization, security, and scalability. For nodes around the world to independently verify every transaction, mainnet blocks cannot grow without limit—otherwise running a node would become increasingly expensive, fewer people could participate in validation, and decentralization would decline.

In other words, every mainnet transaction needs to be repeatedly verified by a large number of nodes, so that the global state remains consistent and trustworthy. The price of this security is a ceiling on capacity.

Why gas fees rise

With that background, the logic of rising gas becomes natural:

1. Block space is limited.
2. When more people want to get on-chain, competition forms.
3. Everyone is willing to pay higher fees to grab priority.
4. So gas fees are pushed up.

High fees and congestion are not some single point of failure, but the scalability bottleneck Ethereum faces in pursuing security and decentralization. This is exactly the starting point L2 aims to solve.

The core idea of L2: move execution out, submit results back to mainnet

Since every transaction on the mainnet is expensive, a natural thought is: can most of the work be done outside the mainnet?

What is L2

L2, or Layer 2, is a scaling network built on top of the Ethereum mainnet (L1). Users can initiate transactions directly on L2 and enjoy lower fees and faster speed.

Its relationship with the mainnet can be understood like this: the mainnet is the final “settlement layer” and security anchor, while L2 handles the “execution” of a large number of everyday transactions.

Separating execution from settlement

This is the most crucial sentence for understanding L2: move execution outside the mainnet, then submit the results back to the mainnet.

Specifically, the general process is:

1. A user initiates and completes a transaction on L2.
2. L2 nodes process a large number of such transactions.
3. L2 compresses and packages these transactions into a batch and submits it to the Ethereum mainnet.
4. The mainnet does not re-execute each transaction one by one; instead, it verifies and records key data or validity proofs.

The key is: the mainnet does not need to handle every small matter itself; it only needs to confirm that the final result is trustworthy and lock it in. You can picture it as a triage desk—many simple services are handled at the triage desk first, and only the summary record goes to the main service desk; the main service desk does not have to handle every small matter personally.

Why this makes things cheaper

Because costs are shared.

The mainnet only processes one batch of data, but behind that batch are thousands of L2 transactions. The high mainnet cost that each transaction originally had to pay is now shared among this batch of transactions, so the per-transaction fee naturally drops significantly, while overall throughput also increases.

It should be emphasized: L2 does not detach from the mainnet. It still relies on the mainnet as the final settlement layer; it merely moves the execution step outside.

Rollup: currently the main L2 scaling path

We said earlier that L2 submits results “back to the mainnet,” but why does the mainnet believe the results submitted by L2 are correct? This is exactly what Rollup solves.

What Rollup does

Rollup is currently the most valued L2 approach in the Ethereum ecosystem. It packages many transactions into a batch and submits only the compressed data and state changes to the mainnet. Because the data is compressed, the amount the mainnet needs to process is smaller, and the cost comes down.

But since the mainnet does not re-execute each transaction one by one, how does it trust this batch of results? Different Rollups give different answers.

Optimistic Rollup: assume correct first, hold accountable later

Optimistic Rollup’s idea is to assume by default that the batch submitted is correct, accept it first, but keep a challenge period. Within this time window, anyone who finds an error can submit a fraud proof pointing out the problem.

You can compare it to “reimburse first, audit later”: you get reimbursed first, but afterward someone can look into it, and fraud will be held accountable. Its security mechanism is after-the-fact.

ZK Rollup: submit a proof, mainnet verifies immediately

ZK Rollup’s approach is different: it requires submitting a validity proof (also called a zero-knowledge proof) for each batch of transactions. When the mainnet receives the batch, it can verify this proof on the spot, thereby confirming that the state transition is correct.

You can compare it to “instant approval after submitting a compliance proof.” Its security mechanism is before-the-fact.

There is no need to go deep into the mathematical construction behind zero-knowledge proofs here. You only need to understand one point: it allows the mainnet to use a short proof to confirm that “the result of this batch of transactions is correct” without having to recompute it all itself.

Key differences between the two paths

The differences between the two are most intuitively reflected in a few aspects:

• Verification method: Optimistic relies on after-the-fact fraud proofs; ZK relies on before-the-fact validity proofs.
• Withdrawal wait: Optimistic withdrawals usually need to wait for the challenge period to end; ZK can theoretically achieve faster finality.
• Complexity and trust assumptions: The two also make different trade-offs on these two points.

It should be noted that not all L2s are Rollups, but Rollup is currently the most mainstream scaling path.

When using L2, what actually happens to assets and withdrawals

After understanding the mechanism, the most practical question is: if I transfer ETH to L2, are the assets still safe? Why do withdrawals sometimes require waiting?

Assets are actually still locked on the mainnet

Let’s start with “entering L2.” When you transfer assets from the mainnet to L2, the assets are actually locked in a bridge contract on the mainnet, and a corresponding equivalent balance is generated on L2.

An analogy: it’s like locking dollars in a safe on the mainnet, then receiving a corresponding voucher on L2. With the voucher, you can use that value on L2.

So there is an easily misunderstood point worth clarifying: after transferring assets to L2, the assets are not really “transferred” from the mainnet to another chain. They are still locked on the mainnet; the balance on L2 is merely a mapped voucher for those locked assets.

When trading on L2, what changes

When trading on L2, what actually changes is the balance on L2, while the corresponding assets on the mainnet remain locked by a smart contract. In other words, all your activity on L2 is ultimately linked to the mainnet through this bridge relationship.

Why withdrawals sometimes require waiting

The process of withdrawing from L2 back to the mainnet leads to different waiting times depending on the mechanism:

• Optimistic Rollup usually needs to wait for the challenge period to end, because the system must leave enough time for people to discover and point out errors.
• ZK Rollup, because verification already occurred at submission, can theoretically complete faster.

This is also why users may feel confused: transactions on L2 confirm quickly, but withdrawing back to the mainnet may take a long time. The rhythms of these two things are not the same.

One more point worth remembering: control of assets is managed by the bridge contract on the mainnet, not held for you by some centralized company. This is its advantage over custodial solutions, but it also means the security of the contract itself is your security boundary—understanding this is key to assessing L2 risk.

L2 is not another L1, nor is it equivalent to an ordinary sidechain

This is the most easily confused category of questions: what exactly is the difference between L2 and the Ethereum mainnet, other public chains, and sidechains?

What is L1

L1, or Layer 1, refers to underlying main chains like Ethereum, Bitcoin, and Solana. They have independent consensus, independent security systems, and their own native assets.

How sidechains differ

A sidechain is also a network connected to the mainnet, interacting with the mainnet through a bridge. But the key point is: a sidechain maintains its own independent consensus, and its security mainly comes from the sidechain itself, not the Ethereum mainnet.

So although a sidechain may feel similar to L2 in user experience (both can offer lower fees), the sources of security and settlement are completely different.

The key to judging: look at two things

To distinguish L2, L1, and sidechains, two questions are enough:

1. Where do assets ultimately settle?
2. Where does the system’s security mainly come from?

Using this standard:

• L2 (Rollup) submits data or proofs to the mainnet, inherits part of the Ethereum mainnet’s security, and ultimately settles on the mainnet.
• L1 is self-contained, with independent settlement and independent security.
• A sidechain has independent consensus, security mainly relies on itself, and it only connects to the mainnet through a bridge.

An analogy: L2 is more like a branch counter of the mainnet, still bound by the main store’s rules; a sidechain is more like an independent franchise store with its own way of operating. To judge whether a chain is an L2, don’t look at whether its name contains L2; look at whether its settlement and security truly rely on the Ethereum mainnet.

What L2 solves, and what it does not solve

By this point, you may wonder: so does L2 actually solve Ethereum’s problems? The answer is—partially solved, but it also brings new trade-offs.

What it does solve

• Significantly lowers fees: by batching and compressing data, the cost per transaction is greatly diluted.
• Increases throughput: a large number of transactions are completed on L2, relieving pressure on the mainnet.

Back to that numerical intuition: suppose a mainnet block can only hold 1,000 transactions, and the per-transaction fee is high; L2 compresses and packages 10,000 transactions into one batch and submits it, with the cost shared among those 10,000 transactions, so the per-transaction cost may drop by about an order of magnitude. Of course, this is just a simplified teaching example; in the real world, the compression ratio and fee reduction depend on transaction types, data costs, and network conditions.

What it does not solve

• Liquidity fragmentation: multiple L2s are independent, and funds and users are scattered across different networks.
• Inconvenient interoperability: cross-chain interactions between different L2s are not always smooth.
• Withdrawal delays: especially with Optimistic Rollup, withdrawing back to the mainnet may require a long wait.
• Trust assumptions: many L2s currently still rely on centralized sequencers or admin permissions, meaning their degree of “decentralization” is still not as good as the mainnet itself.
• Still gets expensive when congested: L2 is not always cheap; fees can rise when busy.

A balanced understanding

So, L2 significantly improves Ethereum’s fees and speed, but it does not wipe out all problems. It moves part of the pressure and cost off the mainnet, while introducing new trade-offs that users must judge for themselves—including differences in security models, withdrawal times, and degrees of centralization.

Back to the opening question: why did Ethereum become expensive and congested? Because block space is scarce, every transaction needs network-wide verification, and when demand is high, fees are pushed up. L2’s answer is direct: move execution off the mainnet and submit results back to the mainnet for settlement, so costs are shared in batches, reducing per-transaction fees and increasing throughput.

And as a user, the most important thing to remember is: different L2s differ in security assumptions, withdrawal methods, and trust models. They are not all indistinguishably “equal to the Ethereum mainnet,” nor are they completely equivalent to an independent public chain. Understanding this lets you more clearly judge: when to use L2, which L2 to use, and what it solves for Ethereum—and what it does not.