去中心化金融与影视投资：DeFi的制片融资模型

// 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";

contract FilmFundingPool is ERC20, Ownable, ReentrancyGuard {
    struct FilmProject {
        string title;
        string director;
        uint256 fundingGoal;
        uint256 totalFunded;
        uint256 deadline;
        bool isFunded;
        bool isReleased;
        address creator;
        uint256 revenueShare;
    }
    
    FilmProject public film;
    uint256 public constant MIN_INVESTMENT = 0.1 ether;
    uint256 public constant MAX_INVESTMENT = 100 ether;
    uint256 public constant PLATFORM_FEE = 25; // 2.5%
    
    mapping(address => uint256) public investorShares;
    mapping(address => bool) public hasClaimedRevenue;
    
    uint256 public totalRevenue;
    uint256 public unclaimedRevenue;
    
    event Funded(address indexed investor, uint256 amount, uint256 shares);
    event RevenueDistributed(uint256 amount, uint256 perShare);
    event RevenueClaimed(address indexed investor, uint256 amount);
    
    constructor(
        string memory _title,
        string memory _director,
        uint256 _fundingGoal,
        uint256 _durationDays,
        address _creator
    ) ERC20(
        string(abi.encodePacked("Film ", _title)),
        "FILM"
    ) {
        film = FilmProject({
            title: _title,
            director: _director,
            fundingGoal: _fundingGoal,
            totalFunded: 0,
            deadline: block.timestamp + (_durationDays * 1 days),
            isFunded: false,
            isReleased: false,
            creator: _creator,
            revenueShare: 0
        });
        
        _mint(address(this), 1000000 * 10**18); // 发行100万份份额
    }
    
    function invest() external payable nonReentrant {
        require(block.timestamp < film.deadline, "融资已结束");
        require(!film.isFunded, "融资目标已达成");
        require(msg.value >= MIN_INVESTMENT, "最低投资额不足");
        require(msg.value <= MAX_INVESTMENT, "超过最高投资额");
        require(
            film.totalFunded + msg.value <= film.fundingGoal,
            "超过融资目标"
        );
        
        film.totalFunded += msg.value;
        
        // 计算份额
        uint256 shares = (msg.value * 1e18) / film.fundingGoal * 1000000;
        _transfer(address(this), msg.sender, shares);
        investorShares[msg.sender] += shares;
        
        emit Funded(msg.sender, msg.value, shares);
        
        // 检查是否达成融资目标
        if (film.totalFunded >= film.fundingGoal) {
            film.isFunded = true;
            _distributeToCreator();
        }
    }
    
    function _distributeToCreator() private {
        uint256 fee = (film.totalFunded * PLATFORM_FEE) / 1000;
        uint256 toCreator = film.totalFunded - fee;
        
        payable(film.creator).transfer(toCreator);
        payable(owner()).transfer(fee);
    }
    
    function distributeRevenue() external payable onlyOwner {
        require(film.isReleased, "电影尚未发布");
        require(msg.value > 0, "收益金额必须大于0");
        
        totalRevenue += msg.value;
        unclaimedRevenue += msg.value;
        
        emit RevenueDistributed(msg.value, msg.value / totalSupply());
    }
    
    function claimRevenue() external nonReentrant {
        require(film.isReleased, "电影尚未发布");
        require(!hasClaimedRevenue[msg.sender], "已领取过分红");
        
        uint256 shares = balanceOf(msg.sender);
        require(shares > 0, "没有份额");
        
        uint256 revenue = (shares * unclaimedRevenue) / totalSupply();
        require(revenue > 0, "无可领取的收益");
        
        hasClaimedRevenue[msg.sender] = true;
        unclaimedRevenue -= revenue;
        
        payable(msg.sender).transfer(revenue);
        
        emit RevenueClaimed(msg.sender, revenue);
    }
    
    function getInvestorInfo(address _investor)
        external view returns (uint256 shares, uint256 invested, bool claimed)
    {
        shares = balanceOf(_investor);
        invested = (shares * film.fundingGoal) / 1000000;
        claimed = hasClaimedRevenue[_investor];
    }
    
    function extendDeadline(uint256 _additionalDays) external onlyOwner {
        require(!film.isFunded, "融资已结束");
        film.deadline += (_additionalDays * 1 days);
    }
    
    function markAsReleased() external onlyOwner {
        require(film.isFunded, "尚未完成融资");
        film.isReleased = true;
    }
}

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import Dict, List, Tuple
import matplotlib.pyplot as plt
import seaborn as sns
from dataclasses import dataclass
from enum import Enum

