第一幕：冷钱包的"底片"失窃——当军工级安全成为叙事漏洞

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

contract FilmMultiSigWallet {
    address[] public signers;
    uint256 public requiredSignatures;
    uint256 public constant TIME_LOCK_DELAY = 7 days;
    
    struct Transaction {
        address to;
        uint256 value;
        bytes data;
        bool executed;
        uint256 timestamp;
        uint256 confirmations;
    }
    
    Transaction[] public transactions;
    mapping(uint256 => mapping(address => bool)) public confirmations;
    mapping(address => bool) public isSigner;
    
    event TransactionCreated(uint256 indexed txId, address indexed to, uint256 value);
    event TransactionConfirmed(uint256 indexed txId, address indexed signer);
    event TransactionExecuted(uint256 indexed txId);
    event SignerAdded(address indexed signer);
    event SignerRemoved(address indexed signer);
    
    modifier onlySigner() {
        require(isSigner[msg.sender], "Not a signer");
        _;
    }
    
    modifier txExists(uint256 txId) {
        require(txId < transactions.length, "Transaction does not exist");
        _;
    }
    
    modifier notExecuted(uint256 txId) {
        require(!transactions[txId].executed, "Transaction already executed");
        _;
    }
    
    modifier timeLockPassed(uint256 txId) {
        require(
            block.timestamp >= transactions[txId].timestamp + TIME_LOCK_DELAY,
            "Time lock not yet passed"
        );
        _;
    }
    
    constructor(address[] memory _signers, uint256 _requiredSignatures) {
        require(_signers.length > 0, "Signers required");
        require(
            _requiredSignatures > 0 && _requiredSignatures <= _signers.length,
            "Invalid required signatures"
        );
        
        for (uint256 i = 0; i < _signers.length; i++) {
            address signer = _signers[i];
            require(signer != address(0), "Invalid signer");
            require(!isSigner[signer], "Duplicate signer");
            
            isSigner[signer] = true;
            signers.push(signer);
        }
        
        requiredSignatures = _requiredSignatures;
    }
    
    function submitTransaction(address to, uint256 value, bytes memory data)
        public
        onlySigner
        returns (uint256)
    {
        uint256 txId = transactions.length;
        transactions.push(Transaction({
            to: to,
            value: value,
            data: data,
            executed: false,
            timestamp: block.timestamp,
            confirmations: 0
        }));
        
        emit TransactionCreated(txId, to, value);
        return txId;
    }
    
    function confirmTransaction(uint256 txId)
        public
        onlySigner
        txExists(txId)
        notExecuted(txId)
    {
        require(!confirmations[txId][msg.sender], "Already confirmed");
        
        confirmations[txId][msg.sender] = true;
        transactions[txId].confirmations++;
        
        emit TransactionConfirmed(txId, msg.sender);
    }
    
    function executeTransaction(uint256 txId)
        public
        onlySigner
        txExists(txId)
        notExecuted(txId)
        timeLockPassed(txId)
    {
        require(
            transactions[txId].confirmations >= requiredSignatures,
            "Not enough confirmations"
        );
        
        Transaction storage txn = transactions[txId];
        txn.executed = true;
        
        (bool success, ) = txn.to.call{value: txn.value}(txn.data);
        require(success, "Transaction failed");
        
        emit TransactionExecuted(txId);
    }
    
    receive() external payable {}
}

import os
import json
import hashlib
import logging
from datetime import datetime, timedelta
from typing import List, Dict, Optional
from dataclasses import dataclass, asdict

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("FilmSecurityAudit")


@dataclass
class WalletAuditReport:
    wallet_address: str
    total_balance_eth: float
    signer_count: int
    required_signatures: int
    total_transactions: int
    pending_transactions: int
    executed_transactions: int
    last_transaction_time: Optional[str]
    average_confirm_time_hours: float
    security_score: int
    vulnerabilities: List[str]
    timestamp: str


