Layer2 扩容解决方案详解

Layer2 扩容解决方案详解 🔄

1. Layer2 基础概念

1.1 什么是 Layer2？

Layer2 是建立在以太坊主网（Layer1）之上的扩容解决方案，它：

• 继承以太坊的安全性
• 提供更高的交易吞吐量
• 降低交易费用
• 保持去中心化特性

1.2 主要类型

1. Rollups
   • Optimistic Rollups
   • ZK Rollups
2. 状态通道
3. Plasma
4. Validium

2. Optimistic Rollups

2.1 工作原理

contract OptimisticRollup {
    struct Transaction {
        address from;
        address to;
        uint256 value;
        bytes data;
    }
    
    struct Batch {
        bytes32 stateRoot;
        Transaction[] transactions;
        uint256 timestamp;
    }
    
    mapping(uint256 => Batch) public batches;
    uint256 public currentBatch;
    
    // 挑战期
    uint256 public constant CHALLENGE_PERIOD = 7 days;
    
    function submitBatch(
        bytes32 newStateRoot,
        Transaction[] calldata transactions
    ) external {
        // 提交新批次
        batches[currentBatch] = Batch({
            stateRoot: newStateRoot,
            transactions: transactions,
            timestamp: block.timestamp
        });
        
        emit BatchSubmitted(currentBatch, newStateRoot);
        currentBatch++;
    }
    
    function challengeBatch(
        uint256 batchId,
        bytes calldata proof
    ) external {
        require(
            block.timestamp <= batches[batchId].timestamp + CHALLENGE_PERIOD,
            "Challenge period expired"
        );
        
        // 验证挑战证明
        require(verifyProof(proof), "Invalid fraud proof");
        
        // 回滚状态
        revertBatch(batchId);
    }
}

2.2 交易提交

async function submitToOptimisticRollup(transaction) {
    const rollupProvider = new ethers.providers.JsonRpcProvider(ROLLUP_RPC_URL);
    const wallet = new ethers.Wallet(PRIVATE_KEY, rollupProvider);
    
    // 构建交易
    const tx = await wallet.sendTransaction({
        to: transaction.to,
        value: transaction.value,
        data: transaction.data
    });
    
    // 等待交易确认
    await tx.wait();
    
    // 等待状态根提交到 L1
    await waitForStateCommitment(tx.hash);
}

3. ZK Rollups

3.1 基础实现

contract ZKRollup {
    struct ZKProof {
        uint256[2] a;
        uint256[2][2] b;
        uint256[2] c;
    }
    
    struct Batch {
        bytes32 stateRoot;
        bytes32 transactionsHash;
        ZKProof proof;
    }
    
    mapping(uint256 => Batch) public batches;
    
    function verifyAndSubmitBatch(
        bytes32 newStateRoot,
        bytes32 txHash,
        ZKProof calldata proof
    ) external {
        require(verifyZKProof(proof), "Invalid ZK proof");
        
        batches[currentBatch] = Batch({
            stateRoot: newStateRoot,
            transactionsHash: txHash,
            proof: proof
        });
        
        emit BatchVerified(currentBatch, newStateRoot);
    }
}

3.2 证明生成

async function generateZKProof(transactions, state) {
    // 使用 circom 和 snarkjs 生成证明
    const circuit = await compileCircuit("rollup.circom");
    const setup = await generateSetup(circuit);
    
    const input = {
        transactions: transactions,
        oldState: state.old,
        newState: state.new
    };
    
    const proof = await generateProof(circuit, input, setup);
    return proof;
}

4. 状态通道

4.1 支付通道

contract PaymentChannel {
    address public participant1;
    address public participant2;
    uint256 public expiresAt;
    
    mapping(address => uint256) public balances;
    
    constructor(address _participant2) payable {
        participant1 = msg.sender;
        participant2 = _participant2;
        balances[msg.sender] = msg.value;
        expiresAt = block.timestamp + 1 days;
    }
    
    function closeChannel(
        uint256 amount1,
        uint256 amount2,
        bytes memory signature1,
        bytes memory signature2
    ) external {
        require(
            verifySignature(amount1, amount2, signature1, participant1) &&
            verifySignature(amount1, amount2, signature2, participant2),
            "Invalid signatures"
        );
        
        balances[participant1] = amount1;
        balances[participant2] = amount2;
        
        // 分配资金
        payable(participant1).transfer(amount1);
        payable(participant2).transfer(amount2);
    }
}

4.2 状态更新

async function updateChannelState(channel, newState) {
    // 签名新状态
    const signature = await wallet.signMessage(
        ethers.utils.arrayify(
            ethers.utils.solidityKeccak256(
                ["address", "uint256", "uint256"],
                [channel.address, newState.amount1, newState.amount2]
            )
        )
    );
    
    // 交换签名
    await exchangeSignatures(channel.counterparty, signature);
    
    return {
        state: newState,
        signature: signature
    };
}

