去中心化身份与创作者信用：DID协议如何重塑数字声誉

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

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

contract CreatorDID is AccessControl, ReentrancyGuard {
    bytes32 public constant ISSUER_ROLE = keccak256("ISSUER_ROLE");
    bytes32 public constant VERIFIER_ROLE = keccak256("VERIFIER_ROLE");

    enum CredentialType {
        EDUCATION, EMPLOYMENT, SKILL, REPUTATION, FINANCIAL, CREATOR
    }

    enum CredentialStatus {
        ISSUED, ACTIVE, REVOKED, EXPIRED, SUSPENDED
    }

    struct DID {
        address owner;
        string didURI;
        bytes32 publicKeyHash;
        uint256 createdAt;
        uint256 lastUpdated;
        uint256 reputationScore;
        bool isActive;
    }

    struct VerifiableCredential {
        bytes32 credentialHash;
        address issuer;
        address holder;
        CredentialType credType;
        string schemaURI;
        uint256 issuedAt;
        uint256 expiresAt;
        CredentialStatus status;
        bytes proof;
    }

    struct ReputationRecord {
        address creator;
        uint256 totalContent;
        uint256 totalViews;
        uint256 totalEngagement;
        uint256 totalRevenue;
        uint256 credibilityScore;
        uint256 lastUpdated;
    }

    mapping(address => DID) public dids;
    mapping(bytes32 => VerifiableCredential) public credentials;
    mapping(address => ReputationRecord) public reputation;
    mapping(address => uint256) public credentialCount;

    uint256 public totalDIDs;
    uint256 public totalCredentials;

    event DIDCreated(address indexed owner, string didURI);
    event CredentialIssued(bytes32 indexed credentialHash, address indexed holder);
    event CredentialRevoked(bytes32 indexed credentialHash);
    event ReputationUpdated(address indexed creator, uint256 score);

    function createDID(string memory _didURI) external returns (address) {
        require(dids[msg.sender].owner == address(0), "DID already exists");
        totalDIDs++;

        dids[msg.sender] = DID({
            owner: msg.sender,
            didURI: _didURI,
            publicKeyHash: keccak256(abi.encodePacked(msg.sender)),
            createdAt: block.timestamp,
            lastUpdated: block.timestamp,
            reputationScore: 0,
            isActive: true
        });

        emit DIDCreated(msg.sender, _didURI);
        return msg.sender;
    }

    function issueCredential(
        address _holder,
        CredentialType _credType,
        string memory _schemaURI,
        uint256 _expiresAt,
        bytes calldata _proof
    ) external onlyRole(ISSUER_ROLE) returns (bytes32) {
        require(dids[_holder].isActive, "Holder DID not active");
        totalCredentials++;

        bytes32 credentialHash = keccak256(abi.encodePacked(
            msg.sender, _holder, _credType, block.timestamp
        ));

        credentials[credentialHash] = VerifiableCredential({
            credentialHash: credentialHash,
            issuer: msg.sender,
            holder: _holder,
            credType: _credType,
            schemaURI: _schemaURI,
            issuedAt: block.timestamp,
            expiresAt: _expiresAt,
            status: CredentialStatus.ACTIVE,
            proof: _proof
        });

        credentialCount[_holder]++;
        emit CredentialIssued(credentialHash, _holder);
        return credentialHash;
    }

    function revokeCredential(bytes32 _credentialHash) external onlyRole(ISSUER_ROLE) {
        VerifiableCredential storage cred = credentials[_credentialHash];
        require(cred.issuer == msg.sender, "Not the issuer");
        cred.status = CredentialStatus.REVOKED;
        emit CredentialRevoked(_credentialHash);
    }

    function updateReputation(
        address _creator,
        uint256 _totalContent,
        uint256 _totalViews,
        uint256 _totalEngagement,
        uint256 _totalRevenue
    ) external {
        ReputationRecord storage record = reputation[_creator];
        record.totalContent = _totalContent;
        record.totalViews = _totalViews;
        record.totalEngagement = _totalEngagement;
        record.totalRevenue = _totalRevenue;

        record.credibilityScore = calculateCredibility(_creator);
        record.lastUpdated = block.timestamp;

        emit ReputationUpdated(_creator, record.credibilityScore);
    }

    function calculateCredibility(address _creator) internal view returns (uint256) {
        ReputationRecord storage record = reputation[_creator];
        if (record.totalContent == 0) return 0;

        uint256 engagementRate = (record.totalEngagement * 10000) / record.totalViews;
        uint256 revenuePerContent = (record.totalRevenue * 10000) / record.totalContent;
        uint256 credentialBonus = credentialCount[_creator] * 100;

        return (engagementRate * 40 + revenuePerContent * 30 + credentialBonus * 30) / 100;
    }

    function verifyCredential(bytes32 _credentialHash) external view returns (bool) {
        VerifiableCredential storage cred = credentials[_credentialHash];
        return cred.status == CredentialStatus.ACTIVE && block.timestamp < cred.expiresAt;
    }
}

