链上保险与影视制作：DeFi保险的制片风险覆盖

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

contract FilmInsurance {
    using SafeERC20 for IERC20;

    IERC20 public premiumToken;
    address public oracle;
    uint256 public poolBalance;
    uint256 public totalShares;

    struct Policy {
        address insured;
        string filmName;
        uint256 coverageAmount;
        uint256 premium;
        uint256 startDate;
        uint256 endDate;
        InsuranceType insuranceType;
        bool active;
        bool claimed;
    }

    enum InsuranceType { 
        COMPLETION,    // 完工担保
        CAST,          // 演员保险
        EQUIPMENT,     // 设备保险
        WEATHER,       // 天气保险
        POST_PRODUCTION // 后期制作保险
    }

    struct Claim {
        uint256 policyId;
        address claimant;
        string description;
        uint256 amount;
        bytes32 evidenceHash;
        ClaimStatus status;
        uint256 timestamp;
    }

    enum ClaimStatus { PENDING, APPROVED, REJECTED, DISPUTED }

    Policy[] public policies;
    Claim[] public claims;
    mapping(address => uint256) public liquidityProviders;
    mapping(address => uint256[]) public userPolicies;

    event PolicyCreated(uint256 indexed policyId, address insured, InsuranceType insuranceType, uint256 coverage);
    event ClaimSubmitted(uint256 indexed claimId, uint256 policyId, uint256 amount);
    event ClaimApproved(uint256 indexed claimId, uint256 payout);
    event ClaimRejected(uint256 indexed claimId, string reason);
    event LiquidityAdded(address indexed provider, uint256 amount);

    constructor(address _premiumToken, address _oracle) {
        premiumToken = IERC20(_premiumToken);
        oracle = _oracle;
    }

    function createPolicy(
        string calldata filmName,
        uint256 coverageAmount,
        InsuranceType insuranceType,
        uint256 duration
    ) external returns (uint256) {
        uint256 premium = calculatePremium(coverageAmount, insuranceType, duration);
        require(premium > 0, "Invalid premium");

        premiumToken.safeTransferFrom(msg.sender, address(this), premium);

        policies.push(Policy({
            insured: msg.sender,
            filmName: filmName,
            coverageAmount: coverageAmount,
            premium: premium,
            startDate: block.timestamp,
            endDate: block.timestamp + duration,
            insuranceType: insuranceType,
            active: true,
            claimed: false
        }));

        uint256 policyId = policies.length - 1;
        userPolicies[msg.sender].push(policyId);
        poolBalance += premium;

        emit PolicyCreated(policyId, msg.sender, insuranceType, coverageAmount);
        return policyId;
    }

    function calculatePremium(
        uint256 coverageAmount,
        InsuranceType insuranceType,
        uint256 duration
    ) public view returns (uint256) {
        uint256 baseRate = 100; // 1% base rate in basis points
        uint256 riskMultiplier = 100;

        if (insuranceType == InsuranceType.COMPLETION) {
            riskMultiplier = 150; // 1.5x
        } else if (insuranceType == InsuranceType.CAST) {
            riskMultiplier = 200; // 2x
        } else if (insuranceType == InsuranceType.WEATHER) {
            riskMultiplier = 120; // 1.2x
        } else if (insuranceType == InsuranceType.POST_PRODUCTION) {
            riskMultiplier = 80; // 0.8x
        }

        uint256 totalRate = (baseRate * riskMultiplier * duration) / (365 days);
        return (coverageAmount * totalRate) / 10000;
    }

    function submitClaim(
        uint256 policyId,
        string calldata description,
        uint256 amount,
        bytes32 evidenceHash
    ) external returns (uint256) {
        Policy storage p = policies[policyId];
        require(p.insured == msg.sender, "Not insured");
        require(p.active, "Policy not active");
        require(!p.claimed, "Already claimed");
        require(block.timestamp <= p.endDate, "Policy expired");
        require(amount <= p.coverageAmount, "Exceeds coverage");

        claims.push(Claim({
            policyId: policyId,
            claimant: msg.sender,
            description: description,
            amount: amount,
            evidenceHash: evidenceHash,
            status: ClaimStatus.PENDING,
            timestamp: block.timestamp
        }));

        uint256 claimId = claims.length - 1;
        emit ClaimSubmitted(claimId, policyId, amount);
        return claimId;
    }

    function approveClaim(uint256 claimId, bytes calldata oracleData) external {
        require(msg.sender == oracle, "Not oracle");
        Claim storage c = claims[claimId];
        require(c.status == ClaimStatus.PENDING, "Not pending");

        // Verify oracle data
        (bool approved, uint256 payoutAmount) = abi.decode(oracleData, (bool, uint256));
        
        if (approved) {
            c.status = ClaimStatus.APPROVED;
            policies[c.policyId].claimed = true;
            poolBalance -= payoutAmount;
            premiumToken.safeTransfer(c.claimant, payoutAmount);
            emit ClaimApproved(claimId, payoutAmount);
        } else {
            c.status = ClaimStatus.REJECTED;
            emit ClaimRejected(claimId, "Insufficient evidence");
        }
    }

    function addLiquidity(uint256 amount) external {
        premiumToken.safeTransferFrom(msg.sender, address(this), amount);
        uint256 shares = (totalShares == 0) ? amount : 
                        (amount * totalShares) / poolBalance;
        liquidityProviders[msg.sender] += shares;
        totalShares += shares;
        poolBalance += amount;
        emit LiquidityAdded(msg.sender, amount);
    }

    function getPolicy(uint256 policyId) external view returns (Policy memory) {
        return policies[policyId];
    }

    function getClaim(uint256 claimId) external view returns (Claim memory) {
        return claims[claimId];
    }
}

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
from datetime import datetime, timedelta
from typing import Dict, List, Tuple
import json
import warnings
warnings.filterwarnings('ignore')

