What is an Ethereum layer 2 and why it matters for payments
If you move money professionally — as a broker, closing attorney, advisor, or any kind of dealmaker who coordinates payment at the finish line — the underlying blockchain infrastructure is not abstract. It determines whether funds confirm in seconds or get stuck behind a queue of strangers, and it determines what fraction of a disbursement evaporates as network fees before it reaches the intended wallet. Ethereum is the most widely used programmable settlement network in crypto, but Ethereum’s main chain has a well-documented throughput problem. Layer 2 networks are the engineered answer to that problem, and understanding them is now a baseline requirement for anyone running high-value onchain payments.
This article explains exactly what a layer 2 is, how the underlying mechanics work, where the cost and speed improvements come from, and what those differences mean in practice when you need a payment to land cleanly and quickly.
The problem with Ethereum mainnet for payments
Ethereum’s base layer — called Layer 1, or L1 — is a globally shared compute environment. Every transaction submitted by every user on the planet competes for space in the same blocks. As the number of people using Ethereum rises, the network becomes more congested, which results in transactions becoming slower and more expensive. That is not a bug; it is the direct consequence of how a decentralized network achieves security. Validators must process and confirm every transaction independently, and there are only so many slots per block.
To put this into perspective, Ethereum mainnet processes a mere 13 transactions per second, while Visa averages 1,700 TPS. For consumer retail activity, that gap is inconvenient. For professionals coordinating time-sensitive disbursements — where multiple parties need to be paid simultaneously at the close of a transaction — it creates real uncertainty.
The cost dimension compounds the throughput issue. Payment for computation on Ethereum is made in the form of a gas fee. The gas fee is the amount of gas used to do some operation, multiplied by the cost per unit gas. That cost is not fixed; it is set by a live market. The “correct” priority fee is determined by the network usage at the time you send your transaction — if there is a lot of demand, you might have to set your priority fee higher, but when there is less demand you can pay less. The implication for payments is direct: if the broader Ethereum ecosystem is busy — a large NFT drop, a market move, a token launch — your disbursement transaction competes with all of that traffic, and fees spike accordingly. During low-traffic periods, a simple stablecoin transfer may cost under $0.10. However, during peak congestion, fees on the Ethereum mainnet can exceed $20.
For a payment of any meaningful size, a $20 fee is noise. But in a scenario with multiple recipients — say, a split disbursement going to a broker, a co-broker, a referral, and an attorney — you are looking at potentially several distinct transactions, each carrying its own gas cost, each timed to mainnet congestion you cannot control. That is friction in the mechanics of getting paid, and it is exactly the kind of problem layer 2 networks were designed to eliminate.
What a layer 2 actually is
Layer 2 is a collective term for Ethereum scaling solutions that handle transactions off Ethereum Layer 1 while still taking advantage of the robust decentralized security of Ethereum Layer 1. A layer 2 is a separate blockchain that extends Ethereum.
The key phrase there is “extends.” A layer 2 is not an independent blockchain that merely mimics Ethereum. It is architecturally coupled to Ethereum’s main chain — it derives its security from Ethereum, and it ultimately settles on Ethereum. The separation of execution from settlement is the core insight.
Layer 2 solutions were developed to tackle the scalability challenge by shifting most of the computational workload involved in processing transactions from the main blockchain to a secondary layer. A Layer 2 solution uses an external, parallel network to facilitate transactions away from the main chain. Your payment executes on the L2, but the record of that state is eventually committed back to Ethereum’s base layer, where it inherits the same security guarantees as any L1 transaction.
The dominant mechanism used by modern layer 2 networks to achieve this is called a rollup.
How rollups work
Rollups are a Layer 2 scaling solution for Ethereum that enhance transaction throughput and reduce costs through a two-layer model involving off-chain execution and on-chain settlement. In this system, transactions are processed off-chain and then aggregated into batches, which are posted to a smart contract on the Ethereum mainnet.
Think of it this way: instead of each transaction knocking individually on Ethereum’s door and paying mainnet prices for its own block of space, a rollup collects hundreds of those transactions and presents them to Ethereum as a single compressed entry. Rollups bundle hundreds of transactions into a single transaction on layer 1. This distributes the L1 transaction fees across everyone in the rollup, making it cheaper for each user.
From a payment perspective, this means the cost of settling your transaction on the underlying Ethereum base layer gets divided across every other transaction that happened to be in the same batch. Your disbursement does not pay full mainnet prices. It pays a small share of a heavily compressed batch submission.
Rollups inherit Ethereum’s security properties by recording their results on the mainnet, ensuring that off-chain computations remain secure and verifiable. The security model does not degrade because the computation moved off-chain. Ethereum still anchors the final record. What changes is who is doing the heavy lifting of processing, and where.
The two types of rollups: optimistic and ZK
Rollups come in two main types: optimistic rollups and ZK rollups. Both achieve the same high-level goal — cheaper, faster transactions that still settle on Ethereum — but they use fundamentally different approaches to prove the validity of transactions to the base layer. For professionals focused on payments, this distinction has one concrete practical consequence: finality.
Optimistic rollups
Optimistic rollups operate under an optimistic assumption: all submitted transactions are valid unless proven otherwise. When a batch is posted to L1, it enters a challenge window, usually 7 days. During this period, anyone can submit a fraud proof if a transaction is deemed invalid.
The design is efficient because the network does not expend computational resources verifying every transaction upfront. It assumes honesty and only does the verification work if someone raises a dispute. Optimistic rollups significantly raise blockchain throughput by processing transactions off-chain, alleviating congestion on the base layer. They reduce transaction fees by minimizing computation on Layer 1, making decentralized applications more accessible.
The tradeoff is that 7-day window. Transactions on optimistic rollups are subject to a dispute period before settlement on Layer 1, meaning transaction settlement is significantly delayed and the time required to withdraw funds can be as much as a week. In practice, this withdrawal delay affects movements of funds back to Ethereum L1, not the experience of transacting on the L2 itself. Users transacting within the same optimistic rollup environment experience fast, cheap confirmations. But if you need to bridge value back to Ethereum mainnet, that week-long window is real.
Liquidity bridges exist that allow users to effectively skip the wait by paying a liquidity provider to front the funds — but that is an additional mechanic to understand and account for. The leading optimistic rollups are Arbitrum and Optimism (OP Mainnet), as well as Base, which is built on the OP Stack.
ZK rollups
ZK rollups operate on cryptographic certainty. Every transaction batch includes a succinct cryptographic proof — a SNARK or STARK — that validates the correctness of the state transitions. Ethereum only accepts the batch if the proof verifies.
There is no dispute window because there is nothing to dispute. The proof is the guarantee. Near-instant finality is the key user-facing advantage. Once an L1 block containing the validity proof is confirmed, the rollup state is final. There is no withdrawal waiting period from the protocol’s perspective.
For payments specifically, ZK rollups offer a cleaner finality story. Pick a ZK rollup if you need: fast withdrawals back to Ethereum in minutes rather than a week, strong cryptographic finality for compliance or settlement reasons, cheap fees at high throughput, or a forward-looking security story.
The tradeoff has historically been on the developer tooling side — ZK rollups offer instant finality, better privacy, and lower long-term costs, but they are complex and harder to build on. That gap has narrowed considerably as ZK infrastructure has matured. Arbitrum and Optimism still lead total value locked, but every new rollup that launches chooses ZK, and the existing optimistic stacks are migrating toward ZK fraud proofs.
What this means for transaction speed and cost, in concrete terms
Layer 2 networks deliver improvements that are not marginal — they are structural. By batching many transactions and optimizing data, Layer 2 networks cut per-transaction costs significantly compared with sending the same action on L1. Users often see fees drop from several dollars to cents or less, depending on network conditions.
A common price to transfer ETH on the Ethereum mainnet is $0.10 to $0.25, and many Layer 2 transactions cost a fraction of a cent. That range compresses even further during normal operating conditions on well-established L2 networks. Arbitrum and zkSync Era frequently offer transaction fees below $0.10, with many periods running under $0.03 depending on network load and batch efficiency.
On the throughput side, the contrast is equally sharp. Ethereum processes roughly 15 to 30 TPS on its base layer, while Arbitrum achieves significantly higher throughput through its optimistic rollup design. Arbitrum currently processes approximately 57 transactions per second in real-world conditions, with a maximum recorded TPS of 2,036 and a theoretical maximum near 6,095 TPS. Base, the L2 built on the OP Stack by Coinbase, has grown its real-world throughput substantially, from roughly 5 TPS to 159 TPS, driven by Coinbase’s massive user funnel.
The practical implication for payment flow is this: a smart contract that routes a payment to five different wallets simultaneously executes on an L2 in seconds, at a cost measured in fractions of a cent, and that state is secured by Ethereum’s base layer. The same transaction on mainnet during a busy period could cost tens of dollars and confirm unpredictably. When you are disbursing proceeds at the close of a deal — with parties on both sides watching — that difference in behavior is not theoretical.
What the Dencun upgrade changed for rollup economics
One infrastructure event worth understanding is the Ethereum network upgrade known as Dencun, which introduced a mechanism called blob transactions. After Dencun, rollup fees dropped considerably since blob transactions lowered the data availability costs for Layer 2 operators.
Before Dencun, layer 2 operators posted their compressed transaction data directly into Ethereum’s main data space, where it competed with all other L1 activity for block space. Dencun introduced blob transactions: a separate data layer for rollups, which was made cheaper than forcing rollups to compete with the rest of Ethereum’s block space. Rollup operators now post their data into a dedicated channel that is priced separately and more cheaply than regular calldata.
The breakthrough came from Ethereum’s Dencun upgrade, which introduced blobs — dedicated data availability space for rollups. By separating rollup data from regular transaction calldata, Dencun reduced L2 data posting costs by 50 to 90 percent across all platforms. That cost reduction flows directly to end users. The same transaction that cost a few cents before Dencun now costs a fraction of a cent on well-optimized L2s during normal conditions.
The long-term trajectory is toward even cheaper data availability as Ethereum’s roadmap progressively expands blob capacity. Ethereum is now viewed as a modular settlement network instead of a monolithic execution chain. That reframing is important for professionals who work with onchain payments: the infrastructure is evolving toward a model where Ethereum’s base layer is a settlement anchor, and L2s are the active execution environment where fast, cheap payments live.
How an L2 actually processes your payment, step by step
Understanding the mechanical sequence helps clarify what “runs on an L2” means for a real payment.
When you submit a transaction on a layer 2 — say, a smart contract call that splits and routes a payment to multiple wallets — the transaction is first received by a component called the sequencer. The sequencer is the L2’s equivalent of a block producer: it orders transactions, executes them, and determines the resulting state. Arbitrum, for example, maintains a block time of just 0.25 seconds, enabling rapid transaction processing while ensuring security through its rollup architecture. Your transaction gets included and confirmed at that speed, not at Ethereum’s 12-second block time.
The sequencer periodically bundles the recent transaction history into a batch and posts it to Ethereum. The rollup smart contract on Ethereum updates the state with a single, compressed transaction that includes the aggregated data of all individual transactions. This compressed transaction is submitted to the mainnet, thereby reducing the computational load and gas fee for each individual transaction.
Depending on the rollup type, either a fraud proof window opens (optimistic) or a validity proof is submitted and verified (ZK). Once the batch settles on Ethereum, the transactions in that batch are as final and tamper-resistant as any L1 transaction. The recipient wallets that received funds in your payment are holding assets whose ownership is secured by Ethereum’s entire validator set.
This is the architecture that makes a fast, cheap, split payment possible without sacrificing the settlement certainty that high-value transactions require. The professional closes the deal; the smart contract handles the routing; the L2 handles execution at speed; Ethereum handles the anchor.
The mainnet vs. L2 decision in practice
Not every payment belongs on an L2. There are scenarios where mainnet Ethereum remains the right rail, and understanding when matters.
For very large transfers — wire-equivalent disbursements in the millions — the primary concern is not cost; it is finality depth. Ethereum mainnet has the deepest validator set, the longest track record, and the most conservative security assumptions. Some institutional counterparties, custodians, and compliance frameworks have specific requirements about which networks they recognize for settlement. If you are disbursing to a wallet managed by a custody provider or an institutional treasury, confirm that the custody platform supports the specific L2 before routing there.
For stablecoin payments to individual professional wallets — co-brokers, advisors, referring attorneys, anyone receiving their split of a deal — the L2 case is strong. Layer 2 solutions such as Arbitrum and Optimism typically enable USDC or USDT settlements for under $0.10 while maintaining fast confirmation times. The recipients get their funds in seconds. The cost of moving money approaches zero relative to the payment size. And the transaction record is immutable and publicly verifiable from the moment the batch settles on Ethereum.
The bridging question is the variable most professionals need to understand. Moving assets from Ethereum mainnet to an L2 requires a bridge — a smart contract mechanism that locks or burns tokens on one side and mints equivalent tokens on the other. Native bridges provided by the rollup operators are generally trustworthy, but they involve a transaction on mainnet and, in the case of optimistic rollups, that 7-day withdrawal window when moving back. For professionals who operate primarily on a single L2 and rarely need to move funds back to mainnet directly, this window is rarely a practical issue. For those who need maximum flexibility — moving assets across networks on short notice — ZK rollup networks with fast withdrawals, or liquidity bridges that bypass the waiting period for a fee, are worth understanding.
The stablecoin layer: why it matters for professional payments
Most professional payments in a deal context are not denominated in ETH. They are denominated in stablecoins — USDC and USDT being the most widely used. The good news is that both assets are natively deployed on the major L2 networks. Sending USDC on Arbitrum or Base is not a bridged or wrapped representation; it is the canonical asset issued directly on that network by Circle.
This matters for two reasons. First, price stability. A broker receiving their commission split wants the amount they expect, not an ETH-denominated amount that moved 4% between when the deal closed and when the transaction confirmed. A stablecoin disbursement on an L2 delivers exactly the agreed amount with no exposure to crypto volatility during transit. Second, liquidity. Because major L2s have deep stablecoin liquidity and direct integrations with centralized exchanges and off-ramps, a recipient who wants to move their USDC off the L2 and into a bank account has a straightforward path to do so — without touching Ethereum mainnet and paying mainnet gas.
For B2B organisations, gas fees are part of the total settlement cost, alongside payment provider margins, fiat on- and off-ramp fees, and treasury management expenses. Understanding L2 gas economics is therefore not just a technical exercise — it is part of understanding the true cost of a payment.
Security inheritance: what it means that an L2 is “secured by Ethereum”
This phrase appears frequently and is worth unpacking precisely. Rollups perform transaction execution outside layer 1 and then the data is posted to layer 1 where consensus is reached. As transaction data is included in layer 1 blocks, this allows rollups to be secured by native Ethereum security.
In practical terms, this means that the history of transactions on an Ethereum rollup is not erasable by the rollup operator. The data exists on Ethereum’s base layer. A rollup operator cannot selectively delete your payment record or reverse a confirmed transaction without attacking Ethereum itself — which would require controlling a majority of Ethereum’s validator stake, an attack that would cost tens of billions of dollars and immediately become visible to the entire ecosystem.
This is the architectural distinction that separates rollups from standalone sidechains. Sidechains, such as the older Polygon PoS chain or Gnosis Chain, run in parallel to Ethereum with their own validator sets and consensus mechanisms. This makes sidechains useful for lowering fees and increasing throughput, but they are better classified as separate Layer 1s that connect to Ethereum rather than true Layer 2 networks. A true L2 rollup does not just connect to Ethereum — it derives its security from Ethereum. Your transaction record is anchored there. That distinction matters when the asset being settled is meaningful in size.
Why this all connects to how deals close onchain
The professional context for all of this is specific: you are not building a protocol or managing a validator node. You are making sure that when a deal closes, money gets to the right wallets, in the right amounts, at the right time, without friction and without ambiguity.
Layer 2 networks change that execution environment in a concrete way. The same Ethereum smart contract logic that enforces a multi-party payment split runs on an L2 at a fraction of the cost and a multiple of the speed. A payment that touches five wallets simultaneously — each receiving their exact negotiated percentage — executes and confirms in seconds, not minutes. The gas cost for the entire operation on a major L2 is measured in cents. And when the transaction settles on Ethereum’s base layer, every party has a permanent, publicly verifiable receipt showing what was paid, to whom, and when.
That is why layer 2 is not a peripheral technical detail for onchain payment professionals. It is the infrastructure layer that determines whether onchain payments are a practical tool or an expensive, unpredictable alternative. A smart contract payment router operating on an L2 — like Shaka — runs in that execution environment by design. The split logic executes where execution is fast and cheap; the settlement certainty comes from where Ethereum anchors it.
Understanding what layer 2 is, and why it was built, is the difference between treating onchain payments as a curiosity and treating them as a professional-grade tool. The mechanics are real, the tradeoffs are knowable, and the infrastructure is production-ready. The question is whether the professionals who move money at the close of deals use it intentionally — or leave it to chance.
