DID去中心化身份：创作者如何掌控自己的数字声誉

did:ethr:0x1234567890abcdef...
did:web:wangsentao.bcu.lat
did:key:z6Mktp...（自证明密钥）

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

/// @title 创作者DID注册表 - 锚定影视创作者的链上身份与作品存证
/// @notice 记录DID到创作者档案的映射，并支持颁发不可转让的SBT职业凭证
contract CreatorDIDRegistry is AccessControl {
    using Counters for Counters.Counter;
    Counters.Counter private _credentialIds;

    bytes32 public constant ISSUER_ROLE = keccak256("ISSUER_ROLE");

    struct CreatorProfile {
        address did;              // 创作者DID控制地址
        string ensName;           // 关联的ENS域名，如 director.eth
        string portfolioURI;      // 作品集元数据URI（IPFS/Arweave）
        uint256 registeredAt;     // 注册时间
        bool verified;            // 是否通过工会或院校认证
    }

    struct Credential {
        uint256 id;
        address holder;           // 持有者DID地址
        address issuer;           // 颁发者（工会/院校/制片方）
        string credentialType;    // 凭证类型：学位、工会会员、作品参与、获奖
        string metadataURI;       // 凭证详情URI
        uint256 issuedAt;
        bytes32 issuerSignature;  // 颁发者签名哈希
    }

    mapping(address => CreatorProfile) public profiles;
    mapping(uint256 => Credential) public credentials;
    mapping(address => uint256[]) public holderCredentials;

    event ProfileRegistered(address indexed did, string ensName, uint256 timestamp);
    event CredentialIssued(uint256 indexed id, address indexed holder, address indexed issuer, string ctype);

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ISSUER_ROLE, msg.sender);
    }

    /// @notice 创作者注册链上身份档案
    function registerProfile(string calldata ensName, string calldata portfolioURI) external {
        require(bytes(profiles[msg.sender].ensName).length == 0, "Profile already exists");
        profiles[msg.sender] = CreatorProfile({
            did: msg.sender,
            ensName: ensName,
            portfolioURI: portfolioURI,
            registeredAt: block.timestamp,
            verified: false
        });
        emit ProfileRegistered(msg.sender, ensName, block.timestamp);
    }

    /// @notice 颁发SBT职业凭证（不可转让：合约不实现transfer逻辑）
    function issueCredential(
        address holder,
        string calldata ctype,
        string calldata metadataURI,
        bytes32 sigHash
    ) external onlyRole(ISSUER_ROLE) returns (uint256) {
        _credentialIds.increment();
        uint256 id = _credentialIds.current();
        credentials[id] = Credential({
            id: id,
            holder: holder,
            issuer: msg.sender,
            credentialType: ctype,
            metadataURI: metadataURI,
            issuedAt: block.timestamp,
            issuerSignature: sigHash
        });
        holderCredentials[holder].push(id);
        emit CredentialIssued(id, holder, msg.sender, ctype);
        return id;
    }

    /// @notice 验证者查询某创作者持有的所有凭证
    function getCredentials(address holder) external view returns (uint256[] memory) {
        return holderCredentials[holder];
    }

    /// @notice 工会/院校认证标记
    function setVerified(address did) external onlyRole(ISSUER_ROLE) {
        profiles[did].verified = true;
    }
}

import json
import time
import hashlib
from web3 import Web3
from eth_account.messages import encode_defunct
from eth_account import Account

