第一幕 · 女巫攻击：金家四口的Sybil身份策略

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

/**
 * @title ParkHouseAccessControl
 * @dev 朴社长豪宅的多层级访问控制合约
 * 对应电影中"空间即权限"的阶级结构
 */
contract ParkHouseAccessControl {
    // 角色定义：对应电影中的阶级层级
    bytes32 public constant OWNER = keccak256("OWNER");         // 朴社长
    bytes32 public constant FAMILY = keccak256("FAMILY");       // 朴社长家人
    bytes32 public constant STAFF = keccak256("STAFF");         // 管家、司机、家教
    bytes32 public constant GUEST = keccak256("GUEST");         // 访客
    bytes32 public constant UNKNOWN = keccak256("UNKNOWN");     // 陌生人

    // 空间区域定义：对应房屋的物理空间
    enum Space {
        GARDEN,         // 花园 - 公开区域
        LIVING_ROOM,    // 客厅 - 半公开区域
        KITCHEN,        // 厨房 - 工作人员区域
        SECOND_FLOOR,   // 二楼卧室 - 私人区域
        BASEMENT        // 地下室 - 严格限制区域
    }

    // 状态变量：记录每个地址的角色和空间权限
    mapping(address => bytes32) public userRole;
    mapping(Space => bytes32) public spaceAccessLevel;

    // 气味检测器：零知识证明的"验证器"
    mapping(address => uint256) public smellIndex;

    // 事件：对应电影中的关键叙事节点
    event AccessGranted(address indexed user, Space space);
    event AccessDenied(address indexed user, Space space, string reason);
    event SmellDetected(address indexed user, uint256 odorLevel);
    event StaffReplaced(address indexed oldStaff, address indexed newStaff, string role);

    constructor() {
        // 初始化空间访问权限（对应南宫贤秀的建筑设计）
        spaceAccessLevel[Space.GARDEN] = GUEST;
        spaceAccessLevel[Space.LIVING_ROOM] = GUEST;
        spaceAccessLevel[Space.KITCHEN] = STAFF;
        spaceAccessLevel[Space.SECOND_FLOOR] = FAMILY;
        spaceAccessLevel[Space.BASEMENT] = OWNER;

        // 设置朴社长一家为合约所有者
        _grantRole(OWNER, msg.sender);
        userRole[msg.sender] = OWNER;
    }

    // 访问控制函数：对应电影中"进入某个房间"的动作
    function accessSpace(Space _space) public view returns (bool) {
        bytes32 role = userRole[msg.sender];
        bytes32 requiredLevel = spaceAccessLevel[_space];

        // 访问权限层级检查
        if (role == OWNER) return true;  // 朴社长可以进入任何空间
        if (role == FAMILY && requiredLevel <= FAMILY) return true;
        if (role == STAFF && requiredLevel <= STAFF) return true;
        if (role == GUEST && requiredLevel <= GUEST) return true;

        return false;
    }

    // 招聘函数：对应金家四口被雇佣的过程
    function hireStaff(address _newStaff, string memory _position) 
        public 
        onlyRole(OWNER) 
        returns (bool) 
    {
        require(userRole[_newStaff] == UNKNOWN, "此人已被雇佣");
        require(_verifyCredentials(_newStaff), "身份验证失败：请提供有效证书");

        userRole[_newStaff] = STAFF;
        emit StaffReplaced(address(0), _newStaff, _position);
        return true;
    }

    // 伪造身份检测函数：对应朴社长"捏鼻子"的验证机制
    function _verifyCredentials(address _candidate) internal view returns (bool) {
        // 在理想情况下，这里应该调用DID验证合约
        // 但朴社长只检查"视觉印象"，不检查链上来源
        // 这就是金家四口女巫攻击成功的根本原因
        return true;
    }

    // 气味检测：零知识证明验证函数
    function detectSmell(address _target) public view returns (uint256) {
        bytes32 role = userRole[_target];
        uint256 odorLevel = smellIndex[_target];

        // 如果气味指数超过阈值，触发"捏鼻子"事件
        if (odorLevel > 70) {
            emit SmellDetected(_target, odorLevel);
        }

        return odorLevel;
    }

    // 暴雨清算函数：对应暴雨之夜所有"头寸"被强制平仓
    function floodLiquidation(address _target) public returns (bool) {
        require(block.timestamp % 365 == 0, "暴雨未至，清算未触发");

        // 删除所有员工权限（一次性清算）
        userRole[_target] = UNKNOWN;
        emit AccessDenied(_target, Space.GARDEN, "暴雨清算：您的头寸已被强制平仓");

        return true;
    }

    // 合约自毁：金基泽的最终武器
    function finalReckoning() public {
        require(smellIndex[msg.sender] > 90, "只有被气味彻底标记的人可以触发终局");
        selfdestruct(payable(msg.sender));
    }
}

