《黑客帝国》与数字身份：当红蓝药丸变成公钥与私钥

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

contract MatrixAwakening {
    enum Pill { None, Blue, Red }

    struct Human {
        address nodeId;
        string name;
        Pill chosenPill;
        uint256 awakenedAt;
        bool isOperator;
        mapping(address => bool) canSeeCode;
    }

    address public morpheusNode;
    mapping(address => Human) public humans;
    address[] public awakenedNodes;
    bool public zionReachable;

    event PillChosen(address indexed nodeId, Pill pill);
    event Awakening(address indexed nodeId, uint256 blockNumber);
    event OperatorDetected(address indexed nodeId);

    modifier onlyMorpheus() {
        require(msg.sender == morpheusNode, "Only Morpheus can offer pills");
        _;
    }

    constructor() {
        morpheusNode = msg.sender;
    }

    function offerPill(address humanAddress, Pill pill) external onlyMorpheus {
        require(pill != Pill.None, "Must offer a valid pill");
        Human storage h = humans[humanAddress];
        h.chosenPill = pill;
        emit PillChosen(humanAddress, pill);
    }

    function takeRedPill() external {
        Human storage h = humans[msg.sender];
        require(h.chosenPill == Pill.Red, "You must be offered a red pill");
        require(h.awakenedAt == 0, "Already awakened");

        h.awakenedAt = block.timestamp;
        h.nodeId = msg.sender;
        awakenedNodes.push(msg.sender);

        if (awakenedNodes.length >= 100) {
            zionReachable = true;
        }

        emit Awakening(msg.sender, block.number);
    }

    function grantOperator(address nodeId) external onlyMorpheus {
        Human storage h = humans[nodeId];
        require(h.awakenedAt > 0, "Node must be awakened");
        h.isOperator = true;
        emit OperatorDetected(nodeId);
    }

    function canSeeTheCode(address nodeId) external view returns (bool) {
        Human storage h = humans[nodeId];
        return h.isOperator;
    }

    function totalAwakened() external view returns (uint256) {
        return awakenedNodes.length;
    }
}

import hashlib
import time
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class MatrixNode:
    node_id: str
    is_awake: bool = False
    can_see_code: bool = False
    pill_received: Optional[str] = None
    belief_score: float = 0.0  # 0 = fully in Matrix, 1 = fully awakened

class MatrixProtocol:
    def __init__(self):
        self.nodes: dict[str, MatrixNode] = {}
        self.agents: dict[str, bool] = {}
        self.block_height = 0

    def register_node(self, node_id: str) -> str:
        """Register a new node in the Matrix"""
        node_hash = hashlib.sha256(node_id.encode()).hexdigest()[:12]
        self.nodes[node_hash] = MatrixNode(node_id=node_hash)
        return node_hash

    def offer_pill(self, node_hash: str, pill_type: str) -> bool:
        """Morpheus offers a pill to a node"""
        node = self.nodes.get(node_hash)
        if not node:
            return False
        node.pill_received = pill_type
        return True

    def take_red_pill(self, node_hash: str) -> dict:
        """Execute the awakening transaction"""
        node = self.nodes.get(node_hash)
        if not node or node.pill_received != "red":
            return {"status": "failed", "reason": "No red pill offered"}

        # Awakening requires multiple confirmations
        confirmations = []
        for other_hash, other_node in self.nodes.items():
            if other_node.is_awake:
                confirmations.append(other_hash)

        if len(confirmations) >= 3:
            node.is_awake = True
            node.belief_score = 1.0
            self.block_height += 1
            return {
                "status": "awakened",
                "node": node_hash,
                "confirmations": len(confirmations),
                "block": self.block_height,
                "timestamp": time.time()
            }
        return {"status": "pending", "reason": "Not enough validators"}

    def agent_attack(self, target_hash: str) -> bool:
        """Agent Smith tries to delete a node"""
        node = self.nodes.get(target_hash)
        if not node:
            return False
        # Agent can only delete nodes that are NOT fully awakened
        if node.belief_score < 1.0:
            del self.nodes[target_hash]
            return True
        return False

    def neo_see_code(self, node_hash: str) -> bool:
        """Neo's ability to see the code"""
        node = self.nodes.get(node_hash)
        if not node or not node.is_awake:
            return False
        # The One can see the code after full awakening
        node.can_see_code = True
        return True

