An Introduction to Layer-2 Scaling Solutions

Detailed Instructions

Users interact with a rollup sequencer, a node that collects and orders transactions. This can be done via a wallet like MetaMask configured for a specific rollup network (e.g., Arbitrum or Optimism). The transaction is executed off-chain, meaning state changes (like token balances) are computed instantly within the rollup's virtual machine. For example, a swap on a rollup-based DEX executes without waiting for Ethereum mainnet confirmation.

• Sub-step 1: Sign and Broadcast: A user signs a transaction with their private key and sends it to the rollup's RPC endpoint (e.g., https://arb1.arbitrum.io/rpc).
• Sub-step 2: Local State Update: The sequencer validates the transaction (checking nonce, signature, and fee) and immediately updates its local state, providing the user with a near-instant confirmation.
• Sub-step 3: Queue for Batching: The validated transaction is placed into the sequencer's mempool, awaiting batch creation.

Tip: Gas fees on the rollup are paid in the native L2 token (e.g., ETH on Arbitrum) and are significantly lower than L1 fees.

Detailed Instructions

The core scaling power of rollups comes from data compression. Instead of publishing each transaction's full data, the sequencer creates a batch or rollup block containing only minimal, essential data. Optimistic Rollups publish the full transaction data (calldata), while ZK-Rollups publish a state diff or a zero-knowledge proof. The data is compressed by removing signatures and using efficient encodings.

• Sub-step 1: Aggregate Transactions: The sequencer aggregates, for example, 1,000 transactions from its mempool.
• Sub-step 2: Compress Data: Signatures might be aggregated into one, and addresses are referenced by indices. A transaction that is 100 bytes on L1 might be reduced to 12 bytes.
• Sub-step 3: Post to L1: The compressed batch is published as calldata to a specific data availability smart contract on Ethereum L1, such as the CanonicalTransactionChain on Optimism (address: 0x5E4e65926BA27467555EB562121fac00D24E9dD2).

Tip: This step is where the majority of gas savings occur, as posting data to Ethereum is the primary cost.

Detailed Instructions

After publishing the batch data, the rollup must prove that the new state root (a Merkle root representing all accounts and balances) is correct. Optimistic Rollups assume correctness and post a state root with a fraud proof window (typically 7 days) for challenges. ZK-Rollups generate a SNARK or STARK validity proof for every batch, cryptographically verifying correctness instantly.

• Sub-step 1: Compute New State Root: The sequencer computes the Merkle root after applying all batched transactions.
• Sub-step 2: Submit Commitment: For an Optimistic Rollup, a transaction is sent to the L1 StateCommitmentChain contract. For a ZK-Rollup, a verifier contract call is made.
• Sub-step 3: Generate Proof (ZK-Rollups): A prover node runs a complex computation to generate a proof, using a command like zksync prover --batch-id 54231. This proof is then submitted to the L1 verifier contract.

Tip: The choice between optimism and zero-knowledge defines the security model and finality time (instant for ZK, delayed for Optimistic).

Detailed Instructions

This is the settlement layer where Ethereum's security is invoked. For Optimistic Rollups, any watcher can submit a fraud proof during the challenge period if they detect invalid state transitions. This involves re-executing the disputed transaction on-chain. For ZK-Rollups, the L1 verifier contract (e.g., 0x4B5DF730c2e6b28E17013A1485E5d9BC41Efe021 on zkSync) mathematically verifies the submitted proof in a single, low-gas operation.

• Sub-step 1: Challenge Period (Optimistic): A 7-day window begins. To challenge, a watcher calls fraudProver.initiateChallenge() with the disputed batch data.
• Sub-step 2: On-Chain Verification: The L1 contract re-executes the transaction. If the challenge is successful, the state is reverted, and the sequencer's bond is slashed.
• Sub-step 3: Finalize Withdrawals: Once the state root is final (after the challenge window or proof verification), users can prove ownership of funds via a Merkle proof to withdraw assets from the L1 bridge contract using a function like withdraw(bytes32 proof).

Tip: Finality for users on the rollup is fast, but moving assets back to L1 requires waiting for this finalization step to complete.

Detailed Instructions

