MiCA牌照与全球加密监管：内容产业的合规新纪元

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

/// @title MiCA合规内容版权结算合约
/// @notice 实现符合MiCA法案要求的链上影视版权收益分配
contract MiCACompliantRoyalty {

    struct RoyaltySplit {
        address payable creator;      // 创作者地址
        uint256 basisPoints;          // 分成比例（基点，10000=100%）
        bool    isVerified;           // 是否通过KYC验证
    }

    struct ContentLicense {
        bytes32  contentHash;        // 影视作品的哈希指纹
        address  paymentToken;        // 稳定币地址（须为MiCA合规EMT）
        uint256  pricePerView;        // 单次观影价格
        uint256  totalRevenue;       // 累计收入
        bool     isActive;            // 发行许可是否有效
        mapping(address => RoyaltySplit) splits;
        address[] payees;
    }

    mapping(bytes32 => ContentLicense) private licenses;
    address public complianceOracle;  // 合规验证预言机地址
    uint256 public constant MAX_BASIS_POINTS = 10000;

    event LicenseIssued(bytes32 indexed contentId, address indexed issuer, uint256 price);
    event RevenueDistributed(bytes32 indexed contentId, uint256 totalAmount);
    event PayeeVerified(address indexed payee, bool status);

    modifier onlyCompliantToken(address token) {
        // 通过合规预言机验证稳定币是否为MiCA合规EMT
        require(
            IComplianceOracle(complianceOracle).isMiCACompliantEMT(token),
            "Payment token is not MiCA-compliant EMT"
        );
        _;
    }

    modifier onlyVerifiedPayee(bytes32 contentId, address payee) {
        require(
            licenses[contentId].splits[payee].isVerified,
            "Payee has not completed MiCA KYC verification"
        );
        _;
    }

    /// @notice 发行内容许可——类比"院线发行许可"
    function issueLicense(
        bytes32 contentId,
        bytes32 contentHash,
        address paymentToken,
        uint256 pricePerView
    ) external onlyCompliantToken(paymentToken) returns (bool) {
        ContentLicense storage license = licenses[contentId];
        require(!license.isActive, "License already issued");
        require(pricePerView > 0, "Price must be positive");

        license.contentHash   = contentHash;
        license.paymentToken  = paymentToken;
        license.pricePerView  = pricePerView;
        license.isActive      = true;

        emit LicenseIssued(contentId, msg.sender, pricePerView);
        return true;
    }

    /// @notice 设置收益分成——类比"票房分账协议"
    function setRoyaltySplit(
        bytes32 contentId,
        address payable payee,
        uint256 basisPoints
    ) external returns (bool) {
        ContentLicense storage license = licenses[contentId];
        require(license.isActive, "License not active");
        require(basisPoints > 0 && basisPoints <= MAX_BASIS_POINTS, "Invalid basis points");

        if (license.splits[payee].creator == address(0)) {
            license.payees.push(payee);
        }
        license.splits[payee].creator     = payee;
        license.splits[payee].basisPoints = basisPoints;

        // 触发合规预言机进行MiCA KYC验证
        IComplianceOracle(complianceOracle).requestVerification(payee);
        return true;
    }

    /// @notice 观众支付观影——类比"票房购票"
    function payForView(bytes32 contentId) external payable returns (bool) {
        ContentLicense storage license = licenses[contentId];
        require(license.isActive, "License not active");

        require(
            IERC20(license.paymentToken).transferFrom(
                msg.sender, address(this), license.pricePerView
            ),
            "Payment transfer failed"
        );

        license.totalRevenue += license.pricePerView;
        return true;
    }

    /// @notice 分配收益——类比"票房结算"
    function distributeRevenue(bytes32 contentId)
        external
        returns (bool)
    {
        ContentLicense storage license = licenses[contentId];
        require(license.isActive, "License not active");

        uint256 totalBasis = 0;
        for (uint i = 0; i < license.payees.length; i++) {
            totalBasis += license.splits[license.payees[i]].basisPoints;
        }
        require(totalBasis == MAX_BASIS_POINTS, "Splits must sum to 100%");

        for (uint i = 0; i < license.payees.length; i++) {
            address payee = license.payees[i];
            if (license.splits[payee].isVerified) {
                uint256 amount = (license.totalRevenue *
                    license.splits[payee].basisPoints) / MAX_BASIS_POINTS;
                require(
                    IERC20(license.paymentToken).transfer(payee, amount),
                    "Distribution failed"
                );
            }
        }

        license.totalRevenue = 0;
        emit RevenueDistributed(contentId, license.totalRevenue);
        return true;
    }

    /// @notice 预言机回写KYC验证结果
    function updateVerification(address payee, bool status)
        external
    {
        require(msg.sender == complianceOracle, "Only oracle");
        for (uint i = 0; i < bytes32(0).length; i++) {
            // 遍历所有许可更新验证状态（简化实现）
        }
        emit PayeeVerified(payee, status);
    }
}

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

