《大都会》与阶级Token化：L1工人与L2精英的双城记

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

contract MetropolisMediator {
    address public freder; // 调解者
    uint256 public constant LABOR_POWER = 1 ether; // 一份劳动 = 1票
    uint256 public constant CAPITAL_POWER = 10 ether; // 一份资本 = 10票

    mapping(address => uint256) public laborStaked; // 工人质押的劳动
    mapping(address => uint256) public capitalStaked; // 精英质押的资本
    mapping(address => uint256) public votingPower; // 投票权

    event ProposalCreated(uint256 id, string description, uint256 deadline);
    event VoteCast(address voter, uint256 proposalId, bool support, uint256 power);
    event MediationExecuted(uint256 proposalId, bool passed);

    struct Proposal {
        string description;
        uint256 deadline;
        uint256 forVotes;
        uint256 againstVotes;
        bool executed;
    }

    Proposal[] public proposals;

    modifier onlyFreder() {
        require(msg.sender == freder, "Only the mediator can call this");
        _;
    }

    constructor() {
        freder = msg.sender;
    }

    // 工人质押劳动证明（PoW）
    function stakeLabor(uint256 amount) external {
        laborStaked[msg.sender] += amount;
        votingPower[msg.sender] = amount * LABOR_POWER;
    }

    // 精英质押资本证明（PoS）
    function stakeCapital(uint256 amount) external {
        capitalStaked[msg.sender] += amount;
        votingPower[msg.sender] = amount * CAPITAL_POWER;
    }

    // 创建提案——调解者发起
    function createProposal(string calldata description, uint256 duration) external onlyFreder {
        proposals.push(Proposal({
            description: description,
            deadline: block.timestamp + duration,
            forVotes: 0,
            againstVotes: 0,
            executed: false
        }));
    }

    // 投票——工人和精英共同参与
    function vote(uint256 proposalId, bool support) external {
        require(votingPower[msg.sender] > 0, "No voting power");
        require(block.timestamp < proposals[proposalId].deadline, "Voting ended");

        uint256 power = votingPower[msg.sender];
        if (support) {
            proposals[proposalId].forVotes += power;
        } else {
            proposals[proposalId].againstVotes += power;
        }

        // 投票后消耗投票权（防止重复投票）
        votingPower[msg.sender] = 0;
    }

    // 执行提案——调解者平衡两个世界
    function executeProposal(uint256 proposalId) external onlyFreder {
        Proposal storage p = proposals[proposalId];
        require(!p.executed, "Already executed");
        require(block.timestamp >= p.deadline, "Voting not ended");

        bool passed = p.forVotes > p.againstVotes;
        p.executed = true;

        emit MediationExecuted(proposalId, passed);
    }
}

import asyncio
from web3 import Web3
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