class FilmGenre(Enum):
    ACTION = "动作"
    COMEDY = "喜剧"
    DRAMA = "剧情"
    HORROR = "恐怖"
    SCI_FI = "科幻"
    DOCUMENTARY = "纪录片"
    ANIMATION = "动画"

@dataclass
class FilmProject:
    title: str
    genre: FilmGenre
    director: str
    budget: float  # 美元
    funding_goal: float  # 代币融资目标
    investor_count: int
    expected_roi: float
    risk_score: float  # 0-1
    
class DeFiFilmAnalyzer:
    def __init__(self):
        self.projects = []
        self.historical_data = self._load_historical_data()
        
    def _load_historical_data(self) -> pd.DataFrame:
        """加载历史电影融资数据，就像导演翻看以前的剧本"""
        data = {
            'genre': ['动作', '喜剧', '剧情', '恐怖', '科幻'],
            'avg_budget': [65_000_000, 35_000_000, 20_000_000, 15_000_000, 100_000_000],
            'avg_box_office': [350_000_000, 180_000_000, 80_000_000, 100_000_000, 500_000_000],
            'success_rate': [0.35, 0.45, 0.25, 0.55, 0.30],
            'avg_roi': [2.5, 3.2, 1.8, 4.0, 2.8]
        }
        return pd.DataFrame(data)
    
    def add_project(self, project: FilmProject):
        """添加新项目到分析池"""
        self.projects.append(project)
        
    def calculate_tokenomics(self, project: FilmProject) -> Dict:
        """计算代币经济学模型，就像计算电影票房分账"""
        # 总代币供应量
        total_supply = 1_000_000  # 100万份
        
        # 初始代币价格
        initial_price = project.funding_goal / total_supply
        
        # 预期回报
        expected_revenue = project.budget * project.expected_roi
        expected_token_value = expected_revenue / total_supply
        
        # 投资者回报率
        investor_roi = (expected_token_value - initial_price) / initial_price
        
        return {
            'total_supply': total_supply,
            'initial_price': initial_price,
            'expected_revenue': expected_revenue,
            'expected_token_value': expected_token_value,
            'investor_roi': investor_roi,
            'funding_efficiency': project.funding_goal / project.budget
        }
    
    def risk_assessment(self, project: FilmProject) -> Dict:
        """风险评估，就像电影审查制度"""
        risk_factors = {
            'genre_risk': 0,
            'budget_risk': 0,
            'roi_risk': 0,
            'market_risk': 0
        }
        
        # 类型风险：根据历史数据
        genre_stats = self.historical_data[
            self.historical_data['genre'] == project.genre.value
        ]
        if not genre_stats.empty:
            success_rate = genre_stats['success_rate'].values[0]
            risk_factors['genre_risk'] = 1 - success_rate
        
        # 预算风险
        if project.budget > 100_000_000:
            risk_factors['budget_risk'] = 0.7
        elif project.budget > 50_000_000:
            risk_factors['budget_risk'] = 0.5
        elif project.budget > 10_000_000:
            risk_factors['budget_risk'] = 0.3
        else:
            risk_factors['budget_risk'] = 0.1
        
        # ROI风险
        if project.expected_roi < 1.0:
            risk_factors['roi_risk'] = 0.9
        elif project.expected_roi < 2.0:
            risk_factors['roi_risk'] = 0.6
        elif project.expected_roi < 3.0:
            risk_factors['roi_risk'] = 0.4
        else:
            risk_factors['roi_risk'] = 0.2
        
        # 综合风险评分
        composite_risk = (
            risk_factors['genre_risk'] * 0.3 +
            risk_factors['budget_risk'] * 0.3 +
            risk_factors['roi_risk'] * 0.2 +
            risk_factors['market_risk'] * 0.2
        )
        
        return {
            'risk_factors': risk_factors,
            'composite_risk': composite_risk,
            'risk_level': '低' if composite_risk < 0.3 else '中' if composite_risk < 0.6 else '高'
        }
    
    def simulate_funding_round(
        self, project: FilmProject, days: int = 30
    ) -> pd.DataFrame:
        """模拟融资过程，就像拍摄日程表"""
        np.random.seed(42)
        
        # 模拟每日融资额
        daily_investors = np.random.poisson(5, days)
        daily_amounts = np.random.exponential(
            project.funding_goal / (days * 5), days
        )
        
        # 累积融资额
        cumulative = np.cumsum(
            np.minimum(daily_investors * daily_amounts, project.funding_goal)
        )
        
        # 确保不超过融资目标
        cumulative = np.minimum(cumulative, project.funding_goal)
        
        dates = [datetime.now() + timedelta(days=i) for i in range(days)]
        
        df = pd.DataFrame({
            'date': dates,
            'daily_investors': daily_investors,
            'daily_amount': daily_amounts * daily_investors,
            'cumulative_funding': cumulative
        })
        
        # 计算融资完成天数
        funded_day = np.argmax(cumulative >= project.funding_goal)
        if cumulative[-1] >= project.funding_goal:
            df['funded'] = True
            df['funded_day'] = funded_day
        else:
            df['funded'] = False
            df['funded_day'] = None
        
        return df
    
    def portfolio_optimization(
        self, projects: List[FilmProject], budget: float
    ) -> Dict:
        """投资组合优化，就像选择拍摄片单"""
        from scipy.optimize import minimize
        
        n = len(projects)
        expected_returns = np.array([p.expected_roi for p in projects])
        risks = np.array([p.risk_score for p in projects])
        
        # 目标函数：最大化夏普比率
        def negative_sharpe(weights):
            portfolio_return = np.sum(weights * expected_returns)
            portfolio_risk = np.sqrt(np.sum(weights ** 2 * risks ** 2))
            return -portfolio_return / portfolio_risk if portfolio_risk > 0 else 0
        
        # 约束条件
        constraints = [
            {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},  # 权重和为1
            {'type': 'ineq', 'fun': lambda x: budget - np.sum(x * np.array([p.budget for p in projects]))}  # 不超预算
        ]
        
        bounds = tuple((0, 0.5) for _ in range(n))  # 单个项目不超过50%
        initial_weights = np.array([1/n] * n)
        
        result = minimize(
            negative_sharpe, initial_weights,
            method='SLSQP', bounds=bounds,
            constraints=constraints
        )
        
        if result.success:
            optimal_weights = result.x
            portfolio_return = np.sum(optimal_weights * expected_returns)
            portfolio_risk = np.sqrt(np.sum(optimal_weights ** 2 * risks ** 2))
            
            allocations = []
            for i, (project, weight) in enumerate(zip(projects, optimal_weights)):
                if weight > 0.01:
                    allocations.append({
                        'project': project.title,
                        'weight': weight,
                        'investment': weight * budget,
                        'expected_return': project.expected_roi
                    })
            
            return {
                'optimal_weights': optimal_weights,
                'portfolio_return': portfolio_return,
                'portfolio_risk': portfolio_risk,
                'sharpe_ratio': portfolio_return / portfolio_risk if portfolio_risk > 0 else 0,
                'allocations': allocations
            }
        else:
            return {'error': '优化失败'}
    
    def visualize_funding_curve(self, df: pd.DataFrame, project_name: str):
        """可视化融资曲线，就像剪辑时间线"""
        fig, axes = plt.subplots(2, 1, figsize=(12, 10))
        
        # 每日融资额
        axes[0].bar(df['date'], df['daily_amount'], alpha=0.7, color='skyblue')
        axes[0].set_title(f'{project_name} - 每日融资额')
        axes[0].set_xlabel('日期')
        axes[0].set_ylabel('融资额 (ETH)')
        axes[0].tick_params(axis='x', rotation=45)
        
        # 累积融资曲线
        axes[1].plot(df['date'], df['cumulative_funding'], 
                    color='green', linewidth=2, marker='o')
        axes[1].axhline(y=df['cumulative_funding'].max(), 
                       color='red', linestyle='--', label='融资目标')
        axes[1].set_title(f'{project_name} - 累积融资曲线')
        axes[1].set_xlabel('日期')
        axes[1].set_ylabel('累积融资额 (ETH)')
        axes[1].legend()
        axes[1].tick_params(axis='x', rotation=45)
        
        plt.tight_layout()
        return plt


