《飞越疯人院》与无许可网络：精神病院作为中心化机构的隐喻

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

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

contract PermissionlessNetwork is AccessControl, ReentrancyGuard {
    bytes32 public constant NURSE_RATCHET_ROLE = keccak256("NURSE_RATCHET_ROLE");
    bytes32 public constant MCMURPHY_ROLE = keccak256("MCMURPHY_ROLE");

    enum PatientStatus {
        ADMITTED, TREATED, RESTRAINED, SHOCKED, ESCAPED, DISCHARGED
    }

    enum RuleType {
        SCHEDULE, MEDICATION, BEHAVIOR, PRIVILEGE, PUNISHMENT
    }

    struct Patient {
        address patientAddress;
        string name;
        PatientStatus status;
        uint256 admissionDate;
        uint256 ruleViolations;
        bool isRestrained;
        bool isEscaped;
    }

    struct Rule {
        uint256 ruleId;
        string description;
        RuleType ruleType;
        uint256 penalty;
        bool isActive;
        address createdBy;
    }

    struct Vote {
        uint256 voteId;
        string proposal;
        address proposer;
        uint256 forVotes;
        uint256 againstVotes;
        bool isPassed;
        uint256 deadline;
    }

    mapping(address => Patient) public patients;
    mapping(uint256 => Rule) public rules;
    mapping(uint256 => Vote) public votes;

    uint256 public ruleCount;
    uint256 public voteCount;
    uint256 public patientCount;
    bool public isPermissionless = false;

    event PatientAdmitted(address indexed patient, string name);
    patient Escaped(address indexed patient);
    event RuleCreated(uint256 indexed ruleId, string description);
    event VoteCast(uint256 indexed voteId, address indexed voter, bool support);

    function admitPatient(string memory _name) external {
        require(patients[msg.sender].patientAddress == address(0), "Already a patient");
        patientCount++;

        patients[msg.sender] = Patient({
            patientAddress: msg.sender,
            name: _name,
            status: PatientStatus.ADMITTED,
            admissionDate: block.timestamp,
            ruleViolations: 0,
            isRestrained: false,
            isEscaped: false
        });

        emit PatientAdmitted(msg.sender, _name);
    }

    function createRule(string memory _description, RuleType _ruleType, uint256 _penalty) external onlyRole(NURSE_RATCHET_ROLE) {
        ruleCount++;
        rules[ruleCount] = Rule({
            ruleId: ruleCount,
            description: _description,
            ruleType: _ruleType,
            penalty: _penalty,
            isActive: true,
            createdBy: msg.sender
        });

        emit RuleCreated(ruleCount, _description);
    }

    function enforceRule(address _patient, uint256 _ruleId) external onlyRole(NURSE_RATCHET_ROLE) {
        Patient storage patient = patients[_patient];
        Rule storage rule = rules[_ruleId];
        require(rule.isActive, "Rule not active");

        patient.ruleViolations++;
        if (rule._ruleType == RuleType.RESTRAINT) {
            patient.isRestrained = true;
            patient.status = PatientStatus.RESTRAINED;
        } else if (rule._ruleType == RuleType.PUNISHMENT) {
            patient.status = PatientStatus.SHOCKED;
        }
    }

    function escape() external {
        Patient storage patient = patients[msg.sender];
        require(!patient.isRestrained, "Patient is restrained");
        require(!patient.isEscaped, "Already escaped");

        patient.isEscaped = true;
        patient.status = PatientStatus.ESCAPED;

        emit PatientEscaped(msg.sender);
    }

    function proposeVote(string memory _proposal) external {
        voteCount++;
        votes[voteCount] = Vote({
            voteId: voteCount,
            proposal: _proposal,
            proposer: msg.sender,
            forVotes: 0,
            againstVotes: 0,
            isPassed: false,
            deadline: block.timestamp + 7 days
        });
    }

    function castVote(uint256 _voteId, bool _support) external {
        Vote storage vote = votes[_voteId];
        require(block.timestamp < vote.deadline, "Voting ended");

        if (_support) {
            vote.forVotes++;
        } else {
            vote.againstVotes++;
        }

        emit VoteCast(_voteId, msg.sender, _support);
    }

    function setPermissionless(bool _permissionless) external {
        isPermissionless = _permissionless;
    }

    function getFreedomIndex(address _patient) external view returns (uint256) {
        Patient storage patient = patients[_patient];
        if (patient.isEscaped) return 100;
        if (patient.isRestrained) return 0;
        return 100 - (patient.ruleViolations * 10);
    }
}

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

@dataclass
class Patient:
    address: str
    name: str
    status: str
    rule_violations: int
    is_restrained: bool
    is_escaped: bool

