第一幕：信任的景深——Web3创作者为何需要声誉锚点

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

contract SoulboundToken {
    string public name;
    string public symbol;
    address public issuer;

    // 声誉代币持有者 => 声誉元数据URI
    mapping(address => string) private _soulboundTokens;
    // 持有者 => 是否已绑定
    mapping(address => bool) private _isBound;
    // 声誉维度评分
    mapping(address => mapping(string => uint256)) public reputationScores;

    event SoulboundMinted(address indexed to, string uri, string category);
    event SoulboundRevoked(address indexed from);
    event ReputationUpdated(address indexed subject, string dimension, uint256 score);

    modifier onlyIssuer() {
        require(msg.sender == issuer, "Only issuer can mint");
        _;
    }

    modifier notBound(address account) {
        require(!_isBound[account], "Already soulbound");
        _;
    }

    constructor(string memory _name, string memory _symbol) {
        name = _name;
        symbol = _symbol;
        issuer = msg.sender;
    }

    // 铸造SBT——不可转让，只能由发行方铸造
    function mintSoulbound(
        address to,
        string memory uri,
        string memory category
    ) external onlyIssuer notBound(to) {
        _soulboundTokens[to] = uri;
        _isBound[to] = true;
        emit SoulboundMinted(to, uri, category);
    }

    // 更新声誉评分
    function updateReputation(
        address subject,
        string memory dimension,
        uint256 score
    ) external onlyIssuer {
        require(score <= 100, "Score must be 0-100");
        reputationScores[subject][dimension] = score;
        emit ReputationUpdated(subject, dimension, score);
    }

    // 撤销SBT（用于惩罚欺诈行为）
    function revokeSoulbound(address from) external onlyIssuer {
        require(_isBound[from], "Not bound");
        delete _soulboundTokens[from];
        _isBound[from] = false;
        emit SoulboundRevoked(from);
    }

    // 查询SBT URI
    function getSoulboundURI(address account) external view returns (string memory) {
        require(_isBound[account], "No soulbound token");
        return _soulboundTokens[account];
    }

    // 查询是否已绑定
    function isBound(address account) external view returns (bool) {
        return _isBound[account];
    }

    // 转移函数——强制回滚，确保不可转让
    function transferFrom(address, address, uint256) external pure returns (bool) {
        revert("Soulbound tokens are non-transferable");
    }

    function safeTransferFrom(address, address, uint256, bytes memory) external pure returns (bool) {
        revert("Soulbound tokens are non-transferable");
    }
}

import time
from dataclasses import dataclass
from typing import Dict, List, Optional
from decimal import Decimal

@dataclass
class CreatorProfile:
    address: str
    project_count: int
    completed_projects: int
    community_votes: List[Dict]
    sbts: List[Dict]
    governance_participation: float
    first_active_timestamp: int

