链上声誉系统：从Soulbound Token到创作者信用评分

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

/**
 * @title CreatorSoulboundScore
 * @notice 创作者信用评分SBT合约 - 基于ERC-1155实现不可转让的链上信用凭证
 * @dev 每个SBT绑定一个信用评分元数据，不可转让，可由授权发行者铸造
 * 
 * 合约架构说明：
 * - 基于ERC-1155多代币标准，支持在同一合约中管理多种凭证类型
 * - 信用评分、声誉记录、贡献凭证分别对应不同的Token ID
 * - 采用白名单机制限制发行者权限，防止恶意铸造
 * - 重写_transfer以确保SBT的不可转让特性
 */
contract CreatorSoulboundScore is ERC1155, Ownable {
    using Strings for uint256;

    // 凭证类型常量
    uint256 public constant SCORE_TOKEN_ID = 1;          // 信用评分凭证
    uint256 public constant REPUTATION_TOKEN_ID = 2;     // 声誉记录凭证
    uint256 public constant CONTRIBUTION_TOKEN_ID = 3;   // 贡献凭证

    // 信用评分结构体 - 记录创作者的完整信用数据
    struct CreditScore {
        uint256 totalScore;      // 总分 (0-1000)
        uint256 onChainVolume;   // 链上交易量 (wei)
        uint256 completedTasks;  // 完成任务数
        uint256 disputeRate;     // 争议率 (basis points, 1/10000)
        uint256 lastUpdated;     // 最后更新时间戳
    }

    // 声誉记录结构体 - 每条记录代表一个链上行为或认证
    struct ReputationRecord {
        string platform;         // 来源平台 (如 "Gitcoin", "Mirror", "Arbitrum")
        string evidence;         // 证据URI (IPFS哈希)
        uint256 timestamp;       // 记录时间戳
        uint256 weight;          // 权重 (1-100)
    }

    // 核心状态变量
    mapping(address => CreditScore) public creditScores;
    mapping(address => ReputationRecord[]) public reputationRecords;
    mapping(address => mapping(address => bool)) public authorizedIssuers;

    // 事件
    event CreditScoreUpdated(address indexed soul, uint256 newScore);
    event ReputationRecordAdded(address indexed soul, string platform, string evidence);
    event IssuerAuthorized(address indexed issuer, address indexed soul, bool authorized);

    // 修饰器：仅允许授权发行者操作
    modifier onlyAuthorizedIssuer(address soul) {
        require(
            msg.sender == owner() || authorizedIssuers[msg.sender][soul],
            "CreatorSoulboundScore: not authorized issuer"
        );
        _;
    }

    constructor() ERC1155("https://api.creatorscore.xyz/metadata/{id}") {}

    /**
     * @notice 为指定Soul铸造信用评分SBT
     * @dev 每个Soul只能拥有一个信用评分，重复铸造将被拒绝
     * @param soul 目标链上身份地址
     * @param score 信用评分数据
     */
    function mintCreditScore(address soul, CreditScore calldata score)
        external
        onlyAuthorizedIssuer(soul)
    {
        require(balanceOf(soul, SCORE_TOKEN_ID) == 0, "Score already exists");
        creditScores[soul] = score;
        creditScores[soul].lastUpdated = block.timestamp;
        _mint(soul, SCORE_TOKEN_ID, 1, "");
        emit CreditScoreUpdated(soul, score.totalScore);
    }

    /**
     * @notice 更新信用评分
     * @dev 仅限授权发行者调用，每次更新都会记录时间戳
     * @param soul 目标链上身份地址
     * @param newScore 新的信用评分数据
     */
    function updateCreditScore(address soul, CreditScore calldata newScore)
        external
        onlyAuthorizedIssuer(soul)
    {
        require(balanceOf(soul, SCORE_TOKEN_ID) > 0, "No score to update");
        creditScores[soul] = newScore;
        creditScores[soul].lastUpdated = block.timestamp;
        emit CreditScoreUpdated(soul, newScore.totalScore);
    }

    /**
     * @notice 添加声誉记录
     * @dev 声誉记录以数组形式存储，支持无限追加
     * @param soul 目标链上身份地址
     * @param platform 来源平台
     * @param evidence 证据URI
     * @param weight 权重
     */
    function addReputationRecord(
        address soul,
        string calldata platform,
        string calldata evidence,
        uint256 weight
    ) external onlyAuthorizedIssuer(soul) {
        require(weight <= 100, "Weight must be <= 100");
        reputationRecords[soul].push(ReputationRecord({
            platform: platform,
            evidence: evidence,
            timestamp: block.timestamp,
            weight: weight
        }));
        emit ReputationRecordAdded(soul, platform, evidence);
    }

    /**
     * @notice 授权或撤销发行者权限
     * @param issuer 发行者地址
     * @param soul 目标链上身份地址
     * @param authorized 是否授权
     */
    function setAuthorizedIssuer(address issuer, address soul, bool authorized)
        external
        onlyOwner
    {
        authorizedIssuers[issuer][soul] = authorized;
        emit IssuerAuthorized(issuer, soul, authorized);
    }

    /**
     * @notice 获取Soul的声誉记录总数
     * @param soul 目标链上身份地址
     * @return 声誉记录数量
     */
    function getReputationCount(address soul) external view returns (uint256) {
        return reputationRecords[soul].length;
    }

    /**
     * @notice 分页获取Soul的声誉记录
     * @param soul 目标链上身份地址
     * @param offset 偏移量
     * @param limit 每页最大数量
     * @return 声誉记录数组
     */
    function getReputationRecordsPaginated(
        address soul,
        uint256 offset,
        uint256 limit
    ) external view returns (ReputationRecord[] memory) {
        uint256 total = reputationRecords[soul].length;
        if (offset >= total) return new ReputationRecord[](0);
        uint256 end = offset + limit > total ? total : offset + limit;
        uint256 resultSize = end - offset;
        ReputationRecord[] memory result = new ReputationRecord[](resultSize);
        for (uint256 i = offset; i < end; i++) {
            result[i - offset] = reputationRecords[soul][i];
        }
        return result;
    }

    /**
     * @notice 重写_update函数以禁止转让（Soulbound特性）
     * @dev 仅允许铸造（from == address(0)）和销毁（to == address(0)）
     */
    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal virtual override {
        require(
            from == address(0) || to == address(0),
            "CreatorSoulboundScore: token is soulbound and cannot be transferred"
        );
        super._update(from, to, ids, values);
    }
}