class CreatorReputationAggregator:
    """聚合影视创作者跨平台链上声誉，生成可验证报告"""

    def __init__(self, rpc_url, registry_contract_address, abi):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.registry = self.w3.eth.contract(
            address=Web3.to_checksum_address(registry_contract_address),
            abi=abi
        )
        self.reports = {}

    def fetch_onchain_credentials(self, did_address):
        """从DID注册表合约读取创作者持有的所有SBT凭证"""
        credential_ids = self.registry.functions.getCredentials(
            Web3.to_checksum_address(did_address)
        ).call()
        credentials = []
        for cid in credential_ids:
            cred = self.registry.functions.credentials(cid).call()
            credentials.append({
                "id": cred[0],
                "holder": cred[1],
                "issuer": cred[2],
                "type": cred[3],
                "metadataURI": cred[4],
                "issuedAt": cred[5],
                "signature": cred[6].hex()
            })
        return credentials

    def aggregate_offchain_reputation(self, platform_data):
        """
        聚合链下平台声誉数据（YouTube、B站、IMDb等）
        platform_data: dict，形如 {"youtube": {...}, "bilibili": {...}}
        """
        aggregated = {
            "total_followers": 0,
            "total_views": 0,
            "awards": [],
            "verified_platforms": []
        }
        for platform, data in platform_data.items():
            aggregated["total_followers"] += data.get("followers", 0)
            aggregated["total_views"] += data.get("views", 0)
            if data.get("verified"):
                aggregated["verified_platforms"].append(platform)
            for award in data.get("awards", []):
                aggregated["awards"].append({
                    "platform": platform,
                    "title": award
                })
        return aggregated

    def generate_reputation_report(self, did_address, platform_data, issuer_private_key):
        """生成并签署一份可验证的声誉报告"""
        credentials = self.fetch_onchain_credentials(did_address)
        offchain = self.aggregate_offchain_reputation(platform_data)

        report = {
            "did": did_address,
            "generatedAt": int(time.time()),
            "onchain_credentials": credentials,
            "offchain_reputation": offchain,
            "issuer": Account.from_key(issuer_private_key).address
        }

        # 对报告内容签名，供验证者离线核验
        report_json = json.dumps(report, sort_keys=True, ensure_ascii=False)
        report_hash = hashlib.sha256(report_json.encode("utf-8")).digest()
        message = encode_defunct(report_hash)
        signed = Account.sign_message(message, issuer_private_key)

        report["reportHash"] = report_hash.hex()
        report["issuerSignature"] = signed.signature.hex()
        self.reports[did_address] = report
        return report

    def verify_report(self, report):
        """验证者侧：核验声誉报告签名是否来自声称的颁发者"""
        report_json = json.dumps(
            {k: v for k, v in report.items()
             if k not in ("reportHash", "issuerSignature")},
            sort_keys=True, ensure_ascii=False
        )
        recomputed = hashlib.sha256(report_json.encode("utf-8")).hexdigest()
        if recomputed != report["reportHash"]:
            return False, "Hash mismatch"
        message = encode_defunct(bytes.fromhex(report["reportHash"]))
        recovered = Account.recover_message(message, signature=report["issuerSignature"])
        return recovered == report["issuer"], recovered


if __name__ == "__main__":
    # 演示：聚合一位导演的链上SBT凭证与多平台声誉
    aggregator = CreatorReputationAggregator(
        rpc_url="https://polygon-rpc.com",
        registry_contract_address="0xCreatorDIDRegistry...",
        abi=[...]  # 注册表合约ABI
    )

    platform_data = {
        "youtube": {"followers": 128000, "views": 9_400_000, "verified": True, "awards": ["银创作者奖"]},
        "bilibili": {"followers": 96000, "views": 5_200_000, "verified": True, "awards": []},
        "imdb": {"followers": 0, "views": 0, "verified": True, "awards": ["最佳新人导演"]},
    }

    report = aggregator.generate_reputation_report(
        did_address="0xDirectorDIDAddress...",
        platform_data=platform_data,
        issuer_private_key="0xIssuerPrivateKey..."
    )
    print(json.dumps(report, indent=2, ensure_ascii=False))
    valid, signer = aggregator.verify_report(report)
    print(f"报告验证结果: {valid}, 签名者: {signer}")

import { ethers } from "ethers";
import { verifyDidJwt } from "did-jwt";
import { Resolver } from "did-resolver";
import { getResolver } from "ethr-did-resolver";