class FilmInsurancePricer:
    def __init__(self):
        self.risk_factors = {
            'budget': 0.3,
            'duration': 0.15,
            'cast_size': 0.1,
            'location_count': 0.15,
            'stunt_count': 0.2,
            'vfx_ratio': 0.1
        }
        self.model = RandomForestRegressor(n_estimators=100, random_state=42)
        self.scaler = StandardScaler()
        self.trained = False

    def generate_training_data(self, n_samples: int = 1000) -> pd.DataFrame:
        """Generate synthetic training data"""
        np.random.seed(42)
        data = []

        for _ in range(n_samples):
            sample = {
                'budget': np.random.uniform(1, 300),  # million USD
                'duration': np.random.randint(30, 365),  # days
                'cast_size': np.random.randint(5, 50),
                'location_count': np.random.randint(1, 30),
                'stunt_count': np.random.randint(0, 20),
                'vfx_ratio': np.random.uniform(0, 1),
                'genre': np.random.choice(['action', 'drama', 'comedy', 'horror', 'sci-fi']),
                'season': np.random.choice(['spring', 'summer', 'fall', 'winter'])
            }

            # Calculate base risk
            base_risk = 0.05  # 5% base risk
            base_risk += sample['budget'] * 0.0005
            base_risk += sample['stunt_count'] * 0.02
            base_risk += sample['location_count'] * 0.005
            base_risk += sample['vfx_ratio'] * 0.03
            base_risk -= sample['duration'] * 0.0001

            # Genre adjustment
            genre_risk = {
                'action': 0.03,
                'drama': 0.01,
                'comedy': 0.015,
                'horror': 0.025,
                'sci-fi': 0.02
            }
            base_risk += genre_risk[sample['genre']]

            # Season adjustment
            season_risk = {
                'spring': 0.01,
                'summer': 0.015,
                'fall': 0.005,
                'winter': 0.025
            }
            base_risk += season_risk[sample['season']]

            # Add noise
            base_risk += np.random.normal(0, 0.01)

            sample['risk_score'] = max(0.01, min(base_risk, 0.5))
            data.append(sample)

        return pd.DataFrame(data)

    def train_model(self, training_data: pd.DataFrame = None):
        """Train the risk pricing model"""
        if training_data is None:
            training_data = self.generate_training_data()

        # Prepare features
        feature_cols = ['budget', 'duration', 'cast_size', 'location_count', 
                       'stunt_count', 'vfx_ratio']
        X = training_data[feature_cols]
        y = training_data['risk_score']

        # Scale features
        X_scaled = self.scaler.fit_transform(X)

        # Train model
        self.model.fit(X_scaled, y)
        self.trained = True

        return {
            'feature_importance': dict(zip(feature_cols, 
                                          self.model.feature_importances_)),
            'training_score': self.model.score(X_scaled, y)
        }

    def calculate_premium(self, coverage_amount: float, 
                          film_params: Dict) -> Dict:
        """Calculate insurance premium for a film"""
        if not self.trained:
            self.train_model()

        # Prepare features
        features = np.array([[
            film_params.get('budget', 100),
            film_params.get('duration', 120),
            film_params.get('cast_size', 20),
            film_params.get('location_count', 10),
            film_params.get('stunt_count', 5),
            film_params.get('vfx_ratio', 0.3)
        ]])

        # Scale and predict
        features_scaled = self.scaler.transform(features)
        risk_score = self.model.predict(features_scaled)[0]

        # Calculate premium
        base_premium = coverage_amount * risk_score
        admin_fee = base_premium * 0.05
        total_premium = base_premium + admin_fee

        # Calculate confidence interval
        predictions = []
        for estimator in self.model.estimators_:
            pred = estimator.predict(features_scaled)[0]
            predictions.append(pred)
        
        ci_lower = np.percentile(predictions, 5)
        ci_upper = np.percentile(predictions, 95)

        return {
            'coverage_amount': coverage_amount,
            'risk_score': risk_score,
            'base_premium': base_premium,
            'admin_fee': admin_fee,
            'total_premium': total_premium,
            'premium_rate': risk_score * 100,  # percentage
            'confidence_interval': [ci_lower * coverage_amount, 
                                   ci_upper * coverage_amount],
            'risk_factors': {
                'budget_risk': film_params.get('budget', 100) * 0.0005,
                'stunt_risk': film_params.get('stunt_count', 5) * 0.02,
                'location_risk': film_params.get('location_count', 10) * 0.005
            }
        }

    def calculate_completion_bond(self, film_params: Dict) -> Dict:
        """Calculate completion bond premium"""
        base_analysis = self.calculate_premium(
            film_params.get('budget', 100) * 1e6, 
            film_params
        )

        # Completion bond has additional factors
        completion_multiplier = 1.2
        bond_premium = base_analysis['total_premium'] * completion_multiplier

        return {
            'film_budget': film_params.get('budget', 100),
            'bond_premium': bond_premium,
            'bond_rate': bond_premium / (film_params.get('budget', 100) * 1e6) * 100,
            'risk_breakdown': base_analysis
        }

    def batch_quote(self, films: List[Dict]) -> List[Dict]:
        """Generate quotes for multiple films"""
        quotes = []
        for film in films:
            quote = self.calculate_premium(
                film.get('coverage', 10e6),
                film
            )
            quote['film_name'] = film.get('name', 'Unknown')
            quotes.append(quote)
        return quotes


