《绿野仙踪》与Layer 2扩展：翡翠城的乐观Rollup

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract OptimisticRollup is AccessControl, ReentrancyGuard {
    bytes32 public constant SEQUENCER_ROLE = keccak256("SEQUENCER_ROLE");
    bytes32 public constant CHALLENGER_ROLE = keccak256("CHALLENGER_ROLE");

    enum TransactionStatus {
        PENDING, OPTIMISTIC, CHALLENGED, FINALIZED, REVERTED
    }

    struct RollupBlock {
        uint256 blockNumber;
        bytes32 stateRoot;
        bytes32 transactionsRoot;
        bytes32 receiptRoot;
        address proposer;
        uint256 timestamp;
        uint256 challengePeriod;
        bool isFinalized;
    }

    struct L2Transaction {
        bytes32 txHash;
        address sender;
        address target;
        uint256 value;
        bytes data;
        uint256 gasLimit;
        uint256 nonce;
        TransactionStatus status;
        uint256 timestamp;
    }

    struct Challenge {
        uint256 challengeId;
        bytes32 blockHash;
        address challenger;
        bytes32 fraudulentTxHash;
        bytes proof;
        uint256 timestamp;
        bool isResolved;
        bool isValid;
    }

    mapping(uint256 => RollupBlock) public blocks;
    mapping(bytes32 => L2Transaction) public transactions;
    mapping(uint256 => Challenge) public challenges;

    uint256 public blockCount;
    uint256 public transactionCount;
    uint256 public challengeCount;
    uint256 public challengePeriod = 7 days;
    uint256 public bondAmount = 1 ether;

    event BlockProposed(uint256 indexed blockNumber, bytes32 stateRoot, address proposer);
    event TransactionSubmitted(bytes32 indexed txHash, address indexed sender, address target);
    event ChallengeSubmitted(uint256 indexed challengeId, bytes32 indexed blockHash, address challenger);
    event BlockFinalized(uint256 indexed blockNumber, bytes32 stateRoot);

    function proposeBlock(bytes32 _stateRoot, bytes32 _transactionsRoot, bytes32 _receiptRoot) external onlyRole(SEQUENCER_ROLE) {
        blockCount++;
        blocks[blockCount] = RollupBlock({
            blockNumber: blockCount,
            stateRoot: _stateRoot,
            transactionsRoot: _transactionsRoot,
            receiptRoot: _receiptRoot,
            proposer: msg.sender,
            timestamp: block.timestamp,
            challengePeriod: challengePeriod,
            isFinalized: false
        });

        emit BlockProposed(blockCount, _stateRoot, msg.sender);
    }

    function submitTransaction(
        address _target,
        uint256 _value,
        bytes calldata _data,
        uint256 _gasLimit
    ) external returns (bytes32) {
        transactionCount++;
        bytes32 txHash = keccak256(abi.encodePacked(
            msg.sender, _target, _value, _data, _gasLimit, transactionCount
        ));

        transactions[txHash] = L2Transaction({
            txHash: txHash,
            sender: msg.sender,
            target: _target,
            value: _value,
            data: _data,
            gasLimit: _gasLimit,
            nonce: transactionCount,
            status: TransactionStatus.OPTIMISTIC,
            timestamp: block.timestamp
        });

        emit TransactionSubmitted(txHash, msg.sender, _target);
        return txHash;
    }

    function submitChallenge(
        bytes32 _blockHash,
        bytes32 _fraudulentTxHash,
        bytes calldata _proof
    ) external payable onlyRole(CHALLENGER_ROLE) {
        require(msg.value >= bondAmount, "Insufficient bond");
        challengeCount++;

        challenges[challengeCount] = Challenge({
            challengeId: challengeCount,
            blockHash: _blockHash,
            challenger: msg.sender,
            fraudulentTxHash: _fraudulentTxHash,
            proof: _proof,
            timestamp: block.timestamp,
            isResolved: false,
            isValid: false
        });

        emit ChallengeSubmitted(challengeCount, _blockHash, msg.sender);
    }

    function resolveChallenge(uint256 _challengeId, bool _isValid) external onlyRole(SEQUENCER_ROLE) {
        Challenge storage challenge = challenges[_challengeId];
        require(!challenge.isResolved, "Already resolved");

        challenge.isResolved = true;
        challenge.isValid = _isValid;

        if (_isValid) {
            L2Transaction storage tx = transactions[challenge.fraudulentTxHash];
            tx.status = TransactionStatus.REVERTED;
            payable(challenge.challenger).transfer(bondAmount * 2);
        } else {
            payable(blocks[0].proposer).transfer(bondAmount);
        }
    }

    function finalizeBlock(uint256 _blockNumber) external onlyRole(SEQUENCER_ROLE) {
        RollupBlock storage block = blocks[_blockNumber];
        require(!block.isFinalized, "Already finalized");
        require(block.timestamp + challengePeriod < block.timestamp, "Challenge period not over");

        block.isFinalized = true;
        emit BlockFinalized(_blockNumber, block.stateRoot);
    }

    function getTransactionStatus(bytes32 _txHash) external view returns (TransactionStatus) {
        return transactions[_txHash].status;
    }

    function getBlockCount() external view returns (uint256) {
        return blockCount;
    }
}

