Layer 2 Scaling — Explained with Examples

// Simplified Optimistic Rollup bridge (conceptual)
contract OptimisticBridge {
    mapping(bytes32 => bool) public proposedRoots;
    mapping(bytes32 => uint256) public challengeDeadline;

    // Sequencer submits a batch of L2 transactions
    function submitBatch(bytes32 newStateRoot, bytes calldata transactions) external {
        proposedRoots[newStateRoot] = true;
        challengeDeadline[newStateRoot] = block.timestamp + 7 days;
        emit BatchSubmitted(newStateRoot, transactions);
    }

    // Anyone can challenge a fraudulent batch during the challenge period
    function challenge(bytes32 stateRoot, bytes calldata fraudProof) external {
        require(challengeDeadline[stateRoot] > block.timestamp, "Challenge period ended");
        require(verifyFraud(stateRoot, fraudProof), "Invalid fraud proof");

        proposedRoots[stateRoot] = false;
        emit BatchChallenged(stateRoot);
    }

    // After challenge period ends, batch is finalized
    function finalize(bytes32 stateRoot) external {
        require(challengeDeadline[stateRoot] < block.timestamp, "Challenge period active");
        require(proposedRoots[stateRoot], "Invalid state root");

        finalizeState(stateRoot);
    }

    event BatchSubmitted(bytes32 stateRoot, bytes transactions);
    event BatchChallenged(bytes32 stateRoot);
}

// Interacting with Arbitrum
const { ethers } = require("ethers");

async function arbitrumExample() {
  const ARBITUM_RPC = "https://arb1.arbitrum.io/rpc";
  const provider = new ethers.providers.JsonRpcProvider(ARBITUM_RPC);

  const l1Provider = new ethers.providers.JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/demo");

  // Compare gas prices
  const l1GasPrice = await l1Provider.getGasPrice();
  const l2GasPrice = await provider.getGasPrice();

  console.log("=== L1 vs L2 Gas Comparison ===");
  console.log("Ethereum L1 gas price:", ethers.utils.formatUnits(l1GasPrice, "gwei"), "Gwei");
  console.log("Arbitrum L2 gas price:", ethers.utils.formatUnits(l2GasPrice, "gwei"), "Gwei");
  console.log("Savings:", ((l1GasPrice.sub(l2GasPrice)).mul(100).div(l1GasPrice)).toString(), "%");

  // Check Arbitrum block time
  const l1Block = await l1Provider.getBlock("latest");
  const l2Block = await provider.getBlock("latest");

  console.log("\n=== Block Times ===");
  console.log("L1 block time: ~12 seconds");
  console.log("L2 block time: ~0.25 seconds (instant)");

  // Get latest block info
  console.log("\nL1 latest block:", l1Block.number);
  console.log("L2 latest block:", l2Block.number);
}

arbitrumExample();

// zksync_example.js
const { ethers } = require("ethers");

async function zkSyncExample() {
  // zkSync Era mainnet RPC
  const provider = new ethers.providers.JsonRpcProvider("https://mainnet.era.zksync.io");

  // Check network details
  const network = await provider.getNetwork();
  console.log("Network:", network.name, "(chain ID:", network.chainId, ")");

  // Compare typical transfer costs
  const l1TransferCost = ethers.utils.parseEther("0.005"); // ~$15 at $3000/ETH
  const zkTransferCost = ethers.utils.parseEther("0.00005"); // ~$0.15

  console.log("\n=== Cost Comparison (Simple Transfer) ===");
  console.log("L1 Ethereum:", ethers.utils.formatEther(l1TransferCost), "ETH");
  console.log("zkSync Era:", ethers.utils.formatEther(zkTransferCost), "ETH");
  console.log("Savings: ~100x");

  // Check if a contract is verified
  const usdcL2 = "0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4";
  console.log("\nUSDC on zkSync:", usdcL2);

  // The magic of ZK: instant finality
  console.log("\nZK Rollup finality: minutes (no 7-day wait!)");
}

zkSyncExample();

// polygon_interaction.js
const { ethers } = require("ethers");