import json
import hashlib
from typing import Dict, List, Optional, Any
from dataclasses import dataclass
from datetime import datetime
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.backends import default_backend

@dataclass
class DIDDocument:
    id: str
    public_key: Dict[str, Any]
    authentication: List[Dict]
    service: List[Dict]
    created: str
    updated: str

class CreatorDIDManager:
    def __init__(self):
        self.did_registry: Dict[str, DIDDocument] = {}
        self.credentials: Dict[str, Dict] = {}
        self.reputation: Dict[str, Dict] = {}
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=2048,
            backend=default_backend()
        )
        self.public_key = self.private_key.public_key()

    def create_did(self, owner: str) -> DIDDocument:
        did_id = f"did:creator:{hashlib.sha256(owner.encode()).hexdigest()[:16]}"
        pub_key_bytes = self.public_key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo
        )

        doc = DIDDocument(
            id=did_id,
            public_key={
                'id': f"{did_id}#keys-1",
                'type': 'RsaVerificationKey2018',
                'controller': did_id,
                'publicKeyPem': pub_key_bytes.decode()
            },
            authentication=[{
                'id': f"{did_id}#keys-1",
                'type': 'RsaSignatureAuthentication2018',
                'publicKey': f"{did_id}#keys-1"
            }],
            service=[{
                'id': f"{did_id}#creator-service",
                'type': 'CreatorService',
                'serviceEndpoint': 'https://api.bcu.lat/creator'
            }],
            created=datetime.now().isoformat(),
            updated=datetime.now().isoformat()
        )

        self.did_registry[did_id] = doc
        self.reputation[owner] = {
            'did': did_id,
            'score': 0,
            'content_count': 0,
            'total_views': 0,
            'total_revenue': 0,
            'last_updated': datetime.now().isoformat()
        }
        return doc

    def issue_verifiable_credential(self, holder_did: str, cred_type: str, claims: Dict) -> Dict:
        credential = {
            '@context': ['https://www.w3.org/2018/credentials/v1'],
            'type': ['VerifiableCredential', cred_type],
            'issuer': self.did_registry.get(holder_did, {}).id,
            'issuanceDate': datetime.now().isoformat(),
            'credentialSubject': {
                'id': holder_did,
                **claims
            },
            'proof': {
                'type': 'RsaSignature2018',
                'created': datetime.now().isoformat(),
                'proofPurpose': 'assertionMethod',
                'verificationMethod': f"{holder_did}#keys-1"
            }
        }

        cred_hash = hashlib.sha256(json.dumps(credential, sort_keys=True).encode()).hexdigest()
        self.credentials[cred_hash] = credential
        return credential

    def calculate_reputation_score(self, creator: str) -> Dict:
        rep = self.reputation.get(creator, {})
        if not rep or rep['content_count'] == 0:
            return {'score': 0, 'factors': {}}

        engagement_rate = rep.get('total_views', 0) / rep['content_count'] if rep['content_count'] > 0 else 0
        revenue_per_content = rep.get('total_revenue', 0) / rep['content_count'] if rep['content_count'] > 0 else 0

        score = (
            min(engagement_rate * 10, 40) +
            min(revenue_per_content * 5, 30) +
            min(rep['content_count'] * 2, 30)
        )

        return {
            'score': min(score, 100),
            'factors': {
                'engagement_rate': engagement_rate,
                'revenue_per_content': revenue_per_content,
                'content_count': rep['content_count']
            }
        }

    def update_creator_stats(self, creator: str, views: int = 0, revenue: int = 0):
        if creator not in self.reputation:
            return
        rep = self.reputation[creator]
        rep['content_count'] += 1
        rep['total_views'] += views
        rep['total_revenue'] += revenue
        rep['last_updated'] = datetime.now().isoformat()
        rep['score'] = self.calculate_reputation_score(creator)['score']

    def verify_credential(self, credential_hash: str) -> bool:
        return credential_hash in self.credentials

    def get_did_document(self, did_id: str) -> Optional[DIDDocument]:
        return self.did_registry.get(did_id)

