数字资产托管与影视基金：机构级DeFi的合规路径

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

contract FilmFundCustody is AccessControl, ReentrancyGuard {
    bytes32 public constant CUSTODIAN_ROLE = keccak256("CUSTODIAN_ROLE");
    bytes32 public constant AUDITOR_ROLE = keccak256("AUDITOR_ROLE");
    bytes32 public constant FUND_MANAGER_ROLE = keccak256("FUND_MANAGER_ROLE");

    enum AssetType {
        STABLE_COIN,
        GOVERNANCE_TOKEN,
        NFT,
        LP_TOKEN,
        REAL_WORLD_ASSET,
        OTHER
    }

    enum CustodyTier {
        BASIC,
        STANDARD,
        ENTERPRISE,
        INSTITUTIONAL
    }

    enum FundStatus {
        FORMING,
        ACTIVE,
        LOCKED,
        DISTRIBUTING,
        CLOSED
    }

    struct CustodyAccount {
        address accountAddress;
        string fundName;
        CustodyTier tier;
        uint256 totalValue;
        uint256 assetCount;
        uint256 createdAt;
        uint256 lastAudit;
        bool isActive;
        bool isMultiSig;
        address[] signers;
        uint256 requiredSignatures;
    }

    struct Asset {
        bytes32 assetId;
        address assetAddress;
        uint256 tokenId;            // for ERC721
        AssetType assetType;
        uint256 amount;
        uint256 value;
        uint256 depositedAt;
        uint256 lastValuation;
        address depositor;
        bool isFrozen;
        bool isWithdrawn;
    }

    struct FundInvestment {
        uint256 investmentId;
        string filmTitle;
        address fundAddress;
        uint256 investedAmount;
        uint256 currentValue;
        uint256 investmentDate;
        uint256 expectedReturn;
        bool isRealized;
        uint256 realizedReturn;
        string ipfsDocumentURI;
    }

    struct AuditReport {
        uint256 reportId;
        address accountAddress;
        uint256 totalAssetsHeld;
        uint256 totalValue;
        uint256 proofOfReserves;
        uint256 timestamp;
        bytes32 auditHash;
        address auditor;
        bool passed;
    }

    mapping(address => CustodyAccount) public custodyAccounts;
    mapping(bytes32 => Asset) public assets;
    mapping(uint256 => FundInvestment) public investments;
    mapping(uint256 => AuditReport) public auditReports;
    mapping(address => bytes32[]) public accountAssets;
    mapping(address => uint256[]) public fundInvestments;

    uint256 private _investmentCounter;
    uint256 private _auditCounter;
    uint256 private _assetCounter;

    uint256 public constant MIN_AUDIT_INTERVAL = 90 days;
    uint256 public constant MAX_SIGNERS = 10;
    uint256 public constant MIN_SIGNERS = 2;

    event AccountCreated(
        address indexed accountAddress,
        string fundName,
        CustodyTier tier,
        uint256 requiredSignatures
    );

    event AssetDeposited(
        bytes32 indexed assetId,
        address indexed assetAddress,
        AssetType assetType,
        uint256 amount
    );

    event AssetWithdrawn(
        bytes32 indexed assetId,
        address indexed beneficiary
    );

    event InvestmentMade(
        uint256 indexed investmentId,
        string filmTitle,
        uint256 amount
    );

    event InvestmentRealized(
        uint256 indexed investmentId,
        uint256 realizedReturn
    );

    event AuditCompleted(
        uint256 indexed reportId,
        address indexed accountAddress,
        bool passed
    );

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(CUSTODIAN_ROLE, msg.sender);
        _grantRole(AUDITOR_ROLE, msg.sender);
        _grantRole(FUND_MANAGER_ROLE, msg.sender);
    }

    function createCustodyAccount(
        string memory _fundName,
        CustodyTier _tier,
        address[] memory _signers,
        uint256 _requiredSignatures
    ) external returns (address) {
        require(_signers.length >= MIN_SIGNERS && _signers.length <= MAX_SIGNERS, "Invalid signers count");
        require(_requiredSignatures > 0 && _requiredSignatures <= _signers.length, "Invalid required sigs");

        custodyAccounts[msg.sender] = CustodyAccount({
            accountAddress: msg.sender,
            fundName: _fundName,
            tier: _tier,
            totalValue: 0,
            assetCount: 0,
            createdAt: block.timestamp,
            lastAudit: 0,
            isActive: true,
            isMultiSig: _signers.length > 1,
            signers: _signers,
            requiredSignatures: _requiredSignatures
        });

        _grantRole(CUSTODIAN_ROLE, msg.sender);

        emit AccountCreated(msg.sender, _fundName, _tier, _requiredSignatures);
        return msg.sender;
    }

    function depositAsset(
        address _assetAddress,
        AssetType _assetType,
        uint256 _amount,
        uint256 _tokenId,
        uint256 _value
    ) external returns (bytes32) {
        CustodyAccount storage account = custodyAccounts[msg.sender];
        require(account.isActive, "Account not active");

        _assetCounter++;
        bytes32 assetId = keccak256(abi.encodePacked(_assetCounter, _assetAddress, block.timestamp));

        if (_assetType == AssetType.NFT) {
            IERC721(_assetAddress).transferFrom(msg.sender, address(this), _tokenId);
        } else {
            IERC20(_assetAddress).transferFrom(msg.sender, address(this), _amount);
        }

        assets[assetId] = Asset({
            assetId: assetId,
            assetAddress: _assetAddress,
            tokenId: _tokenId,
            assetType: _assetType,
            amount: _amount,
            value: _value,
            depositedAt: block.timestamp,
            lastValuation: block.timestamp,
            depositor: msg.sender,
            isFrozen: false,
            isWithdrawn: false
        });

        accountAssets[msg.sender].push(assetId);
        account.totalValue += _value;
        account.assetCount++;

        emit AssetDeposited(assetId, _assetAddress, _assetType, _amount);
        return assetId;
    }

    function withdrawAsset(
        bytes32 _assetId,
        address _beneficiary
    ) external nonReentrant {
        Asset storage asset = assets[_assetId];
        require(!asset.isWithdrawn, "Already withdrawn");
        require(!asset.isFrozen, "Asset frozen");

        asset.isWithdrawn = true;

        if (asset.assetType == AssetType.NFT) {
            IERC721(asset.assetAddress).transferFrom(address(this), _beneficiary, asset.tokenId);
        } else {
            IERC20(asset.assetAddress).transfer(_beneficiary, asset.amount);
        }

        CustodyAccount storage account = custodyAccounts[asset.depositor];
        account.totalValue -= asset.value;
        account.assetCount--;

        emit AssetWithdrawn(_assetId, _beneficiary);
    }

    function makeInvestment(
        string memory _filmTitle,
        uint256 _amount,
        uint256 _expectedReturn,
        string memory _ipfsDocumentURI
    ) external onlyRole(FUND_MANAGER_ROLE) returns (uint256) {
        _investmentCounter++;
        uint256 investmentId = _investmentCounter;

        investments[investmentId] = FundInvestment({
            investmentId: investmentId,
            filmTitle: _filmTitle,
            fundAddress: msg.sender,
            investedAmount: _amount,
            currentValue: _amount,
            investmentDate: block.timestamp,
            expectedReturn: _expectedReturn,
            isRealized: false,
            realizedReturn: 0,
            ipfsDocumentURI: _ipfsDocumentURI
        });

        fundInvestments[msg.sender].push(investmentId);

        emit InvestmentMade(investmentId, _filmTitle, _amount);
        return investmentId;
    }

    function realizeInvestment(
        uint256 _investmentId,
        uint256 _realizedReturn
    ) external onlyRole(FUND_MANAGER_ROLE) {
        FundInvestment storage investment = investments[_investmentId];
        require(!investment.isRealized, "Already realized");

        investment.isRealized = true;
        investment.realizedReturn = _realizedReturn;
        investment.currentValue = _realizedReturn;

        emit InvestmentRealized(_investmentId, _realizedReturn);
    }

    function conductAudit(
        address _accountAddress
    ) external onlyRole(AUDITOR_ROLE) returns (uint256) {
        CustodyAccount storage account = custodyAccounts[_accountAddress];
        require(account.isActive, "Account not active");
        require(
            block.timestamp - account.lastAudit >= MIN_AUDIT_INTERVAL || account.lastAudit == 0,
            "Audit interval not met"
        );

        _auditCounter++;
        uint256 reportId = _auditCounter;

        bytes32[] memory assetIds = accountAssets[_accountAddress];
        uint256 totalValue = 0;
        uint256 assetCount = 0;

        for (uint256 i = 0; i < assetIds.length; i++) {
            Asset storage asset = assets[assetIds[i]];
            if (!asset.isWithdrawn) {
                totalValue += asset.value;
                assetCount++;
            }
        }

        bool passed = (totalValue >= account.totalValue * 95 / 100); // 允许5%的误差

        auditReports[reportId] = AuditReport({
            reportId: reportId,
            accountAddress: _accountAddress,
            totalAssetsHeld: assetCount,
            totalValue: totalValue,
            proofOfReserves: totalValue,
            timestamp: block.timestamp,
            auditHash: keccak256(abi.encodePacked(reportId, _accountAddress, totalValue, block.timestamp)),
            auditor: msg.sender,
            passed: passed
        });

        account.lastAudit = block.timestamp;

        emit AuditCompleted(reportId, _accountAddress, passed);
        return reportId;
    }

    function getAccountSummary(address _accountAddress) external view returns (CustodyAccount memory) {
        return custodyAccounts[_accountAddress];
    }

    function getAssetDetails(bytes32 _assetId) external view returns (Asset memory) {
        return assets[_assetId];
    }

    function getInvestmentDetails(uint256 _investmentId) external view returns (FundInvestment memory) {
        return investments[_investmentId];
    }

    function getAccountAssets(address _accountAddress) external view returns (bytes32[] memory) {
        return accountAssets[_accountAddress];
    }
}

