Layer 2 Solutions

Rollups, state channels, sidechains, and scaling solutions.

Overview

Layer 2 solutions scale Ethereum while inheriting security.

Scaling Approaches

┌─────────────────────────────────────┐
│           Layer 2 Solutions          │
├─────────────────────────────────────┤
│ Optimistic    │ Zero-Knowledge      │
│ Rollups       │ Rollups             │
├─────────────────────────────────────┤
│ State Channels │ Sidechains         │
└─────────────────────────────────────┘

Optimistic Rollups

// Simplified fraud proof
contract OptimisticRollup {
    struct StateUpdate {
        bytes32 stateRoot;
        uint256 blockNumber;
        address submitter;
    }
    
    uint256 public constant CHALLENGE_PERIOD = 7 days;
    
    function submitState(StateUpdate calldata update) public {
        // Store state update
        // Start challenge period
    }
    
    function challenge(uint256 updateId, bytes calldata proof) public {
        // Verify fraud proof
        // Revert invalid state
    }
}

ZK-Rollups

// Simplified ZK proof verification
contract ZKRollup {
    function verifyProof(
        uint[2] calldata a,
        uint[2][2] calldata b,
        uint[2] calldata c,
        uint[4] calldata publicInputs
    ) public view returns (bool) {
        // Verify zk-SNARK proof
        return verifier.verify(a, b, c, publicInputs);
    }
}

State Channels

// Payment channel
contract PaymentChannel {
    address public sender;
    address public receiver;
    uint256 public amount;
    uint256 public expiry;
    
    function open(address _receiver, uint256 _amount) public payable {
        sender = msg.sender;
        receiver = _receiver;
        amount = msg.value;
        expiry = block.timestamp + 1 hours;
    }
    
    function close(bytes calldata signature) public {
        require(block.timestamp < expiry);
        
        // Verify signature
        // Transfer funds
    }
}

Comparison

Practice

Deploy a simple payment channel contract.