# 使用示例
if __name__ == "__main__":
    analyzer = DeFiFilmAnalyzer()
    
    # 创建一个电影项目
    project = FilmProject(
        title="去中心化之梦",
        genre=FilmGenre.SCI_FI,
        director="王森涛",
        budget=5_000_000,
        funding_goal=3_000_000,
        investor_count=500,
        expected_roi=3.5,
        risk_score=0.4
    )
    
    # 分析代币经济学
    tokenomics = analyzer.calculate_tokenomics(project)
    print("代币经济学分析:")
    for key, value in tokenomics.items():
        print(f"  {key}: {value}")
    
    # 风险评估
    risk = analyzer.risk_assessment(project)
    print(f"\n风险评估: {risk['risk_level']} (评分: {risk['composite_risk']:.2f})")
    
    # 模拟融资
    funding_sim = analyzer.simulate_funding_round(project, days=45)
    print(f"\n融资模拟: {funding_sim['funded'].iloc[-1]}")
    
    # 投资组合优化
    projects = [
        FilmProject("项目A", FilmGenre.ACTION, "导演A", 50_000_000, 30_000_000, 1000, 2.5, 0.3),
        FilmProject("项目B", FilmGenre.COMEDY, "导演B", 20_000_000, 12_000_000, 500, 3.2, 0.2),
        FilmProject("项目C", FilmGenre.DRAMA, "导演C", 10_000_000, 6_000_000, 300, 1.8, 0.5),
    ]
    
    portfolio = analyzer.portfolio_optimization(projects, 50_000_000)
    print(f"\n投资组合优化:")
    for alloc in portfolio.get('allocations', []):
        print(f"  {alloc['project']}: {alloc['weight']*100:.1f}% (${alloc['investment']:,.0f})")

