第一幕：融资困境——当票房成为最大的不可知变量

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

contract BoxOfficePredictionMarket {
    address public oracle;
    uint256 public marketId;
    uint256 public immutable resolutionTime;
    bool public resolved;
    
    struct Outcome {
        string range;
        uint256 totalShares;
        mapping(address => uint256) shares;
    }
    
    mapping(uint256 => Outcome) public outcomes;
    mapping(address => uint256) public balances;
    uint256[] public outcomeIds;
    
    event PredictionMade(address indexed predictor, uint256 outcomeId, uint256 amount);
    event MarketResolved(uint256 winningOutcomeId, uint256 finalBoxOffice);
    
    constructor(uint256 _resolutionTime, address _oracle) {
        resolutionTime = _resolutionTime;
        oracle = _oracle;
        // 定义票房区间（单位：百万美元）
        outcomes[0] = Outcome("$0-50M", 0);
        outcomes[1] = Outcome("$50-100M", 0);
        outcomes[2] = Outcome("$100-200M", 0);
        outcomes[3] = Outcome("$200-500M", 0);
        outcomes[4] = Outcome("$500M+", 0);
        outcomeIds = [0, 1, 2, 3, 4];
    }
    
    function predict(uint256 outcomeId) external payable {
        require(!resolved, "Market already resolved");
        require(block.timestamp < resolutionTime, "Prediction period ended");
        require(outcomeId < outcomeIds.length, "Invalid outcome");
        
        outcomes[outcomeId].totalShares += msg.value;
        outcomes[outcomeId].shares[msg.sender] += msg.value;
        emit PredictionMade(msg.sender, outcomeId, msg.value);
    }
    
    function resolve(uint256 winningOutcomeId, uint256 finalBoxOffice) external {
        require(msg.sender == oracle, "Only oracle can resolve");
        require(!resolved, "Already resolved");
        require(block.timestamp >= resolutionTime, "Resolution time not reached");
        
        resolved = true;
        uint256 totalPool = address(this).balance;
        uint256 winningShares = outcomes[winningOutcomeId].totalShares;
        
        // 如果有赢家，按份额分配奖金池
        if (winningShares > 0) {
            for (uint256 i = 0; i < outcomeIds.length; i++) {
                uint256 oid = outcomeIds[i];
                if (oid == winningOutcomeId) {
                    address predictor;
                    uint256 remainingShares = winningShares;
                    // 简化分配逻辑：实际实现需使用可迭代映射
                    balances[msg.sender] = totalPool;
                }
            }
        }
        
        emit MarketResolved(winningOutcomeId, finalBoxOffice);
    }
    
    function withdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance to withdraw");
        balances[msg.sender] = 0;
        payable(msg.sender).transfer(amount);
    }
}

import numpy as np
import pandas as pd
from typing import Dict, List, Tuple
import random

class BoxOfficeSimulationEngine:
    """
    链上票房预测市场模拟引擎
    模拟多个参与者基于不同信息维度进行预测，观察市场价格的收敛过程
    """
    
    def __init__(self, true_box_office: float, n_participants: int = 1000):
        self.true_box_office = true_box_office  # 真实票房（百万美元）
        self.n_participants = n_participants
        self.predictions = []
        self.market_price = 0.0
        
    def generate_participant_signals(self) -> List[float]:
        """生成每个参与者的独立信号，模拟不同信息源"""
        signals = []
        for i in range(self.n_participants):
            # 每个参与者基于真实票房加上不同噪声水平生成信号
            noise_level = np.random.exponential(0.3)  # 噪声水平服从指数分布
            noise = np.random.normal(0, self.true_box_office * noise_level)
            signal = self.true_box_office + noise
            # 参与者不能为负预测
            signals.append(max(signal, 0))
        return signals
    
    def simulate_market_clearing(self, signals: List[float]) -> float:
        """模拟市场出清价格的收敛过程"""
        # 使用中位数作为市场出清价格（对极端值更鲁棒）
        market_price = np.median(signals)
        # 计算置信区间（25%和75%分位数）
        lower_ci = np.percentile(signals, 25)
        upper_ci = np.percentile(signals, 75)
        return market_price, lower_ci, upper_ci
    
    def run_rounds(self, rounds: int = 10) -> pd.DataFrame:
        """
        运行多轮预测，模拟信息更新后的价格收敛
        每一轮中，参与者可以观察到上一轮的市场价格并调整自己的预测
        """
        history = []
        current_signals = self.generate_participant_signals()
        
        for r in range(rounds):
            market_price, lower_ci, upper_ci = self.simulate_market_clearing(current_signals)
            error = abs(market_price - self.true_box_office) / self.true_box_office * 100
            
            history.append({
                'round': r + 1,
                'market_price': market_price,
                'lower_ci': lower_ci,
                'upper_ci': upper_ci,
                'true_value': self.true_box_office,
                'error_pct': error,
                'participants': self.n_participants
            })
            
            # 参与者观察到市场信号后调整预测（贝叶斯更新）
            adjusted_signals = []
            for s in current_signals:
                # 信号向市场价格的加权回归
                weight = 0.3 + 0.5 * (r / rounds)  # 随时间增加市场权重
                adjusted = weight * market_price + (1 - weight) * s
                adjusted_signals.append(adjusted)
            current_signals = adjusted_signals
            
        return pd.DataFrame(history)
    
    def monte_carlo_confidence(self, n_simulations: int = 1000) -> Dict:
        """蒙特卡洛模拟，计算预测市场的置信度分布"""
        results = []
        for _ in range(n_simulations):
            signals = self.generate_participant_signals()
            mp, _, _ = self.simulate_market_clearing(signals)
            results.append(mp)
            
        return {
            'mean': np.mean(results),
            'median': np.median(results),
            'std': np.std(results),
            'ci_95_lower': np.percentile(results, 2.5),
            'ci_95_upper': np.percentile(results, 97.5),
            'true_value': self.true_box_office
        }