# Simulate the Matrix
matrix = MatrixProtocol()
neo = matrix.register_node("Neo")
morpheus = matrix.register_node("Morpheus")
trinity = matrix.register_node("Trinity")
switch = matrix.register_node("Switch")

matrix.offer_pill(neo, "red")
matrix.offer_pill(morpheus, "red")
matrix.offer_pill(trinity, "red")
matrix.offer_pill(switch, "red")

for node in [neo, morpheus, trinity]:
    result = matrix.take_red_pill(node)
    print(f"Node {node}: {result['status']}")

result = matrix.take_red_pill(switch)
print(f"Node {switch}: {result['status']}")

matrix.neo_see_code(neo)
print(f"Neo can see code: {matrix.nodes[neo].can_see_code}")
print(f"Agent attack on Neo: {matrix.agent_attack(neo)}")

class MatrixConsensus {
  constructor() {
    this.nodes = new Map();
    this.difficulty = 100000; // PoW difficulty target
    this.chain = [];
    this.theOne = null;
  }

  addNode(nodeId, power = 1) {
    this.nodes.set(nodeId, {
      id: nodeId,
      power,
      blocksMined: 0,
      belief: 0,
      alive: true
    });
  }

  // Simulate PoW mining for becoming The One
  mineBlock(nodeId) {
    const node = this.nodes.get(nodeId);
    if (!node || !node.alive) return null;

    const target = this.difficulty / node.power;
    let hash = 0;
    let nonce = 0;

    // Proof of Work: find a hash below target
    do {
      hash = this.simpleHash(nodeId + nonce + this.chain.length);
      nonce++;
    } while (hash > target);

    node.blocksMined++;
    node.belief += 1 / node.blocksMined;

    const block = {
      miner: nodeId,
      nonce,
      hash,
      height: this.chain.length,
      previousHash: this.chain.length > 0 
        ? this.chain[this.chain.length - 1].hash 
        : 'genesis',
      timestamp: Date.now()
    };

    this.chain.push(block);

    // Check if this node has enough "belief" to become The One
    if (node.belief >= 3.0 && !this.theOne) {
      this.theOne = nodeId;
      this.activateNeoMode(nodeId);
    }

    return block;
  }

  simpleHash(input) {
    let hash = 0;
    for (let i = 0; i < input.length; i++) {
      const char = input.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash;
    }
    return Math.abs(hash);
  }

  activateNeoMode(nodeId) {
    const node = this.nodes.get(nodeId);
    node.canSeeCode = true;
    console.log(`🎆 ${nodeId} has become The One!`);
    console.log(`   Can see the code: ${node.canSeeCode}`);
  }

  agentAttack(targetId) {
    // Agent can only delete non-One nodes
    if (targetId === this.theOne) return false;
    this.nodes.delete(targetId);
    return true;
  }

  getStatus() {
    return {
      chainHeight: this.chain.length,
      activeNodes: this.nodes.size,
      theOne: this.theOne,
      difficulty: this.difficulty
    };
  }
}

// Run the simulation
const matrix = new MatrixConsensus();
matrix.addNode('Neo', 10);
matrix.addNode('Morpheus', 5);
matrix.addNode('Trinity', 5);
matrix.addNode('Switch', 2);
matrix.addNode('AgentSmith', 100);

// Mine blocks
for (let i = 0; i < 20; i++) {
  const miners = ['Neo', 'Morpheus', 'Trinity', 'Switch'];
  const miner = miners[Math.floor(Math.random() * miners.length)];
  const block = matrix.mineBlock(miner);
  if (block) {
    console.log(`Block ${block.height} mined by ${block.miner} (nonce: ${block.nonce})`);
  }
}

console.log('\nFinal Status:', matrix.getStatus());