# Demo
pricer = FilmInsurancePricer()
training_results = pricer.train_model()

film_params = {
    'budget': 50,  # $50M
    'duration': 90,
    'cast_size': 25,
    'location_count': 15,
    'stunt_count': 8,
    'vfx_ratio': 0.4
}

quote = pricer.calculate_premium(50e6, film_params)
print(json.dumps(quote, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const axios = require('axios');
const cors = require('cors');

const app = express();
app.use(cors());
app.use(express.json());

const INSURANCE_ABI = [
    "function createPolicy(string filmName, uint256 coverageAmount, uint8 insuranceType, uint256 duration) external returns (uint256)",
    "function submitClaim(uint256 policyId, string description, uint256 amount, bytes32 evidenceHash) external returns (uint256)",
    "function approveClaim(uint256 claimId, bytes calldata oracleData) external",
    "function calculatePremium(uint256 coverageAmount, uint8 insuranceType, uint256 duration) external view returns (uint256)",
    "event PolicyCreated(uint256 indexed policyId, address insured, uint8 insuranceType, uint256 coverage)",
    "event ClaimSubmitted(uint256 indexed claimId, uint256 policyId, uint256 amount)",
    "event ClaimApproved(uint256 indexed claimId, uint256 payout)"
];

class FilmInsuranceOracle {
    constructor(providerUrl, insuranceAddress) {
        this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
        this.insurance = new ethers.Contract(insuranceAddress, INSURANCE_ABI, this.provider);
        this.signer = null;
    }

    async connect(privateKey) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        this.signer = wallet.connect(this.provider);
        this.insurance = this.insurance.connect(this.signer);
    }

    async verifyWeatherClaim(location, claimDate) {
        try {
            // In production, call weather API
            const weatherData = {
                location,
                date: claimDate,
                had_storm: Math.random() > 0.7,
                wind_speed: Math.random() * 100,
                precipitation: Math.random() * 50
            };

            const approved = weatherData.had_storm && 
                           weatherData.wind_speed > 50;
            
            const oracleData = ethers.utils.defaultAbiCoder.encode(
                ['bool', 'uint256'],
                [approved, approved ? 100000 : 0] // payout amount
            );

            return oracleData;
        } catch (error) {
            console.error('Weather verification failed:', error);
            return null;
        }
    }

    async verifyCastClaim(actorAddress, accidentDate) {
        try {
            // In production, verify through news APIs or registry
            const isInjured = Math.random() > 0.8;
            const recoveryDays = isInjured ? Math.floor(Math.random() * 30) + 7 : 0;

            const approved = isInjured;
            const payout = isInjured ? recoveryDays * 10000 : 0; // $10k/day

            const oracleData = ethers.utils.defaultAbiCoder.encode(
                ['bool', 'uint256'],
                [approved, payout]
            );

            return oracleData;
        } catch (error) {
            console.error('Cast verification failed:', error);
            return null;
        }
    }

    async autoApproveClaim(claimId) {
        const claim = await this.insurance.claims(claimId);
        const policy = await this.insurance.policies(claim.policyId);

        let oracleData;
        if (policy.insuranceType === 3) { // Weather
            oracleData = await this.verifyWeatherClaim('location', Date.now());
        } else if (policy.insuranceType === 1) { // Cast
            oracleData = await this.verifyCastClaim('actor', Date.now());
        } else {
            // Default approval logic
            oracleData = ethers.utils.defaultAbiCoder.encode(
                ['bool', 'uint256'],
                [true, claim.amount]
            );
        }

        if (oracleData) {
            const tx = await this.insurance.approveClaim(claimId, oracleData);
            const receipt = await tx.wait();
            return receipt;
        }
        return null;
    }
}

app.post('/api/insurance/policy', async (req, res) => {
    const { privateKey, filmName, coverageAmount, insuranceType, duration } = req.body;
    const oracle = new FilmInsuranceOracle(
        process.env.RPC_URL,
        process.env.INSURANCE_ADDRESS
    );
    await oracle.connect(privateKey);
    const insurance = new ethers.Contract(
        process.env.INSURANCE_ADDRESS,
        INSURANCE_ABI,
        new ethers.Wallet(privateKey, 
            new ethers.providers.JsonRpcProvider(process.env.RPC_URL))
    );
    const tx = await insurance.createPolicy(
        filmName,
        ethers.utils.parseEther(coverageAmount.toString()),
        insuranceType,
        duration * 86400
    );
    const receipt = await tx.wait();
    res.json(receipt);
});

app.post('/api/insurance/claim', async (req, res) => {
    const { privateKey, policyId, description, amount, evidenceHash } = req.body;
    const wallet = new ethers.Wallet(privateKey, 
        new ethers.providers.JsonRpcProvider(process.env.RPC_URL));
    const insurance = new ethers.Contract(
        process.env.INSURANCE_ADDRESS,
        INSURANCE_ABI,
        wallet
    );
    const tx = await insurance.submitClaim(
        policyId,
        description,
        ethers.utils.parseEther(amount.toString()),
        evidenceHash
    );
    const receipt = await tx.wait();
    res.json(receipt);
});

app.post('/api/insurance/approve/:claimId', async (req, res) => {
    const oracle = new FilmInsuranceOracle(
        process.env.RPC_URL,
        process.env.INSURANCE_ADDRESS
    );
    await oracle.connect(process.env.ORACLE_PRIVATE_KEY);
    const receipt = await oracle.autoApproveClaim(req.params.claimId);
    res.json(receipt);
});

app.listen(3005, () => {
    console.log('Film Insurance API running on port 3005');
});