《千与千寻》与数字身份：汤婆婆的契约作为Web3灵魂绑定

class SoulboundIdentity:
    """
    灵魂绑定身份系统
    模拟千寻在油屋中的身份绑定与声誉积累机制
    """
    
    def __init__(self, real_name: str, wallet_address: str):
        self.real_name = real_name          # 千寻的真实身份
        self.wallet_address = wallet_address  # 小千的链上地址
        self.is_bound = True                 # 灵魂绑定状态
        self.reputation_score = 0            # 声誉值
        self.action_log = []                 # 行为记录
        self.credentials = []                # 凭证明细
        self.trust_connections = []          # 信任关系
        
    def perform_action(self, action_name: str, action_value: int, 
                       witnesses: list = None) -> dict:
        """
        在链上记录行为，积累声誉
        相当于千寻在油屋中完成一项工作任务
        """
        block = {
            "action": action_name,
            "block_height": len(self.action_log) + 1,
            "value": action_value,
            "timestamp": self._get_timestamp(),
            "witnesses": witnesses or [],
            "verified": True
        }
        self.action_log.append(block)
        self.reputation_score += action_value
        
        # 每次行为都是对身份的重新确认
        print(f"[区块 #{block['block_height']}] {action_name}: +{action_value} 声誉")
        return block
    
    def verify_identity(self, name_to_check: str) -> bool:
        """验证身份——只有知道真实名字的人才能通过验证"""
        return name_to_check == self.real_name
    
    def soulbound_transfer(self) -> bool:
        """
        灵魂绑定代币的转移——永远返回False
        这正是Soulbound Token的核心特征：不可转让
        """
        return False
    
    def add_credential(self, issuer: str, credential_type: str, 
                      claim: dict) -> None:
        """添加可验证凭证（Verifiable Credential）"""
        self.credentials.append({
            "issuer": issuer,
            "type": credential_type,
            "claim": claim,
            "issued_at": self._get_timestamp(),
            "revocable": False  # 灵魂绑定凭证不可撤销
        })
    
    def get_identity_did(self) -> str:
        """生成去中心化身份标识符（DID）"""
        import hashlib
        did_seed = f"{self.real_name}:{self.wallet_address}"
        did_hash = hashlib.sha256(did_seed.encode()).hexdigest()[:16]
        return f"did:spirited:{did_hash}"
    
    def _get_timestamp(self) -> str:
        from datetime import datetime
        return datetime.now().isoformat()

# 千寻进入油屋——签订灵魂绑定契约
chihiro = SoulboundIdentity("千寻", "0xSen...Chihiro")

# 千寻在油屋中的链上行为记录
chihiro.perform_action("清洗腐烂神", 100, witnesses=["锅炉爷爷", "小玲"])
chihiro.perform_action("帮助白龙包扎伤口", 80, witnesses=["白龙"])
chihiro.perform_action("给无脸男留门", 50, witnesses=["无脸男"])
chihiro.perform_action("不嫌弃腐烂神的恶臭", 120, witnesses=["全体员工"])
chihiro.perform_action("为河神拉绳子", 90, witnesses=["河神"])

# 千寻获得的凭证
chihiro.add_credential("钱婆婆", "ResilienceCredential", {
    "quality": "勇敢",
    "level": "S级",
    "note": "在魔女面前保持冷静"
})

print(f"小千的DID: {chihiro.get_identity_did()}")
print(f"小千的声誉值: {chihiro.reputation_score}")
print(f"身份可转让: {chihiro.soulbound_transfer()}")  # 永远不可转让
print(f"绑定状态: {chihiro.is_bound}")

# 验证身份
print(f"身份验证 '千寻': {chihiro.verify_identity('千寻')}")  # True
print(f"身份验证 '小千': {chihiro.verify_identity('小千')}")  # False

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

/**
 * @title YubabaNameContract
 * @notice 汤婆婆的灵魂绑定契约——油屋身份系统的核心合约
 * @dev 本合约模拟了《千与千寻》中汤婆婆的身份绑定机制
 */
