第一幕：存档危机——集中式存储的崩塌

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

contract FilmArchive is ERC721URIStorage, Ownable {
    using ECDSA for bytes32;

    struct Film {
        string title;
        string director;
        uint256 year;
        string ipfsCID;
        string arweaveTx;
        bytes32 encryptedKey;
        uint256 totalSupply;
        uint256 mintedCount;
        bool isActive;
    }

    mapping(uint256 => Film) public films;
    mapping(uint256 => mapping(address => bool)) public hasAccess;
    mapping(uint256 => bytes32) public filmAccessKeys;

    uint256 public filmCounter;
    uint256 public tokenCounter;

    event FilmRegistered(
        uint256 indexed filmId,
        string title,
        string director,
        uint256 year,
        string ipfsCID
    );

    event AccessGranted(
        uint256 indexed filmId,
        address indexed viewer,
        uint256 tokenId
    );

    constructor() ERC721("FilmArchive", "FLM") Ownable(msg.sender) {}

    function registerFilm(
        string memory _title,
        string memory _director,
        uint256 _year,
        string memory _ipfsCID,
        string memory _arweaveTx,
        bytes32 _encryptedKey,
        uint256 _supply
    ) external onlyOwner returns (uint256) {
        filmCounter++;
        films[filmCounter] = Film({
            title: _title,
            director: _director,
            year: _year,
            ipfsCID: _ipfsCID,
            arweaveTx: _arweaveTx,
            encryptedKey: _encryptedKey,
            totalSupply: _supply,
            mintedCount: 0,
            isActive: true
        });
        emit FilmRegistered(filmCounter, _title, _director, _year, _ipfsCID);
        return filmCounter;
    }

    function mintAccessToken(uint256 _filmId) external payable returns (uint256) {
        require(films[_filmId].isActive, "Film not active");
        require(films[_filmId].mintedCount < films[_filmId].totalSupply, "Sold out");

        tokenCounter++;
        films[_filmId].mintedCount++;
        _safeMint(msg.sender, tokenCounter);
        _setTokenURI(tokenCounter, _buildTokenURI(_filmId));

        hasAccess[_filmId][msg.sender] = true;
        emit AccessGranted(_filmId, msg.sender, tokenCounter);
        return tokenCounter;
    }

    function verifyAccess(uint256 _filmId, address _viewer) external view returns (bool) {
        return hasAccess[_filmId][_viewer];
    }

    function getDecryptionKey(uint256 _filmId, bytes memory _signature) external view returns (bytes32) {
        require(hasAccess[_filmId][msg.sender], "No access");
        bytes32 message = keccak256(abi.encodePacked(_filmId, msg.sender));
        address signer = message.toEthSignedMessageHash().recover(_signature);
        require(signer == owner(), "Invalid signature");
        return films[_filmId].encryptedKey;
    }

    function _buildTokenURI(uint256 _filmId) internal view returns (string memory) {
        return string(abi.encodePacked(
            "data:application/json;base64,",
            _base64(bytes(abi.encodePacked(
                '{"name":"FilmArchive Access #', Strings.toString(tokenCounter),
                '","description":"Access token for ', films[_filmId].title,
                '","attributes":[{"trait_type":"Film ID","value":"', Strings.toString(_filmId),
                '"},{"trait_type":"Title","value":"', films[_filmId].title,
                '"},{"trait_type":"Director","value":"', films[_filmId].director,
                '"}]}'
            )))
        ));
    }

    function _base64(bytes memory data) internal pure returns (string memory) {
        string memory TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        uint256 len = data.length;
        if (len == 0) return "";
        uint256 encodedLen = 4 * ((len + 2) / 3);
        bytes memory result = new bytes(encodedLen + 32);
        uint256 ptr;
        assembly {
            ptr := add(result, 32)
        }
        uint256 i;
        uint256 j;
        while (i + 3 <= len) {
            (uint256 a, uint256 b, uint256 c) = (
                uint256(uint8(data[i])),
                uint256(uint8(data[i + 1])),
                uint256(uint8(data[i + 2]))
            );
            uint256 d = (a << 16) | (b << 8) | c;
            bytes memory bTable = bytes(TABLE);
            assembly {
                mstore8(add(ptr, j), mload(add(bTable, add(32, shr(18, d)))))
                mstore8(add(ptr, add(j, 1)), mload(add(bTable, add(32, shr(12, and(d, 0x3F000))))))
                mstore8(add(ptr, add(j, 2)), mload(add(bTable, add(32, shr(6, and(d, 0xFC0))))))
                mstore8(add(ptr, add(j, 3)), mload(add(bTable, add(32, and(d, 0x3F)))))
            }
            i += 3;
            j += 4;
        }
        if (i < len) {
            uint256 remaining = len - i;
            uint256 d = uint256(uint8(data[i])) << 16;
            if (remaining > 1) d |= uint256(uint8(data[i + 1])) << 8;
            bytes memory bTable = bytes(TABLE);
            assembly {
                mstore8(add(ptr, j), mload(add(bTable, add(32, shr(18, d)))))
                mstore8(add(ptr, add(j, 1)), mload(add(bTable, add(32, shr(12, and(d, 0x3F000))))))
            }
            if (remaining == 2) {
                assembly {
                    mstore8(add(ptr, add(j, 2)), mload(add(bTable, add(32, shr(6, and(d, 0xFC0))))))
                }
            }
        }
        return string(result);
    }
}