// DeFi制片融资前端逻辑
const Web3 = require('web3');
const axios = require('axios');

class DefiFilmFrontend {
    constructor(providerUrl, contractAddress) {
        this.web3 = new Web3(providerUrl);
        this.contractAddress = contractAddress;
        this.contract = null;
        this.userAccount = null;
        this.projects = new Map();
    }
    
    // 初始化合约连接
    async initContract(abi) {
        this.contract = new this.web3.eth.Contract(abi, this.contractAddress);
        console.log('[合约] 已初始化');
    }
    
    // 连接钱包
    async connectWallet() {
        if (window.ethereum) {
            try {
                const accounts = await window.ethereum.request({
                    method: 'eth_requestAccounts'
                });
                this.userAccount = accounts[0];
                console.log(`[钱包] 已连接: ${this.userAccount}`);
                return this.userAccount;
            } catch (error) {
                console.error('[钱包] 连接失败:', error);
                throw error;
            }
        } else {
            throw new Error('请安装MetaMask');
        }
    }
    
    // 创建电影项目
    async createProject(projectData) {
        const {
            title, director, fundingGoal,
            durationDays, creator
        } = projectData;
        
        const goalWei = this.web3.utils.toWei(fundingGoal.toString(), 'ether');
        
        try {
            const result = await this.contract.methods
                .createProject(title, director, goalWei, durationDays, creator)
                .send({ from: this.userAccount });
            
            console.log(`[项目] 创建成功: ${title}`);
            return result;
        } catch (error) {
            console.error('[项目] 创建失败:', error);
            throw error;
        }
    }
    