contract YubabaNameContract {
    // ============ 油屋管理权限 ============
    address public owner;  // 汤婆婆——合约的部署者与最高管理者
    
    // ============ 身份映射（状态变量） ============
    mapping(address => string) private realNames;  // 链上地址 -> 真实姓名
    mapping(address => string) public workNames;   // 链上地址 -> 油屋工作名
    mapping(address => bool) public isBound;       // 是否被灵魂绑定
    mapping(address => uint256) public reputation;  // 链上声誉值
    mapping(address => address[]) public guardians; // 守护者列表（多签恢复用）
    
    // ============ 事件日志 ============
    event IdentityBound(address indexed soul, string workName, string realName);
    event IdentityReleased(address indexed soul, string realName);
    event NameForgotten(address indexed soul);
    event ReputationEarned(address indexed soul, uint256 amount, string reason);
    event GuardianAdded(address indexed soul, address indexed guardian);
    
    // ============ 构造函数 ============
    constructor() {
        owner = msg.sender;
    }
    
    // ============ 修饰器 ============
    modifier onlyOwner() {
        require(msg.sender == owner, "只有汤婆婆可以执行此操作");
        _;
    }
    
    modifier onlyBound() {
        require(isBound[msg.sender], "身份尚未绑定，请在汤婆婆处签订契约");
        _;
    }
    
    // ============ 核心身份函数 ============
    
    /**
     * @notice 签订灵魂绑定契约
     * @dev 这是千寻在汤婆婆办公室按下手印的链上对应
     * @param realName 真实名字（如：千寻）
     * @param workName 工作名字（如：小千）
     */
    function bindIdentity(string memory realName, string memory workName) 
        external 
    {
        require(!isBound[msg.sender], "该身份已被绑定，不可重复签约");
        require(bytes(realName).length > 0, "真实名字不能为空");
        require(bytes(workName).length > 0, "工作名字不能为空");
        require(
            keccak256(bytes(realName)) != keccak256(bytes(workName)),
            "工作名字不能与真实名字相同——这是身份转移的关键"
        );
        
        realNames[msg.sender] = realName;
        workNames[msg.sender] = workName;
        isBound[msg.sender] = true;
        
        // 灵魂绑定——一旦绑定，不可自行撤销
        emit IdentityBound(msg.sender, workName, realName);
    }
    
    /**
     * @notice 解除身份绑定
     * @dev 只有汤婆婆可以解除绑定——正如电影中只有汤婆婆能放人
     * @param soul 要解除绑定的灵魂地址
     */
    function releaseIdentity(address soul) 
        external 
        onlyOwner 
    {
        require(isBound[soul], "该地址尚未被绑定");
        string memory releasedName = realNames[soul];
        
        // 解除绑定时打印真实名字（身份恢复）
        delete realNames[soul];
        delete workNames[soul];
        isBound[soul] = false;
        
        emit IdentityReleased(soul, releasedName);
    }
    
    /**
     * @notice 积累链上声誉
     * @dev 对应千寻在油屋中的工作表现记录
     */
    function earnReputation(uint256 amount, string memory reason) 
        external 
        onlyBound 
    {
        reputation[msg.sender] += amount;
        emit ReputationEarned(msg.sender, amount, reason);
    }
    
    /**
     * @notice 添加身份恢复守护者
     * @dev 对应千寻与白龙之间的信任关系
     */
    function addGuardian(address guardian) 
        external 
        onlyBound 
    {
        guardians[msg.sender].push(guardian);
        emit GuardianAdded(msg.sender, guardian);
    }
    
    // ============ 查询函数 ============
    
    /**
     * @notice 查询是否被绑定——灵魂绑定状态查询
     */
    function isSoulbound(address soul) 
        external 
        view 
        returns (bool) 
    {
        return isBound[soul];
    }
    
    /**
     * @notice 获取真实名字——仅合约所有者可查看
     * @dev 对应汤婆婆可以查看所有员工的真实身份
     */
    function getRealName(address soul) 
        external 
        view 
        onlyOwner 
        returns (string memory) 
    {
        return realNames[soul];
    }
    
    /**
     * @notice 灵魂绑定代币转移——不可转让
     * @dev 这是Soulbound Token的核心约束
     */
    function transferSoulboundIdentity(address, address) 
        external 
        pure 
        returns (bool) 
    {
        revert("Soulbound Token不可转让，正如汤婆婆的契约不可撤销");
    }
    
    // ============ 安全机制 ============
    
    /**
     * @notice 多签身份恢复
     * @dev 需要至少2/3的守护者签名才能恢复身份
     *      对应白龙需要千寻的帮助才能想起自己的名字
     */
    function recoverIdentity(address soul, string memory newRealName) 
        external 
    {
        require(guardians[soul].length >= 2, "至少需要两名守护者");
        // 简化版：需要至少2个守护者签名
        // 实际实现需要验证签名
        realNames[soul] = newRealName;
        emit IdentityReleased(soul, newRealName);
    }
}

// 去中心化身份系统——让无脸男拥有链上身份
const { ethers } = require('ethers');