class ReputationScorer:
    def __init__(self):
        # 各维度权重配置
        self.weights = {
            'project_completion': 0.35,
            'delivery_quality': 0.25,
            'governance_participation': 0.20,
            'reputation_network': 0.15,
            'time_weight': 0.05
        }
        # 时间衰减因子——每30天衰减5%
        self.time_decay_factor = 0.95
        self.decay_period_days = 30

    def calculate_project_completion_score(self, profile: CreatorProfile) -> float:
        """计算项目完成率得分"""
        if profile.project_count == 0:
            return 0.0
        completion_rate = profile.completed_projects / profile.project_count
        # 非线性映射：完成率越高，分数增长越快
        score = 100 * (completion_rate ** 1.5)
        return min(score, 100.0)

    def calculate_delivery_quality_score(self, profile: CreatorProfile) -> float:
        """计算交付质量得分"""
        if not profile.community_votes:
            return 0.0
        total_score = 0
        for vote in profile.community_votes:
            weighted_score = vote.get('score', 0) * self._get_time_weight(vote.get('timestamp', 0))
            total_score += weighted_score
        avg_score = total_score / len(profile.community_votes)
        return min(avg_score, 100.0)

    def calculate_governance_score(self, profile: CreatorProfile) -> float:
        """计算治理参与度得分"""
        # 参与率直接映射为分数
        participation_rate = profile.governance_participation  # 0.0 到 1.0
        return min(participation_rate * 100, 100.0)

    def calculate_reputation_network_score(self, profile: CreatorProfile) -> float:
        """计算声誉网络密度得分"""
        if not profile.sbts:
            return 0.0
        # 统计不同发行方签发的SBT数量
        unique_issuers = set()
        total_endorsements = 0
        for sbt in profile.sbts:
            unique_issuers.add(sbt.get('issuer', ''))
            total_endorsements += sbt.get('weight', 1)
        # 发行方多样性 + 背书总量
        diversity_score = min(len(unique_issuers) * 10, 50)
        endorsement_score = min(total_endorsements * 5, 50)
        return diversity_score + endorsement_score

    def _get_time_weight(self, timestamp: int) -> float:
        """计算时间衰减权重"""
        current_time = int(time.time())
        elapsed_days = (current_time - timestamp) / (24 * 3600)
        decay_periods = elapsed_days / self.decay_period_days
        return self.time_decay_factor ** decay_periods

    def calculate_overall_score(self, profile: CreatorProfile) -> Dict:
        """计算综合信用评分"""
        scores = {
            'project_completion': self.calculate_project_completion_score(profile),
            'delivery_quality': self.calculate_delivery_quality_score(profile),
            'governance_participation': self.calculate_governance_score(profile),
            'reputation_network': self.calculate_reputation_network_score(profile),
        }

        # 时间加权：账户存续时间越长，信用越稳定
        account_age_days = (int(time.time()) - profile.first_active_timestamp) / (24 * 3600)
        stability_factor = min(account_age_days / 365, 1.0)  # 一年达到最大稳定系数
        scores['time_weight'] = stability_factor * 100

        # 加权总分
        total_score = sum(
            scores[dimension] * self.weights[dimension]
            for dimension in self.weights
        )

        # 罚分机制：如果存在争议记录
        penalty = 0
        if hasattr(profile, 'dispute_count'):
            penalty = min(profile.dispute_count * 15, 50)

        final_score = max(0, total_score - penalty)

        return {
            'overall_score': round(final_score, 2),
            'dimension_scores': scores,
            'confidence_level': self._get_confidence_level(final_score)
        }

    def _get_confidence_level(self, score: float) -> str:
        """根据分数区间确定信用等级"""
        if score >= 85:
            return "AAA"  # 顶级信誉，类似顶级导演
        elif score >= 70:
            return "AA"   # 高信誉，类似知名导演
        elif score >= 55:
            return "A"    # 良好信誉，类似有经验导演
        elif score >= 40:
            return "BBB"  # 中等信誉，类似新锐导演
        elif score >= 25:
            return "BB"   # 较低信誉，存在风险
        else:
            return "B"    # 低信誉，高风险

// DID身份验证与声誉声明模块
class CreatorIdentityVerifier {
  constructor(provider) {
    this.provider = provider; // Web3 provider
    this.didRegistry = null;  // DID注册合约
    this.sbtContract = null;  // SBT合约
    this.verifiableCredentials = new Map();
  }

  // 初始化合约连接
  async initialize(didRegistryAddress, sbtContractAddress) {
    const ethers = await import('ethers');
    this.didRegistry = new ethers.Contract(
      didRegistryAddress,
      [
        'function resolveDID(string memory did) view returns (address)',
        'function getCredentials(address account) view returns (string[] memory)'
      ],
      this.provider
    );
    this.sbtContract = new ethers.Contract(
      sbtContractAddress,
      [
        'function getSoulboundURI(address account) view returns (string memory)',
        'function isBound(address account) view returns (bool)',
        'function reputationScores(address,string) view returns (uint256)'
      ],
      this.provider
    );
  }

  // 解析DID，获取绑定的钱包地址
  async resolveDID(did) {
    try {
      const address = await this.didRegistry.resolveDID(did);
      return address;
    } catch (error) {
      console.error('DID解析失败，请检查DID格式:', error);
      return null;
    }
  }