#!/usr/bin/env python3
"""
Film Archive Uploader — IPFS + Filecoin Integration
Author: 王森涛
License: MIT
"""

import os
import json
import hashlib
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple
from pathlib import Path

import ipfshttpclient
import requests
from web3 import Web3

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)
logger = logging.getLogger(__name__)


class FilmArchiveUploader:
    """
    Upload film archives to IPFS and initiate Filecoin storage deals.
    """

    def __init__(
        self,
        ipfs_multiaddr: str = "/ip4/127.0.0.1/tcp/5001",
        filecoin_node_url: str = "https://api.node.glif.io",
        wallet_address: str = None,
        contract_address: str = None,
        web3_provider: str = "https://mainnet.infura.io/v3/YOUR_KEY"
    ):
        self.ipfs = ipfshttpclient.connect(ipfs_multiaddr)
        self.filecoin_url = filecoin_node_url
        self.wallet_address = wallet_address
        self.w3 = Web3(Web3.HTTPProvider(web3_provider))
        self.contract_address = contract_address
        self.manifest: Dict[str, Dict] = {}

    def compute_file_hash(self, filepath: str) -> str:
        """Compute SHA-256 hash of file for integrity verification."""
        sha256 = hashlib.sha256()
        with open(filepath, "rb") as f:
            for chunk in iter(lambda: f.read(8192), b""):
                sha256.update(chunk)
        return sha256.hexdigest()

    def upload_to_ipfs(self, filepath: str, pin: bool = True) -> Tuple[str, str]:
        """
        Upload a single file to IPFS.
        Returns (CID, file_hash).
        """
        file_hash = self.compute_file_hash(filepath)
        filename = os.path.basename(filepath)
        filesize = os.path.getsize(filepath)

        logger.info(f"Uploading {filename} ({filesize / 1e6:.2f} MB) to IPFS...")

        result = self.ipfs.add(filepath)
        cid = result["Hash"]

        if pin:
            self.ipfs.pin.add(cid)
            logger.info(f"Pinned {cid}")

        self.manifest[cid] = {
            "filename": filename,
            "filesize": filesize,
            "file_hash": file_hash,
            "timestamp": datetime.utcnow().isoformat(),
            "ipfs_gateway_url": f"https://ipfs.io/ipfs/{cid}"
        }

        logger.info(f"Uploaded {filename} → CID: {cid}")
        return cid, file_hash

    def upload_directory(
        self,
        dirpath: str,
        pattern: str = "*.mp4",
        recursive: bool = True
    ) -> List[str]:
        """
        Upload all matching files in a directory.
        Returns list of CIDs.
        """
        from glob import iglob

        cids = []
        search_path = os.path.join(dirpath, "**", pattern) if recursive else os.path.join(dirpath, pattern)

        for filepath in iglob(search_path, recursive=recursive):
            try:
                cid, _ = self.upload_to_ipfs(filepath)
                cids.append(cid)
            except Exception as e:
                logger.error(f"Failed to upload {filepath}: {e}")

        self._save_manifest()
        return cids

    def create_metadata_json(
        self,
        title: str,
        director: str,
        year: int,
        duration: int,
        cid: str,
        resolution: str = "4K",
        language: str = "zh",
        subtitles: List[str] = None
    ) -> Dict:
        """
        Create structured metadata for a film archive.
        """
        metadata = {
            "title": title,
            "director": director,
            "year": year,
            "duration_seconds": duration,
            "resolution": resolution,
            "language": language,
            "subtitles": subtitles or [],
            "ipfs_cid": cid,
            "ipfs_gateway": f"https://ipfs.io/ipfs/{cid}",
            "created_at": datetime.utcnow().isoformat(),
            "schema_version": "1.0.0"
        }
        return metadata

    def initiate_filecoin_deal(
        self,
        cid: str,
        duration_days: int = 540,
        replication: int = 3,
        verified: bool = True
    ) -> Dict:
        """
        Initiate a Filecoin storage deal for the given CID.
        """
        if not self.wallet_address:
            raise ValueError("Filecoin wallet address is required for storage deals")

        duration_epochs = duration_days * 24 * 60 * 60 / 30  # Filecoin epoch ≈ 30 seconds

        deal_params = {
            "cid": cid,
            "duration": int(duration_epochs),
            "replication": replication,
            "verified_deal": verified,
            "wallet": self.wallet_address
        }

        logger.info(f"Initiating Filecoin deal for CID: {cid} "
                     f"(duration: {duration_days}d, replication: {replication}x)")

        try:
            response = requests.post(
                f"{self.filecoin_url}/api/v0/deal",
                json=deal_params,
                timeout=60
            )
            response.raise_for_status()
            deal_data = response.json()
            logger.info(f"Deal created: {deal_data.get('deal_id', 'N/A')}")
            return deal_data
        except requests.exceptions.RequestException as e:
            logger.error(f"Filecoin deal failed: {e}")
            return {"error": str(e), "status": "failed"}

    def _save_manifest(self, path: str = "archive_manifest.json"):
        """Save upload manifest to local JSON file."""
        with open(path, "w", encoding="utf-8") as f:
            json.dump(self.manifest, f, ensure_ascii=False, indent=2)
        logger.info(f"Manifest saved to {path}")

    def verify_archive(self, cid: str, expected_hash: str) -> bool:
        """
        Verify that a file retrieved from IPFS matches the original hash.
        """
        try:
            retrieved = self.ipfs.cat(cid)
            actual_hash = hashlib.sha256(retrieved).hexdigest()
            match = actual_hash == expected_hash
            logger.info(f"Verification for CID {cid}: {'PASS' if match else 'FAIL'}")
            return match
        except Exception as e:
            logger.error(f"Verification failed for CID {cid}: {e}")
            return False

    def close(self):
        """Close IPFS connection."""
        self.ipfs.close()
        logger.info("IPFS connection closed")