class DecentralizedIdentitySystem {
    /**
     * 去中心化身份系统
     * 模拟W3C DID标准 + 可验证凭证 + 信任图谱
     */
    constructor() {
        this.identities = new Map();              // DID文档存储
        this.verifiableCredentials = new Map();   // 可验证凭证存储
        this.trustGraph = new Map();              // 信任关系图谱
        this.credentialSchema = new Map();        // 凭证架构
    }

    /**
     * 创建去中心化身份标识符（DID）
     * @param {string} entityName - 实体名称
     * @param {string} publicKey - 公钥
     * @param {string} entityType - 实体类型（person/organization/device）
     * @returns {string} DID字符串
     */
    createDID(entityName, publicKey, entityType = 'person') {
        const did = `did:spirited:${entityName.toLowerCase().replace(/\s/g, '')}`;
        
        const didDocument = {
            '@context': [
                'https://www.w3.org/ns/did/v1',
                'https://w3id.org/security/suites/ecdsa-2019/v1'
            ],
            id: did,
            alsoKnownAs: [entityName],
            controller: [did],
            verificationMethod: [{
                id: `${did}#keys-1`,
                type: 'EcdsaSecp256k1VerificationKey2019',
                controller: did,
                publicKeyHex: publicKey,
                // 密钥用途：身份验证 + 凭证签名
                purpose: ['authentication', 'assertionMethod']
            }],
            authentication: [`${did}#keys-1`],
            assertionMethod: [`${did}#keys-1`],
            service: [{
                id: `${did}#bathhouse`,
                type: 'BathhouseService',
                serviceEndpoint: 'https://bathhouse.spirited-realm/v1',
                description: '油屋身份验证服务端点'
            }],
            // 身份元数据
            created: new Date().toISOString(),
            entityType: entityType
        };
        
        this.identities.set(did, {
            document: didDocument,
            reputation: 0,
            createdAt: Date.now(),
            isAnonymous: entityName === 'NoFace',
            lastActivity: Date.now()
        });
        
        console.log(`[DID创建] ${entityName} -> ${did}`);
        return did;
    }

    /**
     * 签发可验证凭证
     * @param {string} issuerDID - 签发者DID
     * @param {string} subjectDID - 持有者DID
     * @param {string} credentialType - 凭证类型
     * @param {object} claim - 声明内容
     * @param {number} expiryDays - 过期天数（0为永不过期）
     * @returns {object} 可验证凭证
     */
    issueCredential(issuerDID, subjectDID, credentialType, claim, expiryDays = 0) {
        // 验证签发者身份
        if (!this.identities.has(issuerDID)) {
            throw new Error(`签发者 ${issuerDID} 身份未注册`);
        }

        const credential = {
            '@context': ['https://www.w3.org/2018/credentials/v1'],
            id: `urn:uuid:${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
            type: ['VerifiableCredential', credentialType],
            issuer: issuerDID,
            issuanceDate: new Date().toISOString(),
            expirationDate: expiryDays > 0 
                ? new Date(Date.now() + expiryDays * 86400000).toISOString()
                : null,
            credentialSubject: {
                id: subjectDID,
                ...claim
            },
            // 证明信息（简化版）
            proof: {
                type: 'EcdsaSecp256k1Signature2019',
                created: new Date().toISOString(),
                verificationMethod: `${issuerDID}#keys-1`,
                proofPurpose: 'assertionMethod'
            }
        };
        
        if (!this.verifiableCredentials.has(subjectDID)) {
            this.verifiableCredentials.set(subjectDID, []);
        }
        this.verifiableCredentials.get(subjectDID).push(credential);
        
        // 更新签发者声誉
        this.identities.get(issuerDID).reputation += 10;
        
