链上众筹与纪录片制作：社区资助的独立纪录片

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract DocumentaryCrowdfunding is ERC20, Ownable, ReentrancyGuard {
    using Counters for Counters.Counter;
    
    Counters.Counter private _projectIds;
    
    struct DocumentaryProject {
        uint256 id;
        string title;
        string director;
        string synopsis;
        string ipfsHash; // 提案文档IPFS哈希
        uint256 fundingGoal;
        uint256 totalFunded;
        uint256 deadline;
        uint256 minContribution;
        uint256 maxContribution;
        address creator;
        Milestone[] milestones;
        uint256 currentMilestone;
        bool isFunded;
        bool isCompleted;
        uint256 completionTimestamp;
    }
    
    struct Milestone {
        string description;
        uint256 amount;
        uint256 deadline;
        bool isApproved;
        bool isPaid;
        uint256 approvalCount;
        uint256 rejectionCount;
        bool isFinalized;
    }
    
    struct Backer {
        uint256 totalContributed;
        uint256 rewardTokens;
        uint256 votingPower;
        bool hasVoted;
        bool hasClaimedRewards;
    }
    
    struct RewardTier {
        string name;
        uint256 minContribution;
        string description;
        uint256 supply;
        uint256 claimed;
    }
    
    mapping(uint256 => DocumentaryProject) public projects;
    mapping(uint256 => mapping(address => Backer)) public backers;
    mapping(uint256 => RewardTier[]) public rewardTiers;
    mapping(address => uint256[]) public backerProjects;
    
    uint256[] public activeProjects;
    
    uint256 public constant PLATFORM_FEE = 25; // 2.5%
    uint256 public constant MIN_CONTRIBUTION = 0.001 ether;
    uint256 public constant MAX_FUNDING_DURATION = 90 days;
    uint256 public constant APPROVAL_THRESHOLD = 60; // 60% approval needed
    
    event ProjectCreated(uint256 indexed projectId, string title, address indexed creator);
    event ContributionMade(uint256 indexed projectId, address indexed backer, uint256 amount);
    event MilestoneApproved(uint256 indexed projectId, uint256 milestoneIndex, uint256 amount);
    event ProjectCompleted(uint256 indexed projectId, uint256 totalFunded);
    event RewardClaimed(uint256 indexed projectId, address indexed backer, uint256 tierIndex);
    
    constructor() ERC20("DocuToken", "DOCU") {}
    
    function createProject(
        string memory _title,
        string memory _director,
        string memory _synopsis,
        string memory _ipfsHash,
        uint256 _fundingGoal,
        uint256 _durationDays,
        uint256 _minContribution,
        uint256 _maxContribution
    ) external returns (uint256) {
        require(_durationDays <= 90, "Duration too long");
        require(_fundingGoal > 0, "Funding goal must be > 0");
        require(_minContribution >= MIN_CONTRIBUTION, "Min contribution too low");
        
        _projectIds.increment();
        uint256 newId = _projectIds.current();
        
        projects[newId] = DocumentaryProject({
            id: newId,
            title: _title,
            director: _director,
            synopsis: _synopsis,
            ipfsHash: _ipfsHash,
            fundingGoal: _fundingGoal,
            totalFunded: 0,
            deadline: block.timestamp + (_durationDays * 1 days),
            minContribution: _minContribution,
            maxContribution: _maxContribution,
            creator: msg.sender,
            milestones: new Milestone[](0),
            currentMilestone: 0,
            isFunded: false,
            isCompleted: false,
            completionTimestamp: 0
        });
        
        activeProjects.push(newId);
        
        emit ProjectCreated(newId, _title, msg.sender);
        return newId;
    }
    
    function addMilestone(
        uint256 _projectId,
        string memory _description,
        uint256 _amount,
        uint256 _deadlineDays
    ) external {
        DocumentaryProject storage project = projects[_projectId];
        require(msg.sender == project.creator, "Only creator");
        require(!project.isFunded, "Already funded");
        
        project.milestones.push(Milestone({
            description: _description,
            amount: _amount,
            deadline: block.timestamp + (_deadlineDays * 1 days),
            isApproved: false,
            isPaid: false,
            approvalCount: 0,
            rejectionCount: 0,
            isFinalized: false
        }));
    }
    
    function addRewardTier(
        uint256 _projectId,
        string memory _name,
        uint256 _minContribution,
        string memory _description,
        uint256 _supply
    ) external {
        DocumentaryProject storage project = projects[_projectId];
        require(msg.sender == project.creator, "Only creator");
        
        rewardTiers[_projectId].push(RewardTier({
            name: _name,
            minContribution: _minContribution,
            description: _description,
            supply: _supply,
            claimed: 0
        }));
    }
    
    function contribute(uint256 _projectId) external payable nonReentrant {
        DocumentaryProject storage project = projects[_projectId];
        require(block.timestamp < project.deadline, "Funding ended");
        require(!project.isFunded, "Already funded");
        require(msg.value >= project.minContribution, "Below minimum");
        require(msg.value <= project.maxContribution, "Above maximum");
        require(
            project.totalFunded + msg.value <= project.fundingGoal,
            "Exceeds goal"
        );
        
        project.totalFunded += msg.value;
        backers[_projectId][msg.sender].totalContributed += msg.value;
        
        // 分配奖励代币
        uint256 rewardTokens = (msg.value * 1000) / project.fundingGoal;
        backers[_projectId][msg.sender].rewardTokens += rewardTokens;
        backers[_projectId][msg.sender].votingPower += rewardTokens;
        
        backerProjects[msg.sender].push(_projectId);
        
        emit ContributionMade(_projectId, msg.sender, msg.value);
        
        if (project.totalFunded >= project.fundingGoal) {
            project.isFunded = true;
            _distributeFunds(_projectId);
        }
    }
    
    function _distributeFunds(uint256 _projectId) internal {
        DocumentaryProject storage project = projects[_projectId];
        
        uint256 totalFee = (project.totalFunded * PLATFORM_FEE) / 1000;
        uint256 creatorAmount = project.totalFunded - totalFee;
        
        // 支付平台费
        payable(owner()).transfer(totalFee);
        
        // 支付第一个里程碑
        if (project.milestones.length > 0) {
            Milestone storage firstMilestone = project.milestones[0];
            uint256 milestonePayment = firstMilestone.amount;
            payable(project.creator).transfer(milestonePayment);
            firstMilestone.isPaid = true;
            project.currentMilestone = 1;
        } else {
            payable(project.creator).transfer(creatorAmount);
        }
    }
    
    function approveMilestone(uint256 _projectId, uint256 _milestoneIndex) external {
        DocumentaryProject storage project = projects[_projectId];
        Backer storage backer = backers[_projectId][msg.sender];
        
        require(backer.totalContributed > 0, "Not a backer");
        require(!backer.hasVoted, "Already voted");
        require(_milestoneIndex < project.milestones.length, "Invalid milestone");
        
        Milestone storage milestone = project.milestones[_milestoneIndex];
        require(!milestone.isFinalized, "Already finalized");
        
        milestone.approvalCount += backer.votingPower;
        backer.hasVoted = true;
        
        _checkMilestoneApproval(_projectId, _milestoneIndex);
    }
    
    function rejectMilestone(uint256 _projectId, uint256 _milestoneIndex) external {
        DocumentaryProject storage project = projects[_projectId];
        Backer storage backer = backers[_projectId][msg.sender];
        
        require(backer.totalContributed > 0, "Not a backer");
        require(!backer.hasVoted, "Already voted");
        require(_milestoneIndex < project.milestones.length, "Invalid milestone");
        
        Milestone storage milestone = project.milestones[_milestoneIndex];
        require(!milestone.isFinalized, "Already finalized");
        
        milestone.rejectionCount += backer.votingPower;
        backer.hasVoted = true;
        
        _checkMilestoneApproval(_projectId, _milestoneIndex);
    }
    
    function _checkMilestoneApproval(uint256 _projectId, uint256 _milestoneIndex) internal {
        DocumentaryProject storage project = projects[_projectId];
        Milestone storage milestone = project.milestones[_milestoneIndex];
        
        uint256 totalVotes = milestone.approvalCount + milestone.rejectionCount;
        uint256 totalBackers = _getTotalVotingPower(_projectId);
        
        if (totalVotes >= totalBackers / 2) {
            milestone.isFinalized = true;
            
            if (milestone.approvalCount * 100 >= totalVotes * APPROVAL_THRESHOLD / 100) {
                milestone.isApproved = true;
                _releaseMilestonePayment(_projectId, _milestoneIndex);
            }
            
            // 重置投票状态
            _resetVotes(_projectId);
        }
    }
    
    function _releaseMilestonePayment(uint256 _projectId, uint256 _milestoneIndex) internal {
        DocumentaryProject storage project = projects[_projectId];
        Milestone storage milestone = project.milestones[_milestoneIndex];
        
        require(!milestone.isPaid, "Already paid");
        
        milestone.isPaid = true;
        payable(project.creator).transfer(milestone.amount);
        
        emit MilestoneApproved(_projectId, _milestoneIndex, milestone.amount);
        
        // 检查是否所有里程碑都已完成
        bool allComplete = true;
        for (uint256 i = 0; i < project.milestones.length; i++) {
            if (!project.milestones[i].isPaid) {
                allComplete = false;
                break;
            }
        }
        
        if (allComplete) {
            project.isCompleted = true;
            project.completionTimestamp = block.timestamp;
            emit ProjectCompleted(_projectId, project.totalFunded);
        }
    }
    
    function _getTotalVotingPower(uint256 _projectId) internal view returns (uint256) {
        // 简化版本：返回所有支持者的投票权总和
        return projects[_projectId].totalFunded;
    }
    
    function _resetVotes(uint256 _projectId) internal {
        // 重置投票状态（简化版本）
    }
    
    function claimReward(uint256 _projectId, uint256 _tierIndex) external nonReentrant {
        DocumentaryProject storage project = projects[_projectId];
        require(project.isCompleted, "Project not completed");
        
        Backer storage backer = backers[_projectId][msg.sender];
        require(!backer.hasClaimedRewards, "Already claimed");
        
        RewardTier storage tier = rewardTiers[_projectId][_tierIndex];
        require(tier.claimed < tier.supply, "Tier fully claimed");
        require(backer.totalContributed >= tier.minContribution, "Below tier minimum");
        
        tier.claimed++;
        backer.hasClaimedRewards = true;
        
        // 铸造奖励NFT或发放代币
        _mint(msg.sender, tier.minContribution * 10);
        
        emit RewardClaimed(_projectId, msg.sender, _tierIndex);
    }
    
    function getProjectInfo(uint256 _projectId)
        external view returns (DocumentaryProject memory)
    {
        return projects[_projectId];
    }
    
    function getBackerInfo(uint256 _projectId, address _backer)
        external view returns (Backer memory)
    {
        return backers[_projectId][_backer];
    }
    
    function getRewardTiers(uint256 _projectId)
        external view returns (RewardTier[] memory)
    {
        return rewardTiers[_projectId];
    }
    
    function getActiveProjects() external view returns (uint256[] memory) {
        return activeProjects;
    }
}

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import Dict, List
import matplotlib.pyplot as plt
from dataclasses import dataclass
from collections import defaultdict

