《搏击俱乐部》与DAO：第一条规则即智能合约

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

contract FightClubProtocol {
    address public founder; // 泰勒·德顿
    mapping(address => bool) public members;
    mapping(address => uint256) public fightCount;
    uint256 public totalFights;
    bool public emergencyStop;

    event FightStarted(address indexed fighterA, address indexed fighterB, uint256 timestamp);
    event FightEnded(address indexed winner, address indexed loser, uint256 round);

    modifier onlyMember() {
        require(members[msg.sender], "第一条规定：不许谈论搏击俱乐部，你不是成员");
        _;
    }

    modifier firstRule() {
        // 第一条规定不仅仅是沉默，更是一种零知识证明
        // 你知道搏击俱乐部存在，但你无法向外界证明它
        _;
    }

    constructor() {
        founder = msg.sender;
        // 泰勒的创世区块
    }

    function join() external payable {
        // 加入不需要任何费用——但需要付出代价
        require(!members[msg.sender], "你已经是成员了");
        members[msg.sender] = true;
    }

    function startFight(address opponent) external onlyMember firstRule {
        require(members[opponent], "对手不是成员");
        require(opponent != msg.sender, "不能和自己打——除非你是杰克");
        require(fightCount[msg.sender] < 1 || fightCount[opponent] < 1, "一次只打一场");

        fightCount[msg.sender]++;
        fightCount[opponent]++;

        emit FightStarted(msg.sender, opponent, block.timestamp);
    }

    function endFight(address winner, address loser) external onlyMember {
        require(fightCount[winner] > 0 && fightCount[loser] > 0, "没有正在进行的比赛");
        fightCount[winner] = 0;
        fightCount[loser] = 0;
        totalFights++;

        emit FightEnded(winner, loser, totalFights);
    }
}

import hashlib
import time
from typing import List, Dict
from dataclasses import dataclass
from enum import Enum

class ProposalType(Enum):
    # 项目迈周的各类破坏行动
    PROPAGANDA = "propaganda"       # 传播理念
    INFILTRATION = "infiltration"   # 渗透机构
    SABOTAGE = "sabotage"           # 破坏设施
    LIQUIDATION = "liquidation"     # 清除债务记录
    LIBERATION = "liberation"       # "解放"行动

@dataclass
class MayhemProposal:
    proposal_id: str
    proposer: str
    proposal_type: ProposalType
    description: str
    target: str
    votes_for: int
    votes_against: int
    status: str  # pending, active, passed, rejected, executed
    created_at: int
    executed_at: int = None

class ProjectMayhemDAO:
    """
    项目迈周DAO——去中心化破坏组织的链上治理模型
    """
    def __init__(self):
        self.members = {}  # address -> membership level
        self.proposals = []
        self.executed_operations = []
        self.quorum = 0.3  # 30% 参与率阈值
        self.voting_period = 7 * 24 * 3600  # 7天投票期

    def recruit_member(self, address: str, initiator: str) -> bool:
        """
        招募新成员——需要现有成员的推荐
        在电影中，这对应着"带一个朋友来训练"
        """
        if initiator not in self.members:
            return False
        if self.members[initiator] < 2:  # 需要达到一定等级才能推荐
            return False
        self.members[address] = 1  # 初始等级：学徒
        return True

    def submit_proposal(self, proposer: str, ptype: ProposalType,
                        description: str, target: str) -> str:
        """提交链上提案"""
        pid = hashlib.sha256(f"{proposer}{time.time()}".encode()).hexdigest()[:16]
        proposal = MayhemProposal(
            proposal_id=pid,
            proposer=proposer,
            proposal_type=ptype,
            description=description,
            target=target,
            votes_for=0,
            votes_against=0,
            status="pending",
            created_at=int(time.time())
        )
        self.proposals.append(proposal)
        return pid

    def vote(self, voter: str, proposal_id: str, support: bool) -> bool:
        """链上投票——每个成员一票"""
        if voter not in self.members:
            return False
        for prop in self.proposals:
            if prop.proposal_id == proposal_id and prop.status == "pending":
                if support:
                    prop.votes_for += 1
                else:
                    prop.votes_against += 1
                # 自动检查是否达到阈值
                if (prop.votes_for + prop.votes_against) >= len(self.members) * self.quorum:
                    prop.status = "passed" if prop.votes_for > prop.votes_against else "rejected"
                return True
        return False

    def execute_proposal(self, proposal_id: str) -> bool:
        """执行通过的提案——链上操作"""
        for prop in self.proposals:
            if prop.proposal_id == proposal_id and prop.status == "passed":
                prop.status = "executed"
                prop.executed_at = int(time.time())
                # 记录操作日志
                self.executed_operations.append({
                    "type": prop.proposal_type.value,
                    "target": prop.target,
                    "timestamp": prop.executed_at
                })
                print(f"[执行] {prop.description} — 目标: {target}")
                return True
        return False

# 模拟项目迈周的第一次行动
dao = ProjectMayhemDAO()
# 泰勒作为创始成员
dao.members["Tyler_Durden"] = 3  # 创始人等级
# 提交第一个提案：破坏城市雕塑
pid = dao.submit_proposal("Tyler_Durden", ProposalType.SABOTAGE,
                          "破坏市中心雕塑，唤醒麻木的消费主义灵魂",
                          "City_Art_Museum")
print(f"提案提交: {pid}")

// 链上日志分析：杰克·泰勒的双重身份追踪
const { ethers } = require('ethers');

// 模拟一个区块链分析器，追踪"分裂身份"的链上证据
class IdentityAnalyzer {
  constructor() {
    this.transactions = [];
    this.identityMap = new Map();
    this.suspiciousPatterns = [];
  }