    // 投资电影项目
    async investInProject(projectId, amount) {
        const amountWei = this.web3.utils.toWei(amount.toString(), 'ether');
        
        try {
            const result = await this.contract.methods
                .invest(projectId)
                .send({
                    from: this.userAccount,
                    value: amountWei
                });
            
            console.log(`[投资] 成功投资 ${amount} ETH 到项目 ${projectId}`);
            return result;
        } catch (error) {
            console.error('[投资] 失败:', error);
            throw error;
        }
    }
    
    // 获取项目信息
    async getProjectInfo(projectId) {
        try {
            const result = await this.contract.methods
                .getProject(projectId)
                .call();
            
            const project = {
                id: projectId,
                title: result.title,
                director: result.director,
                fundingGoal: this.web3.utils.fromWei(result.fundingGoal, 'ether'),
                totalFunded: this.web3.utils.fromWei(result.totalFunded, 'ether'),
                deadline: new Date(result.deadline * 1000),
                isFunded: result.isFunded,
                isReleased: result.isReleased,
                creator: result.creator,
                progress: (result.totalFunded / result.fundingGoal) * 100
            };
            
            this.projects.set(projectId, project);
            return project;
        } catch (error) {
            console.error('[项目] 获取信息失败:', error);
            throw error;
        }
    }
    
    // 计算投资回报
    calculateReturns(investedAmount, projectInfo) {
        const totalSupply = 1000000; // 总份额
        const shares = (investedAmount / parseFloat(projectInfo.fundingGoal)) * totalSupply;
        const sharePercentage = (shares / totalSupply) * 100;
        
        return {
            shares: Math.floor(shares),
            sharePercentage: sharePercentage.toFixed(2),
            estimatedReturn: this.projectRevenueEstimate(projectInfo, shares)
        };
    }
    
    // 项目收益预估
    projectRevenueEstimate(projectInfo, shares) {
        // 基于历史数据的简单预估模型
        const genreMultipliers = {
            '动作': 3.5,
            '喜剧': 2.8,
            '剧情': 1.5,
            '恐怖': 4.0,
            '科幻': 3.2,
            '纪录片': 1.2,
            '动画': 2.5
        };
        
        const budget = parseFloat(projectInfo.fundingGoal);
        const multiplier = genreMultipliers['科幻'] || 2.0;
        const estimatedRevenue = budget * multiplier;
        const perShareValue = estimatedRevenue / 1000000;
        
        return {
            estimatedRevenue: estimatedRevenue,
            perShareValue: perShareValue,
            userEstimatedReturn: shares * perShareValue,
            roi: ((perShareValue * shares) / budget) - 1
        };
    }
    
    // 获取投资组合
    async getPortfolio(userAddress) {
        const portfolio = {
            totalInvested: 0,
            totalCurrentValue: 0,
            totalUnclaimedRevenue: 0,
            investments: []
        };
        
        for (const [projectId, project] of this.projects) {
            try {
                const investorInfo = await this.contract.methods
                    .getInvestorInfo(projectId, userAddress)
                    .call();
                
                if (parseInt(investorInfo.shares) > 0) {
                    const invested = parseFloat(
                        this.web3.utils.fromWei(investorInfo.invested, 'ether')
                    );
                    const claimed = investorInfo.claimed;
                    
                    const returns = this.calculateReturns(invested, project);
                    
                    portfolio.totalInvested += invested;
                    portfolio.investments.push({
                        projectId,
                        projectTitle: project.title,
                        invested,
                        shares: parseInt(investorInfo.shares),
                        currentValue: returns.estimatedReturn.userEstimatedReturn,
                        claimed,
                        progress: project.progress
                    });
                }
            } catch (error) {
                console.error(`获取项目 ${projectId} 的投资信息失败:`, error);
            }
        }
        
        return portfolio;
    }
    
    // 领取分红
    async claimRevenue(projectId) {
        try {
            const result = await this.contract.methods
                .claimRevenue(projectId)
                .send({ from: this.userAccount });
            
            console.log(`[分红] 已领取项目 ${projectId} 的分红`);
            return result;
        } catch (error) {
            console.error('[分红] 领取失败:', error);
            throw error;
        }
    }
    