class PermissionlessSimulator:
    def __init__(self):
        self.patients: Dict[str, Patient] = {}
        self.rules: List[Dict] = []
        self.votes: List[Dict] = []
        self.is_permissionless = False

    def admit_patient(self, address: str, name: str) -> Patient:
        patient = Patient(
            address=address,
            name=name,
            status='admitted',
            rule_violations=0,
            is_restrained=False,
            is_escaped=False
        )
        self.patients[address] = patient
        return patient

    def create_rule(self, description: str, rule_type: str, penalty: int) -> Dict:
        rule = {
            'rule_id': len(self.rules) + 1,
            'description': description,
            'rule_type': rule_type,
            'penalty': penalty,
            'is_active': True
        }
        self.rules.append(rule)
        return rule

    def enforce_rule(self, patient_address: str, rule_id: int) -> Dict:
        patient = self.patients.get(patient_address)
        rule = self.rules[rule_id - 1] if rule_id <= len(self.rules) else None

        if not patient or not rule:
            return {'success': False, 'error': 'Patient or rule not found'}

        patient.rule_violations += 1
        if rule['rule_type'] == 'restraint':
            patient.is_restrained = True
            patient.status = 'restrained'
        elif rule['rule_type'] == 'shock':
            patient.status = 'shocked'

        return {'success': True, 'patient': patient.name, 'violations': patient.rule_violations}

    def escape(self, patient_address: str) -> Dict:
        patient = self.patients.get(patient_address)
        if not patient:
            return {'success': False, 'error': 'Patient not found'}
        if patient.is_restrained:
            return {'success': False, 'error': 'Patient is restrained'}
        if patient.is_escaped:
            return {'success': False, 'error': 'Already escaped'}

        patient.is_escaped = True
        patient.status = 'escaped'
        return {'success': True, 'message': f'{patient.name} has escaped!'}

    def propose_vote(self, proposal: str, proposer: str) -> Dict:
        vote = {
            'vote_id': len(self.votes) + 1,
            'proposal': proposal,
            'proposer': proposer,
            'for_votes': 0,
            'against_votes': 0,
            'is_passed': False,
            'deadline': datetime.now() + timedelta(days=7)
        }
        self.votes.append(vote)
        return vote

    def cast_vote(self, vote_id: int, voter: str, support: bool) -> Dict:
        vote = self.votes[vote_id - 1] if vote_id <= len(self.votes) else None
        if not vote:
            return {'success': False, 'error': 'Vote not found'}
        if datetime.now() > vote['deadline']:
            return {'success': False, 'error': 'Voting ended'}

        if support:
            vote['for_votes'] += 1
        else:
            vote['against_votes'] += 1

        return {'success': True, 'vote_id': vote_id, 'for': vote['for_votes'], 'against': vote['against_votes']}

    def get_freedom_index(self, patient_address: str) -> int:
        patient = self.patients.get(patient_address)
        if not patient:
            return 0
        if patient.is_escaped:
            return 100
        if patient.is_restrained:
            return 0
        return max(0, 100 - patient.rule_violations * 10)

    def simulate_escape_attempt(self, patient_address: str, num_attempts: int = 100) -> Dict:
        success = 0
        for _ in range(num_attempts):
            patient = self.patients.get(patient_address)
            if not patient:
                continue
            if not patient.is_restrained and not patient.is_escaped:
                result = self.escape(patient_address)
                if result['success']:
                    success += 1
                # Reset for next attempt
                patient.is_escaped = False
                patient.status = 'admitted'

        return {
            'total_attempts': num_attempts,
            'successful_escapes': success,
            'success_rate': (success / num_attempts) * 100
        }

sim = PermissionlessSimulator()
mcMurphy = sim.admit_patient('0xMcMurphy', 'Randle McMurphy')
freedom = sim.get_freedom_index('0xMcMurphy')
print(f"Freedom index: {freedom}")

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

class PermissionlessClient {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.patients = new Map();
    this.rules = [];
    this.votes = [];
    this.isPermissionless = false;
  }

  async admitPatient(address, name) {
    const patient = {
      address,
      name,
      status: 'admitted',
      ruleViolations: 0,
      isRestrained: false,
      isEscaped: false,
      admissionDate: Math.floor(Date.now() / 1000)
    };
    this.patients.set(address, patient);
    return patient;
  }

  async createRule(description, ruleType, penalty) {
    const rule = {
      ruleId: this.rules.length + 1,
      description,
      ruleType,
      penalty,
      isActive: true,
      createdBy: 'nurse_ratchet'
    };
    this.rules.push(rule);
    return rule;
  }

  async enforceRule(patientAddress, ruleId) {
    const patient = this.patients.get(patientAddress);
    const rule = this.rules[ruleId - 1];

    if (!patient || !rule) return { success: false };
    patient.ruleViolations++;

    if (rule.ruleType === 'restraint') {
      patient.isRestrained = true;
      patient.status = 'restrained';
    } else if (rule.ruleType === 'shock') {
      patient.status = 'shocked';
    }

    return { success: true, patient: patient.name, violations: patient.ruleViolations };
  }

  async escape(patientAddress) {
    const patient = this.patients.get(patientAddress);
    if (!patient) return { success: false, error: 'Not found' };
    if (patient.isRestrained) return { success: false, error: 'Restrained' };

    patient.isEscaped = true;
    patient.status = 'escaped';
    return { success: true, message: `${patient.name} has escaped!` };
  }

  async proposeVote(proposal, proposer) {
    const vote = {
      voteId: this.votes.length + 1,
      proposal,
      proposer,
      forVotes: 0,
      againstVotes: 0,
      isPassed: false,
      deadline: Math.floor(Date.now() / 1000) + 7 * 86400
    };
    this.votes.push(vote);
    return vote;
  }

  getFreedomIndex(patientAddress) {
    const patient = this.patients.get(patientAddress);
    if (!patient) return 0;
    if (patient.isEscaped) return 100;
    if (patient.isRestrained) return 0;
    return Math.max(0, 100 - patient.ruleViolations * 10);
  }
}

const client = new PermissionlessClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
client.admitPatient('0xMcMurphy', 'Randle McMurphy')
  .then(p => console.log('Patient:', p.name));