# 模拟：假设真实票房为5亿美元
engine = BoxOfficeSimulationEngine(true_box_office=500, n_participants=1000)
history = engine.run_rounds(rounds=10)

print("票房预测市场收敛过程模拟")
print("=" * 60)
print(f"真实票房: ${engine.true_box_office:.0f}M")
print(f"模拟参与者: {engine.n_participants}")
print("-" * 60)

for _, row in history.iterrows():
    print(f"第{int(row['round'])}轮 | "
          f"市场价: ${row['market_price']:.1f}M | "
          f"置信区间: ${row['lower_ci']:.1f}M-${row['upper_ci']:.1f}M | "
          f"误差: {row['error_pct']:.1f}%")

confidence = engine.monte_carlo_confidence()
print("-" * 60)
print(f"蒙特卡洛分析 (1000次模拟):")
print(f"  预测均值: ${confidence['mean']:.1f}M")
print(f"  预测中位数: ${confidence['median']:.1f}M")
print(f"  95%置信区间: ${confidence['ci_95_lower']:.1f}M - ${confidence['ci_95_upper']:.1f}M")

import React, { useState, useEffect } from 'react';
import { ethers } from 'ethers';
import { Line } from 'react-chartjs-2';
import {
  Chart as ChartJS,
  CategoryScale,
  LinearScale,
  PointElement,
  LineElement,
  Title,
  Tooltip,
  Legend
} from 'chart.js';

ChartJS.register(CategoryScale, LinearScale, PointElement, LineElement, Title, Tooltip, Legend);

