《海上钢琴师》与封闭生态：1900作为私有链隐喻

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

contract PrivateChain1900 {
    address public captain;
    mapping(address => bool) public crew;
    mapping(address => bool) public passengers;

    struct Transaction {
        address from;
        address to;
        uint256 value;
        uint256 timestamp;
        string data;
        bool verified;
    }

    Transaction[] public ledger;
    uint256 public constant MAX_TRANSACTIONS_PER_BLOCK = 88;

    modifier onlyCaptain() {
        require(msg.sender == captain, "Only captain");
        _;
    }

    modifier onlyCrew() {
        require(crew[msg.sender], "Only crew");
        _;
    }

    constructor() {
        captain = msg.sender;
        crew[msg.sender] = true;
    }

    function addPassenger(address passenger) external onlyCrew {
        passengers[passenger] = true;
    }

    function submitTransaction(address to, uint256 value, string calldata data) external onlyPassenger {
        require(ledger.length < MAX_TRANSACTIONS_PER_BLOCK, "Block full");
        ledger.push(Transaction({
            from: msg.sender,
            to: to,
            value: value,
            timestamp: block.timestamp,
            data: data,
            verified: false
        }));
    }

    function verifyTransaction(uint256 txId) external onlyCrew {
        require(txId < ledger.length, "Not found");
        require(!ledger[txId].verified, "Already verified");
        ledger[txId].verified = true;
    }

    function isOnChain(address user) external view returns (bool) {
        return crew[user] || passengers[user];
    }
}

from enum import Enum

class NodeRole(Enum):
    CAPTAIN = "captain"
    CREW = "crew"
    PASSENGER = "passenger"

class PrivateChainSimulator:
    def __init__(self, name, max_tx=88):
        self.name = name
        self.max_tx = max_tx
        self.nodes = {}
        self.blocks = []
        self.pending = []

    def add_node(self, address, role):
        if role == NodeRole.CAPTAIN and any(r == NodeRole.CAPTAIN for r in self.nodes.values()):
            print("Captain exists")
            return False
        self.nodes[address] = role
        print(f"Node {address[:8]} joined as {role.value}")
        return True

    def submit_tx(self, fr, to, value, data=""):
        if fr not in self.nodes:
            return None
        tx = {"id": len(self.pending)+1, "from": fr, "to": to, "value": value, "verified": False}
        self.pending.append(tx)
        return tx["id"]

    def verify_tx(self, tx_id, verifier):
        if verifier not in self.nodes or self.nodes[verifier] not in [NodeRole.CAPTAIN, NodeRole.CREW]:
            return False
        for tx in self.pending:
            if tx["id"] == tx_id and not tx["verified"]:
                tx["verified"] = True
                return True
        return False

ship = PrivateChainSimulator("Virginia")
ship.add_node("0x1900", NodeRole.CAPTAIN)
ship.add_node("0xMax", NodeRole.CREW)
ship.add_node("0xPassenger", NodeRole.PASSENGER)
ship.submit_tx("0xPassenger", "0x1900", 100)
print(ship.pending)

class PianoChain {
  constructor() {
    this.keys = 88;
    this.chain = [];
  }

  createBlock(transactions, prevHash) {
    return {
      index: this.chain.length,
      timestamp: Date.now(),
      transactions,
      previousHash: prevHash,
      hash: "piano_" + this.chain.length
    };
  }

  playMelody(notes) {
    if (notes.length > this.keys) {
      console.log("88 keys only!");
      return null;
    }
    const txs = notes.map((n, i) => ({ from: "1900", to: "audience", note: n }));
    const prev = this.chain.length > 0 ? this.chain[this.chain.length-1].hash : "0";
    this.chain.push(this.createBlock(txs, prev));
    console.log("Played: " + notes.join(" "));
  }

  stepOnLand() {
    console.log("1900 looks at the city...");
    console.log("No 88 keys here.");
    return false;
  }
}

const piano = new PianoChain();
piano.playMelody(["C","D","E","F","G","A","B"]);
console.log(piano.chain.length + " blocks");