  // 验证创作者的SBT声誉
  async verifyCreatorReputation(creatorAddress) {
    const isBound = await this.sbtContract.isBound(creatorAddress);
    if (!isBound) {
      return {
        verified: false,
        message: '该创作者尚未绑定SBT声誉代币',
        reputationScore: 0
      };
    }

    // 获取SBT元数据URI
    const sbtURI = await this.sbtContract.getSoulboundURI(creatorAddress);

    // 获取各维度声誉评分
    const dimensions = [
      'project_completion',
      'delivery_quality',
      'governance_participation',
      'reputation_network'
    ];

    const scores = {};
    for (const dimension of dimensions) {
      const score = await this.sbtContract.reputationScores(creatorAddress, dimension);
      scores[dimension] = score.toNumber();
    }

    // 计算综合评分
    const weights = {
      project_completion: 0.35,
      delivery_quality: 0.25,
      governance_participation: 0.20,
      reputation_network: 0.20
    };

    let totalScore = 0;
    for (const [dimension, weight] of Object.entries(weights)) {
      totalScore += (scores[dimension] || 0) * weight;
    }

    return {
      verified: true,
      message: '声誉验证通过',
      sbtURI,
      dimensionScores: scores,
      overallScore: Math.round(totalScore),
      confidenceLevel: totalScore >= 85 ? 'AAA' :
                       totalScore >= 70 ? 'AA' :
                       totalScore >= 55 ? 'A' :
                       totalScore >= 40 ? 'BBB' :
                       totalScore >= 25 ? 'BB' : 'B'
    };
  }

  // 创建可验证的声誉声明凭证
  async createReputationClaim(creatorAddress, claimData) {
    // 构造一个签名消息，声明者的声誉数据
    const message = JSON.stringify({
      type: 'ReputationClaim',
      creator: creatorAddress,
      timestamp: Math.floor(Date.now() / 1000),
      claims: claimData,
      // 包含一个随机数防止重放攻击
      nonce: crypto.randomUUID()
    });

    // 使用EIP-712结构化签名
    const signer = this.provider.getSigner();
    const signature = await signer.signMessage(message);

    return {
      message,
      signature,
      verificationMethod: 'EIP-191'
    };
  }

  // 验证声誉声明凭证
  async verifyReputationClaim(claimMessage, signature) {
    try {
      const parsed = JSON.parse(claimMessage);
      const recoveredAddress = ethers.utils.verifyMessage(
        claimMessage,
        signature
      );

      if (recoveredAddress.toLowerCase() !== parsed.creator.toLowerCase()) {
        return {
          valid: false,
          reason: '签名验证失败：签名者地址与声明中的创作者地址不匹配'
        };
      }

      // 验证时间戳在合理范围内（24小时内）
      const currentTime = Math.floor(Date.now() / 1000);
      const timeDiff = currentTime - parsed.timestamp;
      if (timeDiff > 86400) {
        return {
          valid: false,
          reason: '声誉声明已过期（超过24小时）'
        };
      }

      return {
        valid: true,
        creatorAddress: parsed.creator,
        claims: parsed.claims,
        timestamp: parsed.timestamp
      };
    } catch (error) {
      return {
        valid: false,
        reason: '验证过程出错：' + error.message
      };
    }
  }

  // 对比两个创作者的声誉——用于策展决策
  async compareCreators(addressA, addressB) {
    const [repA, repB] = await Promise.all([
      this.verifyCreatorReputation(addressA),
      this.verifyCreatorReputation(addressB)
    ]);

    const comparison = {
      winner: repA.overallScore >= repB.overallScore ? addressA : addressB,
      scoreA: repA.overallScore || 0,
      scoreB: repB.overallScore || 0,
      difference: Math.abs((repA.overallScore || 0) - (repB.overallScore || 0))
    };

    return comparison;
  }
}

// 使用示例：在DAO提案投票前验证提案者信誉
async function validateProposalCreator(proposerAddress, provider) {
  const verifier = new CreatorIdentityVerifier(provider);
  await verifier.initialize(
    '0x_DID_REGISTRY_ADDRESS',
    '0x_SBT_CONTRACT_ADDRESS'
  );

  const reputation = await verifier.verifyCreatorReputation(proposerAddress);

  if (!reputation.verified) {
    console.log('❌ 提案者未绑定声誉：', reputation.message);
    return false;
  }

  console.log('📊 提案者声誉评分:', reputation.overallScore);
  console.log('🏆 信用等级:', reputation.confidenceLevel);

  // 信用等级低于BBB的提案者需要额外抵押
  if (reputation.confidenceLevel === 'B' || reputation.confidenceLevel === 'BB') {
    console.log('⚠️ 低信誉提案者，建议增加抵押品要求');
    return {
      approved: false,
      requiresCollateral: true,
      collateralMultiplier: 1.5
    };
  }

  return {
    approved: true,
    requiresCollateral: false,
    reputation
  };
}