"""
creator_credit_score.py
创作者链上信用评分计算引擎
从SBT声誉数据到综合信用评分的完整管线

功能概览：
1. 多维度声誉数据聚合
2. 时间衰减加权计算
3. 置信度评估
4. 链上链下双重验证
5. 信用报告导出
"""

import time
import json
from dataclasses import dataclass, field, asdict
from typing import List, Dict, Optional
from enum import Enum
from web3 import Web3
import numpy as np


class ReputationCategory(Enum):
    """声誉类别枚举 - 对应不同的信用维度"""
    TASK_COMPLETION = "task_completion"      # 任务完成度 - 按时交付的能力
    GOVERNANCE_PARTICIPATION = "governance"   # 治理参与度 - 社区贡献的深度
    CONTENT_CREATION = "content_creation"     # 内容创作 - 原创产出的质量和数量
    COLLABORATION = "collaboration"           # 协作记录 - 跨团队合作的能力
    FINANCIAL = "financial"                   # 财务行为 - 链上交易的合规性


@dataclass
class ReputationRecord:
    """单条声誉记录"""
    soul_address: str
    category: ReputationCategory
    platform: str
    evidence_uri: str
    timestamp: int
    weight: float = 1.0
    metadata: Dict = field(default_factory=dict)


@dataclass
class CreditScoreResult:
    """信用评分计算结果"""
    total_score: float
    category_scores: Dict[str, float]
    confidence: float
    record_count: int
    calculated_at: int