class MetropolisOnChainAnalyzer:
    """
    分析《大都会》双层网络中的交易流
    L1（工人层）= 高Gas消耗，低价值
    L2（精英层）= 低Gas消耗，高价值
    """
    
    def __init__(self, rpc_url: str):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.labor_address = "0xLaboR.....0001"  # 工人合约地址
        self.capital_address = "0xCapiTAL.....0002"  # 精英合约地址
        
    async def fetch_transactions(self, block_range: tuple) -> pd.DataFrame:
        """获取指定区块范围内的所有交易"""
        txs = []
        for block_num in range(block_range[0], block_range[1]):
            block = self.w3.eth.get_block(block_num, full_transactions=True)
            for tx in block.transactions:
                gas_cost = tx.gas * tx.gas_price
                txs.append({
                    'block': block_num,
                    'hash': tx.hash.hex(),
                    'from': tx['from'],
                    'to': tx.to,
                    'value': tx.value / 1e18,  # 转换为ETH
                    'gas_used': tx.gas,
                    'gas_price': tx.gas_price / 1e9,  # 转换为Gwei
                    'gas_cost_eth': gas_cost / 1e18,
                    'timestamp': block.timestamp
                })
        return pd.DataFrame(txs)
    
    def classify_layer(self, df: pd.DataFrame) -> pd.DataFrame:
        """
        根据交易特征分类L1（工人层）和L2（精英层）
        工人层：高频小额，高Gas消耗
        精英层：低频大额，低Gas消耗
        """
        df['layer'] = 'unknown'
        
        # 如果gas_cost_eth > 0.01且value < 0.1，标记为L1
        df.loc[(df['gas_cost_eth'] > 0.01) & (df['value'] < 0.1), 'layer'] = 'L1'
        
        # 如果gas_cost_eth < 0.001且value > 1.0，标记为L2
        df.loc[(df['gas_cost_eth'] < 0.001) & (df['value'] > 1.0), 'layer'] = 'L2'
        
        return df
    
    def calculate_extraction_ratio(self, df: pd.DataFrame) -> float:
        """
        计算经济剥削率
        = (L2净收益 - L1净收益) / L1净收益
        """
        l1_df = df[df['layer'] == 'L1']
        l2_df = df[df['layer'] == 'L2']
        
        l1_net = l1_df['value'].sum() - l1_df['gas_cost_eth'].sum()
        l2_net = l2_df['value'].sum() - l2_df['gas_cost_eth'].sum()
        
        if l1_net == 0:
            return float('inf')
        
        return (l2_net - l1_net) / abs(l1_net)
    
    async def analyze(self, block_range: tuple) -> dict:
        """执行完整分析"""
        df = await self.fetch_transactions(block_range)
        df = self.classify_layer(df)
        
        extraction_ratio = self.calculate_extraction_ratio(df)
        
        result = {
            'total_blocks': block_range[1] - block_range[0],
            'total_transactions': len(df),
            'l1_transactions': len(df[df['layer'] == 'L1']),
            'l2_transactions': len(df[df['layer'] == 'L2']),
            'l1_gas_cost': df[df['layer'] == 'L1']['gas_cost_eth'].sum(),
            'l2_gas_cost': df[df['layer'] == 'L2']['gas_cost_eth'].sum(),
            'l1_value': df[df['layer'] == 'L1']['value'].sum(),
            'l2_value': df[df['layer'] == 'L2']['value'].sum(),
            'extraction_ratio': extraction_ratio,
            'timestamp': datetime.now().isoformat()
        }
        
        return result
    
    def visualize(self, df: pd.DataFrame):
        """可视化L1和L2的交易分布"""
        fig, axes = plt.subplots(2, 2, figsize=(14, 10))
        
        # 1. Gas消耗对比
        l1_data = df[df['layer'] == 'L1']['gas_cost_eth']
        l2_data = df[df['layer'] == 'L2']['gas_cost_eth']
        axes[0, 0].boxplot([l1_data, l2_data], labels=['L1 (Workers)', 'L2 (Elites)'])
        axes[0, 0].set_title('Gas Cost per Transaction (ETH)')
        axes[0, 0].set_ylabel('Gas Cost (ETH)')
        
        # 2. 交易价值对比
        axes[0, 1].hist([l1_data, l2_data], bins=30, alpha=0.7, 
                        label=['L1 Workers', 'L2 Elites'])
        axes[0, 1].set_title('Transaction Value Distribution')
        axes[0, 1].set_xlabel('Value (ETH)')
        axes[0, 1].set_ylabel('Frequency')
        axes[0, 1].legend()
        
        # 3. 时间序列 - Gas消耗
        l1_ts = df[df['layer'] == 'L1'].groupby('timestamp')['gas_cost_eth'].sum()
        l2_ts = df[df['layer'] == 'L2'].groupby('timestamp')['gas_cost_eth'].sum()
        axes[1, 0].plot(l1_ts.index, l1_ts.values, label='L1 Gas', alpha=0.8)
        axes[1, 0].plot(l2_ts.index, l2_ts.values, label='L2 Gas', alpha=0.8)
        axes[1, 0].set_title('Gas Cost Over Time')
        axes[1, 0].set_xlabel('Time')
        axes[1, 0].set_ylabel('Gas Cost (ETH)')
        axes[1, 0].legend()
        
        # 4. 剥削率热力图
        extraction_ratios = []
        for i in range(10):
            subset = df.iloc[i::10]
            l1_net = subset[subset['layer'] == 'L1']['value'].sum() - \
                     subset[subset['layer'] == 'L1']['gas_cost_eth'].sum()
            l2_net = subset[subset['layer'] == 'L2']['value'].sum() - \
                     subset[subset['layer'] == 'L2']['gas_cost_eth'].sum()
            extraction_ratios.append((l2_net - l1_net) / abs(l1_net) if l1_net != 0 else 0)
        
        axes[1, 1].bar(range(10), extraction_ratios)
        axes[1, 1].set_title('Extraction Ratio by Sample Window')
        axes[1, 1].set_xlabel('Sample Window')
        axes[1, 1].set_ylabel('Extraction Ratio')
        axes[1, 1].axhline(y=1, color='r', linestyle='--', label='Equality Line')
        axes[1, 1].legend()
        
        plt.tight_layout()
        plt.savefig('metropolis_onchain_analysis.png', dpi=150)
        plt.show()

