《寄生虫》与代币经济学：阶级流动性作为Token分配模型

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

contract ParasiteTokenDistribution {
    address public ceo;          // 朴社长——项目方
    address public icoContract;  // 早期投资者
    address public foundation;   // 基金会
    
    uint256 public constant TOTAL_SUPPLY = 1_000_000_000 * 10**18;
    uint256 public privateSalePct = 65;    // 私募轮65%
    uint256 public publicSalePct = 15;     // 公募轮15%
    uint256 public teamVestedPct = 15;     // 团队15%
    uint256 public communityPct = 5;       // 社区5%
    
    mapping(address => uint256) public balance;
    mapping(address => SocioClass) public class;
    
    enum SocioClass { HALF_BASEMENT, REGULAR, EXECUTIVE, PENTHOUSE }
    
    constructor() {
        ceo = msg.sender;
        // 初始分配——金家永远无法触及的层级
        balance[ceo] = TOTAL_SUPPLY * privateSalePct / 100;
        // 私募投资者
        balance[icoContract] = TOTAL_SUPPLY * publicSalePct / 100;
        // 团队锁仓
        balance[foundation] = TOTAL_SUPPLY * teamVestedPct / 100;
        // 社区空投——金家唯一的入场券，但只有5%
        balance[address(0x1234)] = TOTAL_SUPPLY * communityPct / 100;
        
        class[ceo] = SocioClass.PENTHOUSE;
        class[icoContract] = SocioClass.EXECUTIVE;
        class[foundation] = SocioClass.REGULAR;
        class[address(0x1234)] = SocioClass.HALF_BASEMENT;
    }
    
    function checkClass(address citizen) public view returns (SocioClass) {
        return class[citizen];
    }
    
    // 金家伪造成绩单——访问控制漏洞
    function upgradeClass(address citizen, SocioClass newClass) public {
        // 漏洞：没有权限检查！金家通过伪造身份进入上层
        class[citizen] = newClass;
    }
}

#!/usr/bin/env python3
"""
《寄生虫》多签共谋攻击模拟器
模拟金家四口通过Social Engineering逐步渗透朴家生态系统的过程
"""

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

class SocialClass(Enum):
    HALF_BASEMENT = "半地下室"
    REGULAR = "普通公寓"
    EXECUTIVE = "高管住宅"
    PENTHOUSE = "顶层豪宅"

@dataclass
class FamilyMember:
    name: str
    role: str
    identity: str
    trust_score: float
    social_class: SocialClass
    private_key: str  # 伪造的身份凭证
    
    def forge_identity(self, target_identity: str, target_role: str) -> bool:
        """金家核心技能：伪造身份凭证"""
        # 伪造学历/经历/推荐信
        forged_hash = hashlib.sha256(
            f"{self.identity}:{target_identity}:{self.private_key}".encode()
        ).hexdigest()
        
        # 伪造成功概率取决于朴家的验证强度
        verification_bypass = self.trust_score > 0.7
        if verification_bypass:
            self.identity = target_identity
            self.role = target_role
            self.social_class = SocialClass.EXECUTIVE
            return True
        return False

class ParkHousehold:
    """朴家——目标协议，拥有高TVL（Total Value Locked）"""
    
    def __init__(self):
        self.employees: Dict[str, FamilyMember] = {}
        self.security_level = 0.3  # 朴太太的安全意识很低
        self.verification_oracle = "single_source"  # 单一预言机
        
    def verify_credential(self, member: FamilyMember) -> bool:
        """朴家的身份验证——存在预言机操纵漏洞"""
        if self.verification_oracle == "single_source":
            # 只依赖推荐信（单一预言机），容易被操纵
            return member.trust_score > 0.5
        return False
    
    def hire(self, member: FamilyMember, position: str) -> bool:
        """雇佣函数——每次调用都会降低安全等级"""
        if self.verify_credential(member):
            self.employees[position] = member
            self.security_level *= 0.8  # 多一个人进入，安全水平下降20%
            return True
        return False

