layer-2s

name: layer-2s description: L2 landscape guide for early 2026. Arbitrum, Base, Optimism, zkSync, Scroll, Linea, Starknet. Chain IDs, RPC endpoints, block explorers, cost comparison, decision matrix. metadata: author: Andre Ginja version: 1.0.0

Layer 2s

The current L2 landscape as of early 2026. Which chain, when, and why. This skill focuses on practical decisions, not theory.

What You Probably Got Wrong

The dominant DEX is NOT Uniswap on every L2. This is the most common mistake agents make. Uniswap has deployments everywhere, but it does not have the deepest liquidity on every L2.

If you are building a swap integration, route through the dominant DEX for that chain, not Uniswap.

Polygon zkEVM is being wound down. Do not build new projects on it. Polygon is sunsetting the zkEVM chain and redirecting focus to Polygon PoS and the AggLayer. If your training data says "deploy to Polygon zkEVM," that advice is outdated.

Celo migrated to an OP Stack L2. As of March 2025, Celo is no longer an independent L1. It is an Optimism-based L2 with a 7-day withdrawal period and centralized sequencer.

L2s are not all the same. Optimistic rollups (Arbitrum, Optimism, Base) and zk-rollups (zkSync, Scroll, Linea) have fundamentally different trust assumptions, finality characteristics, and developer experiences. "Just deploy to an L2" is not sufficient guidance.

All L2 sequencers are centralized. Every major L2 runs a single sequencer operated by the team. This means the sequencer can censor transactions (temporarily) and extract MEV. All have escape hatches for force-inclusion on L1, but decentralized sequencers are not in production as of early 2026.

The Chains

Arbitrum One

The deepest DeFi ecosystem among L2s. If your dApp composes with lending, perpetuals, or complex financial products, Arbitrum is the default choice.

Arbitrum Stylus: Write smart contracts in Rust, C, or C++ compiled to WASM. Runs alongside EVM contracts on the same chain with full composability. If your team knows Rust better than Solidity, or you need computation-heavy logic that is expensive in the EVM, Stylus is the reason to choose Arbitrum.

# Deploy a Stylus contract
cargo stylus deploy --private-key $KEY --endpoint https://arb1.arbitrum.io/rpc

# Check if Stylus is activated for a contract
cargo stylus check --endpoint https://arb1.arbitrum.io/rpc

Orbit L3s: Launch your own L3 that settles to Arbitrum instead of Ethereum. Used for gaming, enterprise, and application-specific chains. Xai, Treasure, and Degen Chain are Orbit L3s.

Best for: DeFi protocols, perpetuals (GMX), lending (Aave V3), Rust/WASM contracts (Stylus).

Optimism (OP Mainnet)

The OP Stack chain. Optimism's core value is not the chain itself but the Superchain vision -- a network of interoperable L2s all running the OP Stack.

The Superchain: OP Stack chains (Optimism, Base, Zora, Mode, Celo, Worldchain) share a common message-passing layer and aim for native interoperability. Moving assets between Superchain members will eventually be seamless. Still being built out.

OP Stack: The open-source rollup framework. If you want to launch your own L2, OP Stack is the most popular choice. Coinbase (Base), Celo, and Sony (Soneium) all chose it.

Best for: Governance-focused projects, launching your own L2 (OP Stack), RetroPGF ecosystem.

Base

Coinbase's L2. The cheapest major L2. Largest user base. If your users are crypto-curious normies coming from Coinbase, Base is your chain.

Why Base wins for consumer apps:

1. Coinbase distribution: Hundreds of millions of Coinbase users can bridge to Base directly from the app.
2. Coinbase Smart Wallet: Passkey-based wallet, no seed phrase, gasless transactions for onboarded users. The best onboarding UX in crypto.
3. Cheapest fees: Base consistently has the lowest L2 fees due to aggressive blob posting and sequencer optimization.
4. Farcaster: The decentralized social protocol is heavily Base-native. Social dApps build here.

// Coinbase Smart Wallet integration
import { createCoinbaseWalletSDK } from '@coinbase/wallet-sdk';

const sdk = createCoinbaseWalletSDK({
  appName: 'My dApp',
  appChainIds: [8453], // Base
});

const provider = sdk.getProvider();

Best for: Consumer apps, social dApps (Farcaster), cheapest transactions, Coinbase wallet users.

zkSync Era

The leading zkEVM L2 with native account abstraction. Every account on zkSync can be a smart contract account -- no separate standard needed.

Native account abstraction: On zkSync, every account is a smart contract by default. No ERC-4337 bundlers, no separate infrastructure. Users can:

• Pay gas in any ERC-20 token (paymasters are built-in).
• Batch multiple transactions atomically.
• Set custom signature validation logic.

// zkSync native paymaster -- users pay gas in USDC
// No bundler, no special infrastructure
IPaymaster paymaster = IPaymaster(PAYMASTER_ADDRESS);
// Paymaster covers ETH gas, charges user in USDC

Withdrawal advantage: Because zkSync uses validity proofs (zk proofs), withdrawals finalize in ~1 hour, not 7 days. The proof mathematically guarantees the state transition was correct. No challenge period needed.