const REGISTRY_ABI = [
  "function getCredentials(address) view returns (uint256[])",
  "function credentials(uint256) view returns (uint256,address,address,string,string,uint256,bytes32)",
  "function profiles(address) view returns (address,string,string,uint256,bool)"
];

class CreatorAuth {
  constructor(rpcUrl, registryAddress, providerRpc) {
    this.provider = new ethers.JsonRpcProvider(providerRpc);
    this.registry = new ethers.Contract(registryAddress, REGISTRY_ABI, this.provider);
    this.didResolver = new Resolver(
      getResolver({
        networks: [{ name: "mainnet", chainId: 1, rpcUrl }],
        registry: "0xdca7f...";
      })
    );
  }

  // 通过ENS域名解析创作者DID地址
  async resolveDidFromEns(ensName) {
    const resolver = await this.provider.getResolver(ensName);
    if (!resolver) throw new Error(`ENS ${ensName} 未解析到地址`);
    const address = await resolver.getAddress();
    const textRecord = await resolver.getText("did");
    return { address, textRecord };
  }

  // 验证创作者提交的可验证凭证JWT（VC-JWT格式）
  async verifyCredential(credentialJwt, expectedHolder) {
    try {
      const verified = await verifyDidJwt(
        credentialJwt,
        this.didResolver,
        { verificationPolicy: { proofPurpose: "assertionMethod" } }
      );
      const payload = verified.payload;
      if (payload.vc.credentialSubject.id !== expectedHolder) {
        return { valid: false, reason: "凭证持有者不匹配" };
      }
      if (payload.exp && Date.now() / 1000 > payload.exp) {
        return { valid: false, reason: "凭证已过期" };
      }
      return {
        valid: true,
        issuer: payload.iss,
        type: payload.vc.type,
        subject: payload.vc.credentialSubject
      };
    } catch (err) {
      return { valid: false, reason: err.message };
    }
  }

  // 从链上读取某DID下所有SBT凭证
  async fetchOnchainCredentials(didAddress) {
    const ids = await this.registry.getCredentials(didAddress);
    const credentials = [];
    for (const id of ids) {
      const cred = await this.registry.credentials(id);
      credentials.push({
        id: cred[0].toString(),
        holder: cred[1],
        issuer: cred[2],
        type: cred[3],
        metadataURI: cred[4],
        issuedAt: new Date(cred[5].toNumber() * 1000).toISOString(),
        signature: cred[6]
      });
    }
    return credentials;
  }

  // 检查创作者是否具备某项目要求的资格
  async checkQualifications(didAddress, requiredTypes) {
    const credentials = await this.fetchOnchainCredentials(didAddress);
    const heldTypes = new Set(credentials.map(c => c.type));
    const missing = requiredTypes.filter(t => !heldTypes.has(t));
    return {
      qualified: missing.length === 0,
      held: credentials,
      missing
    };
  }

  // 主流程：通过ENS验证创作者并检查资格
  async authenticateCreator(ensName, requiredCredentialTypes) {
    const { address, textRecord } = await this.resolveDidFromEns(ensName);
    if (!textRecord) throw new Error(`${ensName} 未关联DID`);
    const qualifications = await this.checkQualifications(address, requiredCredentialTypes);
    return {
      ens: ensName,
      did: textRecord,
      address,
      qualifications
    };
  }
}

// 使用示例：验证一位导演是否具备"本科以上学历+导演协会会员+获奖记录"
const auth = new CreatorAuth(
  "https://mainnet.infura.io/v3/...",
  "0xCreatorDIDRegistry...",
  "https://polygon-rpc.com"
);

auth.authenticateCreator("director.eth", ["学历SBT", "导演协会会员SBT", "获奖SBT"])
  .then(result => console.log(JSON.stringify(result, null, 2)))
  .catch(err => console.error("身份验证失败:", err));