manager = CreatorDIDManager()
did = manager.create_did('0xCreator123')
print(f"Created DID: {did.id}")
manager.update_creator_stats('0xCreator123', views=10000, revenue=500)
score = manager.calculate_reputation_score('0xCreator123')
print(f"Reputation score: {score['score']}")

const { ethers } = require('ethers');
const { DID, VerifiableCredential, Resolver } = require('did-resolver');
const { getResolver } = require('ethr-did-resolver');

class CreatorDIDClient {
  constructor(providerUrl, registryAddress) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.registryAddress = registryAddress;
    this.didRegistry = {};
    this.credentialRegistry = {};
    this.reputationScores = new Map();
  }

  async createDID(owner) {
    const didId = `did:ethr:${owner}`;
    const didDocument = {
      '@context': 'https://www.w3.org/ns/did/v1',
      id: didId,
      verificationMethod: [{
        id: `${didId}#controller`,
        type: 'EcdsaSecp256k1RecoveryMethod2020',
        controller: didId,
        blockchainAccountId: `${owner}@eip155:1`
      }],
      authentication: [`${didId}#controller`],
      assertionMethod: [`${didId}#controller`],
      service: [{
        id: `${didId}#creator`,
        type: 'CreatorService',
        serviceEndpoint: 'https://bcu.lat/creator'
      }]
    };

    this.didRegistry[didId] = didDocument;
    return didDocument;
  }

  async issueCredential(holderDid, credType, claims) {
    const credential = {
      '@context': [
        'https://www.w3.org/2018/credentials/v1',
        'https://www.w3.org/2018/credentials/examples/v1'
      ],
      type: ['VerifiableCredential', 'CreatorCredential'],
      issuer: this.didRegistry[holderDid]?.id || holderDid,
      issuanceDate: new Date().toISOString(),
      credentialSubject: {
        id: holderDid,
        type: credType,
        ...claims
      },
      proof: {
        type: 'EcdsaSecp256k1Signature2019',
        created: new Date().toISOString(),
        proofPurpose: 'assertionMethod',
        verificationMethod: `${holderDid}#controller`
      }
    };

    const credHash = ethers.utils.keccak256(
      ethers.utils.toUtf8Bytes(JSON.stringify(credential))
    );
    this.credentialRegistry[credHash] = credential;
    return { credential, credHash };
  }

  async calculateReputation(creatorAddress) {
    const score = this.reputationScores.get(creatorAddress) || {
      total: 0,
      contentCount: 0,
      totalViews: 0,
      totalRevenue: 0,
      credibilityScore: 0
    };

    if (score.contentCount === 0) return { score: 0, level: 'newcomer' };

    const engagementRate = score.totalViews / score.contentCount;
    const revenuePerContent = score.totalRevenue / score.contentCount;

    score.credibilityScore = Math.min(
      Math.floor(engagementRate * 10 + revenuePerContent * 5 + score.contentCount * 2),
      100
    );

    let level = 'newcomer';
    if (score.credibilityScore > 80) level = 'trusted';
    else if (score.credibilityScore > 60) level = 'established';
    else if (score.credibilityScore > 40) level = 'growing';
    else if (score.credibilityScore > 20) level = 'emerging';

    return { score: score.credibilityScore, level };
  }

  async updateCreatorStats(creator, stats) {
    const current = this.reputationScores.get(creator) || {
      total: 0,
      contentCount: 0,
      totalViews: 0,
      totalRevenue: 0,
      credibilityScore: 0
    };

    current.contentCount += stats.contentCount || 1;
    current.totalViews += stats.views || 0;
    current.totalRevenue += stats.revenue || 0;
    current.total += stats.total || 0;

    const result = await this.calculateReputation(creator);
    current.credibilityScore = result.score;

    this.reputationScores.set(creator, current);
    return current;
  }

  async verifyCredential(credentialHash) {
    return credentialHash in this.credentialRegistry;
  }

  async getDIDDocument(didId) {
    return this.didRegistry[didId] || null;
  }

  async createCreatorDAO(daoName, members) {
    const dao = {
      name: daoName,
      members: members.map(m => ({
        did: m.did,
        role: m.role,
        reputation: this.reputationScores.get(m.address)?.credibilityScore || 0,
        joinDate: new Date().toISOString()
      })),
      createdAt: new Date().toISOString()
    };
    return dao;
  }
}

const client = new CreatorDIDClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY', '0xRegistry');
client.createDID('0xCreator123').then(doc => console.log('DID:', doc.id));