interface IComplianceOracle {
    function isMiCACompliantEMT(address token) external view returns (bool);
    function requestVerification(address payee) external;
}

"""
NFT影视作品合规分类器
基于Howey测试与CLARITY Act框架的自动化分级工具
"""

from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional


class RegulatoryClass(Enum):
    """监管分级——类比电影审查级别"""
    FUNCTIONAL = "功能性资产（排除证券定义）"
    INVESTMENT_CONTRACT = "投资合同（SEC监管）"
    COMMODITY = "商品（CFTC监管）"
    UNCERTAIN = "需个案审查"


@dataclass
class NFTProject:
    """NFT影视项目元数据"""
    name: str
    content_type: str                    # film, series, music, animation
    purchase_purpose: List[str]          # 购买目的
    promises_profit: bool                # 是否承诺利润
    shares_revenue: bool                 # 是否分享项目收益
    voting_rights: str                   # 投票权类型
    decentralization_level: float        # 去中心化程度（0.0-1.0）
    disclosure_complete: bool            # 信息披露是否完整
    secondary_market_active: bool        # 二级市场是否活跃


class MiCAHoweyClassifier:
    """MiCA + Howey + CLARITY 三重合规分类器"""

    SECURITIES_THRESHOLDS = {
        "profit_promise": 0.85,
        "revenue_share": 0.90,
        "decentralization_exempt": 0.80
    }

    def classify(self, project: NFTProject) -> RegulatoryClass:
        """执行分级审查"""
        howey_score = self._howey_analysis(project)
        clarity_exemption = self._clarity_exemption(project)

        if howey_score >= self.SECURITIES_THRESHOLDS["revenue_share"] \
           and project.shares_revenue:
            return RegulatoryClass.INVESTMENT_CONTRACT

        if project.purchase_purpose == ["viewing"] \
           and not project.promises_profit \
           and not project.shares_revenue:
            return RegulatoryClass.FUNCTIONAL

        if clarity_exemption and project.secondary_market_active:
            return RegulatoryClass.COMMODITY

        return RegulatoryClass.UNCERTAIN

    def _howey_analysis(self, project: NFTProject) -> float:
        """Howey四要素评分"""
        score = 0.0
        # 要素1：投资金钱
        score += 0.25
        # 要素2：共同企业
        score += 0.25
        # 要素3：预期利润
        if project.promises_profit:
            score += 0.25
        # 要素4：来自他人努力
        if project.shares_revenue and project.decentralization_level < 0.5:
            score += 0.25
        return score

    def _clarity_exemption(self, project: NFTProject) -> bool:
        """CLARITY Act豁免判定"""
        return (
            project.decentralization_level
            >= self.SECURITIES_THRESHOLDS["decentralization_exempt"]
            and project.disclosure_complete
        )

    def generate_compliance_report(
        self, project: NFTProject
    ) -> dict:
        """生成合规报告——类比"审查分级意见书""""
        classification = self.classify(project)
        return {
            "project_name": project.name,
            "content_type": project.content_type,
            "classification": classification.value,
            "howey_score": self._howey_analysis(project),
            "clarity_exemption": self._clarity_exemption(project),
            "mica_category": self._mica_mapping(classification),
            "required_disclosures": self._get_disclosures(classification),
            "jurisdiction_notes": self._jurisdiction_notes(project),
        }

    def _mica_mapping(self, classification: RegulatoryClass) -> str:
        """映射到MiCA分类"""
        mapping = {
            RegulatoryClass.FUNCTIONAL: "其他加密资产（轻监管）",
            RegulatoryClass.INVESTMENT_CONTRACT: "受MiCA白皮书条款约束",
            RegulatoryClass.COMMODITY: "其他加密资产（轻监管）",
            RegulatoryClass.UNCERTAIN: "需提交ESMA个案审查",
        }
        return mapping.get(classification, "未分类")

    def _get_disclosures(self, classification: RegulatoryClass) -> List[str]:
        """获取所需披露文件清单"""
        disclosures = {
            RegulatoryClass.FUNCTIONAL: [
                "功能用途声明",
                "无投资承诺声明",
                "使用条款与条件"
            ],
            RegulatoryClass.INVESTMENT_CONTRACT: [
                "MiCA合规白皮书",
                "Howey测试分析报告",
                "风险披露文件",
                "发行方资质证明",
                "审计财务报告"
            ],
            RegulatoryClass.COMMODITY: [
                "去中心化程度证明",
                "信息披露完整报告",
                "二级市场流动性说明"
            ],
            RegulatoryClass.UNCERTAIN: [
                "ESMA预审申请",
                "法律意见书",
                "完整项目白皮书",
                "代币经济模型文档"
            ],
        }
        return disclosures.get(classification, [])

    def _jurisdiction_notes(self, project: NFTProject) -> str:
        """跨境合规提示"""
        notes = []
        if project.secondary_market_active:
            notes.append("二级市场流通需同时满足MiCA与CLARITY要求")
        if project.shares_revenue:
            notes.append("收益分成模式触发多国证券法管辖")
        if project.decentralization_level < 0.5:
            notes.append("中心化程度高，发行方需承担更多合规义务")
        return " | ".join(notes) if notes else "无特殊跨境合规要求"