if __name__ == "__main__":
    uploader = FilmArchiveUploader(
        wallet_address="f1abc123...",
        contract_address="0x..."
    )

    # Upload a sample film archive
    cid, file_hash = uploader.upload_to_ipfs("C:/Archives/2024_Film_4K_Restored.mkv")
    print(f"Uploaded with CID: {cid}")

    # Create metadata
    metadata = uploader.create_metadata_json(
        title="示例电影档案",
        director="导演姓名",
        year=2024,
        duration=7200,
        cid=cid
    )
    print(json.dumps(metadata, ensure_ascii=False, indent=2))

    # Initiate Filecoin deal
    deal = uploader.initiate_filecoin_deal(cid, duration_days=540)
    print(f"Filecoin deal: {deal}")

    uploader.close()

/**
 * Decentralized Film Archive Browser
 * Supports IPFS, Arweave, and NFT-gated access
 */

class FilmArchiveBrowser {
    constructor(web3Provider, contractAddress) {
        this.ipfsGateway = 'https://ipfs.io/ipfs/';
        this.arweaveGateway = 'https://arweave.net/';
        this.web3 = null;
        this.contract = null;
        this.contractAddress = contractAddress;
        this.currentFilm = null;
        this.connectedAccount = null;

        // Initialize Web3 if available
        if (typeof window.ethereum !== 'undefined') {
            this.web3 = new Web3(window.ethereum);
        } else if (web3Provider) {
            this.web3 = new Web3(web3Provider);
        }

        this.init();
    }