# 执行分析
async def main():
    analyzer = MetropolisOnChainAnalyzer("https://ethereum.example.com/rpc")
    result = await analyzer.analyze((18000000, 18001000))
    print(f"Extraction Ratio: {result['extraction_ratio']:.2f}x")
    print(f"L1 Workers paid {result['l1_gas_cost']:.2f} ETH in gas")
    print(f"L2 Elites enjoyed {result['l2_value']:.2f} ETH in value")

# asyncio.run(main())

// Metropolis Mediator DAO - Governance Interface
// 连接L1（工人）和L2（精英）的治理DApp

const Web3 = require('web3');
const ethers = require('ethers');

class MetropolisGovernance {
  constructor(contractAddress, abi, providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.contract = new ethers.Contract(contractAddress, abi, this.provider);
    this.web3 = new Web3(providerUrl);
    
    // 治理参数
    this.weights = {
      laborWeight: 1,    // 工人投票权权重
      capitalWeight: 10,  // 精英投票权权重
    };
    
    this.statistics = {
      totalProposals: 0,
      passedProposals: 0,
      rejectedProposals: 0,
      laborParticipation: 0,
      capitalParticipation: 0,
    };
  }

  /**
   * 创建新提案 - 仅调解者（Freder）可调用
   */
  async createProposal(description, durationInDays = 7) {
    const signer = this.provider.getSigner();
    const contractWithSigner = this.contract.connect(signer);
    
    const duration = durationInDays * 24 * 60 * 60; // 转换为秒
    const tx = await contractWithSigner.createProposal(description, duration);
    const receipt = await tx.wait();
    
    this.statistics.totalProposals++;
    
    return {
      transactionHash: receipt.transactionHash,
      proposalId: receipt.events[0].args.proposalId.toString(),
      description,
      deadline: new Date(Date.now() + duration * 1000).toISOString(),
    };
  }

  /**
   * 投票 - 支持或反对提案
   * voterType: 'labor' | 'capital'
   */
  async vote(proposalId, support, voterType) {
    const signer = this.provider.getSigner();
    const address = await signer.getAddress();
    
    // 计算投票权重
    let power;
    if (voterType === 'labor') {
      power = await this.contract.laborStaked(address) * this.weights.laborWeight;
      this.statistics.laborParticipation++;
    } else {
      power = await this.contract.capitalStaked(address) * this.weights.capitalWeight;
      this.statistics.capitalParticipation++;
    }
    
    if (power === 0) {
      throw new Error(`No voting power for ${voterType} address ${address}`);
    }
    
    const contractWithSigner = this.contract.connect(signer);
    const tx = await contractWithSigner.vote(proposalId, support);
    const receipt = await tx.wait();
    
    const proposal = await this.contract.proposals(proposalId);
    
    return {
      transactionHash: receipt.transactionHash,
      proposalId,
      voter: address,
      voterType,
      votingPower: power.toString(),
      support,
      forVotes: proposal.forVotes.toString(),
      againstVotes: proposal.againstVotes.toString(),
    };
  }