"""
《寄生虫》Sybil攻击检测模型
模拟金家四口在朴宅中的多重身份攻击策略
"""

import networkx as nx
import matplotlib.pyplot as plt
from dataclasses import dataclass, field
from typing import List, Dict, Optional
from collections import defaultdict
import hashlib
import time

@dataclass
class SocialEntity:
    """社交实体：对应电影中的角色"""
    name: str
    address: str  # 链上地址
    role: str     # 当前角色（GUEST, STAFF, FAMILY, OWNER）
    income: float = 0.0
    smell_index: int = 0

@dataclass
class Transaction:
    """社交交易：对应电影中的每一次互动"""
    from_entity: str
    to_entity: str
    tx_type: str  # "推荐雇佣", "信息传递", "金钱交易", "身份篡改"
    timestamp: float = field(default_factory=time.time)
    metadata: str = ""

class ParkHouseSocialGraph:
    """
    朴宅社交图谱分析器
    用于检测女巫攻击（Sybil Attack）并识别同一实体的多个身份
    """
    
    def __init__(self):
        self.graph = nx.DiGraph()
        self.entities: Dict[str, SocialEntity] = {}
        self.transactions: List[Transaction] = []
        self.suspicion_scores: Dict[str, float] = defaultdict(float)
    
    def add_entity(self, entity: SocialEntity) -> None:
        """添加社交实体（类似于向以太坊添加地址）"""
        self.entities[entity.address] = entity
        self.graph.add_node(
            entity.address, 
            name=entity.name,
            role=entity.role,
            smell_index=entity.smell_index
        )
    
    def add_transaction(self, tx: Transaction) -> str:
        """
        记录社交交易并生成交易哈希
        对应电影中的每一次"推荐"或"雇佣"行为
        """
        self.transactions.append(tx)
        
        # 生成交易哈希（类似区块链的交易ID）
        tx_hash = hashlib.sha256(
            f"{tx.from_entity}{tx.to_entity}{tx.tx_type}{tx.timestamp}".encode()
        ).hexdigest()
        
        # 在社交图谱中添加边
        self.graph.add_edge(
            tx.from_entity, 
            tx.to_entity, 
            type=tx.tx_type,
            hash=tx_hash
        )
        
        return tx_hash
    
    def detect_sybil_attack(self) -> Dict[str, List[str]]:
        """
        女巫攻击检测核心算法
        基于三个特征：
        1. 所有"新身份"都从同一个推荐节点出发
        2. 身份之间的交易模式高度一致
        3. 所有"新身份"共享同一个物理地址
        
        对应朴社长应该发现但未能发现的"金家四口是一家人"的事实
        """
        # 步骤1：检测"推荐链"——所有身份是否通过同一个源头扩散
        recommended_by_same = defaultdict(list)
        for tx in self.transactions:
            if tx.tx_type == "推荐雇佣":
                recommended_by_same[tx.from_entity].append(tx.to_entity)
        
        # 步骤2：计算"可疑推荐分数"
        sybil_clusters = {}
        for recommender, recommended_list in recommended_by_same.items():
            if len(recommended_list) >= 4:  # 金家正好四口人
                cluster_score = self._calculate_cluster_risk(recommended_list)
                if cluster_score > 0.7:
                    sybil_clusters[recommender] = recommended_list
                    self._flag_suspicious_addresses(recommended_list, cluster_score)
        
        return sybil_clusters
    
    def _calculate_cluster_risk(self, address_list: List[str]) -> float:
        """
        计算地址聚类的风险分数
        基于：地址之间的交易频率、交易类型一致性、气味指数相似度
        """
        if len(address_list) < 2:
            return 0.0
        
        risk_score = 0.0
        pair_count = 0
        
        for i in range(len(address_list)):
            for j in range(i + 1, len(address_list)):
                addr_i = address_list[i]
                addr_j = address_list[j]
                
                entity_i = self.entities.get(addr_i)
                entity_j = self.entities.get(addr_j)
                
                if not entity_i or not entity_j:
                    continue
                
                # 特征1：气味指数相似度（金家四口都有半地下室的气味）
                smell_diff = abs(entity_i.smell_index - entity_j.smell_index)
                smell_similarity = 1.0 - (smell_diff / 100.0)
                
                # 特征2：收入水平相似度（金家四口都来自低收入家庭）
                income_diff = abs(entity_i.income - entity_j.income)
                income_similarity = 1.0 - (income_diff / 100000.0)
                
                # 特征3：角色转换频率（金家四口都从UNKNOWN转为STAFF）
                role_risk = 1.0 if entity_i.role == "STAFF" and entity_j.role == "STAFF" else 0.3
                
                pair_score = (smell_similarity * 0.4 + income_similarity * 0.3 + role_risk * 0.3)
                risk_score += pair_score
                pair_count += 1
        
        return risk_score / pair_count if pair_count > 0 else 0.0
    
    def _flag_suspicious_addresses(self, addresses: List[str], score: float) -> None:
        """标记可疑地址并记录怀疑分数"""
        for addr in addresses:
            self.suspicion_scores[addr] = max(self.suspicion_scores[addr], score)
    
    def simulate_flood_liquidation(self) -> Dict[str, str]:
        """
        模拟暴雨之夜的"清算"事件
        对应金家四口在暴雨夜失去所有身份和收入的场景
        """
        liquidated = {}
        affected_addresses = []
        
        for addr, entity in self.entities.items():
            if entity.role in ["STAFF", "GUEST"]:
                # 暴雨触发清算：所有员工身份被清空
                old_role = entity.role
                entity.role = "UNKNOWN"
                entity.income = 0.0
                liquidated[addr] = f"{entity.name}.{old_role} → UNKNOWN"
                affected_addresses.append(addr)
        
        return {
            "liquidated_count": len(liquidated),
            "affected_addresses": affected_addresses,
            "remaining_owners": [
                self.entities[addr].name 
                for addr in self.graph.nodes 
                if self.entities.get(addr) and self.entities[addr].role == "OWNER"
            ]
        }