class FilmWalletSecurityAuditor:
    def __init__(self, wallet_address: str, abi_path: str):
        self.wallet_address = wallet_address
        self.abi_path = abi_path
        self.risk_indicators = {
            "single_signer": "Single signer detected - high risk for film funds",
            "low_threshold": "Signature threshold too low for production budget",
            "no_time_lock": "No time lock configured - immediate execution risk",
            "inactive_signers": "Inactive signers detected - key management risk",
            "high_velocity": "Unusual transaction velocity detected",
        }

    def load_abi(self) -> Dict:
        try:
            with open(self.abi_path, "r") as f:
                return json.load(f)
        except FileNotFoundError:
            logger.warning(f"ABI file not found at {self.abi_path}")
            return {}

    def simulate_balance_check(self, eth_price: float = 2500.0) -> float:
        """Simulate balance check for demo purposes.
        In production, this would call the blockchain via Web3."""
        simulated_balance = 245.75
        logger.info(f"Wallet balance: {simulated_balance} ETH "
                     f"(${simulated_balance * eth_price:,.2f} USD)")
        return simulated_balance

    def analyze_signer_health(self, signers: List[str]) -> List[str]:
        """Analyze signer configuration for security risks."""
        vulnerabilities = []
        
        if len(signers) < 2:
            vulnerabilities.append(
                self.risk_indicators["single_signer"]
            )
        
        if len(signers) == 2:
            vulnerabilities.append(
                "Only 2 signers configured - consider adding a third"
            )
        
        return vulnerabilities

    def check_time_lock_config(self, time_lock_days: int) -> List[str]:
        """Verify time lock configuration."""
        vulnerabilities = []
        
        if time_lock_days == 0:
            vulnerabilities.append(
                self.risk_indicators["no_time_lock"]
            )
        elif time_lock_days < 3:
            vulnerabilities.append(
                f"Time lock only {time_lock_days} days - "
                f"recommend minimum 7 days for film funds"
            )
        
        return vulnerabilities

    def generate_report(self) -> WalletAuditReport:
        """Generate comprehensive security audit report."""
        balance = self.simulate_balance_check()
        
        signers = [
            "0x1234...abcd",
            "0x5678...efgh",
            "0x9012...ijkl"
        ]
        
        vulnerabilities = []
        vulnerabilities.extend(self.analyze_signer_health(signers))
        vulnerabilities.extend(self.check_time_lock_config(7))
        
        security_score = 100
        security_score -= len(vulnerabilities) * 15
        
        report = WalletAuditReport(
            wallet_address=self.wallet_address,
            total_balance_eth=balance,
            signer_count=len(signers),
            required_signatures=2,
            total_transactions=47,
            pending_transactions=2,
            executed_transactions=45,
            last_transaction_time=datetime.now().isoformat(),
            average_confirm_time_hours=8.5,
            security_score=max(0, security_score),
            vulnerabilities=vulnerabilities,
            timestamp=datetime.now().isoformat()
        )
        
        return report

    def print_report(self, report: WalletAuditReport):
        """Format and print audit report for film production team."""
        print("=" * 60)
        print("  电影融资多签钱包安全审计报告")
        print("  Film Multi-Sig Wallet Security Audit")
        print("=" * 60)
        print(f"\n钱包地址: {report.wallet_address}")
        print(f"总余额: {report.total_balance_eth:.2f} ETH")
        print(f"签名者数量: {report.signer_count}")
        print(f"所需签名数: {report.required_signatures}")
        print(f"安全评分: {report.security_score}/100")
        print(f"\n交易统计:")
        print(f"  总交易数: {report.total_transactions}")
        print(f"  待处理: {report.pending_transactions}")
        print(f"  已执行: {report.executed_transactions}")
        print(f"  平均确认时间: {report.average_confirm_time_hours:.1f}小时")
        
        if report.vulnerabilities:
            print(f"\n风险提示:")
            for v in report.vulnerabilities:
                print(f"  ⚠ {v}")
        else:
            print(f"\n* 未发现安全风险")
        
        print(f"\n审计时间: {report.timestamp}")
        print("=" * 60)


if __name__ == "__main__":
    auditor = FilmWalletSecurityAuditor(
        wallet_address="0x742d35Cc6634C0532925a3b844Bc4a9e8f9e8f9e",
        abi_path="./film_multisig_abi.json"
    )
    
    report = auditor.generate_report()
    auditor.print_report(report)
    
    report_hash = hashlib.sha256(
        json.dumps(asdict(report), default=str).encode()
    ).hexdigest()
    
    print(f"\n审计报告哈希值: {report_hash}")
    print("请将此哈希值存储在链上以供后续验证。")

const Web3 = require('web3');
const EventEmitter = require('events');

class FilmWalletManager extends EventEmitter {
  constructor(providerUrl, contractAddress, contractAbi) {
    super();
    this.web3 = new Web3(providerUrl);
    this.contract = new this.web3.eth.Contract(contractAbi, contractAddress);
    this.transactionQueue = [];
    this.alertThresholds = {
      largeTransfer: 100, // ETH
      unusualVelocity: 5, // transactions per hour
      signerInactivity: 30, // days
    };
  }

  async initialize() {
    const signers = await this.contract.methods.getSigners().call();
    const required = await this.contract.methods.requiredSignatures().call();
    const balance = await this.web3.eth.getBalance(this.contract.options.address);

    console.log(`[FilmWalletManager] 钱包初始化完成`);
    console.log(`[FilmWalletManager] 签名者: ${signers.length}人`);
    console.log(`[FilmWalletManager] 所需签名: ${required}/${signers.length}`);
    console.log(`[FilmWalletManager] 余额: ${this.web3.utils.fromWei(balance, 'ether')} ETH`);

    this.startMonitoring();
    return { signers, required, balance };
  }

  startMonitoring(intervalMs = 30000) {
    console.log(`[FilmWalletManager] 开始监控钱包活动 (间隔: ${intervalMs}ms)`);
    
    setInterval(async () => {
      try {
        const txCount = await this.contract.methods.getTransactionCount().call();
        const balance = await this.web3.eth.getBalance(this.contract.options.address);
        
        this.emit('update', {
          transactionCount: txCount,
          balance: this.web3.utils.fromWei(balance, 'ether'),
          timestamp: Date.now(),
        });

        await this.checkAlertConditions(balance, txCount);
      } catch (error) {
        this.emit('error', error);
      }
    }, intervalMs);
  }

