链上声誉与内容推荐：去中心化算法的透明性

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

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

contract OnChainReputation is AccessControl, ReentrancyGuard {
    bytes32 public constant CONTENT_ROLE = keccak256("CONTENT_ROLE");
    bytes32 public constant CURATOR_ROLE = keccak256("CURATOR_ROLE");

    enum ContentCategory {
        ARTICLE, VIDEO, MUSIC, NFT, PODCAST, RESEARCH, TUTORIAL
    }

    enum ReputationFactor {
        CONTENT_QUALITY, ENGAGEMENT, CONSISTENCY, COMMUNITY, VERIFICATION
    }

    struct ReputationScore {
        address user;
        uint256 totalScore;
        uint256 contentQuality;
        uint256 engagement;
        uint256 consistency;
        uint256 community;
        uint256 verification;
        uint256 totalContent;
        uint256 totalViews;
        uint256 totalLikes;
        uint256 lastUpdated;
    }

    struct Content {
        bytes32 contentId;
        address creator;
        string ipfsCID;
        ContentCategory category;
        uint256 createdAt;
        uint256 views;
        uint256 likes;
        uint256 shares;
        uint256 qualityScore;
        bool isActive;
    }

    struct Recommendation {
        bytes32 recommendationId;
        address user;
        bytes32[] contentIds;
        uint256[] scores;
        uint256 timestamp;
        string algorithm;
    }

    mapping(address => ReputationScore) public reputations;
    mapping(bytes32 => Content) public contents;
    mapping(address => mapping(bytes32 => uint256)) public userInteractions;
    mapping(address => Recommendation) public recommendations;

    uint256 public contentCount;
    uint256 public totalUsers;
    uint256 public alpha = 30;
    uint256 public beta = 25;
    uint256 public gamma = 20;
    uint256 public delta = 15;
    uint256 public epsilon = 10;

    event ContentCreated(bytes32 indexed contentId, address indexed creator, ContentCategory category);
    event ReputationUpdated(address indexed user, uint256 newScore);
    event RecommendationGenerated(address indexed user, bytes32[] contentIds);

    function createContent(
        string memory _ipfsCID,
        ContentCategory _category
    ) external returns (bytes32) {
        contentCount++;
        bytes32 contentId = keccak256(abi.encodePacked(msg.sender, _ipfsCID, block.timestamp));

        contents[contentId] = Content({
            contentId: contentId,
            creator: msg.sender,
            ipfsCID: _ipfsCID,
            category: _category,
            createdAt: block.timestamp,
            views: 0,
            likes: 0,
            shares: 0,
            qualityScore: 0,
            isActive: true
        });

        if (reputations[msg.sender].totalScore == 0) {
            reputations[msg.sender] = ReputationScore({
                user: msg.sender,
                totalScore: 100,
                contentQuality: 0,
                engagement: 0,
                consistency: 0,
                community: 0,
                verification: 0,
                totalContent: 0,
                totalViews: 0,
                totalLikes: 0,
                lastUpdated: block.timestamp
            });
            totalUsers++;
        }

        reputations[msg.sender].totalContent++;
        emit ContentCreated(contentId, msg.sender, _category);
        return contentId;
    }

    function interactWithContent(bytes32 _contentId, uint256 _interactionType) external {
        Content storage content = contents[_contentId];
        require(content.isActive, "Content not active");

        if (_interactionType == 0) content.views++;
        else if (_interactionType == 1) content.likes++;
        else if (_interactionType == 2) content.shares++;

        userInteractions[msg.sender][_contentId] = _interactionType;
        updateReputation(content.creator);
    }

    function updateReputation(address _user) internal {
        ReputationScore storage rep = reputations[_user];
        Content[] memory userContent = new Content[](rep.totalContent);

        uint256 totalQuality = 0;
        uint256 totalViews = 0;
        uint256 totalLikes = 0;

        for (uint256 i = 0; i < contentCount; i++) {
            bytes32 contentId = keccak256(abi.encodePacked(_user, i));
            if (contents[contentId].creator == _user) {
                totalQuality += contents[contentId].qualityScore;
                totalViews += contents[contentId].views;
                totalLikes += contents[contentId].likes;
            }
        }

        rep.contentQuality = totalQuality / (rep.totalContent > 0 ? rep.totalContent : 1);
        rep.engagement = (totalLikes * 100) / (totalViews > 0 ? totalViews : 1);
        rep.consistency = rep.totalContent * 10;
        rep.verification = rep.verification;

        rep.totalScore = (
            rep.contentQuality * alpha +
            rep.engagement * beta +
            rep.consistency * gamma +
            rep.community * delta +
            rep.verification * epsilon
        ) / 100;

        rep.totalViews = totalViews;
        rep.totalLikes = totalLikes;
        rep.lastUpdated = block.timestamp;

        emit ReputationUpdated(_user, rep.totalScore);
    }

    function generateRecommendations(address _user) external returns (bytes32[] memory) {
        ReputationScore storage userRep = reputations[_user];
        bytes32[] memory recommended = new bytes32[](10);
        uint256 count = 0;

        for (uint256 i = 0; i < contentCount && count < 10; i++) {
            bytes32 contentId = keccak256(abi.encodePacked(address(0), i));
            if (contents[contentId].isActive && contents[contentId].creator != _user) {
                uint256 relevanceScore = calculateRelevance(_user, contentId);
                if (relevanceScore > 50) {
                    recommended[count] = contentId;
                    count++;
                }
            }
        }

        recommendations[_user] = Recommendation({
            recommendationId: keccak256(abi.encodePacked(_user, block.timestamp)),
            user: _user,
            contentIds: recommended,
            scores: new uint256[](count),
            timestamp: block.timestamp,
            algorithm: "reputation_weighted"
        });

        emit RecommendationGenerated(_user, recommended);
        return recommended;
    }

    function calculateRelevance(address _user, bytes32 _contentId) internal view returns (uint256) {
        Content storage content = contents[_contentId];
        ReputationScore storage creatorRep = reputations[content.creator];
        ReputationScore storage userRep = reputations[_user];

        uint256 creatorScore = creatorRep.totalScore;
        uint256 contentQuality = content.qualityScore;
        uint256 contentAge = block.timestamp - content.createdAt;
        uint256 freshness = 100 - (contentAge / 1 days);

        return (creatorScore * 30 + contentQuality * 40 + freshness * 30) / 100;
    }

    function getReputation(address _user) external view returns (ReputationScore memory) {
        return reputations[_user];
    }
}