# 使用示例：对一部NFT影视项目执行合规分类
if __name__ == "__main__":
    viewing_nft = NFTProject(
        name="《链上蒙太奇》观影NFT",
        content_type="film",
        purchase_purpose=["viewing"],
        promises_profit=False,
        shares_revenue=False,
        voting_rights="none",
        decentralization_level=0.3,
        disclosure_complete=True,
        secondary_market_active=True
    )

    investment_nft = NFTProject(
        name="《链上蒙太奇》版权分成NFT",
        content_type="film",
        purchase_purpose=["investment", "viewing"],
        promises_profit=True,
        shares_revenue=True,
        voting_rights="financial_decisions",
        decentralization_level=0.4,
        disclosure_complete=False,
        secondary_market_active=False
    )

    classifier = MiCAHoweyClassifier()

    for project in [viewing_nft, investment_nft]:
        report = classifier.generate_compliance_report(project)
        print(f"\n{'='*60}")
        print(f"项目：{report['project_name']}")
        print(f"分级：{report['classification']}")
        print(f"MiCA类别：{report['mica_category']}")
        print(f"Howey评分：{report['howey_score']:.2f}")
        print(f"所需披露：{', '.join(report['required_disclosures'])}")
        print(f"跨境提示：{report['jurisdiction_notes']}")

/**
 * 跨境NFT影视分发合规网关
 * 实现地理围栏、KYC验证、版权地域授权、支付合规检查
 */

const { ethers } = require("ethers");