    async init() {
        if (this.web3 && this.contractAddress) {
            const abi = [
                'function registerFilm(string title, string director, uint256 year, string ipfsCID, string arweaveTx, bytes32 encryptedKey, uint256 supply) external returns (uint256)',
                'function mintAccessToken(uint256 filmId) external payable returns (uint256)',
                'function verifyAccess(uint256 filmId, address viewer) external view returns (bool)',
                'function getDecryptionKey(uint256 filmId, bytes signature) external view returns (bytes32)',
                'function films(uint256) external view returns (string title, string director, uint256 year, string ipfsCID, string arweaveTx, bytes32 encryptedKey, uint256 totalSupply, uint256 mintedCount, bool isActive)',
                'event FilmRegistered(uint256 indexed filmId, string title, string director, uint256 year, string ipfsCID)',
                'event AccessGranted(uint256 indexed filmId, address indexed viewer, uint256 tokenId)'
            ];
            this.contract = new this.web3.eth.Contract(abi, this.contractAddress);
        }
    }

    async connectWallet() {
        if (!window.ethereum) {
            throw new Error('MetaMask is not installed');
        }
        const accounts = await window.ethereum.request({
            method: 'eth_requestAccounts'
        });
        this.connectedAccount = accounts[0];
        return this.connectedAccount;
    }

    async loadFilmFromChain(filmId) {
        if (!this.contract) {
            throw new Error('Contract not initialized');
        }
        const film = await this.contract.methods.films(filmId).call();
        this.currentFilm = {
            id: filmId,
            title: film.title,
            director: film.director,
            year: Number(film.year),
            ipfsCID: film.ipfsCID,
            arweaveTx: film.arweaveTx,
            encryptedKey: film.encryptedKey,
            totalSupply: Number(film.totalSupply),
            mintedCount: Number(film.mintedCount),
            isActive: film.isActive
        };
        return this.currentFilm;
    }

    async checkAccess(filmId, address) {
        if (!this.contract) return false;
        return await this.contract.methods.verifyAccess(filmId, address).call();
    }

    async fetchFromIPFS(cid) {
        const url = `${this.ipfsGateway}${cid}`;
        const response = await fetch(url, { mode: 'cors' });
        if (!response.ok) {
            throw new Error(`IPFS fetch failed: ${response.statusText}`);
        }
        return response;
    }

    async fetchFromArweave(txId) {
        const url = `${this.arweaveGateway}${txId}`;
        const response = await fetch(url, { mode: 'cors' });
        if (!response.ok) {
            throw new Error(`Arweave fetch failed: ${response.statusText}`);
        }
        return response;
    }

