《愤怒的公牛》与PoW共识：拳击作为工作量证明的隐喻

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

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

contract PoWConsensus is AccessControl {
    bytes32 public constant MINER_ROLE = keccak256("MINER_ROLE");
    bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");

    struct Block {
        uint256 blockNumber;
        uint256 timestamp;
        bytes32 parentHash;
        bytes32 stateRoot;
        bytes32 transactionsRoot;
        bytes32 receiptRoot;
        address miner;
        uint256 difficulty;
        uint256 nonce;
        bytes32 hash;
        uint256 reward;
        bool isValid;
    }

    struct Miner {
        address minerAddress;
        uint256 hashPower;
        uint256 totalBlocksMined;
        uint256 totalRewards;
        uint256 lastMined;
        bool isActive;
    }

    struct MiningRound {
        uint256 roundId;
        uint256 startTime;
        uint256 endTime;
        uint256 difficulty;
        uint256 totalHashPower;
        uint256 blocksMined;
        address[] participants;
        uint256 totalRewards;
    }

    mapping(uint256 => Block) public blocks;
    mapping(address => Miner) public miners;
    mapping(uint256 => MiningRound) public rounds;

    uint256 public currentBlockNumber;
    uint256 public currentDifficulty;
    uint256 public totalHashPower;
    uint256 public activeMiners;
    uint256 public blockReward = 6.25 ether;
    uint256 public difficultyAdjustmentInterval = 2016;
    uint256 public targetBlockTime = 600;

    event BlockMined(uint256 indexed blockNumber, address indexed miner, bytes32 hash);
    event DifficultyAdjusted(uint256 oldDifficulty, uint256 newDifficulty);
    event MinerRegistered(address indexed miner, uint256 hashPower);

    function registerMiner(uint256 _hashPower) external {
        require(miners[msg.sender].minerAddress == address(0), "Already registered");
        miners[msg.sender] = Miner({
            minerAddress: msg.sender,
            hashPower: _hashPower,
            totalBlocksMined: 0,
            totalRewards: 0,
            lastMined: 0,
            isActive: true
        });
        activeMiners++;
        totalHashPower += _hashPower;
        _grantRole(MINER_ROLE, msg.sender);
        emit MinerRegistered(msg.sender, _hashPower);
    }

    function mineBlock(
        bytes32 _parentHash,
        bytes32 _stateRoot,
        bytes32 _transactionsRoot,
        uint256 _nonce
    ) external onlyRole(MINER_ROLE) returns (uint256) {
        require(miners[msg.sender].isActive, "Miner not active");

        currentBlockNumber++;
        bytes32 blockHash = keccak256(abi.encodePacked(
            currentBlockNumber,
            block.timestamp,
            _parentHash,
            _stateRoot,
            _transactionsRoot,
            msg.sender,
            currentDifficulty,
            _nonce
        ));

        require(validateProofOfWork(blockHash, currentDifficulty), "Invalid PoW");

        Block memory newBlock = Block({
            blockNumber: currentBlockNumber,
            timestamp: block.timestamp,
            parentHash: _parentHash,
            stateRoot: _stateRoot,
            transactionsRoot: _transactionsRoot,
            receiptRoot: bytes32(0),
            miner: msg.sender,
            difficulty: currentDifficulty,
            nonce: _nonce,
            hash: blockHash,
            reward: blockReward,
            isValid: true
        });

        blocks[currentBlockNumber] = newBlock;
        miners[msg.sender].totalBlocksMined++;
        miners[msg.sender].totalRewards += blockReward;
        miners[msg.sender].lastMined = block.timestamp;

        emit BlockMined(currentBlockNumber, msg.sender, blockHash);
        return currentBlockNumber;
    }

    function validateProofOfWork(bytes32 _hash, uint256 _difficulty) internal pure returns (bool) {
        uint256 target = type(uint256).max / _difficulty;
        return uint256(_hash) < target;
    }

    function adjustDifficulty() external onlyRole(VALIDATOR_ROLE) {
        if (currentBlockNumber % difficultyAdjustmentInterval != 0) return;

        uint256 oldDifficulty = currentDifficulty;
        uint256 timeElapsed = blocks[currentBlockNumber].timestamp - blocks[currentBlockNumber - difficultyAdjustmentInterval].timestamp;
        uint256 expectedTime = difficultyAdjustmentInterval * targetBlockTime;

        if (timeElapsed < expectedTime / 2) {
            currentDifficulty = currentDifficulty * 2;
        } else if (timeElapsed > expectedTime * 2) {
            currentDifficulty = currentDifficulty / 2;
        }

        emit DifficultyAdjusted(oldDifficulty, currentDifficulty);
    }

    function getMinerStats(address _miner) external view returns (uint256 blocks, uint256 rewards, uint256 hashPower) {
        Miner storage miner = miners[_miner];
        return (miner.totalBlocksMined, miner.totalRewards, miner.hashPower);
    }

    function calculateHashPowerShare(address _miner) external view returns (uint256) {
        if (totalHashPower == 0) return 0;
        return (miners[_miner].hashPower * 10000) / totalHashPower;
    }
}