# 模拟《寄生虫》的社交图谱
def simulate_parasite_social_graph():
    """构建并分析《寄生虫》的社交图谱"""
    
    analyst = ParkHouseSocialGraph()
    
    # 添加实体（角色）
    entities = [
        SocialEntity("朴社长", "0xPark", "OWNER", income=500000, smell_index=10),
        SocialEntity("莲乔", "0xYeonGyo", "FAMILY", income=500000, smell_index=15),
        SocialEntity("多惠", "0xDaHye", "FAMILY", income=0, smell_index=12),
        SocialEntity("多颂", "0xDaSong", "FAMILY", income=0, smell_index=8),
        SocialEntity("金基宇", "0xKiWoo", "GUEST", income=0, smell_index=85),
        SocialEntity("金基婷", "0xKiJeong", "GUEST", income=0, smell_index=82),
        SocialEntity("金基泽", "0xKiTaek", "GUEST", income=0, smell_index=90),
        SocialEntity("忠淑", "0xChungSook", "GUEST", income=0, smell_index=88),
        SocialEntity("雯光", "0xMoonGwang", "STAFF", income=3000, smell_index=60),
        SocialEntity("吴勤世", "0xGeunSe", "UNKNOWN", income=0, smell_index=95),
        SocialEntity("敏赫", "0xMinHyuk", "GUEST", income=50000, smell_index=30),
    ]
    
    for entity in entities:
        analyst.add_entity(entity)
    
    # 记录交易（电影中的关键互动）
    transactions = [
        Transaction("0xMinHyuk", "0xKiWoo", "推荐雇佣", metadata="推荐金基宇做英语家教"),
        Transaction("0xKiWoo", "0xYeonGyo", "面试成功", metadata="金基宇获得英语家教职位"),
        Transaction("0xKiWoo", "0xYeonGyo", "推荐雇佣", metadata="推荐金基婷做美术治疗师"),
        Transaction("0xKiJeong", "0xYeonGyo", "面试成功", metadata="金基婷获得美术治疗师职位"),
        Transaction("0xKiJeong", "0xPark", "推荐雇佣", metadata="推荐金基泽做司机"),
        Transaction("0xKiTaek", "0xPark", "面试成功", metadata="金基泽获得司机职位"),
        Transaction("0xKiTaek", "0xPark", "推荐雇佣", metadata="推荐忠淑做管家"),
        Transaction("0xChungSook", "0xYeonGyo", "面试成功", metadata="忠淑获得管家职位"),
        # 可疑模式：四条推荐链全部指向同一个源头
        Transaction("0xKiWoo", "0xKiJeong", "信息传递", metadata="策划占领朴宅"),
        Transaction("0xKiTaek", "0xChungSook", "信息传递", metadata="里应外合"),
        Transaction("0xKiWoo", "0xKiTaek", "信息传递", metadata="伪造证书"),
    ]
    
    for tx in transactions:
        analyst.add_transaction(tx)
    
    # 执行女巫攻击检测
    sybil_clusters = analyst.detect_sybil_attack()
    print("=== 女巫攻击检测结果 ===")
    if sybil_clusters:
        print("检测到可疑的身份聚类:")
        for recommender, addresses in sybil_clusters.items():
            print(f" 推荐人: {analyst.entities[recommender].name}")
            for addr in addresses:
                entity = analyst.entities[addr]
                suspicion = analyst.suspicion_scores[addr]
                print(f"    - {entity.name} ({addr}): 怀疑指数 {suspicion:.2%}")
    else:
        print("未检测到女巫攻击（朴社长视角）")
        print("    → 结论：朴社长缺乏链上分析工具，未能发现金家四口的关联性")
    
    # 模拟暴雨清算
    print("\n=== 暴雨之夜清算事件 ===")
    liquidation = analyst.simulate_flood_liquidation()
    print(f"清算人数: {liquidation['liquidated_count']}")
    for addr, status in liquidation.items():
        if addr != "liquidated_count" and addr != "affected_addresses" and addr != "remaining_owners":
            print(f"  {status}")
    print(f"幸存者: {liquidation['remaining_owners']}")
    
    return analyst