  /**
   * 记录链上活动——相当于杰克的内心独白
   * 每个交易都是一次"自我对话"
   */
  logActivity(address, action, timestamp, metadata = {}) {
    const entry = {
      address,
      action,
      timestamp,
      metadata,
      blockHeight: Math.floor(timestamp / 600) // 假设每10分钟一个块
    };

    this.transactions.push(entry);

    // 实时分析：检测地址是否存在"分裂行为"
    if (!this.identityMap.has(address)) {
      this.identityMap.set(address, {
        appearances: [],
        personalities: [],
        lastDetected: null
      });
    }

    const profile = this.identityMap.get(address);
    profile.appearances.push(entry);

    // 检测关键事件：失眠、购买家具、炸毁公寓
    if (action === 'sleep_disruption' && metadata.severity > 7) {
      console.log(`[警报] 检测到严重失眠事件: ${address} — 意识开始分裂`);
      // 失眠是"分裂"的前兆——新的身份即将诞生
      profile.personalities.push('Tyler_Durden');
    }

    if (action === 'consumer_purchase' && metadata.category === 'IKEA') {
      console.log(`[日志] 消费主义行为: ${address} 购买了 ${metadata.item}`);
      // 消费主义对应于"旧身份"的维持
      profile.personalities.push('Jack_Narrator');
    }

    if (action === 'explosive_device' && metadata.target === 'own_apartment') {
      console.log(`[关键事件] 自我毁灭行为: ${address} 炸毁了自己的公寓`);
      // 炸毁公寓是"身份切换"的链上信号
      profile.personalities.push('Identity_Merge_Required');
      this._triggerIdentityMerge(address);
    }

    return entry;
  }

  /**
   * 身份合并检测——发现同一个地址的多个身份
   */
  _triggerIdentityMerge(address) {
    const profile = this.identityMap.get(address);
    if (!profile) return;

    const uniquePersonalities = [...new Set(profile.personalities)];
    console.log(`\n===== 身份分析报告 =====`);
    console.log(`地址: ${address}`);
    console.log(`检测到 ${uniquePersonalities.length} 个独立身份`);
    console.log(`身份列表: ${uniquePersonalities.join(', ')}`);

    if (uniquePersonalities.includes('Tyler_Durden') &&
        uniquePersonalities.includes('Jack_Narrator')) {
      console.log(`
      ⚠️ 多签检测完成！
      该地址存在两个独立的签名者：
        - 私钥 1/2: 杰克 (Jack) — 消费主义人格，IKEA爱好者
        - 私钥 2/2: 泰勒 (Tyler) — 无政府主义人格，协议创始人
      结论：这是一个分裂身份的多签钱包，需要两个私钥同时签名才能完成"真相交易"
      `);
      this.suspiciousPatterns.push({
        type: 'split_identity',
        address,
        personalities: uniquePersonalities,
        detectedAt: Date.now(),
        // 建议：执行"自我枪击"以完成身份合并
        recommendedAction: 'execute_self_gunshot'
      });
    }
  }

  /**
   * 分析链上行为模式——叙事重建
   */
  generateNarrative(startBlock, endBlock) {
    const relevantTxs = this.transactions.filter(
      tx => tx.blockHeight >= startBlock && tx.blockHeight <= endBlock
    );

    console.log(`\n[叙事重建] 区块 ${startBlock} 至 ${endBlock}`);

    // 按时间线组织叙事
    const timeline = relevantTxs.sort((a, b) => a.timestamp - b.timestamp);

    console.log('时间线分析：');
    timeline.forEach((tx, i) => {
      const actionEmoji = tx.action === 'explosive_device' ? '💥' :
                          tx.action === 'consumer_purchase' ? '🛒' : '📝';
      console.log(`  ${i + 1}. ${actionEmoji} [${new Date(tx.timestamp * 1000).toISOString()}] ${tx.action}`);
      // 深度分析：每个行为的潜在动机
      if (tx.metadata.psychological) {
        console.log(`     心理状态: ${tx.metadata.psychological}`);
      }
    });

    return timeline;
  }
}

// 模拟电影中的关键事件
const analyzer = new IdentityAnalyzer();

// 事件1：杰克的失眠与消费主义
analyzer.logActivity('0xJackTyler', 'sleep_disruption', 900000000, {
  severity: 9,
  psychological: '存在性焦虑，被消费主义异化'
});

analyzer.logActivity('0xJackTyler', 'consumer_purchase', 900010000, {
  category: 'IKEA',
  item: '瑞典风格咖啡桌',
  price: 499.99,
  psychological: '用物品填补内心的空洞'
});

// 事件2：遇见泰勒（新身份诞生）
analyzer.logActivity('0xJackTyler', 'meet_person', 900020000, {
  person: 'Tyler_Durden',
  location: '飞机上',
  psychological: '镜像投射，自我否定的外化'
});

// 事件3：加入搏击俱乐部（协议交互）
analyzer.logActivity('0xJackTyler', 'join_protocol', 900030000, {
  protocol: 'FightClub',
  location: '地下室',
  firstRule: '不谈论搏击俱乐部'
});

// 事件4：炸毁公寓（身份切换）
analyzer.logActivity('0xJackTyler', 'explosive_device', 900040000, {
  target: 'own_apartment',
  damage: 'total',
  psychological: '自我毁灭是重建的开始'
});

// 事件5：项目迈周（DAO治理）
analyzer.logActivity('0xJackTyler', 'dao_proposal', 900050000, {
  proposal: 'ProjectMayhem_Phase_1',
  target: '消费主义基础设施',
  vote: 'yes'
});

// 生成完整叙事
analyzer.generateNarrative(15000000, 15000010);
console.log('\n[最终结论] 杰克和泰勒共享同一个以太坊地址，使用了2-of-2多签方案');