import hashlib
import time
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from datetime import datetime
import random
import struct

@dataclass
class Block:
    block_number: int
    timestamp: int
    parent_hash: str
    transactions: List[str]
    miner: str
    difficulty: int
    nonce: int
    hash: str
    reward: float

class PoWMiner:
    def __init__(self, miner_address: str, hash_power: int):
        self.miner_address = miner_address
        self.hash_power = hash_power
        self.blocks_mined = 0
        self.total_rewards = 0.0
        self.chain: List[Block] = []
        self.is_mining = False

    def calculate_hash(self, block_number: int, timestamp: int, parent_hash: str,
                       transactions: List[str], miner: str, difficulty: int, nonce: int) -> str:
        block_data = struct.pack('!I', block_number) + \
                     struct.pack('!I', timestamp) + \
                     bytes.fromhex(parent_hash[2:] if parent_hash.startswith('0x') else parent_hash) + \
                     str(transactions).encode() + \
                     miner.encode() + \
                     struct.pack('!I', difficulty) + \
                     struct.pack('!I', nonce)
        return hashlib.sha256(block_data).hexdigest()

    def mine_block(self, parent_hash: str, transactions: List[str], difficulty: int) -> Optional[Block]:
        block_number = len(self.chain) + 1
        timestamp = int(time.time())
        nonce = 0
        target = 2 ** (256 - difficulty)

        self.is_mining = True
        start_time = time.time()

        while self.is_mining:
            block_hash = self.calculate_hash(
                block_number, timestamp, parent_hash,
                transactions, self.miner_address, difficulty, nonce
            )

            if int(block_hash, 16) < target:
                block = Block(
                    block_number=block_number,
                    timestamp=timestamp,
                    parent_hash=parent_hash,
                    transactions=transactions,
                    miner=self.miner_address,
                    difficulty=difficulty,
                    nonce=nonce,
                    hash=block_hash,
                    reward=6.25
                )
                self.blocks_mined += 1
                self.total_rewards += 6.25
                self.chain.append(block)
                self.is_mining = False
                elapsed = time.time() - start_time
                print(f"Block #{block_number} mined in {elapsed:.2f}s - nonce: {nonce}")
                return block

            nonce += 1
            if nonce % 100000 == 0:
                elapsed = time.time() - start_time
                hashrate = nonce / elapsed
                print(f"Mining... {nonce} hashes, hash rate: {hashrate:.0f} H/s")

        return None

    def estimate_mining_time(self, difficulty: int) -> float:
        target = 2 ** (256 - difficulty)
        avg_hashes = 2 ** 256 / target
        return avg_hashes / self.hash_power

    def calculate_hash_power_share(self, total_hash_power: int) -> float:
        return (self.hash_power / total_hash_power) * 100

class MiningPool:
    def __init__(self, pool_address: str, fee_percent: float = 0.01):
        self.pool_address = pool_address
        self.fee_percent = fee_percent
        self.miners: List[PoWMiner] = []
        self.total_hash_power = 0
        self.blocks_mined = 0

    def add_miner(self, miner: PoWMiner):
        self.miners.append(miner)
        self.total_hash_power += miner.hash_power

    def simulate_mining(self, difficulty: int, blocks: int) -> List[Block]:
        mined_blocks = []
        parent_hash = '0x' + '0' * 64

        for _ in range(blocks):
            total_weight = sum(m.hash_power for m in self.miners)
            rand = random.uniform(0, total_weight)
            cumulative = 0

            for miner in self.miners:
                cumulative += miner.hash_power
                if rand <= cumulative:
                    result = miner.mine_block(
                        parent_hash,
                        [f"tx_{i}" for i in range(5)],
                        difficulty
                    )
                    if result:
                        mined_blocks.append(result)
                        parent_hash = result.hash
                        self.blocks_mined += 1
                    break

        return mined_blocks

    def distribute_rewards(self, block: Block) -> Dict[str, float]:
        total_reward = block.reward * (1 - self.fee_percent)
        distributions = {}

        for miner in self.miners:
            share = miner.hash_power / self.total_hash_power
            reward = total_reward * share
            distributions[miner.miner_address] = reward
            miner.total_rewards += reward

        return distributions

pool = MiningPool('0xPool')
miner1 = PoWMiner('0xMiner1', 100)
miner2 = PoWMiner('0xMiner2', 200)
pool.add_miner(miner1)
pool.add_miner(miner2)
print(f"Total hash power: {pool.total_hash_power}")

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