        console.log(`[凭证签发] ${issuerDID} -> ${subjectDID}: ${credentialType}`);
        return credential;
    }

    /**
     * 验证身份信息
     * @param {string} did - 要验证的DID
     * @returns {object} 验证结果
     */
    verifyIdentity(did) {
        const identity = this.identities.get(did);
        if (!identity) {
            return {
                valid: false,
                reason: '未找到身份记录——无脸男，无身份',
                recommendations: ['请先创建DID', '或请信任方为你签发凭证']
            };
        }
        
        const credentials = this.verifiableCredentials.get(did) || [];
        const verifiedClaims = credentials.map(c => ({
            type: c.type[1],
            issuer: c.issuer,
            claims: c.credentialSubject,
            issuedAt: c.issuanceDate,
            isExpired: c.expirationDate ? new Date(c.expirationDate) < new Date() : false
        }));
        
        // 计算身份可信度
        const trustScore = Math.min(
            identity.reputation + credentials.length * 20,
            100
        );
        
        return {
            valid: true,
            isAnonymous: identity.isAnonymous,
            reputation: identity.reputation,
            trustScore: trustScore,
            verifiedClaims: verifiedClaims,
            didDocument: identity.document,
            lastActivity: new Date(identity.lastActivity).toISOString()
        };
    }

    /**
     * 建立信任关系
     * @param {string} fromDID - 信任方DID
     * @param {string} toDID - 被信任方DID
     * @param {number} trustLevel - 信任等级（0-100）
     * @param {string} context - 信任上下文
     */
    establishTrust(fromDID, toDID, trustLevel, context = 'general') {
        if (!this.identities.has(fromDID) || !this.identities.has(toDID)) {
            throw new Error('双方都需要先注册DID');
        }
        
        if (!this.trustGraph.has(fromDID)) {
            this.trustGraph.set(fromDID, []);
        }
        
        const trustRelation = {
            target: toDID,
            level: Math.min(Math.max(trustLevel, 0), 100),
            context: context,
            timestamp: Date.now(),
            oneWay: false  // 双向信任
        };
        
        this.trustGraph.get(fromDID).push(trustRelation);
        this.identities.get(fromDID).reputation += 5;
        
        console.log(`[信任建立] ${fromDID} 信任 ${toDID} (等级: ${trustLevel})`);
        return trustRelation;
    }

    /**
     * 查找信任路径
     * @param {string} fromDID - 起始DID
     * @param {string} toDID - 目标DID
     * @param {number} maxDepth - 最大深度
     * @returns {array} 信任路径
     */
    findTrustPath(fromDID, toDID, maxDepth = 3) {
        const visited = new Set();
        const queue = [[fromDID, [fromDID]]];
        
        while (queue.length > 0) {
            const [current, path] = queue.shift();
            
            if (current === toDID) {
                return path;
            }
            
            if (path.length > maxDepth) continue;
            
            const trustRelations = this.trustGraph.get(current) || [];
            for (const relation of trustRelations) {
                if (!visited.has(relation.target)) {
                    visited.add(relation.target);
                    queue.push([relation.target, [...path, relation.target]]);
                }
            }
        }
        
        return null;  // 未找到信任路径
    }

    /**
     * 批量创建无脸男的完整身份
     */
    createNoFaceFullIdentity() {
        // 1. 创建无脸男DID
        const noFaceDID = this.createDID('NoFace', '0x000...Anonymous', 'anonymous');
        
        // 2. 千寻为无脸男签发凭证
        const chihiroDID = this.createDID('Chihiro', '0xSen...Chihiro');
        this.issueCredential(
            chihiroDID,
            noFaceDID,
            'BathhouseGuestCredential',
            { 
                kindness: 'high',
                isFriend: true,
                recommendation: '沉默但善良的客人'
            }
        );
        
        // 3. 白龙为无脸男签发凭证
        const hakuDID = this.createDID('Haku', '0xNigi...Haku');
        this.issueCredential(
            hakuDID,
            noFaceDID,
            'SpiritCompanionCredential',
            {
                trustLevel: 'medium',
                note: '被千寻接纳的沉默者'
            }
        );
        
        // 4. 建立信任关系
        this.establishTrust(chihiroDID, noFaceDID, 100, 'friendship');
        this.establishTrust(hakuDID, noFaceDID, 60, 'acquaintance');
        this.establishTrust(noFaceDID, chihiroDID, 100, 'gratitude');
        
        // 5. 验证身份
        const verification = this.verifyIdentity(noFaceDID);
        
        return {
            did: noFaceDID,
            verification: verification,
            trustPath: this.findTrustPath(chihiroDID, noFaceDID)
        };
    }
}

// 执行：无脸男的身份创建
const identitySystem = new DecentralizedIdentitySystem();
const result = identitySystem.createNoFaceFullIdentity();

console.log('\n====== 无脸男身份创建完成 ======');
console.log(`DID: ${result.did}`);
console.log(`身份验证结果:`);
console.log(`  有效: ${result.verification.valid}`);
console.log(`  匿名: ${result.verification.isAnonymous}`);
console.log(`  声誉: ${result.verification.reputation}`);
console.log(`  可信度: ${result.verification.trustScore}/100`);
console.log(`  凭证数量: ${result.verification.verifiedClaims.length}`);
console.log(`信任路径: ${result.trustPath ? result.trustPath.join(' -> ') : '无'}`);
console.log('================================\n');