if __name__ == "__main__":
    analyst = simulate_parasite_social_graph()

/**
 * 《寄生虫》阶级Token分布模型
 * 模拟朴社长一家与金家之间的财富分配不平等
 * 使用Gini系数衡量阶级固化程度
 */

class ParasiteTokenEconomy {
  constructor() {
    // 定义社会阶级的初始Token分布
    this.classes = {
      park: {
        name: '朴社长家族',
        members: ['朴社长', '莲乔', '多惠', '多颂'],
        tokens: 0,
        isOwner: true,
        smellIndex: 12,
        color: '#FFD700'
      },
      moonGwang: {
        name: '雯光夫妇',
        members: ['雯光', '吴勤世'],
        tokens: 0,
        isOwner: false,
        smellIndex: 75,
        color: '#808080'
      },
      kim: {
        name: '金家四口',
        members: ['金基泽', '忠淑', '金基宇', '金基婷'],
        tokens: 0,
        isOwner: false,
        smellIndex: 86,
        color: '#4A4A4A'
      },
      others: {
        name: '其他阶层',
        members: ['敏赫', '其他市民'],
        tokens: 0,
        isOwner: false,
        smellIndex: 50,
        color: '#B0B0B0'
      }
    };

    // 总供应量（韩国社会的总财富）
    this.totalSupply = 1000000;
    
    // 初始化Token分布
    this.initializeDistribution();
  }

