链上治理与内容分级：DAO自治的内容评级

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract DAOContentRating is ERC721, Ownable {
    struct Content {
        uint256 id;
        string title;
        string creator;
        bytes32 contentHash;
        uint256 currentRating;
        uint256 totalVotes;
        uint256[] ratings;
        uint256 createdAt;
        bool isRated;
    }
    
    struct RatingCriteria {
        uint256 id;
        string name;
        string description;
        uint256 weight;
        bool isActive;
    }
    
    struct RatingProposal {
        uint256 id;
        uint256 contentId;
        uint256 proposedRating;
        address proposer;
        uint256 yesVotes;
        uint256 noVotes;
        uint256 votingEnd;
        bool isExecuted;
    }
    
    mapping(uint256 => Content) public contents;
    mapping(uint256 => RatingCriteria) public criteria;
    mapping(uint256 => RatingProposal) public proposals;
    mapping(address => uint256) public voterReputation;
    
    uint256 public contentCount;
    uint256 public criteriaCount;
    uint256 public proposalCount;
    
    uint256 public constant VOTING_PERIOD = 7 days;
    uint256 public constant MIN_VOTES = 100;
    
    event ContentRegistered(uint256 indexed id, string title);
    event RatingProposed(uint256 indexed proposalId, uint256 contentId, uint256 rating);
    event RatingUpdated(uint256 indexed contentId, uint256 newRating);
    event CriteriaAdded(uint256 indexed id, string name, uint256 weight);
    
    constructor() ERC721("DAORating", "DRTG") {}
    
    function registerContent(
        string memory _title,
        string memory _creator,
        bytes32 _contentHash
    ) external returns (uint256) {
        contentCount++;
        contents[contentCount] = Content({
            id: contentCount,
            title: _title,
            creator: _creator,
            contentHash: _contentHash,
            currentRating: 0,
            totalVotes: 0,
            ratings: new uint256[](0),
            createdAt: block.timestamp,
            isRated: false
        });
        
        _safeMint(msg.sender, contentCount);
        emit ContentRegistered(contentCount, _title);
        return contentCount;
    }
    
    function addCriteria(string memory _name, string memory _description, uint256 _weight) external onlyOwner {
        criteriaCount++;
        criteria[criteriaCount] = RatingCriteria({
            id: criteriaCount,
            name: _name,
            description: _description,
            weight: _weight,
            isActive: true
        });
        
        emit CriteriaAdded(criteriaCount, _name, _weight);
    }
    
    function proposeRating(uint256 _contentId, uint256 _proposedRating) external returns (uint256) {
        proposalCount++;
        proposals[proposalCount] = RatingProposal({
            id: proposalCount,
            contentId: _contentId,
            proposedRating: _proposedRating,
            proposer: msg.sender,
            yesVotes: 0,
            noVotes: 0,
            votingEnd: block.timestamp + VOTING_PERIOD,
            isExecuted: false
        });
        
        emit RatingProposed(proposalCount, _contentId, _proposedRating);
        return proposalCount;
    }
    
    function voteOnRating(uint256 _proposalId, bool _support) external {
        RatingProposal storage proposal = proposals[_proposalId];
        require(block.timestamp <= proposal.votingEnd, "Voting ended");
        require(!proposal.isExecuted, "Already executed");
        
        if (_support) {
            proposal.yesVotes += voterReputation[msg.sender] + 1;
        } else {
            proposal.noVotes += voterReputation[msg.sender] + 1;
        }
    }
    
    function executeRating(uint256 _proposalId) external {
        RatingProposal storage proposal = proposals[_proposalId];
        require(block.timestamp > proposal.votingEnd, "Voting not ended");
        require(!proposal.isExecuted, "Already executed");
        
        uint256 totalVotes = proposal.yesVotes + proposal.noVotes;
        if (totalVotes >= MIN_VOTES && proposal.yesVotes > proposal.noVotes) {
            Content storage content = contents[proposal.contentId];
            content.currentRating = proposal.proposedRating;
            content.isRated = true;
            content.totalVotes = totalVotes;
            
            emit RatingUpdated(proposal.contentId, proposal.proposedRating);
        }
        
        proposal.isExecuted = true;
    }
    
    function getContentRating(uint256 _contentId) external view returns (uint256) {
        return contents[_contentId].currentRating;
    }
}

import numpy as np
import pandas as pd
from typing import Dict, List
import matplotlib.pyplot as plt

class RatingAnalyzer:
    def __init__(self):
        self.ratings = []
        
    def generate_synthetic_data(self, n: int = 200):
        np.random.seed(42)
        rating_levels = ['G', 'PG', 'PG-13', 'R', 'NC-17']
        
        for i in range(n):
            rating = {
                'id': i + 1,
                'title': f'内容_{i+1}',
                'rating': np.random.choice(rating_levels, p=[0.1, 0.2, 0.3, 0.3, 0.1]),
                'votes': int(np.random.exponential(500)),
                'approval_rate': np.random.uniform(0.3, 0.95),
                'voter_count': int(np.random.exponential(100)),
                'is_controversial': np.random.random() > 0.8
            }
            self.ratings.append(rating)
    
    def analyze_rating_distribution(self) -> Dict:
        df = pd.DataFrame(self.ratings)
        return {
            'distribution': df['rating'].value_counts().to_dict(),
            'avg_votes': df['votes'].mean(),
            'avg_approval': df['approval_rate'].mean(),
            'controversial_rate': df['is_controversial'].mean(),
            'avg_voters': df['voter_count'].mean()
        }
    
    def generate_report(self) -> str:
        eff = self.analyze_rating_distribution()
        report = f"""
=== 内容评级分析 ===

评级分布:
{eff['distribution']}

平均投票数: {eff['avg_votes']:.0f}
平均批准率: {eff['avg_approval']:.1%}
争议率: {eff['controversial_rate']:.1%}
平均投票者: {eff['avg_voters']:.0f}
"""
        return report


if __name__ == "__main__":
    analyzer = RatingAnalyzer()
    analyzer.generate_synthetic_data(200)
    report = analyzer.generate_report()
    print(report)

class DAORatingManager {
    constructor(providerUrl, contractAddress) {
        this.web3 = new Web3(providerUrl);
        this.contract = new this.web3.eth.Contract([], contractAddress);
    }
    
    async registerContent(title, creator, contentHash) {
        return await this.contract.methods
            .registerContent(title, creator, contentHash)
            .send({ from: this.userAccount });
    }
    
    async proposeRating(contentId, rating) {
        return await this.contract.methods
            .proposeRating(contentId, rating)
            .send({ from: this.userAccount });
    }
    
    async voteOnRating(proposalId, support) {
        return await this.contract.methods
            .voteOnRating(proposalId, support)
            .send({ from: this.userAccount });
    }
    
    async getContentRating(contentId) {
        return await this.contract.methods.getContentRating(contentId).call();
    }
}

const manager = new DAORatingManager('https://mainnet.infura.io/v3/YOUR_ID', '0x...');