import hashlib
import json
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from datetime import datetime, timedelta
import random

@dataclass
class L2Block:
    block_number: int
    state_root: str
    transactions_root: str
    proposer: str
    timestamp: int
    is_finalized: bool

@dataclass
class L2Transaction:
    tx_hash: str
    sender: str
    target: str
    value: int
    data: str
    status: str

class OptimisticRollupSimulator:
    def __init__(self, challenge_period: int = 7):
        self.blocks: List[L2Block] = []
        self.transactions: Dict[str, L2Transaction] = {}
        self.challenges: List[Dict] = []
        self.challenge_period = challenge_period
        self.block_count = 0
        self.tx_count = 0

    def propose_block(self, state_root: str, transactions_root: str, proposer: str) -> L2Block:
        self.block_count += 1
        block = L2Block(
            block_number=self.block_count,
            state_root=state_root,
            transactions_root=transactions_root,
            proposer=proposer,
            timestamp=int(datetime.now().timestamp()),
            is_finalized=False
        )
        self.blocks.append(block)
        return block

    def submit_transaction(self, sender: str, target: str, value: int, data: str) -> L2Transaction:
        self.tx_count += 1
        tx_hash = hashlib.sha256(f"{sender}{target}{value}{data}{self.tx_count}".encode()).hexdigest()[:16]
        tx = L2Transaction(
            tx_hash=tx_hash,
            sender=sender,
            target=target,
            value=value,
            data=data,
            status='optimistic'
        )
        self.transactions[tx_hash] = tx
        return tx

    def submit_challenge(self, block_number: int, fraudulent_tx_hash: str, challenger: str) -> Dict:
        challenge = {
            'challenge_id': len(self.challenges) + 1,
            'block_number': block_number,
            'fraudulent_tx_hash': fraudulent_tx_hash,
            'challenger': challenger,
            'timestamp': datetime.now().isoformat(),
            'is_resolved': False,
            'is_valid': False
        }
        self.challenges.append(challenge)

        tx = self.transactions.get(fraudulent_tx_hash)
        if tx:
            tx.status = 'challenged'

        return challenge

    def resolve_challenge(self, challenge_id: int, is_valid: bool) -> Dict:
        challenge = self.challenges[challenge_id - 1]
        challenge['is_resolved'] = True
        challenge['is_valid'] = is_valid

        if is_valid:
            tx = self.transactions.get(challenge['fraudulent_tx_hash'])
            if tx:
                tx.status = 'reverted'

        return {'success': True, 'is_valid': is_valid}

    def finalize_block(self, block_number: int) -> Dict:
        block = self.blocks[block_number - 1]
        if block.is_finalized:
            return {'success': False, 'error': 'Already finalized'}

        now = int(datetime.now().timestamp())
        if now < block.timestamp + self.challenge_period * 86400:
            return {'success': False, 'error': 'Challenge period not over'}

        block.is_finalized = True
        return {'success': True, 'block_number': block_number}

    def calculate_l2_gas_savings(self, l1_gas_cost: float, l2_gas_cost: float) -> float:
        return (l1_gas_cost - l2_gas_cost) / l1_gas_cost * 100

    def simulate_oz_journey(self, num_transactions: int = 100) -> Dict:
        proposer = '0xSequencer'
        state_root = hashlib.sha256(b'state').hexdigest()

        self.propose_block(state_root, hashlib.sha256(b'tx').hexdigest(), proposer)

        for i in range(num_transactions):
            self.submit_transaction(
                f'0xDorothy{i}',
                f'0xEmeraldCity{i}',
                random.randint(1, 1000),
                f'move_to_oz_{i}'
            )

        return {
            'blocks': len(self.blocks),
            'transactions': len(self.transactions),
            'finalized': sum(1 for b in self.blocks if b.is_finalized),
            'gas_savings': self.calculate_l2_gas_savings(100, 0.1)
        }