class MultiSigAttack:
    """金家的多签共谋攻击器"""
    
    def __init__(self):
        self.kim_family = [
            FamilyMember("金基宇", "英语家教", "伪造延世大学", 0.85, SocialClass.HALF_BASEMENT, "fake_cred_1"),
            FamilyMember("金基婷", "艺术治疗师", "伪造艺术学位", 0.82, SocialClass.HALF_BASEMENT, "fake_cred_2"),
            FamilyMember("金父", "司机", "伪造驾驶记录", 0.78, SocialClass.HALF_BASEMENT, "fake_cred_3"),
            FamilyMember("金母", "管家", "伪造从医经历", 0.80, SocialClass.HALF_BASEMENT, "fake_cred_4"),
        ]
        self.park = ParkHousehold()
        self.attack_phases = []
        
    def execute_attack(self) -> Dict[str, bool]:
        """执行多签共谋攻击"""
        results = {}
        positions = ["tutor", "therapist", "driver", "housekeeper"]
        
        for i, member in enumerate(self.kim_family):
            # 每个家庭成员都是一个独立的"攻击向量"
            phase = f"phase_{i+1}"
            hired = self.park.hire(member, positions[i])
            results[phase] = hired
            
            if hired:
                self.attack_phases.append({
                    "phase": phase,
                    "attacker": member.name,
                    "position": positions[i],
                    "park_security": self.park.security_level
                })
                
        return results
    
    def report_attack_surface(self):
        """分析攻击面——朴家的安全漏洞报告"""
        print("=" * 60)
        print("《寄生虫》多签共谋攻击面分析报告")
        print("=" * 60)
        print(f"\n目标协议：朴家生态系统")
        print(f"初始安全等级：{self.park.security_level:.2f}")
        print(f"预言机类型：{self.park.verification_oracle}（存在操纵风险）")
        print(f"\n攻击向量：4个伪造身份")
        print(f"\n攻击路径：")
        
        for phase in self.attack_phases:
            print(f"  {phase['phase']}: {phase['attacker']} → {phase['position']}")
            print(f"    安全等级下降至：{phase['park_security']:.2f}")
        
        print(f"\n最终安全等级：{self.park.security_level:.2f}")
        print(f"攻击成功概率：{(1 - self.park.security_level) * 100:.1f}%")
        print("=" * 60)

# 执行攻击模拟
if __name__ == "__main__":
    attack = MultiSigAttack()
    results = attack.execute_attack()
    attack.report_attack_surface()

/**
 * 《寄生虫》链上清算模拟器
 * 模拟暴雨之夜金家从半地下室到顶层公寓的流动性危机
 */

class LiquidationCascade {
    constructor() {
        this.assets = {
            kimFamily: {
                housing: 0.5,       // 半地下室价值 0.5 ETH
                savings: 0.1,       // 储蓄 0.1 ETH
                employment: 0.3,    // 兼职收入现值 0.3 ETH
                total: 0.9
            },
            parkFamily: {
                housing: 100,       // 顶层公寓价值 100 ETH
                savings: 500,       // 储蓄 500 ETH
                business: 2000,     // 公司价值 2000 ETH
                total: 2600
            }
        };
        
        this.rainIntensity = 0;     // 0-1, 暴雨强度
        this.liquidationPrice = 0.5; // 清算阈值
        this.flashLoanActive = false;
    }
    