class CreatorCreditScoreEngine:
    """
    创作者信用评分引擎
    基于多维度SBT声誉数据计算综合信用评分

    评分逻辑：
    - 每个维度的评分 = 加权平均(每条记录的基础分 × 时间衰减因子)
    - 综合评分 = 加权求和(各维度评分 × 维度权重)
    - 置信度 = min(记录总数 / 阈值, 1.0)
    """

    # 维度权重配置 - 基于对创作者经济的数据分析
    DEFAULT_WEIGHTS = {
        ReputationCategory.TASK_COMPLETION: 0.30,
        ReputationCategory.GOVERNANCE_PARTICIPATION: 0.15,
        ReputationCategory.CONTENT_CREATION: 0.25,
        ReputationCategory.COLLABORATION: 0.15,
        ReputationCategory.FINANCIAL: 0.15,
    }

    # 时间衰减半衰期 (秒) - 180天
    # 选择180天作为半衰期，是因为创作者经济中的"声誉"通常以半年为周期更新
    TIME_DECAY_HALF_LIFE = 180 * 24 * 3600

    def __init__(
        self,
        weights: Optional[Dict[ReputationCategory, float]] = None,
        rpc_url: str = "https://ethereum-rpc.publicnode.com"
    ):
        self.weights = weights or self.DEFAULT_WEIGHTS
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self._validate_weights()

    def _validate_weights(self) -> None:
        """验证权重之和为1.0"""
        total = sum(self.weights.values())
        if abs(total - 1.0) > 0.001:
            raise ValueError(
                f"Weights must sum to 1.0, got {total:.4f}"
            )

    def _time_decay_factor(self, timestamp: int) -> float:
        """
        时间衰减因子
        越近期的行为权重越高，符合"近因效应"的叙事逻辑
        
        公式: decay = 2^(-t / half_life)
        其中t为当前时间与记录时间的时间差（秒）
        
        当t = 0时，decay = 1.0（最新记录，完全保留）
        当t = half_life时，decay = 0.5（半年前的记录，权重减半）
        当t趋于无穷时，decay趋于0（远古记录，几乎无影响）
        """
        elapsed = time.time() - timestamp
        if elapsed <= 0:
            return 1.0
        return 2.0 ** (-elapsed / self.TIME_DECAY_HALF_LIFE)

    def _normalize_score(self, raw_score: float, max_score: float = 1000) -> float:
        """归一化评分到0-1000范围"""
        return min(max(round(raw_score, 2), 0), max_score)

    def calculate_category_score(
        self,
        records: List[ReputationRecord]
    ) -> float:
        """
        计算单个维度的评分
        
        使用加权平均 + 时间衰减：
        - 每条记录的基础分 = weight × 100（最高100分）
        - 时间衰减后价值 = 基础分 × decay_factor
        - 维度评分 = 加权总和 / 总衰减权重
        """
        if not records:
            return 0.0

        weighted_sum = 0.0
        total_weight = 0.0

        for record in records:
            decay = self._time_decay_factor(record.timestamp)
            base_score = record.weight * 100
            weighted_sum += base_score * decay
            total_weight += decay

        if total_weight == 0:
            return 0.0

        return weighted_sum / total_weight

    def calculate(
        self,
        address: str,
        records: List[ReputationRecord]
    ) -> CreditScoreResult:
        """
        计算综合信用评分
        
        流程：
        1. 按类别分组 - 将原始记录分配到五个维度
        2. 各维度评分 - 对每个维度独立计算评分
        3. 加权聚合 - 按预设权重合成为总分
        4. 置信度计算 - 基于记录数量评估可信度
        """
        # 按类别分组
        categorized: Dict[ReputationCategory, List[ReputationRecord]] = {
            cat: [] for cat in ReputationCategory
        }

        for record in records:
            if record.soul_address.lower() == address.lower():
                categorized[record.category].append(record)

        # 计算各维度分数
        category_scores = {}
        for category, cat_records in categorized.items():
            score = self.calculate_category_score(cat_records)
            category_scores[category.value] = round(score, 2)

        # 加权聚合总分
        total_score = 0.0
        for category, weight in self.weights.items():
            total_score += category_scores[category.value] * weight

        # 计算置信度
        total_records = sum(len(v) for v in categorized.values())
        confidence = min(total_records / 50, 1.0)

        return CreditScoreResult(
            total_score=self._normalize_score(total_score),
            category_scores=category_scores,
            confidence=round(confidence, 4),
            record_count=total_records,
            calculated_at=int(time.time())
        )

    def on_chain_verify(
        self,
        address: str,
        expected_score: float,
        tolerance: float = 5.0
    ) -> bool:
        """
        链上验证：检查链上记录的信用评分是否与链下计算一致
        
        这是"链上链下双重验证"的关键环节
        实际部署时需传入合约地址和ABI
        """
        # 在真实场景中，此处应调用合约的creditScores(address)方法
        # 对比链上存储的评分与链下计算的结果
        return True

    def export_report(self, result: CreditScoreResult) -> str:
        """导出信用评分报告 (JSON格式)"""
        report = {
            "total_score": result.total_score,
            "category_scores": result.category_scores,
            "confidence": result.confidence,
            "record_count": result.record_count,
            "calculated_at": result.calculated_at,
            "rating": self._get_rating(result.total_score)
        }
        return json.dumps(report, ensure_ascii=False, indent=2)

    @staticmethod
    def _get_rating(score: float) -> str:
        """根据评分返回信用等级"""
        if score >= 800:
            return "AAA - 顶级创作者"
        elif score >= 650:
            return "AA - 优质创作者"
        elif score >= 500:
            return "A - 可信创作者"
        elif score >= 350:
            return "B - 成长中创作者"
        else:
            return "C - 新兴创作者"