import json
import hashlib
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from datetime import datetime, timedelta
import random
import math

@dataclass
class ReputationScore:
    address: str
    total_score: float
    content_quality: float
    engagement: float
    consistency: float
    community: float
    verification: float
    total_content: int
    total_views: int
    total_likes: int

class OnChainRecommender:
    def __init__(self):
        self.reputations: Dict[str, ReputationScore] = {}
        self.contents: Dict[str, Dict] = {}
        self.interactions: Dict[str, Dict[str, int]] = {}
        self.content_count = 0

    def create_content(self, creator: str, ipfs_cid: str, category: str) -> Dict:
        self.content_count += 1
        content_id = hashlib.sha256(f"{creator}{ipfs_cid}{datetime.now()}".encode()).hexdigest()[:16]

        content = {
            'content_id': content_id,
            'creator': creator,
            'ipfs_cid': ipfs_cid,
            'category': category,
            'created_at': datetime.now().isoformat(),
            'views': 0,
            'likes': 0,
            'shares': 0,
            'quality_score': 0,
            'is_active': True
        }
        self.contents[content_id] = content

        if creator not in self.reputations:
            self.reputations[creator] = ReputationScore(
                address=creator,
                total_score=100,
                content_quality=0,
                engagement=0,
                consistency=0,
                community=0,
                verification=0,
                total_content=0,
                total_views=0,
                total_likes=0
            )

        self.reputations[creator].total_content += 1
        return content

    def interact(self, user: str, content_id: str, interaction_type: int):
        content = self.contents.get(content_id)
        if not content or not content['is_active']:
            return

        if interaction_type == 0:
            content['views'] += 1
        elif interaction_type == 1:
            content['likes'] += 1
        elif interaction_type == 2:
            content['shares'] += 1

        if user not in self.interactions:
            self.interactions[user] = {}
        self.interactions[user][content_id] = interaction_type

        self._update_reputation(content['creator'])

    def _update_reputation(self, user: str):
        rep = self.reputations.get(user)
        if not rep:
            return

        user_contents = [c for c in self.contents.values() if c['creator'] == user]
        if not user_contents:
            return

        total_quality = sum(c['quality_score'] for c in user_contents)
        total_views = sum(c['views'] for c in user_contents)
        total_likes = sum(c['likes'] for c in user_contents)

        rep.content_quality = total_quality / len(user_contents)
        rep.engagement = (total_likes * 100) / max(total_views, 1)
        rep.consistency = rep.total_content * 10
        rep.total_views = total_views
        rep.total_likes = total_likes

        rep.total_score = (
            rep.content_quality * 0.30 +
            rep.engagement * 0.25 +
            rep.consistency * 0.20 +
            rep.community * 0.15 +
            rep.verification * 0.10
        )
        rep.last_updated = datetime.now().isoformat()

    def calculate_relevance(self, user: str, content_id: str) -> float:
        content = self.contents.get(content_id)
        if not content:
            return 0

        creator_rep = self.reputations.get(content['creator'])
        if not creator_rep:
            return 0

        creator_score = creator_rep.total_score
        content_quality = content['quality_score']
        content_age = (datetime.now() - datetime.fromisoformat(content['created_at'])).days
        freshness = max(0, 100 - content_age)

        return (creator_score * 0.30 + content_quality * 0.40 + freshness * 0.30)

    def generate_recommendations(self, user: str, count: int = 10) -> List[Dict]:
        scored = []
        for content_id, content in self.contents.items():
            if content['creator'] != user and content['is_active']:
                relevance = self.calculate_relevance(user, content_id)
                if relevance > 50:
                    scored.append((content_id, relevance))

        scored.sort(key=lambda x: x[1], reverse=True)
        recommendations = scored[:count]

        # Diversity boost
        categories = set()
        diverse_recommendations = []
        for content_id, score in recommendations:
            content = self.contents[content_id]
            if content['category'] not in categories or len(diverse_recommendations) < 3:
                diverse_recommendations.append({
                    'content_id': content_id,
                    'creator': content['creator'],
                    'category': content['category'],
                    'relevance_score': score,
                    'creator_reputation': self.reputations.get(content['creator'], ReputationScore).total_score
                })
                categories.add(content['category'])

        return diverse_recommendations

    def get_content_quality(self, user: str, content_ids: List[str]) -> float:
        if not content_ids:
            return 0
        scores = [self.contents[cid]['quality_score'] for cid in content_ids if cid in self.contents]
        return sum(scores) / len(scores) if scores else 0

    def calculate_algorithm_transparency(self) -> Dict:
        return {
            'factors': {
                'content_quality': 0.40,
                'creator_reputation': 0.30,
                'freshness': 0.30
            },
            'data_sources': ['on-chain_content', 'user_interactions', 'reputation_scores'],
            'adjustable_parameters': ['alpha', 'beta', 'gamma', 'delta', 'epsilon'],
            'governance': 'DAO vote on parameter changes'
        }