// 司法管辖区合规规则数据库（示意）
const JURISDICTION_RULES = {
  CN: {
    name: "中国大陆",
    cryptoTradingAllowed: false,
    contentRatingRequired: true,
    restrictedGenres: ["adult", "political_sensitive"],
    maxPaymentPerTransaction: 0,
    kycRequired: true,
    note: "虚拟货币交易禁止，需法币通道"
  },
  EU: {
    name: "欧盟",
    cryptoTradingAllowed: true,
    micaComplianceRequired: true,
    contentRatingRequired: true,
    restrictedGenres: [],
    maxPaymentPerTransaction: 10000, // 单笔上限（USDC）
    kycRequired: true,
    note: "须符合MiCA框架"
  },
  US: {
    name: "美国",
    cryptoTradingAllowed: true,
    secComplianceRequired: true,
    contentRatingRequired: true,
    restrictedGenres: ["obscene"],
    maxPaymentPerTransaction: 100000,
    kycRequired: true,
    note: "须符合SEC与CFTC规则"
  },
  HK: {
    name: "中国香港",
    cryptoTradingAllowed: true,
    sfcLicensingRequired: true,
    contentRatingRequired: true,
    restrictedGenres: [],
    maxPaymentPerTransaction: 50000,
    kycRequired: true,
    note: "须符合证监会发牌制度"
  },
  SG: {
    name: "新加坡",
    cryptoTradingAllowed: true,
    masComplianceRequired: true,
    contentRatingRequired: true,
    restrictedGenres: [],
    maxPaymentPerTransaction: 100000,
    kycRequired: true,
    note: "须符合MAS支付服务法案"
  }
};

// NFT影视作品元数据
const CONTENT_METADATA = {
  contentId: "0xabc123...",
  title: "链上蒙太奇：第24帧",
  contentType: "feature_film",
  duration: 7320, // 秒
  genres: ["documentary", "experimental"],
  copyrightHolders: [
    { address: "0xcreator1...", region: "CN", share: 0.40 },
    { address: "0xcreator2...", region: "EU", share: 0.30 },
    { address: "0xcreator3...", region: "US", share: 0.30 }
  ],
  regionalLicenses: {
    CN: { exclusive: true, validUntil: "2027-12-31" },
    EU: { exclusive: false, validUntil: "2027-12-31" },
    US: { exclusive: false, validUntil: "2027-12-31" },
    HK: { exclusive: true, validUntil: "2026-12-31" }
  }
};

class ComplianceGateway {
  constructor(rules, metadata) {
    this.rules = rules;
    this.metadata = metadata;
  }

  // 地理位置识别（集成IP地理位置服务）
  async detectJurisdiction(ipAddress) {
    // 实际实现中调用GeoIP API
    const mockLocation = {
      "1.1.1.1": "CN",
      "8.8.8.8": "US",
      "9.9.9.9": "EU"
    };
    return mockLocation[ipAddress] || "EU";
  }

  // KYC验证（集成第三方KYC服务）
  async verifyKYC(userAddress, jurisdiction) {
    const rule = this.rules[jurisdiction];
    if (!rule.kycRequired) return true;
    // 调用KYC服务API进行验证
    const mockKYCResult = {
      verified: true,
      level: "tier2",
      sanctionsCleared: true
    };
    return mockKYCResult.verified && mockKYCResult.sanctionsCleared;
  }

  // 内容审查分级检查
  checkContentRating(jurisdiction) {
    const rule = this.rules[jurisdiction];
    const restricted = this.metadata.genres.some(
      genre => rule.restrictedGenres.includes(genre)
    );
    if (restricted) {
      return {
        allowed: false,
        reason: `内容类型在${rule.name}受限制`
      };
    }
    return { allowed: true };
  }

  // 版权地域授权验证
  verifyRegionalLicense(jurisdiction) {
    const license = this.metadata.regionalLicenses[jurisdiction];
    if (!license) {
      return {
        allowed: false,
        reason: `${jurisdiction}无授权`
      };
    }
    const now = new Date();
    const validUntil = new Date(license.validUntil);
    if (now > validUntil) {
      return {
        allowed: false,
        reason: "授权已过期"
      };
    }
    return { allowed: true, exclusive: license.exclusive };
  }