rollup = OptimisticRollupSimulator()
result = rollup.simulate_oz_journey(50)
print(f"L2 transactions: {result['transactions']}, Gas savings: {result['gas_savings']:.1f}%")

const { ethers } = require('ethers');
const crypto = require('crypto');

class OptimisticRollupClient {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.blocks = [];
    this.transactions = new Map();
    this.challenges = [];
    this.blockCount = 0;
    this.txCount = 0;
    this.challengePeriod = 7 * 86400;
  }

  async proposeBlock(stateRoot, transactionsRoot, proposer) {
    this.blockCount++;
    const block = {
      blockNumber: this.blockCount,
      stateRoot,
      transactionsRoot,
      proposer,
      timestamp: Math.floor(Date.now() / 1000),
      isFinalized: false
    };
    this.blocks.push(block);
    return block;
  }

  async submitTransaction(sender, target, value, data) {
    this.txCount++;
    const txHash = ethers.utils.keccak256(
      ethers.utils.toUtf8Bytes(`${sender}${target}${value}${data}${this.txCount}`)
    );

    const tx = {
      txHash,
      sender,
      target,
      value: ethers.BigNumber.from(value),
      data,
      status: 'optimistic'
    };

    this.transactions.set(txHash, tx);
    return tx;
  }

  async submitChallenge(blockNumber, fraudulentTxHash, challenger) {
    const challenge = {
      challengeId: this.challenges.length + 1,
      blockNumber,
      fraudulentTxHash,
      challenger,
      timestamp: Math.floor(Date.now() / 1000),
      isResolved: false,
      isValid: false
    };

    this.challenges.push(challenge);
    const tx = this.transactions.get(fraudulentTxHash);
    if (tx) tx.status = 'challenged';

    return challenge;
  }

  async resolveChallenge(challengeId, isValid) {
    const challenge = this.challenges[challengeId - 1];
    challenge.isResolved = true;
    challenge.isValid = isValid;

    if (isValid) {
      const tx = this.transactions.get(challenge.fraudulentTxHash);
      if (tx) tx.status = 'reverted';
    }

    return { success: true, isValid };
  }

  async finalizeBlock(blockNumber) {
    const block = this.blocks[blockNumber - 1];
    if (!block || block.isFinalized) return { success: false };

    const now = Math.floor(Date.now() / 1000);
    if (now < block.timestamp + this.challengePeriod) {
      return { success: false, error: 'Challenge period not over' };
    }

    block.isFinalized = true;
    return { success: true };
  }

  calculateGasSavings(l1Gas, l2Gas) {
    return ((l1Gas - l2Gas) / l1Gas * 100).toFixed(1);
  }
}

const client = new OptimisticRollupClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
client.proposeBlock('0xStateRoot', '0xTxRoot', '0xSequencer')
  .then(b => console.log('L2 block:', b.blockNumber));