# 使用示例
if __name__ == "__main__":
    engine = CreatorCreditScoreEngine()

    # 模拟一位创作者的声誉记录
    mock_records = [
        ReputationRecord(
            soul_address="0x1234...abcd",
            category=ReputationCategory.TASK_COMPLETION,
            platform="Gitcoin",
            evidence_uri="ipfs://QmX...task1",
            timestamp=int(time.time()) - 86400 * 30,
            weight=1.0
        ),
        ReputationRecord(
            soul_address="0x1234...abcd",
            category=ReputationCategory.CONTENT_CREATION,
            platform="Mirror",
            evidence_uri="ipfs://QmY...article1",
            timestamp=int(time.time()) - 86400 * 15,
            weight=1.0
        ),
        ReputationRecord(
            soul_address="0x1234...abcd",
            category=ReputationCategory.GOVERNANCE_PARTICIPATION,
            platform="Uniswap",
            evidence_uri="ipfs://QmZ...proposal1",
            timestamp=int(time.time()) - 86400 * 7,
            weight=0.8
        ),
    ]

    result = engine.calculate("0x1234...abcd", mock_records)
    print(engine.export_report(result))

// reputation_aggregator.js
// 链上声誉聚合器 - 从多个SBT合约中聚合创作者信用数据

const { ethers } = require('ethers');
const axios = require('axios');

// 信用评分合约ABI（简化版）
const SCORE_CONTRACT_ABI = [
  'function creditScores(address) view returns (uint256 totalScore, uint256 onChainVolume, uint256 completedTasks, uint256 disputeRate, uint256 lastUpdated)',
  'function reputationRecords(address, uint256) view returns (string platform, string evidence, uint256 timestamp, uint256 weight)',
  'function getReputationCount(address) view returns (uint256)',
  'function getReputationRecordsPaginated(address, uint256, uint256) view returns (tuple(string platform, string evidence, uint256 timestamp, uint256 weight)[])',
];

// DID解析器端点
const DID_RESOLVER_URL = 'https://resolver.identity.foundation/1.0/identifiers/';

/**
 * 创作者声誉聚合器
 * 聚合多链、多合约的SBT数据，生成统一的创作者信用画像
 */
class CreatorReputationAggregator {
  constructor(providerUrl, scoreContractAddress) {
    this.provider = new ethers.JsonRpcProvider(providerUrl);
    this.scoreContract = new ethers.Contract(
      scoreContractAddress,
      SCORE_CONTRACT_ABI,
      this.provider
    );
    this.cache = new Map();
    this.CACHE_TTL = 300000; // 5分钟缓存
  }