async function polygonExample() {
  const POLYGON_RPC = "https://polygon-rpc.com";
  const provider = new ethers.providers.JsonRpcProvider(POLYGON_RPC);

  // Get MATIC balance
  const address = "0x0000000000000000000000000000000000001010"; // Polygon staking contract
  const balance = await provider.getBalance(address);
  console.log("Polygon staking contract MATIC:", ethers.utils.formatEther(balance));

  // Check block time
  const latestBlock = await provider.getBlock("latest");
  console.log("Latest Polygon block:", latestBlock.number);
  console.log("Polygon block time: ~2 seconds");
  console.log("Polygon TPS: ~7,000 (theoretical)");

  // Check bridge contract
  const bridgeAddress = "0xA0c68C638235ee32657e8f720a23ceC1bFc77C77";
  console.log("\nPolygon Plasma Bridge:", bridgeAddress);
  console.log("Withdrawal time: ~3 hours (needs checkpoint)");

  // Security comparison
  console.log("\n=== Security Model ===");
  console.log("Validators: Polyon's own set (not Ethereum)");
  console.log("If 2/3 of validators collude, funds can be stolen");
  console.log("Risk: Medium (higher than rollups, lower than standalone L1)");
}

polygonExample();

# l2_security_analyzer.py
def analyze_l2_security(solution_name, security_model, validator_set,
                         withdrawal_time, exploits, tvl_billions):
    """
    Analyze the security tradeoffs of a Layer 2 solution.
    """

    print(f"=== L2 Security Analysis: {solution_name} ===")

    strengths = []
    weaknesses = []

    if "fraud proof" in security_model.lower():
        strengths.append("Cryptographic fraud proofs (trustless)")
        weaknesses.append(f"7-day withdrawal delay ({withdrawal_time})")
    elif "zk proof" in security_model.lower():
        strengths.append("Instant finality via ZK proofs")
        strengths.append("No challenge period needed")
    elif "sidechain" in security_model.lower():
        weaknesses.append("Independent validator set (not Ethereum)")
        weaknesses.append("Lower security guarantees")
        weaknesses.append("Bridge is a central point of failure")

    if exploits > 0:
        weaknesses.append(f"{exploits} known exploits")
    else:
        strengths.append("No major exploits to date")

    print(f"  Security model: {security_model}")
    print(f"  Validator set: {validator_set}")
    print(f"  Withdrawal time: {withdrawal_time}")
    print(f"  TVL: ${tvl_billions}B")
    print(f"  Strengths:")
    for s in strengths:
        print(f"    ✓ {s}")
    print(f"  Weaknesses:")
    for w in weaknesses:
        print(f"    ✗ {w}")

    score = len(strengths) * 10 - len(weaknesses) * 8
    if exploits > 3:
        score -= 15
    print(f"\n  Security score: {max(0, score)}/100")
    print()

analyze_l2_security(
    "Arbitrum",
    "Optimistic rollup with fraud proofs",
    "Ethereum validators (L1 security)",
    "~7 days",
    0,
    12.5
)

analyze_l2_security(
    "Polygon PoS",
    "Sidechain with own validator set",
    "100 independent validators",
    "~3 hours (checkpoint)",
    1,
    6.8
)

// Gas-optimized contract for L2 deployment
contract L2GasOptimized {
    // Use uint256 instead of smaller types (EVM word size)
    uint256 public counter;

    // Use calldata instead of memory for read-only params
    function batchIncrement(uint256[] calldata amounts) external {
        uint256 total = 0;
        for (uint256 i = 0; i < amounts.length; i++) {
            total += amounts[i];
        }
        counter += total;
    }

    // Use unchecked blocks for safe math (saves gas)
    function fastIncrement(uint256 amount) external {
        unchecked {
            counter += amount;
        }
    }

    // Pack structs tightly
    struct UserData {
        uint128 balance;  // 128 bits
        uint64 lastLogin; // 64 bits
        uint16 status;    // 16 bits
        // Total: 256 bits = 1 storage slot
    }
}