class PoWMiner {
  constructor(minerAddress, hashPower) {
    this.minerAddress = minerAddress;
    this.hashPower = hashPower;
    this.blocksMined = 0;
    this.totalRewards = ethers.BigNumber.from(0);
    this.chain = [];
    this.isMining = false;
  }

  calculateHash(blockNumber, timestamp, parentHash, transactions, miner, difficulty, nonce) {
    const data = Buffer.concat([
      Buffer.from(blockNumber.toString(16).padStart(8, '0'), 'hex'),
      Buffer.from(timestamp.toString(16).padStart(8, '0'), 'hex'),
      Buffer.from(parentHash.slice(2), 'hex'),
      Buffer.from(JSON.stringify(transactions)),
      Buffer.from(miner),
      Buffer.from(difficulty.toString(16).padStart(8, '0'), 'hex'),
      Buffer.from(nonce.toString(16).padStart(8, '0'), 'hex')
    ]);
    return crypto.createHash('sha256').update(data).digest('hex');
  }

  async mineBlock(parentHash, transactions, difficulty) {
    const blockNumber = this.chain.length + 1;
    const timestamp = Math.floor(Date.now() / 1000);
    let nonce = 0;
    const target = BigInt(2) ** BigInt(256 - difficulty);

    this.isMining = true;
    const startTime = Date.now();

    while (this.isMining) {
      const blockHash = this.calculateHash(
        blockNumber, timestamp, parentHash,
        transactions, this.minerAddress, difficulty, nonce
      );

      const hashInt = BigInt('0x' + blockHash);
      if (hashInt < target) {
        const block = {
          blockNumber,
          timestamp,
          parentHash,
          transactions,
          miner: this.minerAddress,
          difficulty,
          nonce,
          hash: blockHash,
          reward: ethers.utils.parseEther('6.25')
        };

        this.blocksMined++;
        this.totalRewards = this.totalRewards.add(block.reward);
        this.chain.push(block);
        this.isMining = false;

        const elapsed = (Date.now() - startTime) / 1000;
        console.log(`Block #${blockNumber} mined in ${elapsed}s - nonce: ${nonce}`);
        return block;
      }

      nonce++;
      if (nonce % 100000 === 0) {
        const elapsed = (Date.now() - startTime) / 1000;
        const hashRate = nonce / elapsed;
        console.log(`Mining... ${nonce} hashes, ${hashRate.toFixed(0)} H/s`);
      }
    }

    return null;
  }

  estimateMiningTime(difficulty) {
    const target = BigInt(2) ** BigInt(256 - difficulty);
    const maxHash = BigInt(2) ** BigInt(256);
    const avgHashes = Number(maxHash / target);
    return avgHashes / this.hashPower;
  }

  calculateHashPowerShare(totalHashPower) {
    return (this.hashPower / totalHashPower) * 100;
  }

  getStats() {
    return {
      address: this.minerAddress,
      hashPower: this.hashPower,
      blocksMined: this.blocksMined,
      totalRewards: ethers.utils.formatEther(this.totalRewards),
      chainLength: this.chain.length
    };
  }
}

class MiningPool {
  constructor(poolAddress, feePercent = 0.01) {
    this.poolAddress = poolAddress;
    this.feePercent = feePercent;
    this.miners = [];
    this.totalHashPower = 0;
    this.blocksMined = 0;
  }

  addMiner(miner) {
    this.miners.push(miner);
    this.totalHashPower += miner.hashPower;
  }

  async simulateMiningRound(difficulty, blocks) {
    const minedBlocks = [];
    let parentHash = '0x' + '0'.repeat(64);

    for (let i = 0; i < blocks; i++) {
      const totalWeight = this.miners.reduce((sum, m) => sum + m.hashPower, 0);
      let rand = Math.random() * totalWeight;
      let cumulative = 0;

      for (const miner of this.miners) {
        cumulative += miner.hashPower;
        if (rand <= cumulative) {
          const result = await miner.mineBlock(
            parentHash,
            [`tx_${i}_0`, `tx_${i}_1`, `tx_${i}_2`],
            difficulty
          );
          if (result) {
            minedBlocks.push(result);
            parentHash = result.hash;
            this.blocksMined++;
          }
          break;
        }
      }
    }

    return minedBlocks;
  }

  distributeRewards(block) {
    const totalReward = Number(ethers.utils.formatEther(block.reward)) * (1 - this.feePercent);
    const distributions = {};

    for (const miner of this.miners) {
      const share = miner.hashPower / this.totalHashPower;
      const reward = totalReward * share;
      distributions[miner.minerAddress] = reward;
    }

    return distributions;
  }
}

const pool = new MiningPool('0xPool');
const miner1 = new PoWMiner('0xMiner1', 100);
const miner2 = new PoWMiner('0xMiner2', 200);
pool.addMiner(miner1);
pool.addMiner(miner2);
console.log('Total hash power:', pool.totalHashPower);