5. Plasma

5.1 Plasma Chain

contract PlasmaChain {
    struct PlasmaBlock {
        bytes32 root;        // Merkle root
        uint256 timestamp;
        address operator;
    }
    
    mapping(uint256 => PlasmaBlock) public plasmaBlocks;
    uint256 public currentBlock;
    
    function submitBlock(bytes32 root) external {
        plasmaBlocks[currentBlock] = PlasmaBlock({
            root: root,
            timestamp: block.timestamp,
            operator: msg.sender
        });
        
        emit BlockSubmitted(currentBlock, root);
        currentBlock++;
    }
    
    function withdraw(
        uint256 blockNum,
        bytes calldata txBytes,
        bytes32[] calldata proof
    ) external {
        require(
            verifyMerkleProof(
                plasmaBlocks[blockNum].root,
                keccak256(txBytes),
                proof
            ),
            "Invalid merkle proof"
        );
        
        // 处理提款
        processWithdrawal(txBytes);
    }
}

5.2 Merkle 树实现

class MerkleTree {
    constructor(leaves) {
        this.leaves = leaves.map(leaf => keccak256(leaf));
        this.layers = [this.leaves];
        this.buildTree();
    }
    
    buildTree() {
        while (this.layers[this.layers.length - 1].length > 1) {
            this.layers.push(
                this.getNextLayer(this.layers[this.layers.length - 1])
            );
        }
    }
    
    getProof(index) {
        let proof = [];
        let currentIndex = index;
        
        for (let i = 0; i < this.layers.length - 1; i++) {
            const layer = this.layers[i];
            const isRight = currentIndex % 2;
            const pairIndex = isRight ? currentIndex - 1 : currentIndex + 1;
            
            if (pairIndex < layer.length) {
                proof.push(layer[pairIndex]);
            }
            
            currentIndex = Math.floor(currentIndex / 2);
        }
        
        return proof;
    }
}

6. 跨 Layer 通信

6.1 消息桥接

contract MessageBridge {
    mapping(bytes32 => bool) public processedMessages;
    
    event MessageSent(
        address indexed from,
        address indexed to,
        bytes data,
        uint256 nonce
    );
    
    function sendMessage(
        address to,
        bytes calldata data
    ) external {
        bytes32 messageHash = keccak256(
            abi.encodePacked(
                msg.sender,
                to,
                data,
                block.number
            )
        );
        
        emit MessageSent(msg.sender, to, data, block.number);
    }
    
    function receiveMessage(
        address from,
        address to,
        bytes calldata data,
        uint256 nonce,
        bytes calldata proof
    ) external {
        bytes32 messageHash = keccak256(
            abi.encodePacked(from, to, data, nonce)
        );
        
        require(
            !processedMessages[messageHash],
            "Message already processed"
        );
        
        require(
            verifyMessageProof(messageHash, proof),
            "Invalid message proof"
        );
        
        processedMessages[messageHash] = true;
        
        // 执行跨层消息
        executeMessage(to, data);
    }
}

6.2 资产桥接

contract TokenBridge {
    mapping(address => mapping(address => uint256)) public deposits;
    
    function deposit(address token, uint256 amount) external {
        IERC20(token).transferFrom(msg.sender, address(this), amount);
        deposits[token][msg.sender] += amount;
        
        emit Deposit(msg.sender, token, amount);
    }
    
    function withdraw(
        address token,
        uint256 amount,
        bytes calldata proof
    ) external {
        require(
            verifyWithdrawalProof(
                msg.sender,
                token,
                amount,
                proof
            ),
            "Invalid withdrawal proof"
        );
        
        deposits[token][msg.sender] -= amount;
        IERC20(token).transfer(msg.sender, amount);
        
        emit Withdrawal(msg.sender, token, amount);
    }
}

7. 性能优化

7.1 批处理优化

contract BatchProcessor {
    struct Batch {
        bytes32[] txHashes;
        uint256 timestamp;
        bytes32 merkleRoot;
    }
    
    function processBatch(Batch calldata batch) external {
        require(
            verifyBatchMerkleRoot(batch.txHashes, batch.merkleRoot),
            "Invalid merkle root"
        );
        
        for (uint i = 0; i < batch.txHashes.length; i++) {
            processTransaction(batch.txHashes[i]);
        }
    }
}

7.2 数据压缩

function compressTransactionData(transactions) {
    // 使用 RLP 编码
    const encoded = ethers.utils.RLP.encode(
        transactions.map(tx => [
            tx.nonce,
            tx.gasPrice,
            tx.gasLimit,
            tx.to,
            tx.value,
            tx.data
        ])
    );
    
    // 使用 zlib 压缩
    return zlib.deflateSync(encoded);
}

8. 相关资源

• Optimism 文档
• zkSync 文档
• Arbitrum 文档
• Polygon 文档
• Layer2 生态概览