    /**
     * 暴雨触发清算——链上流动性危机
     */
    triggerRainStorm() {
        console.log('🌧️ 暴雨来袭！首尔降水量达到历史极值');
        console.log('--- 链上清算开始 ---\n');
        
        // 模拟清算瀑布
        for (let hour = 0; hour < 24; hour++) {
            this.rainIntensity = Math.min(1, this.rainIntensity + 0.05);
            
            // 金家的资产价值随着暴雨而下降
            const housingImpact = this.rainIntensity * 0.8;
            this.assets.kimFamily.housing = Math.max(0, 0.5 - housingImpact * 0.5);
            
            // 就业价值归零（被朴家解雇）
            if (hour >= 6) {
                this.assets.kimFamily.employment = 0;
            }
            
            // 计算当前总价值
            this.assets.kimFamily.total = 
                this.assets.kimFamily.housing + 
                this.assets.kimFamily.savings + 
                this.assets.kimFamily.employment;
            
            // 检查是否触发清算
            if (this.assets.kimFamily.total < this.liquidationPrice) {
                console.log(`⏰ 第${hour}小时：金家资产跌破清算阈值！`);
                console.log(`   当前总价值：${this.assets.kimFamily.total.toFixed(2)} ETH`);
                console.log(`   清算阈值：${this.liquidationPrice} ETH`);
                console.log(`   🚨 触发强制平仓！`);
                return this.executeLiquidation(hour);
            }
            
            // 每个小时的状态报告
            if (hour % 3 === 0) {
                console.log(`第${hour}小时：暴雨强度 ${(this.rainIntensity * 100).toFixed(0)}%`);
                console.log(`  金家资产：${this.assets.kimFamily.total.toFixed(2)} ETH`);
                console.log(`  朴家资产：${this.assets.parkFamily.total} ETH (未受影响)`);
                console.log(`  贫富差距：${(this.assets.parkFamily.total / this.assets.kimFamily.total).toFixed(0)}x\n`);
            }
        }
    }
    
    executeLiquidation(hour) {
        console.log('\n--- 清算执行详情 ---');
        console.log('清算对象：金家四口');
        console.log('清算原因：流动性枯竭（暴雨导致半地下室被淹）');
        console.log('清算结果：');
        console.log('  - 住房：已归零（被洪水淹没）');
        console.log('  - 储蓄：已耗尽（用于修复房屋）');
        console.log('  - 就业：已归零（被朴家解雇）');
        console.log('  - 社会地位：从 EXECUTIVE 回滚至 HALF_BASEMENT\n');
        
        console.log('⚠️ 清算瀑布完成');
        console.log('金家总资产损失：100%');
        console.log('朴家总资产损失：0%');
        console.log('链上阶级流动性：已归零\n');
        
        return {
            status: 'LIQUIDATED',
            totalLoss: 100,
            classMobility: 0
        };
    }
}

// 运行清算模拟
const cascade = new LiquidationCascade();
const result = cascade.triggerRainStorm();

// 最终分析
console.log('=== 《寄生虫》链上流动性危机分析 ===');
console.log('金家经历的是一场典型的"链上清算瀑布"：');
console.log('1. 外部冲击（暴雨）→ 2. 资产贬值 → 3. 触发清算 → 4. 强制平仓 → 5. 阶级归零');
console.log('====================================');

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

/**
 * @title ParasiteLiquidityProtocol
 * @notice 基于《寄生虫》阶级流动性隐喻的Token分配模型
 * @dev 核心机制：贡献证明（Proof of Contribution）替代初始分配特权
 */