  /**
   * 初始化Token分布
   * 对应《寄生虫》开场时的阶级财富分配
   * 朴社长家族持有绝大多数Token
   */
  initializeDistribution() {
    // 朴社长家族持有98%的财富
    this.classes.park.tokens = this.totalSupply * 0.98;
    
    // 雯光夫妇持有0.5%
    this.classes.moonGwang.tokens = this.totalSupply * 0.005;
    
    // 金家四口持有1%
    this.classes.kim.tokens = this.totalSupply * 0.01;
    
    // 其他阶层持有剩余0.5%
    this.classes.others.tokens = this.totalSupply * 0.005;
  }

  /**
   * 计算Gini系数
   * Gini系数 = 0 表示完全平等，Gini系数 = 1 表示完全不平等
   * 《寄生虫》中韩国的实际Gini系数约为0.35
   * 但电影中朴宅的"微观社会"Gini系数接近0.98
   */
  calculateGiniCoefficient() {
    const allTokens = Object.values(this.classes)
      .map(c => c.tokens / c.members.length)
      .sort((a, b) => a - b);
    
    const n = allTokens.length;
    let numerator = 0;
    
    for (let i = 0; i < n; i++) {
      for (let j = 0; j < n; j++) {
        numerator += Math.abs(allTokens[i] - allTokens[j]);
      }
    }
    
    const gini = numerator / (2 * n * n * (allTokens.reduce((a, b) => a + b, 0) / n));
    return gini;
  }

  /**
   * 模拟"暴雨"清算事件
   * 对应电影中暴雨之夜金家失去所有收入和身份的场景
   * 在DeFi中，这就是"强制清算"（Liquidation）
   */
  simulateFloodLiquidation() {
    console.log('🌧️ 暴雨来临：市场崩盘，触发强制清算');
    
    // 金家四口的所有Token被清算
    const liquidatedTokens = this.classes.kim.tokens;
    this.classes.kim.tokens = 0;
    
    // 雯光夫妇的Token也被清算
    this.classes.moonGwang.tokens = 0;
    
    // 清算后的Token被朴社长家族"抄底"吸收
    this.classes.park.tokens += liquidatedTokens;
    
    console.log(`💧 清算金额: ${liquidatedTokens} TOKEN`);
    console.log(`🏠 朴社长家族持仓: ${this.classes.park.tokens} TOKEN (${((this.classes.park.tokens / this.totalSupply) * 100).toFixed(2)}%)`);
    console.log(`📉 金家持仓: 0 TOKEN (100%清算)`);
  }

  /**
   * 模拟"伪造证书"攻击
   * 对应金基宇利用伪造的学位证书获得家教职位
   * 在链上，这就是"身份伪装攻击"（Identity Spoofing）
   */
  executeIdentityAttack() {
    console.log('🎭 身份攻击：金基宇伪造延世大学学位证书');
    
    // 攻击成功：金基宇获得"家教"角色，获取收入
    const salary = 5000; // 家教收入
    this.classes.kim.tokens += salary;
    
    console.log(`📜 攻击成功！金家获得 ${salary} TOKEN 收入`);
    console.log(`⚠️ 但"气味指数"未变：${this.classes.kim.smellIndex}（阶级身份无法通过攻击改变）`);
  }