@dataclass
class DocumentaryProject:
    title: str
    director: str
    genre: str
    funding_goal: float
    duration_days: int
    backers_count: int
    success_rate: float
    avg_contribution: float

class DocuCrowdfundingAnalyzer:
    def __init__(self):
        self.projects = []
        
    def generate_synthetic_data(self, n_projects: int = 200):
        """生成模拟的纪录片众筹数据"""
        np.random.seed(42)
        
        genres = ['社会议题', '环境', '历史', '人物传记', '音乐', '科技', '艺术', '政治']
        directors = ['张导演', '李导演', '王导演', '赵导演', '陈导演', '刘导演']
        
        for i in range(n_projects):
            project = DocumentaryProject(
                title=f"纪录片_{i+1}",
                director=np.random.choice(directors),
                genre=np.random.choice(genres),
                funding_goal=np.random.uniform(10, 500),  # ETH
                duration_days=np.random.randint(14, 90),
                backers_count=np.random.randint(10, 500),
                success_rate=np.random.beta(2, 3),
                avg_contribution=np.random.uniform(0.1, 5)
            )
            self.projects.append(project)
    
    def analyze_success_factors(self) -> pd.DataFrame:
        """分析成功因素"""
        df = pd.DataFrame([{
            'title': p.title,
            'genre': p.genre,
            'funding_goal': p.funding_goal,
            'duration': p.duration_days,
            'backers': p.backers_count,
            'success_rate': p.success_rate,
            'avg_contribution': p.avg_contribution,
            'is_successful': p.success_rate > 0.5
        } for p in self.projects])
        
        # 各类型成功率
        genre_success = df.groupby('genre')['is_successful'].mean().sort_values()
        
        # 融资目标与成功率关系
        goal_bins = pd.cut(df['funding_goal'], bins=5)
        goal_success = df.groupby(goal_bins)['is_successful'].mean()
        
        return df, genre_success, goal_success
    
    def simulate_crowdfunding_campaign(self, project: DocumentaryProject) -> Dict:
        """模拟众筹活动"""
        days = list(range(project.duration_days))
        
        # S形曲线增长
        daily_backers = []
        cumulative = 0
        
        for day in days:
            growth_rate = 1 / (1 + np.exp(-0.2 * (day - project.duration_days * 0.3)))
            new_backers = int(np.random.poisson(5 * growth_rate))
            new_amount = new_backers * project.avg_contribution
            
            cumulative += new_amount
            daily_backers.append({
                'day': day,
                'new_backers': new_backers,
                'new_amount': new_amount,
                'cumulative': cumulative,
                'progress': cumulative / project.funding_goal * 100
            })
        
        return {
            'project': project,
            'daily_data': daily_backers,
            'total_raised': cumulative,
            'success': cumulative >= project.funding_goal,
            'days_to_goal': next((d['day'] for d in daily_backers if d['cumulative'] >= project.funding_goal), None)
        }
    
    def visualize_analysis(self):
        df, genre_success, goal_success = self.analyze_success_factors()
        
        fig, axes = plt.subplots(2, 2, figsize=(14, 12))
        
        # 1. 各类型成功率
        ax1 = axes[0, 0]
        ax1.barh(genre_success.index, genre_success.values, color='teal', alpha=0.7)
        ax1.set_title('各类型纪录片众筹成功率')
        ax1.set_xlabel('成功率')
        ax1.axvline(x=0.5, color='red', linestyle='--', label='平均线')
        ax1.legend()
        
        # 2. 融资目标与成功率
        ax2 = axes[0, 1]
        goal_success.plot(kind='bar', ax=ax2, color='coral', alpha=0.7)
        ax2.set_title('融资目标与成功率')
        ax2.set_xlabel('融资目标范围')
        ax2.set_ylabel('成功率')
        
        # 3. 众筹模拟曲线
        ax3 = axes[1, 0]
        sample_project = DocumentaryProject("示例项目", "导演", "社会议题", 100, 45, 0, 0, 0.5)
        simulation = self.simulate_crowdfunding_campaign(sample_project)
        days = [d['day'] for d in simulation['daily_data']]
        cumulative = [d['cumulative'] for d in simulation['daily_data']]
        ax3.plot(days, cumulative, color='green', linewidth=2)
        ax3.axhline(y=sample_project.funding_goal, color='red', linestyle='--', label='融资目标')
        ax3.fill_between(days, cumulative, alpha=0.3, color='green')
        ax3.set_title('众筹资金增长曲线（S形）')
        ax3.set_xlabel('天数')
        ax3.set_ylabel('累积金额 (ETH)')
        ax3.legend()
        
        # 4. 支持者分布
        ax4 = axes[1, 1]
        backers = df['backers']
        ax4.hist(backers, bins=20, color='purple', alpha=0.7, edgecolor='black')
        ax4.axvline(backers.mean(), color='red', linestyle='--', label=f'平均: {backers.mean():.0f}')
        ax4.set_title('支持者数量分布')
        ax4.set_xlabel('支持者数量')
        ax4.set_ylabel('项目数量')
        ax4.legend()
        
        plt.tight_layout()
        return plt