Before bridging assets, you must understand the underlying bridge architecture. There are two primary models: trusted (custodial) bridges, which rely on a central entity, and trustless (decentralized) bridges, which use smart contracts and cryptographic proofs. For most DeFi users, trustless bridges like the official Optimism Gateway or Arbitrum Bridge are preferred for security. Key components include the deposit contract on L1 (Ethereum), a messaging protocol (like Canonical or AnyTrust), and the withdrawal contract on L2. Always verify the contract addresses from official sources, for example, the Optimism L1 Standard Bridge is typically at 0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1.

• Sub-step 1: Research the Bridge Type: Determine if the bridge is native (official) or third-party.
• Sub-step 2: Identify Core Contracts: Locate the official L1 and L2 bridge contract addresses.
• Sub-step 3: Assess Security: Check audit reports and whether the bridge uses fraud proofs or validity proofs.

Tip: Bookmark the official documentation pages for your chosen L2 (e.g., docs.optimism.io) to avoid phishing sites.

Detailed Instructions

Proper preparation prevents failed transactions and lost funds. First, ensure your Web3 wallet (like MetaMask) is connected to the Ethereum Mainnet network. You will need ETH in this wallet to pay for gas fees for the deposit transaction, which can vary but often costs between $10-$50 depending on congestion. The assets you wish to bridge (e.g., USDC, DAI) must be ERC-20 tokens in your wallet on the L1 network. Some bridges require you to approve the bridge contract to spend your tokens before depositing. This is a separate transaction requiring its own gas. Check your token's bridge compatibility; not all ERC-20s are supported natively on every L2.

• Sub-step 1: Fund Your Wallet: Ensure you have at least 0.05 ETH for gas on Mainnet.
• Sub-step 2: Add the L2 Network: Pre-add the L2's RPC details to your wallet for after the bridge (e.g., Arbitrum One Network ID: 42161).
• Sub-step 3: Token Approval: If required, call the approve function for the token contract.

codeCopy
// Example token approval transaction data for USDC
const data = tokenContract.interface.encodeFunctionData('approve', [
  '0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1', // Bridge address
  '1000000000' // Amount in smallest unit (e.g., 1000 USDC)
]);

Tip: Use a gas tracker like Etherscan's Gas Tracker to time your transaction for lower fees.

Detailed Instructions

This is the core action of bridging. Navigate to the official bridge UI (e.g., bridge.arbitrum.io). Connect your wallet and select the asset and amount. The interface will show you an estimated bridging time, which can range from ~10 minutes for Optimistic Rollups to near-instant for some ZK-Rollups. When you click "Deposit," your wallet will prompt you to confirm a transaction to the L1 bridge contract. This transaction locks your tokens in the L1 contract and emits an event that the L2 validators will pick up. Important: Do not close the window until the transaction is confirmed on L1. The transaction hash is crucial for tracking. You can monitor progress on a block explorer.

• Sub-step 1: Input Details: Enter the exact amount and confirm the destination L2 address.
• Sub-step 2: Review Transaction: Check the gas fee and the estimated arrival time on L2.
• Sub-step 3: Sign and Broadcast: Confirm the transaction in your wallet and save the TX hash (e.g., 0xabcd...1234).

Tip: For large sums, consider doing a small test transaction first (e.g., $10 worth) to verify the entire process works correctly.

Detailed Instructions

After your L1 transaction is confirmed, there is a waiting period. For Optimistic Rollups like Optimism and Arbitrum, this is a challenge period (typically 7 days) where the transaction can be disputed. During this time, your funds are technically on L2 but may not be immediately spendable for withdrawals back to L1. However, they are usually usable within the L2 ecosystem immediately. For ZK-Rollups like zkSync or StarkNet, finality is much faster as it relies on validity proofs. Once the waiting period is over (or the state is proven), you can claim your funds. Switch your wallet to the L2 network, and your bridged balance should appear. If using a third-party bridge, you may need to manually trigger a claim transaction.

• Sub-step 1: Monitor Progress: Use the bridge's status page or a block explorer with your TX hash.
• Sub-step 2: Switch Networks: In MetaMask, select the added L2 network (e.g., "Arbitrum One").
• Sub-step 3: Verify Balance: Check that your asset balance is reflected in your wallet on the L2 network.

Tip: You can track the status of an Optimism deposit by visiting https://optimistic.etherscan.io/tx/<yourL1TxHash> which will show the corresponding L2 transaction.