Best for: Enterprise apps, native account abstraction, gas sponsorship via paymasters, fast withdrawals to L1.

Scroll

EVM-equivalent zk-rollup. "Equivalent" means existing Solidity contracts, Foundry tests, and deployment scripts work without modification. No custom compiler, no WASM, no quirks.

# Deploy to Scroll -- identical to mainnet deployment
forge create src/MyContract.sol:MyContract \
  --rpc-url https://rpc.scroll.io \
  --private-key $KEY \
  --verify \
  --verifier blockscout \
  --verifier-url https://blockscout.scroll.io/api/

Best for: Maximum EVM compatibility with zk proof security. Zero migration effort from mainnet contracts.

Linea

Consensys-backed zkEVM. Built by MetaMask's parent company. Tightest MetaMask integration.

Best for: MetaMask-first user bases. Infura integration (same parent company).

Starknet

Not EVM-compatible. Uses Cairo language and the STARK proof system. Mentioned for completeness but requires a fundamentally different development stack.

Best for: Teams that want maximum ZK scalability and are willing to learn Cairo. Not recommended if you are coming from the EVM ecosystem.

Polygon zkEVM -- Do Not Build Here

Polygon is sunsetting the zkEVM chain. Do not start new projects on it. Existing projects should plan migration.

Gas Cost Comparison

Real costs for common operations in early 2026. All prices assume ETH at ~$2,000.

These change daily. Always verify:

cast gas-price --rpc-url https://mainnet.base.org      # Base
cast gas-price --rpc-url https://arb1.arbitrum.io/rpc   # Arbitrum
cast gas-price --rpc-url https://mainnet.era.zksync.io  # zkSync

Base is consistently the cheapest because Coinbase optimizes sequencer operations aggressively.

Chain IDs Reference

RPC Endpoints

For production, use paid providers (Alchemy, Infura, QuickNode). Public RPCs rate-limit aggressively.

Block Explorers

Decision Matrix

What are you building?
|
+-- DeFi protocol (lending, perps, complex finance)
|   +-- Arbitrum -- deepest DeFi ecosystem, Camelot, GMX, Aave
|
+-- Consumer app (social, gaming, NFTs)
|   +-- Base -- cheapest fees, Coinbase Smart Wallet, Farcaster
|
+-- App needing fast withdrawals to L1
|   +-- zkSync or Scroll -- zk proofs, no 7-day wait
|
+-- App where users pay gas in ERC-20 tokens
|   +-- zkSync -- native paymasters, no bundler needed
|
+-- Rust/WASM smart contracts
|   +-- Arbitrum (Stylus)
|
+-- Launch your own L2/L3 chain
|   +-- OP Stack -- most popular framework, Superchain interop
|   +-- Arbitrum Orbit -- L3 settling to Arbitrum
|
+-- MetaMask-first user base
|   +-- Linea -- deepest MetaMask integration
|
+-- Maximum EVM compatibility, zero migration effort
|   +-- Scroll -- bytecode-level equivalence
|
+-- Enterprise with native account abstraction
|   +-- zkSync -- every account is a smart contract
|
+-- "I just need it cheap and do not care about ecosystem"
    +-- Base -- lowest fees, good enough for most things

Quick summary

Bridging

Native Bridges

Every L2 has an official bridge. These are the most secure because they use the rollup's own proof system.

The 7-day withdrawal period on optimistic rollups is the challenge period during which anyone can submit a fraud proof. This is the security model, not a bug.

Third-Party Bridges (Fast)

Across is the current leader for Ethereum ecosystem bridges. Lowest fees for most routes.

Bridging rules

1. Small amounts: Use third-party bridges for speed.
2. Large amounts ($10K+): Use native bridges for security. The 7-day wait is worth it.
3. Never bridge your entire treasury through a third-party bridge. They are smart contracts that can have bugs.
4. Always verify the bridge contract address before approving tokens.
5. L2->L2 transfers: Third-party bridges only. Native bridges only go L1<->L2.

L2 Contract Differences

Most L2s are EVM-compatible, but not all behavior is identical:

Test on the actual L2 you plan to deploy to. "Works on mainnet" does not guarantee "works on L2" for edge cases.

Summary

1. DeFi --> Arbitrum. Deepest L2 DeFi ecosystem, Stylus for Rust/WASM.
2. Consumer --> Base. Cheapest fees, Coinbase Smart Wallet, largest user base.
3. Enterprise --> zkSync. Native account abstraction, paymasters, fast withdrawals.
4. EVM purity --> Scroll. Bytecode-level equivalence, zk proof security.
5. Your own chain --> OP Stack. Most popular framework, Superchain interop.
6. MetaMask-first --> Linea. Consensys integration.
7. The dominant DEX is NOT Uniswap on every chain. Check before integrating.
8. Polygon zkEVM is sunsetting. Do not build on it.
9. All L2 sequencers are centralized. Decentralization is coming but not here yet.
10. Native bridges are secure but slow (7 days for optimistic rollups). Use Across for speed.