if __name__ == "__main__":
    analyzer = DocuCrowdfundingAnalyzer()
    analyzer.generate_synthetic_data(200)
    df, genre_success, goal_success = analyzer.analyze_success_factors()
    
    print("=== 纪录片众筹分析 ===")
    print(f"总项目数: {len(df)}")
    print(f"平均成功率: {df['is_successful'].mean():.1%}")
    print(f"\n各类型成功率:")
    for genre, rate in genre_success.items():
        print(f"  {genre}: {rate:.1%}")

class DocumentaryCrowdfunding {
    constructor(providerUrl, contractAddress) {
        this.web3 = new Web3(providerUrl);
        this.contractAddress = contractAddress;
        this.contract = null;
        this.userAccount = null;
    }
    
    async initContract(abi) {
        this.contract = new this.web3.eth.Contract(abi, this.contractAddress);
    }
    
    async connectWallet() {
        if (window.ethereum) {
            const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
            this.userAccount = accounts[0];
            return this.userAccount;
        }
        throw new Error('请安装MetaMask');
    }
    
    async createProject(projectData) {
        const { title, director, synopsis, ipfsHash, fundingGoal, durationDays, minContribution, maxContribution } = projectData;
        const goalWei = this.web3.utils.toWei(fundingGoal.toString(), 'ether');
        const minWei = this.web3.utils.toWei(minContribution.toString(), 'ether');
        const maxWei = this.web3.utils.toWei(maxContribution.toString(), 'ether');
        
        const result = await this.contract.methods
            .createProject(title, director, synopsis, ipfsHash, goalWei, durationDays, minWei, maxWei)
            .send({ from: this.userAccount });
        
        return result;
    }
    
