第一幕：当区块链遇见欧盟——MiCA如何重塑数字内容生态

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract ContentIPNFT is ERC721, Ownable {
    struct RoyaltyInfo {
        address recipient;
        uint256 basisPoints;
    }

    mapping(uint256 => string) private _tokenURIs;
    mapping(uint256 => RoyaltyInfo) private _royalties;
    uint256 private _tokenIdCounter;

    event ContentMinted(uint256 indexed tokenId, address creator, string uri);
    event RoyaltyPaid(uint256 indexed tokenId, address recipient, uint256 amount);

    constructor() ERC721("ContentIP", "CIP") Ownable(msg.sender) {}

    function mintContent(address creator, string memory uri, uint256 royaltyBps) external onlyOwner returns (uint256) {
        _tokenIdCounter++;
        uint256 newTokenId = _tokenIdCounter;
        _safeMint(creator, newTokenId);
        _tokenURIs[newTokenId] = uri;
        _royalties[newTokenId] = RoyaltyInfo(creator, royaltyBps);
        emit ContentMinted(newTokenId, creator, uri);
        return newTokenId;
    }

    function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address, uint256) {
        RoyaltyInfo memory info = _royalties[tokenId];
        uint256 royaltyAmount = (salePrice * info.basisPoints) / 10000;
        return (info.recipient, royaltyAmount);
    }

    function transferContent(uint256 tokenId, address to) external {
        require(ownerOf(tokenId) == msg.sender, "Not token owner");
        safeTransferFrom(msg.sender, to, tokenId);
    }
}

import asyncio
import aiohttp
from dataclasses import dataclass
from datetime import datetime

@dataclass
class CASPStatus:
    name: str
    country: str
    license_id: str
    status: str
    expiry: datetime

MICA_DEADLINE = datetime(2026, 7, 1)
AMF_DEADLINE = datetime(2026, 6, 30)

async def fetch_casp_registry(session: aiohttp.ClientSession, country_code: str) -> list[CASPStatus]:
    url = f"https://registers.esma.europa.eu/api/casp/{country_code}"
    async with session.get(url) as resp:
        data = await resp.json()
        return [
            CASPStatus(
                name=item["name"],
                country=country_code,
                license_id=item["license_id"],
                status=item["status"],
                expiry=datetime.fromisoformat(item["expiry"])
            )
            for item in data.get("results", [])
        ]

async def check_compliance_status():
    async with aiohttp.ClientSession() as session:
        countries = ["LV", "LT", "FR", "DE", "IT", "MT", "PL"]
        tasks = [fetch_casp_registry(session, cc) for cc in countries]
        all_casps = []
        for result in await asyncio.gather(*tasks, return_exceptions=True):
            if isinstance(result, list):
                all_casps.extend(result)

        now = datetime.now()
        for casp in all_casps:
            days_remaining = (casp.expiry - now).days
            if casp.expiry < MICA_DEADLINE:
                print(f"[URGENT] {casp.name} ({casp.country}): {days_remaining}d remaining")
            elif casp.status != "active":
                print(f"[PENDING] {casp.name} ({casp.country}): awaiting approval")

asyncio.run(check_compliance_status())

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

const provider = new ethers.JsonRpcProvider("https://rpc.eu.mica-compliant.chain");
const wallet = new ethers.Wallet(process.env.DISTRIBUTOR_KEY, provider);

const CONTRACT_ABI = [
  "function royaltyInfo(uint256, uint256) view returns (address, uint256)",
  "function ownerOf(uint256) view returns (address)"
];

const contract = new ethers.Contract(
  "0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18",
  CONTRACT_ABI,
  wallet
);

async function distributeRoyalties(tokenIds, totalSalePrice) {
  const distributions = [];
  for (const tokenId of tokenIds) {
    const [recipient, royaltyAmount] = await contract.royaltyInfo(tokenId, totalSalePrice);
    distributions.push({ tokenId, recipient, royaltyAmount: royaltyAmount.toString() });

    const tx = await wallet.sendTransaction({
      to: recipient,
      value: royaltyAmount,
    });
    const receipt = await tx.wait();
    console.log(`Paid ${ethers.formatEther(royaltyAmount)} ETH to ${recipient} | tx: ${receipt.hash}`);
  }
  return distributions;
}

async function verifyCASPCompliance(caspLicenseId) {
  const registryUrl = `https://registers.esma.europa.eu/api/casp/verify/${caspLicenseId}`;
  const response = await fetch(registryUrl);
  const data = await response.json();
  return {
    isValid: data.status === "active",
    country: data.country,
    expiry: data.expiry,
    passportedCountries: data.passported_countries
  };
}

async function main() {
  const compliance = await verifyCASPCompliance("LV-CASP-2025-00142");
  if (!compliance.isValid) {
    throw new Error(`CASP license expired or invalid: ${compliance.country}`);
  }
  console.log(`CASP verified | Country: ${compliance.country} | Passports: ${compliance.passportedCountries.join(", ")}`);

  const tokenIds = [1, 2, 3, 4, 5];
  const salePrice = ethers.parseEther("10.0");
  await distributeRoyalties(tokenIds, salePrice);
}

main().catch(console.error);