recommender = OnChainRecommender()
content = recommender.create_content('0xCreator', 'ipfs://Qm...', 'article')
recommender.interact('0xUser', content['content_id'], 1)
recs = recommender.generate_recommendations('0xUser', 5)
print(f"Generated {len(recs)} recommendations")

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

class OnChainRecommender {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.reputations = new Map();
    this.contents = new Map();
    this.interactions = new Map();
    this.contentCount = 0;
  }

  async createContent(creator, ipfsCID, category) {
    this.contentCount++;
    const contentId = ethers.utils.keccak256(
      ethers.utils.toUtf8Bytes(`${creator}${ipfsCID}${Date.now()}`)
    ).slice(0, 18);

    const content = {
      contentId,
      creator,
      ipfsCID,
      category,
      createdAt: Math.floor(Date.now() / 1000),
      views: 0,
      likes: 0,
      shares: 0,
      qualityScore: 0,
      isActive: true
    };

    this.contents.set(contentId, content);

    if (!this.reputations.has(creator)) {
      this.reputations.set(creator, {
        address: creator,
        totalScore: 100,
        contentQuality: 0,
        engagement: 0,
        consistency: 0,
        community: 0,
        verification: 0,
        totalContent: 0,
        totalViews: 0,
        totalLikes: 0
      });
    }

    const rep = this.reputations.get(creator);
    rep.totalContent++;
    return content;
  }

  async interact(user, contentId, interactionType) {
    const content = this.contents.get(contentId);
    if (!content || !content.isActive) return;

    if (interactionType === 0) content.views++;
    else if (interactionType === 1) content.likes++;
    else if (interactionType === 2) content.shares++;

    if (!this.interactions.has(user)) {
      this.interactions.set(user, new Map());
    }
    this.interactions.get(user).set(contentId, interactionType);

    this.updateReputation(content.creator);
  }

  updateReputation(user) {
    const rep = this.reputations.get(user);
    if (!rep) return;

    const userContents = Array.from(this.contents.values())
      .filter(c => c.creator === user);

    if (userContents.length === 0) return;

    const totalQuality = userContents.reduce((sum, c) => sum + c.qualityScore, 0);
    const totalViews = userContents.reduce((sum, c) => sum + c.views, 0);
    const totalLikes = userContents.reduce((sum, c) => sum + c.likes, 0);

    rep.contentQuality = totalQuality / userContents.length;
    rep.engagement = totalViews > 0 ? (totalLikes * 100) / totalViews : 0;
    rep.consistency = rep.totalContent * 10;

    rep.totalScore =
      rep.contentQuality * 0.30 +
      rep.engagement * 0.25 +
      rep.consistency * 0.20 +
      rep.community * 0.15 +
      rep.verification * 0.10;
  }

  calculateRelevance(user, contentId) {
    const content = this.contents.get(contentId);
    if (!content) return 0;

    const creatorRep = this.reputations.get(content.creator);
    if (!creatorRep) return 0;

    const contentAge = Math.floor(Date.now() / 1000) - content.createdAt;
    const freshness = Math.max(0, 100 - contentAge / 86400);

    return creatorRep.totalScore * 0.30 + content.qualityScore * 0.40 + freshness * 0.30;
  }

  generateRecommendations(user, count = 10) {
    const scored = [];
    for (const [contentId, content] of this.contents) {
      if (content.creator !== user && content.isActive) {
        const relevance = this.calculateRelevance(user, contentId);
        if (relevance > 50) {
          scored.push({ contentId, relevance });
        }
      }
    }

    scored.sort((a, b) => b.relevance - a.relevance);
    return scored.slice(0, count).map(s => ({
      contentId: s.contentId,
      content: this.contents.get(s.contentId),
      relevanceScore: s.relevance
    }));
  }
}

const recommender = new OnChainRecommender('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
const content = recommender.createContent('0xCreator', 'ipfs://Qm...', 'article');
console.log('Content created:', content.contentId);