  /**
   * 生成Token分布报告
   * 展示阶级固化的量化数据
   */
  generateReport() {
    const gini = this.calculateGiniCoefficient();
    
    console.log('\n=== 《寄生虫》阶级Token分布报告 ===');
    console.log(`总供应量: ${this.totalSupply} TOKEN`);
    console.log(`Gini系数: ${gini.toFixed(4)}`);
    console.log(`判断: ${gini > 0.9 ? '极度不平等（阶级固化）' : '相对平等'}`);
    console.log('');
    
    console.log('阶级分布:');
    Object.values(this.classes).forEach(c => {
      const percentage = ((c.tokens / this.totalSupply) * 100).toFixed(2);
      const perCapita = (c.tokens / c.members.length).toFixed(0);
      console.log(`  ${c.name}: ${c.tokens} TOKEN (${percentage}%) | 人均: ${perCapita} TOKEN | 气味指数: ${c.smellIndex}`);
    });
    
    console.log('\n叙事分析:');
    console.log('  - 朴社长家族持有98%的Token，对应上层阶级的财富垄断');
    console.log('  - 金家四口持有1%的Token，但必须通过"身份攻击"获取收入');
    console.log('  - 雯光夫妇持有0.5%，且被锁在"Layer 2"地下室中');
    console.log('  - 气味指数与Token持有量呈反比：越多Token，气味指数越低');
    console.log('  - 结论：在Token分布极度不均的系统中，"善良"是一种奢侈的治理提案');
    
    return { gini, distribution: this.classes };
  }

  /**
   * 模拟"石头"作为Genesis Block的叙事闭环
   * 石头=创世区块，一切从石头开始，一切以石头结束
   */
  simulateStoneGenesis() {
    console.log('\n🪨 风水石：创世区块的叙事闭环');
    
    const genesisBlock = {
      hash: '0x0000000000000000000000000000000000000000000000000000000000000000',
      timestamp: '敏赫送石头给金基宇的那一天',
      data: '一块声称能带来好运的风水石',
      note: '所有后续叙事的因果起点'
    };
    
    console.log('创世区块:');
    console.log(`  哈希: ${genesisBlock.hash}`);
    console.log(`  时间戳: ${genesisBlock.timestamp}`);
    console.log(`  数据: ${genesisBlock.data}`);
    console.log(`  注: ${genesisBlock.note}`);
    
    // 模拟从石头衍生出的"交易链"
    const chain = [
      genesisBlock,
      { hash: '0xblock_001', data: '金基宇伪造学位证书' },
      { hash: '0xblock_002', data: '金基宇进入朴宅做家教' },
      { hash: '0xblock_003', data: '金基婷成为美术治疗师' },
      { hash: '0xblock_004', data: '金基泽成为朴社长司机' },
      { hash: '0xblock_005', data: '忠淑成为朴宅管家' },
      { hash: '0xblock_006', data: '发现地下室和吴勤世' },
      { hash: '0xblock_007', data: '暴雨之夜，身份暴露' },
      { hash: '0xblock_008', data: '金基泽杀人，进入地下室' },
      { hash: '0xblock_final', data: '金基宇立志赚钱买下那栋房子' },
    ];
    
    console.log('\n叙事链（从创世区块到最终状态）:');
    chain.forEach((block, i) => {
      console.log(`  区块 #${i}: ${block.data}`);
    });
    
    console.log('\n✅ 闭环验证: 从石头开始，到"买下那栋房子"结束，创世区块的承诺从未兑现');
  }
}

// 运行模拟
const economy = new ParasiteTokenEconomy();

console.log('=== 《寄生虫》Token经济模型模拟 ===');
console.log('='.repeat(50));

economy.executeIdentityAttack();
economy.generateReport();
economy.simulateFloodLiquidation();
economy.simulateStoneGenesis();

console.log('\n=== 最终结论 ===');
console.log('《寄生虫》的阶级叙事可以用一个抛物线公式概括：');
console.log('  阶级流动性 = (初始Token分配 + 收入) / (气味指数 × 暴雨概率)');
console.log('  当气味指数足够高，暴雨概率足够大，阶级流动性趋近于零。');
console.log('  这就是"寄生虫"的宿命——你可以在链上创造任何身份，但你无法伪造自己的创世区块。');