import json
import time
import hashlib
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
from enum import Enum

class CustodyTier(Enum):
    BASIC = "basic"
    STANDARD = "standard"
    ENTERPRISE = "enterprise"
    INSTITUTIONAL = "institutional"

class AssetType(Enum):
    STABLE_COIN = "stablecoin"
    GOVERNANCE_TOKEN = "governance_token"
    NFT = "nft"
    LP_TOKEN = "lp_token"
    RWA = "real_world_asset"

class FundStatus(Enum):
    FORMING = "forming"
    ACTIVE = "active"
    LOCKED = "locked"
    DISTRIBUTING = "distributing"
    CLOSED = "closed"

@dataclass
class CustodyAccount:
    address: str
    fund_name: str
    tier: CustodyTier
    total_value: int
    asset_count: int
    created_at: int
    last_audit: int
    is_active: bool
    signers: List[str]
    required_sigs: int

@dataclass
class Asset:
    asset_id: str
    asset_address: str
    asset_type: AssetType
    amount: int
    value: int
    deposited_at: int
    depositor: str
    is_withdrawn: bool

@dataclass
class FilmInvestment:
    investment_id: int
    film_title: str
    amount: int
    current_value: int
    investment_date: int
    expected_return: float
    is_realized: bool
    realized_return: int