    // 处理二级市场交易
    async sellShares(projectId, amount, price) {
        // 在去中心化交易所上架
        const priceWei = this.web3.utils.toWei(price.toString(), 'ether');
        
        try {
            // 先授权
            await this.contract.methods
                .approve(this.contractAddress, amount)
                .send({ from: this.userAccount });
            
            // 创建卖单
            const result = await this.contract.methods
                .createSellOrder(projectId, amount, priceWei)
                .send({ from: this.userAccount });
            
            console.log(`[交易] 上架卖单: ${amount} 份额，单价 ${price} ETH`);
            return result;
        } catch (error) {
            console.error('[交易] 上架失败:', error);
            throw error;
        }
    }
    
    // 项目市场分析
    async marketAnalysis(projectId) {
        const project = await this.getProjectInfo(projectId);
        
        // 模拟市场数据
        const analysis = {
            projectTitle: project.title,
            fundingProgress: project.progress.toFixed(1) + '%',
            daysRemaining: Math.max(0, Math.floor(
                (project.deadline - new Date()) / (1000 * 60 * 60 * 24)
            )),
            investorCount: await this.getInvestorCount(projectId),
            averageInvestment: project.totalFunded / 
                (await this.getInvestorCount(projectId) || 1),
            sentimentScore: this.calculateSentiment(project),
            riskLevel: this.assessRisk(project)
        };
        
        return analysis;
    }
    
    // 情感分析（模拟）
    calculateSentiment(project) {
        const factors = {
            fundingSpeed: project.progress / 30, // 30天基准
            investorDiversity: Math.min(1, 0.5),
            socialMentions: 0.7
        };
        
        return Object.values(factors).reduce((a, b) => a + b, 0) / 3;
    }
    
    // 风险评估
    assessRisk(project) {
        const riskFactors = [];
        
        if (project.progress < 20 && project.deadline < new Date()) {
            riskFactors.push('融资进度缓慢');
        }
        if (parseFloat(project.fundingGoal) > 10000) {
            riskFactors.push('高融资目标');
        }
        if (!project.isFunded) {
            riskFactors.push('尚未完成融资');
        }
        
        return {
            level: riskFactors.length > 2 ? '高' : riskFactors.length > 0 ? '中' : '低',
            factors: riskFactors
        };
    }
    
    // 获取投资者数量
    async getInvestorCount(projectId) {
        try {
            const count = await this.contract.methods
                .getInvestorCount(projectId)
                .call();
            return parseInt(count);
        } catch {
            return 0;
        }
    }
    
    // 事件监听
    listenToEvents() {
        // 监听融资事件
        this.contract.events.Funded({
            filter: {},
            fromBlock: 'latest'
        })
        .on('data', event => {
            console.log('[事件] 新投资:', event.returnValues);
            this.updateUI(event);
        })
        .on('error', console.error);
        
        // 监听分红事件
        this.contract.events.RevenueDistributed({
            filter: {},
            fromBlock: 'latest'
        })
        .on('data', event => {
            console.log('[事件] 新分红:', event.returnValues);
            this.updateUI(event);
        })
        .on('error', console.error);
    }
    
    updateUI(event) {
        // 在实际应用中，这里会更新React/Vue组件
        console.log('[UI] 更新看板');
    }
}

// 使用示例
const frontend = new DefiFilmFrontend(
    'https://mainnet.infura.io/v3/YOUR_PROJECT_ID',
    '0xContractAddress'
);

// 初始化
(async () => {
    const abi = []; // 合约ABI
    await frontend.initContract(abi);
    await frontend.connectWallet();
    
    // 创建项目
    await frontend.createProject({
        title: '去中心化之梦',
        director: '王森涛',
        fundingGoal: 3000,
        durationDays: 30,
        creator: '0xCreatorAddress'
    });
    
    // 投资
    await frontend.investInProject(1, 10);
    
    // 获取投资组合
    const portfolio = await frontend.getPortfolio('0xUserAddress');
    console.log('投资组合:', portfolio);
})();