    async streamFilm(filmId, container) {
        const film = this.currentFilm || await this.loadFilmFromChain(filmId);
        const hasAccess = await this.checkAccess(filmId, this.connectedAccount);

        if (!hasAccess) {
            container.innerHTML = `
                <div class="access-denied">
                    <h3>访问受限</h3>
                    <p>您需要持有该电影的NFT访问令牌才能观看。</p>
                    <button onclick="browser.mintAndPlay(${filmId})">
                        铸造NFT — 获取访问权限
                    </button>
                </div>
            `;
            return;
        }

        // Try IPFS first, fall back to Arweave
        let videoUrl = null;
        try {
            const ipfsResponse = await this.fetchFromIPFS(film.ipfsCID);
            const blob = await ipfsResponse.blob();
            videoUrl = URL.createObjectURL(blob);
        } catch (ipfsError) {
            console.warn('IPFS fetch failed, trying Arweave:', ipfsError);
            try {
                const arweaveResponse = await this.fetchFromArweave(film.arweaveTx);
                const blob = await arweaveResponse.blob();
                videoUrl = URL.createObjectURL(blob);
            } catch (arweaveError) {
                console.error('Both IPFS and Arweave failed:', arweaveError);
                container.innerHTML = `
                    <div class="error">
                        <h3>加载失败</h3>
                        <p>无法从去中心化存储网络获取影片内容。</p>
                        <p>请稍后重试，或联系档案管理员。</p>
                    </div>
                `;
                return;
            }
        }

        // Display film metadata and player
        container.innerHTML = `
            <div class="film-player">
                <div class="film-metadata">
                    <h2>${film.title}</h2>
                    <p>导演: ${film.director} | 年份: ${film.year}</p>
                    <p>档案ID: #${film.id} | 存储: IPFS + Arweave</p>
                </div>
                <video controls width="100%" crossorigin="anonymous">
                    <source src="${videoUrl}" type="video/mp4">
                    您的浏览器不支持视频播放
                </video>
                <div class="archive-info">
                    <p>🔗 IPFS: <a href="${this.ipfsGateway}${film.ipfsCID}" target="_blank">${film.ipfsCID.slice(0, 20)}...</a></p>
                    <p>🔗 Arweave: <a href="${this.arweaveGateway}${film.arweaveTx}" target="_blank">${film.arweaveTx.slice(0, 20)}...</a></p>
                    <p>🗂️ 供应量: ${film.mintedCount}/${film.totalSupply} 已铸造</p>
                </div>
            </div>
        `;
    }

    async mintAndPlay(filmId) {
        if (!this.connectedAccount) {
            await this.connectWallet();
        }
        try {
            const result = await this.contract.methods.mintAccessToken(filmId).send({
                from: this.connectedAccount,
                value: this.web3.utils.toWei('0.01', 'ether')
            });
            console.log('NFT minted:', result.transactionHash);
            // Refresh and play
            const container = document.querySelector('#film-player');
            await this.streamFilm(filmId, container);
        } catch (error) {
            console.error('Mint failed:', error);
            alert('铸造NFT失败，请检查钱包余额和网络连接。');
        }
    }

    async searchArchive(keyword) {
        if (!this.contract) return [];
        const filmCount = await this.contract.methods.filmCounter().call();
        const results = [];
        for (let i = 1; i <= Number(filmCount); i++) {
            const film = await this.contract.methods.films(i).call();
            if (film.title.toLowerCase().includes(keyword.toLowerCase()) ||
                film.director.toLowerCase().includes(keyword.toLowerCase())) {
                results.push({
                    id: i,
                    title: film.title,
                    director: film.director,
                    year: Number(film.year)
                });
            }
        }
        return results;
    }

    async generateManifest(filmId) {
        const film = this.currentFilm || await this.loadFilmFromChain(filmId);
        const manifest = {
            "@context": "https://www.w3.org/ns/activitystreams",
            type: "FilmArchive",
            id: `urn:film:${filmId}`,
            title: film.title,
            director: film.director,
            year: film.year,
            storage: {
                primary: {
                    network: "IPFS",
                    cid: film.ipfsCID,
                    gateway: `${this.ipfsGateway}${film.ipfsCID}`
                },
                backup: {
                    network: "Arweave",
                    transactionId: film.arweaveTx,
                    gateway: `${this.arweaveGateway}${film.arweaveTx}`
                }
            },
            access: {
                type: "NFT-gated",
                contract: this.contractAddress,
                tokenSupply: film.totalSupply,
                tokensMinted: film.mintedCount
            },
            verifiedAt: new Date().toISOString()
        };
        return manifest;
    }
}

// Usage example
const browser = new FilmArchiveBrowser(
    'https://mainnet.infura.io/v3/YOUR_KEY',
    '0x1234567890abcdef...'
);

// Connect wallet on page load
document.addEventListener('DOMContentLoaded', async () => {
    try {
        await browser.connectWallet();
        console.log('Connected:', browser.connectedAccount);
    } catch (e) {
        console.log('Please install MetaMask');
    }
});