@dataclass
class AuditReport:
    report_id: int
    account: str
    total_assets: int
    total_value: int
    timestamp: int
    passed: bool


class FilmFundCustodyManager:
    """
    影视基金数字资产托管系统
    """

    def __init__(self):
        self.accounts: Dict[str, CustodyAccount] = {}
        self.assets: Dict[str, Asset] = {}
        self.investments: Dict[int, FilmInvestment] = {}
        self.audits: Dict[int, AuditReport] = {}
        self.account_assets: Dict[str, List[str]] = {}
        self.investment_counter = 0
        self.audit_counter = 0
        self.asset_counter = 0

    def _hash(self, *args) -> str:
        return hashlib.sha256(":".join(str(a) for a in args).encode()).hexdigest()

    def create_custody_account(
        self,
        address: str,
        fund_name: str,
        tier: CustodyTier,
        signers: List[str],
        required_sigs: int
    ) -> str:
        if address in self.accounts:
            raise ValueError(f"账户 {address[:8]} 已存在")

        if required_sigs > len(signers):
            raise ValueError("要求签名数超过签名人总数")

        account = CustodyAccount(
            address=address,
            fund_name=fund_name,
            tier=tier,
            total_value=0,
            asset_count=0,
            created_at=int(time.time()),
            last_audit=0,
            is_active=True,
            signers=signers,
            required_sigs=required_sigs
        )

        self.accounts[address] = account
        self.account_assets[address] = []

        print(f"[托管账户] {address[:8]}: {fund_name}")
        print(f"  等级: {tier.value}, 签名人: {len(signers)}, 要求: {required_sigs}")

        return address

    def deposit_asset(
        self,
        account_address: str,
        depositor: str,
        asset_address: str,
        asset_type: AssetType,
        amount: int,
        value: int
    ) -> str:
        if account_address not in self.accounts:
            raise ValueError(f"账户 {account_address[:8]} 不存在")

        account = self.accounts[account_address]
        if not account.is_active:
            raise ValueError("账户已停用")

        self.asset_counter += 1
        asset_id = self._hash(str(self.asset_counter), asset_address, str(time.time()))

        asset = Asset(
            asset_id=asset_id,
            asset_address=asset_address,
            asset_type=asset_type,
            amount=amount,
            value=value,
            deposited_at=int(time.time()),
            depositor=depositor,
            is_withdrawn=False
        )

        self.assets[asset_id] = asset
        self.account_assets[account_address].append(asset_id)
        account.total_value += value
        account.asset_count += 1

        print(f"[存入] {asset_id[:16]}...: {amount} {asset_type.value}")
        print(f"  价值: ${value:,}, 账户: {account_address[:8]}")

        return asset_id

    def withdraw_asset(
        self,
        asset_id: str,
        beneficiary: str,
        signatures: List[str]
    ) -> bool:
        if asset_id not in self.assets:
            raise ValueError(f"资产 {asset_id[:16]}... 不存在")

        asset = self.assets[asset_id]
        if asset.is_withdrawn:
            raise ValueError("资产已提取")

        # 查找账户并验证签名
        for addr, acc in self.accounts.items():
            if asset_id in self.account_assets.get(addr, []):
                if len(signatures) < acc.required_sigs:
                    raise ValueError(f"签名不足: 需要{acc.required_sigs}, 收到{len(signatures)}")

                # 验证签名人
                valid_sigs = sum(1 for s in signatures if s in acc.signers)
                if valid_sigs < acc.required_sigs:
                    raise ValueError(f"有效签名不足")

                acc.total_value -= asset.value
                acc.asset_count -= 1
                break

        asset.is_withdrawn = True

        print(f"[提取] {asset_id[:16]}... → {beneficiary[:8]}")
        print(f"  签名: {len(signatures)}/{len(signatures)} 有效")

        return True

    def make_investment(
        self,
        fund_address: str,
        film_title: str,
        amount: int,
        expected_return: float
    ) -> int:
        self.investment_counter += 1
        investment_id = self.investment_counter

        investment = FilmInvestment(
            investment_id=investment_id,
            film_title=film_title,
            amount=amount,
            current_value=amount,
            investment_date=int(time.time()),
            expected_return=expected_return,
            is_realized=False,
            realized_return=0
        )

        self.investments[investment_id] = investment

        print(f"[投资] #{investment_id}: {film_title}")
        print(f"  金额: ${amount:,}, 预期回报: {expected_return:.1%}")

        return investment_id

    def realize_investment(
        self,
        investment_id: int,
        realized_return: int
    ) -> bool:
        if investment_id not in self.investments:
            raise ValueError(f"投资 #{investment_id} 不存在")

        investment = self.investments[investment_id]
        if investment.is_realized:
            raise ValueError("投资已实现")

        investment.is_realized = True
        investment.realized_return = realized_return
        investment.current_value = realized_return

        roi = (realized_return - investment.amount) / investment.amount
        print(f"[实现] #{investment_id}: {investment.film_title}")
        print(f"  投入: ${investment.amount:,}, 回报: ${realized_return:,}")
        print(f"  ROI: {roi:.1%}")

        return True

    def conduct_audit(
        self,
        account_address: str,
        auditor: str
    ) -> Dict:
        if account_address not in self.accounts:
            raise ValueError(f"账户 {account_address[:8]} 不存在")

        account = self.accounts[account_address]
        if not account.is_active:
            raise ValueError("账户已停用")

        self.audit_counter += 1
        report_id = self.audit_counter

        # 计算资产总额
        asset_ids = self.account_assets.get(account_address, [])
        total_value = 0
        active_count = 0

        for aid in asset_ids:
            if aid in self.assets and not self.assets[aid].is_withdrawn:
                total_value += self.assets[aid].value
                active_count += 1

        # 允许5%的误差
        expected_value = account.total_value
        variance = abs(total_value - expected_value) / max(expected_value, 1)
        passed = variance <= 0.05

        report = AuditReport(
            report_id=report_id,
            account=account_address,
            total_assets=active_count,
            total_value=total_value,
            timestamp=int(time.time()),
            passed=passed
        )

        self.audits[report_id] = report
        account.last_audit = int(time.time())

        print(f"[审计] #{report_id}: {account.fund_name}")
        print(f"  资产: {active_count}项, 总值: ${total_value:,}")
        print(f"  预期: ${expected_value:,}, 偏差: {variance:.2%}")
        print(f"  结果: {'通过' if passed else '未通过'}")

        return {
            "report_id": report_id,
            "total_assets": active_count,
            "total_value": total_value,
            "expected_value": expected_value,
            "variance": variance,
            "passed": passed,
            "auditor": auditor
        }

    def get_fund_performance(self, account_address: str) -> Dict:
        if account_address not in self.accounts:
            raise ValueError(f"账户 {account_address[:8]} 不存在")

        account = self.accounts[account_address]
        fund_investments = [i for i in self.investments.values()]

        total_invested = sum(i.amount for i in fund_investments)
        total_current = sum(i.current_value for i in fund_investments)
        total_realized = sum(i.realized_return for i in fund_investments if i.is_realized)

        performance = {
            "fund_name": account.fund_name,
            "total_invested": total_invested,
            "total_current_value": total_current,
            "total_realized": total_realized,
            "unrealized_pnl": total_current - total_invested,
            "realized_pnl": total_realized - total_invested,
            "investment_count": len(fund_investments),
            "realized_count": sum(1 for i in fund_investments if i.is_realized),
            "roi": (total_current - total_invested) / total_invested if total_invested > 0 else 0
        }

        return performance

    def simulate_fund_operations(self) -> Dict:
        """
        模拟影视基金的数字资产托管
        """
        print(f"\n{'='*60}")
        print(f"  影视基金数字资产托管模拟")
        print(f"  机构级DeFi的合规路径")
        print(f"{'='*60}\n")

        # 1. 创建托管账户
        print(">>> 1. 创建基金托管账户\n")
        fund_account = self.create_custody_account(
            address="0xFilmFund...Alpha",
            fund_name="Alpha Film Fund I",
            tier=CustodyTier.INSTITUTIONAL,
            signers=["0xFundMgr...Main", "0xFundMgr...Compliance", "0xAuditor...External"],
            required_sigs=2
        )

        # 2. 存入资产
        print("\n>>> 2. 存入数字资产\n")
        self.deposit_asset(
            account_address=fund_account,
            depositor="0xInvestor...Institution",
            asset_address="0xUSDC...Stable",
            asset_type=AssetType.STABLE_COIN,
            amount=5000000,
            value=5000000
        )

        self.deposit_asset(
            account_address=fund_account,
            depositor="0xInvestor...Fund",
            asset_address="0xNFT...FilmIP",
            asset_type=AssetType.NFT,
            amount=1,
            value=2000000
        )

        # 3. 影视投资
        print("\n>>> 3. 影视投资\n")
        inv1 = self.make_investment(
            fund_address=fund_account,
            film_title="《链上蒙太奇：区块链纪录片》",
            amount=2000000,
            expected_return=1.5
        )

        inv2 = self.make_investment(
            fund_address=fund_account,
            film_title="《DeFi叙事：去中心化金融电影》",
            amount=1500000,
            expected_return=1.8
        )

        inv3 = self.make_investment(
            fund_address=fund_account,
            film_title="《Token化时代：三部曲动画》",
            amount=3000000,
            expected_return=2.0
        )

        # 4. 多签提取
        print("\n>>> 4. 多签提取\n")
        asset_ids = self.account_assets.get(fund_account, [])
        if asset_ids:
            self.withdraw_asset(
                asset_id=asset_ids[0],
                beneficiary="0xFilmProd...Studio",
                signatures=["0xFundMgr...Main", "0xFundMgr...Compliance"]
            )

        # 5. 投资实现
        print("\n>>> 5. 投资回报实现\n")
        self.realize_investment(inv1, 3500000)
        self.realize_investment(inv2, 2800000)

        # 6. 审计
        print("\n>>> 6. 机构级审计\n")
        audit_result = self.conduct_audit(
            account_address=fund_account,
            auditor="Deloitte_Crypto_Audit"
        )

        # 7. 基金表现
        print("\n>>> 7. 基金表现\n")
        performance = self.get_fund_performance(fund_account)
        print(f"  总投资: ${performance['total_invested']:,}")
        print(f"  当前价值: ${performance['total_current_value']:,}")
        print(f"  已实现回报: ${performance['total_realized']:,}")
        print(f"  未实现盈亏: ${performance['unrealized_pnl']:,}")
        print(f"  ROI: {performance['roi']:.1%}")
        print(f"  投资数: {performance['investment_count']}, 已实现: {performance['realized_count']}")

        print(f"\n{'='*60}")
        print(f"  模拟完成")
        print(f"{'='*60}")

        return {
            "fund_account": fund_account,
            "investments": 3,
            "total_invested": performance["total_invested"],
            "roi": performance["roi"],
            "audit_passed": audit_result["passed"]
        }


def main():
    manager = FilmFundCustodyManager()
    result = manager.simulate_fund_operations()

    print(f"\n=== 模拟结果 ===")
    print(f"基金账户: {result['fund_account'][:8]}...")
    print(f"投资数: {result['investments']}")
    print(f"总投资: ${result['total_invested']:,}")
    print(f"ROI: {result['roi']:.1%}")
    print(f"审计通过: {result['audit_passed']}")


if __name__ == "__main__":
    main()