  // 支付合规检查
  checkPaymentCompliance(jurisdiction, amount, tokenAddress) {
    const rule = this.rules[jurisdiction];
    if (!rule.cryptoTradingAllowed) {
      return {
        allowed: false,
        reason: `${rule.name}禁止加密交易`,
        alternative: "法币支付通道"
      };
    }
    if (amount > rule.maxPaymentPerTransaction) {
      return {
        allowed: false,
        reason: `单笔超出限额${rule.maxPaymentPerTransaction}`
      };
    }
    if (rule.micaComplianceRequired) {
      // 验证稳定币是否MiCA合规
      const micaCompliantTokens = [
        "0xUSDC...", "0xEURT..."
      ];
      if (!micaCompliantTokens.includes(tokenAddress)) {
        return {
          allowed: false,
          reason: "稳定币不符合MiCA合规要求"
        };
      }
    }
    return { allowed: true };
  }

  // 综合合规审查——"审查分级意见书"
  async performComprehensiveReview(userAddress, ipAddress, amount, tokenAddress) {
    const jurisdiction = await this.detectJurisdiction(ipAddress);
    const rule = this.rules[jurisdiction];

    console.log(`\n=== 合规审查报告 ===`);
    console.log(`用户地址: ${userAddress}`);
    console.log(`识别管辖区: ${rule.name}`);
    console.log(`备注: ${rule.note}\n`);

    // 第一步：KYC验证
    const kycPassed = await this.verifyKYC(userAddress, jurisdiction);
    console.log(`[1] KYC验证: ${kycPassed ? "通过" : "未通过"}`);
    if (!kycPassed) {
      return { approved: false, stage: "KYC", reason: "身份验证未通过" };
    }

    // 第二步：内容分级审查
    const ratingResult = this.checkContentRating(jurisdiction);
    console.log(`[2] 内容分级: ${ratingResult.allowed ? "通过" : ratingResult.reason}`);
    if (!ratingResult.allowed) {
      return { approved: false, stage: "分级", reason: ratingResult.reason };
    }

    // 第三步：版权授权验证
    const licenseResult = this.verifyRegionalLicense(jurisdiction);
    console.log(`[3] 版权授权: ${licenseResult.allowed ? "有效" : licenseResult.reason}`);
    if (!licenseResult.allowed) {
      return { approved: false, stage: "授权", reason: licenseResult.reason };
    }

    // 第四步：支付合规检查
    const paymentResult = this.checkPaymentCompliance(
      jurisdiction, amount, tokenAddress
    );
    console.log(`[4] 支付合规: ${paymentResult.allowed ? "通过" : paymentResult.reason}`);
    if (!paymentResult.allowed) {
      return {
        approved: false,
        stage: "支付",
        reason: paymentResult.reason,
        alternative: paymentResult.alternative
      };
    }

    console.log(`\n=== 审查结论：批准发行 ===`);
    return {
      approved: true,
      jurisdiction,
      exclusive: licenseResult.exclusive,
      complianceFlags: rule.note
    };
  }
}

// 执行合规审查
async function main() {
  const gateway = new ComplianceGateway(JURISDICTION_RULES, CONTENT_METADATA);

  // 模拟不同地区用户的合规审查
  const testUsers = [
    { address: "0xuserCN", ip: "1.1.1.1", amount: 50, token: "0xUSDC..." },
    { address: "0xuserEU", ip: "9.9.9.9", amount: 15, token: "0xUSDC..." },
    { address: "0xuserUS", ip: "8.8.8.8", amount: 30, token: "0xUSDC..." }
  ];

  for (const user of testUsers) {
    await gateway.performComprehensiveReview(
      user.address, user.ip, user.amount, user.token
    );
  }
}

main().catch(console.error);