  /**
   * 执行提案 - 调解者平衡两个世界
   */
  async executeProposal(proposalId) {
    const signer = this.provider.getSigner();
    const contractWithSigner = this.contract.connect(signer);
    
    const tx = await contractWithSigner.executeProposal(proposalId);
    const receipt = await tx.wait();
    
    const proposal = await this.contract.proposals(proposalId);
    const passed = proposal.forVotes > proposal.againstVotes;
    
    if (passed) {
      this.statistics.passedProposals++;
    } else {
      this.statistics.rejectedProposals++;
    }
    
    return {
      transactionHash: receipt.transactionHash,
      proposalId,
      passed,
      forVotes: proposal.forVotes.toString(),
      againstVotes: proposal.againstVotes.toString(),
    };
  }

  /**
   * 分析治理公平性 - 计算Gini系数
   */
  calculateGiniCoefficient(voteDistribution) {
    const sorted = voteDistribution.sort((a, b) => a - b);
    const n = sorted.length;
    
    let cumulative = 0;
    let giniSum = 0;
    
    for (let i = 0; i < n; i++) {
      cumulative += sorted[i];
      giniSum += (i + 1) * sorted[i];
    }
    
    if (cumulative === 0) return 0;
    
    const gini = (2 * giniSum) / (n * cumulative) - (n + 1) / n;
    return gini;
  }

  /**
   * 生成治理报告
   */
  async generateReport() {
    const proposalCount = await this.contract.proposals.length;
    const proposals = [];
    
    for (let i = 0; i < proposalCount; i++) {
      const p = await this.contract.proposals(i);
      proposals.push({
        id: i,
        description: p.description,
        deadline: new Date(p.deadline * 1000).toISOString(),
        forVotes: p.forVotes.toString(),
        againstVotes: p.againstVotes.toString(),
        executed: p.executed,
      });
    }
    
    // 计算投票权力集中度
    const powerDistribution = [];
    for (const proposal of proposals) {
      powerDistribution.push(Number(proposal.forVotes));
      powerDistribution.push(Number(proposal.againstVotes));
    }
    
    const gini = this.calculateGiniCoefficient(powerDistribution);
    
    return {
      ...this.statistics,
      proposalCount,
      proposals,
      giniCoefficient: gini,
      governanceHealth: gini < 0.5 ? 'Balanced' : 'Centralized',
      timestamp: new Date().toISOString(),
    };
  }
}

// 使用示例
async function main() {
  const CONTRACT_ADDRESS = '0xMetropolisMediator...';
  const ABI = []; // 合约ABI
  const PROVIDER = 'https://ethereum.example.com';
  
  const dao = new MetropolisGovernance(CONTRACT_ADDRESS, ABI, PROVIDER);
  
  // 创建提案
  const proposal = await dao.createProposal(
    '调整工人工作时长：从10小时/天改为8小时/天'
  );
  console.log('Proposal created:', proposal);
  
  // 工人投票
  const laborVote = await dao.vote(proposal.proposalId, true, 'labor');
  console.log('Labor vote cast:', laborVote);
  
  // 精英投票
  const capitalVote = await dao.vote(proposal.proposalId, false, 'capital');
  console.log('Capital vote cast:', capitalVote);
  
  // 执行提案
  const result = await dao.executeProposal(proposal.proposalId);
  console.log('Proposal executed:', result);
  
  // 生成治理报告
  const report = await dao.generateReport();
  console.log('Governance Report:', JSON.stringify(report, null, 2));
}

// main().catch(console.error);