const BoxOfficePredictionMarket = ({ contractAddress, abi, provider }) => {
  const [marketData, setMarketData] = useState(null);
  const [selectedOutcome, setSelectedOutcome] = useState(null);
  const [betAmount, setBetAmount] = useState('');
  const [priceHistory, setPriceHistory] = useState([]);
  const [walletBalance, setWalletBalance] = useState('0');
  const [loading, setLoading] = useState(false);

  const outcomes = [
    { id: 0, label: '$0-50M', color: '#ff6b6b', probability: 0.08 },
    { id: 1, label: '$50-100M', color: '#feca57', probability: 0.15 },
    { id: 2, label: '$100-200M', color: '#48dbfb', probability: 0.32 },
    { id: 3, label: '$200-500M', color: '#ff9ff3', probability: 0.35 },
    { id: 4, label: '$500M+', color: '#54a0ff', probability: 0.10 }
  ];

  useEffect(() => {
    const fetchMarketData = async () => {
      if (!provider) return;
      try {
        const contract = new ethers.Contract(contractAddress, abi, provider);
        // 获取市场状态
        const isResolved = await contract.resolved();
        const resolutionTime = await contract.resolutionTime();
        
        // 获取每个结果的总份额
        const shares = await Promise.all(
          outcomes.map(o => contract.outcomes(o.id))
        );
        
        const totalPool = shares.reduce((sum, s) => sum + Number(s.totalShares), 0);
        
        const updatedOutcomes = outcomes.map((o, i) => ({
          ...o,
          totalShares: Number(shares[i].totalShares),
          probability: totalPool > 0 ? Number(shares[i].totalShares) / totalPool : o.probability
        }));
        
        setMarketData({
          isResolved,
          resolutionTime: Number(resolutionTime),
          totalPool,
          outcomes: updatedOutcomes
        });
        
      } catch (error) {
        console.error('Error fetching market data:', error);
      }
    };

    fetchMarketData();
    const interval = setInterval(fetchMarketData, 15000);
    return () => clearInterval(interval);
  }, [provider, contractAddress]);

  const handlePredict = async () => {
    if (!selectedOutcome || !betAmount || !provider) return;
    setLoading(true);
    try {
      const signer = provider.getSigner();
      const contract = new ethers.Contract(contractAddress, abi, signer);
      const tx = await contract.predict(selectedOutcome, {
        value: ethers.parseEther(betAmount)
      });
      await tx.wait();
      
      // 记录交易到价格历史
      setPriceHistory(prev => [...prev, {
        time: new Date().toLocaleTimeString(),
        outcome: outcomes.find(o => o.id === selectedOutcome)?.label,
        amount: betAmount
      }]);
      
      setBetAmount('');
      alert('预测成功提交！');
    } catch (error) {
      console.error('Prediction error:', error);
      alert('预测失败，请重试');
    }
    setLoading(false);
  };

  const chartData = {
    labels: ['预售期', '预告发布', '首周', '第二周', '第三周', '下映'],
    datasets: outcomes.map((outcome) => ({
      label: outcome.label,
      data: [0.10, 0.12, 0.15, 0.25, 0.30, outcome.probability],
      borderColor: outcome.color,
      backgroundColor: outcome.color + '20',
      tension: 0.4,
      fill: false
    }))
  };

  return (
    <div style={{
      background: 'linear-gradient(145deg, #0a0a1a, #1a1a2e)',
      color: '#e0e0e0',
      padding: '24px',
      borderRadius: '16px',
      fontFamily: "'Inter', sans-serif",
      maxWidth: '1200px',
      margin: '0 auto'
    }}>
      <div style={{ fontSize: '24px', fontWeight: '700', marginBottom: '24px', color: '#fff' }}>
        🎬 票房预测市场 - 链上交易台
      </div>
      
      <div style={{ display: 'grid', gridTemplateColumns: '2fr 1fr', gap: '24px' }}>
        {/* 预测图表 */}
        <div style={{
          background: '#16213e',
          borderRadius: '12px',
          padding: '20px'
        }}>
          <div style={{ fontSize: '14px', color: '#8892b0', marginBottom: '12px' }}>
            票房概率分布叙事流 (实时更新)
          </div>
          <Line 
            data={chartData} 
            options={{
              responsive: true,
              plugins: {
                legend: { position: 'bottom', labels: { color: '#8892b0' } }
              },
              scales: {
                x: { ticks: { color: '#8892b0' } },
                y: { ticks: { color: '#8892b0', callback: v => (v * 100).toFixed(0) + '%' } }
              }
            }} 
          />
        </div>
        
        {/* 交易面板 */}
        <div style={{
          background: '#16213e',
          borderRadius: '12px',
          padding: '20px'
        }}>
          <div style={{ fontSize: '14px', color: '#8892b0', marginBottom: '16px' }}>
            选择票房区间进行预测
          </div>
          
          {marketData?.outcomes.map(outcome => (
            <div
              key={outcome.id}
              onClick={() => setSelectedOutcome(outcome.id)}
              style={{
                display: 'flex',
                justifyContent: 'space-between',
                alignItems: 'center',
                padding: '12px',
                marginBottom: '8px',
                background: selectedOutcome === outcome.id ? outcome.color + '30' : '#0f3460',
                borderRadius: '8px',
                cursor: 'pointer',
                border: selectedOutcome === outcome.id ? `2px solid ${outcome.color}` : '2px solid transparent',
                transition: 'all 0.3s ease'
              }}
            >
              <span style={{ fontWeight: '600' }}>{outcome.label}</span>
              <span style={{ color: outcome.color, fontWeight: '700' }}>
                {(outcome.probability * 100).toFixed(1)}%
              </span>
            </div>
          ))}
          
          <div style={{ marginTop: '16px' }}>
            <input
              type="text"
              placeholder="输入ETH金额"
              value={betAmount}
              onChange={e => setBetAmount(e.target.value)}
              style={{
                width: '100%',
                padding: '12px',
                background: '#0f3460',
                border: '1px solid #1a4a7a',
                borderRadius: '8px',
                color: '#fff',
                fontSize: '16px',
                boxSizing: 'border-box'
              }}
            />
          </div>
          
          <button
            onClick={handlePredict}
            disabled={loading || !selectedOutcome || !betAmount}
            style={{
              width: '100%',
              marginTop: '12px',
              padding: '14px',
              background: 'linear-gradient(90deg, #e74c3c, #f39c12)',
              border: 'none',
              borderRadius: '8px',
              color: '#fff',
              fontSize: '16px',
              fontWeight: '700',
              cursor: loading ? 'not-allowed' : 'pointer',
              opacity: loading ? 0.7 : 1
            }}
          >
            {loading ? '提交中...' : '提交预测 🎯'}
          </button>
          
          <div style={{ marginTop: '16px', fontSize: '12px', color: '#8892b0' }}>
            总奖金池: {marketData?.totalPool ? ethers.formatEther(marketData.totalPool) : '0'} ETH
          </div>
        </div>
      </div>
      
      {/* 交易历史 */}
      {priceHistory.length > 0 && (
        <div style={{ marginTop: '24px', background: '#16213e', borderRadius: '12px', padding: '16px' }}>
          <div style={{ fontSize: '14px', color: '#8892b0', marginBottom: '8px' }}>交易记录</div>
          {priceHistory.map((tx, i) => (
            <div key={i} style={{ display: 'flex', justifyContent: 'space-between', padding: '4px 0', fontSize: '13px' }}>
              <span>{tx.time}</span>
              <span>{tx.outcome}</span>
              <span style={{ color: '#48dbfb' }}>{tx.amount} ETH</span>
            </div>
          ))}
        </div>
      )}
    </div>
  );
};

export default BoxOfficePredictionMarket;