contract ParasiteLiquidityProtocol {
    using SafeMath for uint256;
    
    // 金家——底层协议参与者
    struct KimFamily {
        uint256 laborHours;       // 工作时间（折叠披萨盒、代驾、家教）
        uint256 educationScore;   // 教育水平（基宇伪造的延世大学学历）
        uint256 trustLevel;       // 社会信任度（朴家的好感度）
        uint256 contribution;     // 贡献积分
        bool verified;            // 是否通过链上验证
    }
    
    // 朴家——上层协议参与者
    struct ParkFamily {
        uint256 capital;          // 初始资本（IT公司收益）
        uint256 networkValue;     // 人脉网络价值
        uint256 socialCapital;    // 社会资本（江南区业主身份）
    }
    
    // 流动性池——阶级跃迁的通道
    struct MobilityPool {
        uint256 totalLiquidity;   // 总流动性
        uint256 classThreshold;   // 阶级跃迁阈值
        uint256 exitFee;          // 退出费用（社会流动性成本）
    }
    
    ParkFamily public park;
    MobilityPool public pool;
    mapping(address => KimFamily) public kimFamilies;
    
    uint256 public constant INITIAL_CLASS_THRESHOLD = 1000 ether;
    uint256 public constant MIN_CONTRIBUTION = 100 ether;
    
    event ClassUpgrade(address indexed member, uint256 newClass);
    event Liquidation(address indexed member, string reason);
    
    constructor() {
        park = ParkFamily({
            capital: 10000 ether,
            networkValue: 5000 ether,
            socialCapital: 3000 ether
        });
        
        pool = MobilityPool({
            totalLiquidity: 0,
            classThreshold: INITIAL_CLASS_THRESHOLD,
            exitFee: 10 ether
        });
    }
    
    /**
     * @notice 金家通过贡献证明获得流动性
     * @param laborHours 工作时间
     * @param skillScore 技能评分
     * @dev 这是金家唯一的"阶级跃迁"函数
     */
    function contributeLabor(uint256 laborHours, uint256 skillScore) external {
        require(laborHours > 0, "Zero contribution");
        
        KimFamily storage kim = kimFamilies[msg.sender];
        kim.laborHours += laborHours;
        kim.educationScore += skillScore;
        
        // 贡献积分 = 时间 * 技能 * 信任度
        uint256 contribution = laborHours * skillScore * 100;
        kim.contribution += contribution;
        
        // 注入流动性池
        pool.totalLiquidity += contribution;
        
        // 检查是否达到阶级跃迁阈值
        if (kim.contribution >= pool.classThreshold) {
            _upgradeClass(msg.sender);
        }
        
        emit ClassUpgrade(msg.sender, _calculateClass(kim.contribution));
    }
    
    /**
     * @notice 内部函数：执行阶级跃迁
     * @param member 金家成员地址
     * @dev 类似于跨链桥——从半地下室链迁移到顶层公寓链
     */
    function _upgradeClass(address member) internal {
        KimFamily storage kim = kimFamilies[member];
        require(kim.contribution >= pool.classThreshold, "Insufficient contribution");
        
        // 验证链上身份（防止伪造——基宇的漏洞点）
        require(kim.verified, "Identity not verified");
        
        // 扣除退出费用（社会流动性成本）
        pool.totalLiquidity -= pool.exitFee;
        
        // 重置贡献积分——阶级跃迁后的"归零"机制
        kim.contribution = 0;
        
        // 动态调整阈值——防止阶级固化
        pool.classThreshold = pool.classThreshold.mul(110).div(100);
    }
    
    /**
     * @notice 朴家作为"验证者"检验身份真伪
     * @param member 被验证地址
     * @param proof 链上身份证明
     * @dev 朴家拥有验证权——这是阶级流动性的关键节点
     */
    function verifyIdentity(address member, bytes32 proof) external {
        require(msg.sender == address(this), "Only protocol can verify");
        // 验证逻辑：检查proof是否为有效的链上学历证明
        // 这是《寄生虫》中基宇的"伪造攻击"的防御点
        KimFamily storage kim = kimFamilies[member];
        kim.verified = _verifyOnChainCredential(proof);
    }
    
    function _calculateClass(uint256 contribution) internal pure returns (uint256) {
        if (contribution >= 1000 ether) return 4;  // PENTHOUSE
        if (contribution >= 500 ether) return 3;   // EXECUTIVE
        if (contribution >= 100 ether) return 2;   // REGULAR
        return 1;                                   // HALF_BASEMENT
    }
    
    function _verifyOnChainCredential(bytes32 proof) internal pure returns (bool) {
        // 链上学历验证——防止《寄生虫》式伪造
        // 使用Merkle Tree验证链上学历证书
        return proof != bytes32(0);
    }
    
    /**
     * @notice 查看金家当前的阶级状态
     * @param member 金家成员地址
     * @return class 当前阶级（1-4）
     * @return progress 距离下一个阶级的进度
     */
    function checkClassProgress(address member) external view returns (uint256 class, uint256 progress) {
        KimFamily storage kim = kimFamilies[member];
        class = _calculateClass(kim.contribution);
        progress = kim.contribution.mul(100).div(pool.classThreshold);
    }
}