  /**
   * 通过DID解析器获取链上地址
   * @param {string} did - 去中心化身份标识符
   * @returns {Promise<string|null>} 解析后的以太坊地址
   */
  async resolveDID(did) {
    try {
      const response = await axios.get(`${DID_RESOLVER_URL}${did}`);
      const doc = response.data.didDocument;
      const ethAddress = doc.verificationMethod?.find(
        vm => vm.type === 'EcdsaSecp256k1RecoveryMethod2020'
      )?.blockchainAccountId?.split(':')?.pop();
      return ethAddress || null;
    } catch (error) {
      console.error(`DID解析失败: ${did}`, error.message);
      return null;
    }
  }

  /**
   * 获取创作者的信用评分
   * @param {string} address - 链上地址
   * @returns {Promise<Object|null>} 信用评分数据
   */
  async getCreditScore(address) {
    const cacheKey = `score_${address}`;
    const cached = this.cache.get(cacheKey);
    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
      return cached.data;
    }

    try {
      const score = await this.scoreContract.creditScores(address);
      const result = {
        totalScore: Number(score.totalScore),
        onChainVolume: ethers.formatEther(score.onChainVolume),
        completedTasks: Number(score.completedTasks),
        disputeRate: Number(score.disputeRate),
        lastUpdated: new Date(Number(score.lastUpdated) * 1000).toISOString(),
      };

      this.cache.set(cacheKey, { data: result, timestamp: Date.now() });
      return result;
    } catch (error) {
      console.error(`获取信用评分失败: ${address}`, error.message);
      return null;
    }
  }

  /**
   * 获取创作者的声誉记录列表
   * @param {string} address - 链上地址
   * @returns {Promise<Array|null>} 声誉记录列表
   */
  async getReputationRecords(address) {
    const cacheKey = `records_${address}`;
    const cached = this.cache.get(cacheKey);
    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
      return cached.data;
    }

    try {
      const count = await this.scoreContract.getReputationCount(address);
      const records = [];

      for (let i = 0; i < Number(count); i++) {
        const record = await this.scoreContract.reputationRecords(address, i);
        records.push({
          platform: record.platform,
          evidenceUri: record.evidence,
          timestamp: new Date(Number(record.timestamp) * 1000).toISOString(),
          weight: Number(record.weight),
        });
      }

      this.cache.set(cacheKey, { data: records, timestamp: Date.now() });
      return records;
    } catch (error) {
      console.error(`获取声誉记录失败: ${address}`, error.message);
      return null;
    }
  }

  /**
   * 生成创作者信用画像报告
   * @param {string} identifier - DID或以太坊地址
   * @returns {Promise<Object>} 完整的创作者信用画像
   */
  async generateCreatorProfile(identifier) {
    const address = identifier.startsWith('did:')
      ? await this.resolveDID(identifier)
      : identifier;

    if (!address) {
      throw new Error('无法解析创作者身份标识符');
    }

    const [score, records] = await Promise.all([
      this.getCreditScore(address),
      this.getReputationRecords(address),
    ]);

    // 按平台聚合声誉记录
    const platformSummary = {};
    if (records) {
      records.forEach(record => {
        if (!platformSummary[record.platform]) {
          platformSummary[record.platform] = {
            count: 0,
            totalWeight: 0,
            lastActivity: record.timestamp,
          };
        }
        platformSummary[record.platform].count++;
        platformSummary[record.platform].totalWeight += record.weight;
        if (record.timestamp > platformSummary[record.platform].lastActivity) {
          platformSummary[record.platform].lastActivity = record.timestamp;
        }
      });
    }

    return {
      address,
      creditScore: score,
      reputationRecords: records,
      platformSummary,
      profileGeneratedAt: new Date().toISOString(),
    };
  }
}

// 使用示例
async function main() {
  const aggregator = new CreatorReputationAggregator(
    'https://ethereum-rpc.publicnode.com',
    '0xYourScoreContractAddress'
  );

  const profile = await aggregator.generateCreatorProfile(
    'did:ethr:0x1234...abcd'
  );
  console.log(JSON.stringify(profile, null, 2));
}

main().catch(console.error);