    async contribute(projectId, amount) {
        const amountWei = this.web3.utils.toWei(amount.toString(), 'ether');
        const result = await this.contract.methods
            .contribute(projectId)
            .send({ from: this.userAccount, value: amountWei });
        return result;
    }
    
    async voteOnMilestone(projectId, milestoneIndex, approve) {
        const method = approve ? 'approveMilestone' : 'rejectMilestone';
        const result = await this.contract.methods[method](projectId, milestoneIndex)
            .send({ from: this.userAccount });
        return result;
    }
    
    async getProjectDetails(projectId) {
        const project = await this.contract.methods.getProjectInfo(projectId).call();
        const tiers = await this.contract.methods.getRewardTiers(projectId).call();
        
        return {
            id: projectId,
            title: project.title,
            director: project.director,
            synopsis: project.synopsis,
            fundingGoal: this.web3.utils.fromWei(project.fundingGoal, 'ether'),
            totalFunded: this.web3.utils.fromWei(project.totalFunded, 'ether'),
            progress: (project.totalFunded / project.fundingGoal * 100).toFixed(1),
            deadline: new Date(project.deadline * 1000),
            isFunded: project.isFunded,
            isCompleted: project.isCompleted,
            rewardTiers: tiers.map(t => ({
                name: t.name,
                minContribution: this.web3.utils.fromWei(t.minContribution, 'ether'),
                description: t.description,
                supply: t.supply,
                claimed: t.claimed
            }))
        };
    }
}

// 使用示例
const platform = new DocumentaryCrowdfunding('https://mainnet.infura.io/v3/YOUR_ID', '0x...');
(async () => {
    await platform.initContract([]);
    await platform.connectWallet();
    console.log('纪录片众筹平台已连接');
})();