  async checkAlertConditions(balance, txCount) {
    const balanceEth = parseFloat(this.web3.utils.fromWei(balance, 'ether'));
    
    if (balanceEth > this.alertThresholds.largeTransfer) {
      const recentTxs = await this.getRecentTransactions(10);
      const velocity = this.calculateTransactionVelocity(recentTxs);
      
      if (velocity > this.alertThresholds.unusualVelocity) {
        this.emit('alert', {
          level: 'critical',
          message: `检测到异常交易速度！最近${velocity.toFixed(1)}笔/小时`,
          data: { velocity, recentTxs },
        });
      }
    }
  }

  async submitTransaction(to, value, data = '0x') {
    const txId = await this.contract.methods
      .submitTransaction(to, value, data)
      .call();

    console.log(`[FilmWalletManager] 提交交易: #${txId}`);
    console.log(`[FilmWalletManager] 接收方: ${to}`);
    console.log(`[FilmWalletManager] 金额: ${this.web3.utils.fromWei(value, 'ether')} ETH`);

    this.transactionQueue.push({
      id: txId,
      to,
      value,
      data,
      status: 'pending',
      timestamp: Date.now(),
    });

    this.emit('transactionSubmitted', { txId, to, value });
    return txId;
  }

  async confirmTransaction(txId, privateKey) {
    const account = this.web3.eth.accounts.privateKeyToAccount(privateKey);
    const tx = await this.contract.methods.confirmTransaction(txId);
    
    const gas = await tx.estimateGas({ from: account.address });
    const gasPrice = await this.web3.eth.getGasPrice();
    
    const signed = await account.signTransaction({
      to: this.contract.options.address,
      data: tx.encodeABI(),
      gas,
      gasPrice,
    });
    
    const receipt = await this.web3.eth.sendSignedTransaction(signed.rawTransaction);
    
    console.log(`[FilmWalletManager] 确认交易 #${txId} 完成`);
    console.log(`[FilmWalletManager] 交易哈希: ${receipt.transactionHash}`);
    
    this.emit('transactionConfirmed', { txId, receipt });
    return receipt;
  }

  async getRecentTransactions(count = 5) {
    const total = await this.contract.methods.getTransactionCount().call();
    const start = Math.max(0, parseInt(total) - count);
    const transactions = [];
    
    for (let i = start; i < total; i++) {
      const tx = await this.contract.methods.transactions(i).call();
      transactions.push(tx);
    }
    
    return transactions;
  }

  calculateTransactionVelocity(transactions) {
    if (transactions.length < 2) return 0;
    
    const now = Date.now() / 1000;
    const oldest = Math.min(...transactions.map(tx => parseInt(tx.timestamp)));
    const timeSpan = (now - oldest) / 3600; // hours
    
    return timeSpan > 0 ? transactions.length / timeSpan : 0;
  }

  async addSigner(newSigner, privateKey) {
    const account = this.web3.eth.accounts.privateKeyToAccount(privateKey);
    const tx = await this.contract.methods.addSigner(newSigner);
    
    const gas = await tx.estimateGas({ from: account.address });
    const signed = await account.signTransaction({
      to: this.contract.options.address,
      data: tx.encodeABI(),
      gas,
      gasPrice: await this.web3.eth.getGasPrice(),
    });
    
    const receipt = await this.web3.eth.sendSignedTransaction(signed.rawTransaction);
    
    console.log(`[FilmWalletManager] 添加签名者: ${newSigner}`);
    this.emit('signerAdded', { signer: newSigner, receipt });
    
    return receipt;
  }

  generateReport() {
    return {
      contractAddress: this.contract.options.address,
      queueLength: this.transactionQueue.length,
      pendingTransactions: this.transactionQueue.filter(tx => tx.status === 'pending').length,
      alertThresholds: this.alertThresholds,
      monitoringStatus: 'active',
    };
  }
}

async function main() {
  const provider = 'https://mainnet.infura.io/v3/YOUR_PROJECT_ID';
  const contractAddress = '0x742d35Cc6634C0532925a3b844Bc4a9e8f9e8f9e';
  const contractAbi = []; // Load from ABI file

  const manager = new FilmWalletManager(provider, contractAddress, contractAbi);
  
  manager.on('update', (data) => {
    console.log(`[钱包状态] 交易数: ${data.transactionCount}, 余额: ${data.balance} ETH`);
  });
  
  manager.on('alert', (alert) => {
    console.log(`[系统警报] 级别: ${alert.level}`);
    console.log(`[系统警报] 消息: ${alert.message}`);
  });
  
  manager.on('error', (error) => {
    console.error(`[系统错误] ${error.message}`);
  });
  
  await manager.initialize();
  
  console.log('\n[FilmWalletManager] 钱包管理面板已启动');
  console.log('[FilmWalletManager] 正在监控链上活动...');
  console.log('[FilmWalletManager] 提示: 任何大额交易都将触发警报通知');
}

main().catch(console.error);