第一幕：版权法的取景框，再也框不住AI的广角镜头

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

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

contract MusicCopyrightNFT is ERC721URIStorage, Ownable {
    struct MusicMetadata {
        string title;
        string artistDID;
        uint256 creationTimestamp;
        bytes32 contentHash;
        address[] contributors;
        uint256[] royaltyShares;
        string licenseType;
        bool isAvailableForTraining;
    }

    uint256 private _tokenIdCounter;
    mapping(uint256 => MusicMetadata) public musicMetadata;
    mapping(bytes32 => bool) public contentHashExists;
    mapping(address => uint256[]) public creatorTokens;

    event MusicRegistered(
        uint256 indexed tokenId,
        string title,
        address indexed creator,
        bytes32 contentHash
    );

    event RoyaltyDistributed(
        uint256 indexed tokenId,
        address indexed recipient,
        uint256 amount
    );

    constructor() ERC721("MusicCopyrightNFT", "MUSIC") Ownable(msg.sender) {}

    function registerMusic(
        string memory title,
        string memory artistDID,
        bytes32 contentHash,
        address[] memory contributors,
        uint256[] memory royaltyShares,
        string memory licenseType
    ) public returns (uint256) {
        require(!contentHashExists[contentHash], "Content already registered");
        require(
            contributors.length == royaltyShares.length,
            "Contributors and shares mismatch"
        );

        uint256 totalShares = 0;
        for (uint256 i = 0; i < royaltyShares.length; i++) {
            totalShares += royaltyShares[i];
        }
        require(totalShares == 10000, "Royalty shares must sum to 10000");

        _tokenIdCounter++;
        uint256 newTokenId = _tokenIdCounter;

        _safeMint(msg.sender, newTokenId);

        MusicMetadata storage meta = musicMetadata[newTokenId];
        meta.title = title;
        meta.artistDID = artistDID;
        meta.creationTimestamp = block.timestamp;
        meta.contentHash = contentHash;
        meta.contributors = contributors;
        meta.royaltyShares = royaltyShares;
        meta.licenseType = licenseType;
        meta.isAvailableForTraining = true;

        contentHashExists[contentHash] = true;
        creatorTokens[msg.sender].push(newTokenId);

        emit MusicRegistered(newTokenId, title, msg.sender, contentHash);
        return newTokenId;
    }

    function distributeRoyalty(
        uint256 tokenId,
        uint256 totalAmount
    ) public onlyOwner {
        MusicMetadata storage meta = musicMetadata[tokenId];
        require(totalAmount > 0, "Amount must be positive");

        for (uint256 i = 0; i < meta.contributors.length; i++) {
            uint256 share = (totalAmount * meta.royaltyShares[i]) / 10000;
            if (share > 0) {
                payable(meta.contributors[i]).transfer(share);
                emit RoyaltyDistributed(tokenId, meta.contributors[i], share);
            }
        }
    }

    function setTrainingAvailability(
        uint256 tokenId,
        bool available
    ) public {
        require(
            ownerOf(tokenId) == msg.sender,
            "Only owner can set availability"
        );
        musicMetadata[tokenId].isAvailableForTraining = available;
    }

    function getMusicMetadata(
        uint256 tokenId
    ) public view returns (MusicMetadata memory) {
        return musicMetadata[tokenId];
    }

    function getCreatorTokens(
        address creator
    ) public view returns (uint256[] memory) {
        return creatorTokens[creator];
    }
}

import hashlib
import json
from web3 import Web3
from typing import List, Dict, Optional
import time

class TrainingDataComplianceChecker:
    """
    AI训练数据版权合规检查器
    用于验证训练数据集中所有作品的版权状态
    """

    def __init__(self, rpc_url: str, contract_address: str, contract_abi: Dict):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.contract = self.w3.eth.contract(
            address=Web3.to_checksum_address(contract_address),
            abi=contract_abi
        )

    def compute_content_hash(self, audio_file_path: str) -> bytes:
        """
        计算音频文件的SHA-256哈希值作为数字指纹
        """
        sha256_hash = hashlib.sha256()
        with open(audio_file_path, "rb") as f:
            for byte_block in iter(lambda: f.read(4096), b""):
                sha256_hash.update(byte_block)
        return sha256_hash.digest()

    def check_copyright_status(self, content_hash: bytes) -> Dict:
        """
        检查给定内容的版权登记状态
        返回：是否已登记、所有者、许可类型等
        """
        try:
            # 遍历链上已注册的音乐作品
            total_tokens = self.contract.functions.totalSupply().call()
            for token_id in range(1, total_tokens + 1):
                metadata = self.contract.functions.getMusicMetadata(token_id).call()
                if metadata[3] == content_hash:  # contentHash匹配
                    return {
                        "registered": True,
                        "token_id": token_id,
                        "title": metadata[0],
                        "artist_did": metadata[1],
                        "license_type": metadata[5],
                        "available_for_training": metadata[6]
                    }
            return {"registered": False}
        except Exception as e:
            return {"error": str(e), "registered": False}

    def check_dataset_compliance(
        self,
        audio_file_paths: List[str]
    ) -> Dict:
        """
        批量检查训练数据集的版权合规性
        """
        results = {
            "total_files": len(audio_file_paths),
            "compliant_files": 0,
            "non_compliant_files": 0,
            "details": []
        }

        for file_path in audio_file_paths:
            content_hash = self.compute_content_hash(file_path)
            status = self.check_copyright_status(content_hash)

            entry = {
                "file_path": file_path,
                "content_hash": "0x" + content_hash.hex(),
                "status": status
            }

            if status.get("registered") and status.get("available_for_training"):
                results["compliant_files"] += 1
                entry["compliance"] = "PASS"
            else:
                results["non_compliant_files"] += 1
                entry["compliance"] = "FAIL"
                if not status.get("registered"):
                    entry["reason"] = "内容未在链上登记版权"
                elif not status.get("available_for_training"):
                    entry["reason"] = "版权持有者未授权用于AI训练"

            results["details"].append(entry)

        compliance_rate = (
            results["compliant_files"] / results["total_files"] * 100
            if results["total_files"] > 0
            else 0
        )
        results["compliance_rate"] = round(compliance_rate, 2)

        return results

    def generate_compliance_report(
        self,
        compliance_results: Dict
    ) -> str:
        """
        生成合规检查报告
        """
        report_lines = []
        report_lines.append("=" * 60)
        report_lines.append("AI训练数据版权合规检查报告")
        report_lines.append("=" * 60)
        report_lines.append(f"检查时间: {time.strftime('%Y-%m-%d %H:%M:%S')}")
        report_lines.append(f"文件总数: {compliance_results['total_files']}")
        report_lines.append(f"合规文件: {compliance_results['compliant_files']}")
        report_lines.append(f"不合规文件: {compliance_results['non_compliant_files']}")
        report_lines.append(f"合规率: {compliance_results['compliance_rate']}%")
        report_lines.append("-" * 60)

        if compliance_results['non_compliant_files'] > 0:
            report_lines.append("\n不合规文件详情:")
            for detail in compliance_results['details']:
                if detail['compliance'] == 'FAIL':
                    report_lines.append(
                        f"  - {detail['file_path']}: {detail.get('reason', '未知原因')}"
                    )

        return "\n".join(report_lines)

    def monitor_new_registrations(self, interval_seconds: int = 60):
        """
        监听链上新版权登记事件
        用于实时更新训练数据合规状态
        """
        event_filter = self.contract.events.MusicRegistered.create_filter(
            from_block="latest"
        )
        print(f"开始监听新版权登记事件，每{interval_seconds}秒检查一次...")

        while True:
            try:
                new_events = event_filter.get_new_entries()
                for event in new_events:
                    token_id = event['args']['tokenId']
                    title = event['args']['title']
                    creator = event['args']['creator']
                    content_hash = event['args']['contentHash']

                    print(f"\n[新版权登记]")
                    print(f"  Token ID: {token_id}")
                    print(f"  标题: {title}")
                    print(f"  创作者: {creator}")
                    print(f"  内容哈希: {content_hash.hex()}")
                    print(f"  时间: {time.strftime('%Y-%m-%d %H:%M:%S')}")

                time.sleep(interval_seconds)

            except KeyboardInterrupt:
                print("\n监听已停止")
                break
            except Exception as e:
                print(f"监听错误: {e}")
                time.sleep(interval_seconds)


# 使用示例
if __name__ == "__main__":
    RPC_URL = "https://ethereum-sepolia-rpc.publicnode.com"
    CONTRACT_ADDRESS = "0xYourDeployedContractAddress"

    # 假设的合约ABI（简化为示例）
    CONTRACT_ABI = {
        "abi": [
            {
                "inputs": [{"name": "tokenId", "type": "uint256"}],
                "name": "getMusicMetadata",
                "outputs": [
                    {"name": "title", "type": "string"},
                    {"name": "artistDID", "type": "string"},
                    {"name": "creationTimestamp", "type": "uint256"},
                    {"name": "contentHash", "type": "bytes32"},
                    {"name": "contributors", "type": "address[]"},
                    {"name": "royaltyShares", "type": "uint256[]"},
                    {"name": "licenseType", "type": "string"},
                    {"name": "isAvailableForTraining", "type": "bool"}
                ],
                "stateMutability": "view",
                "type": "function"
            }
        ]
    }

    checker = TrainingDataComplianceChecker(RPC_URL, CONTRACT_ADDRESS, CONTRACT_ABI)

    # 模拟检查训练数据集
    audio_files = [
        "training_data/song_001.wav",
        "training_data/song_002.wav",
        "training_data/song_003.wav"
    ]

    results = checker.check_dataset_compliance(audio_files)
    report = checker.generate_compliance_report(results)
    print(report)

// 链上版税结算前端SDK
// 用于流媒体平台的实时版税分配

const Web3 = require('web3');
const axios = require('axios');

class OnChainRoyaltySettlement {
  constructor(providerUrl, contractAddress, contractAbi) {
    this.web3 = new Web3(new Web3.providers.HttpProvider(providerUrl));
    this.contract = new this.web3.eth.Contract(
      contractAbi,
      contractAddress
    );
    this.listeners = new Map();
  }

  /**
   * 记录一次播放事件并触发版税分配
   */
  async recordPlayback(songTokenId, listenerAddress, platformFee) {
    try {
      const playbackEvent = {
        songTokenId: songTokenId,
        listener: listenerAddress,
        platform: this.web3.eth.defaultAccount,
        timestamp: Math.floor(Date.now() / 1000),
        platformFee: platformFee,
        streamingRevenue: 0.004, // 单次播放收入（美元）
      };

      // 计算实际可分成的金额
      const netRevenue = playbackEvent.streamingRevenue * (1 - platformFee);

      // 调用智能合约的版税分配函数
      const tx = await this.contract.methods
        .distributeRoyalty(songTokenId, this.web3.utils.toWei(
          netRevenue.toString(), 'ether'
        ))
        .send({ from: this.web3.eth.defaultAccount });

      console.log(`[Playback] Song #${songTokenId} played by ${listenerAddress}`);
      console.log(`[Royalty] Distributed ${netRevenue} ETH to contributors`);

      // 触发回调
      this._emit('royaltyDistributed', {
        songTokenId,
        netRevenue,
        txHash: tx.transactionHash,
        timestamp: playbackEvent.timestamp,
      });

      return {
        success: true,
        txHash: tx.transactionHash,
        netRevenue: netRevenue,
      };
    } catch (error) {
      console.error(`[Error] Playback recording failed: ${error.message}`);
      return {
        success: false,
        error: error.message,
      };
    }
  }

  /**
   * 批量结算（用于流媒体平台的每日结算）
   */
  async batchSettle(songTokenIds, totalAmounts) {
    const results = [];
    for (let i = 0; i < songTokenIds.length; i++) {
      const result = await this.recordPlayback(
        songTokenIds[i],
        '0x0000000000000000000000000000000000000000',
        0.3 // 平台抽成30%
      );
      results.push(result);

      // 避免交易频率过高
      if (i < songTokenIds.length - 1) {
        await this._sleep(1000);
      }
    }
    return results;
  }

  /**
   * 查询作品的版税收入历史
   */
  async getRoyaltyHistory(songTokenId, fromBlock, toBlock) {
    try {
      const events = await this.contract.getPastEvents('RoyaltyDistributed', {
        filter: { tokenId: songTokenId },
        fromBlock: fromBlock,
        toBlock: toBlock || 'latest',
      });

      return events.map(event => ({
        tokenId: event.returnValues.tokenId,
        recipient: event.returnValues.recipient,
        amount: this.web3.utils.fromWei(
          event.returnValues.amount, 'ether'
        ),
        transactionHash: event.transactionHash,
        blockNumber: event.blockNumber,
      }));
    } catch (error) {
      console.error(`[Error] Royalty history query failed: ${error.message}`);
      return [];
    }
  }

  /**
   * 实时监听版税分配事件
   */
  async startRoyaltyListener(callback) {
    const eventSubscription = this.contract.events.RoyaltyDistributed({
      fromBlock: 'latest',
    });

    eventSubscription.on('data', (event) => {
      const royaltyData = {
        tokenId: event.returnValues.tokenId,
        recipient: event.returnValues.recipient,
        amount: this.web3.utils.fromWei(
          event.returnValues.amount, 'ether'
        ),
        txHash: event.transactionHash,
        blockNumber: event.blockNumber,
      };

      console.log(`[Live] Royalty distributed: Song #${royaltyData.tokenId}`);
      console.log(`[Live] Recipient: ${royaltyData.recipient}`);
      console.log(`[Live] Amount: ${royaltyData.amount} ETH`);

      if (callback) {
        callback(royaltyData);
      }
    });

    eventSubscription.on('error', (error) => {
      console.error(`[Listener Error] ${error.message}`);
    });

    return eventSubscription;
  }

  /**
   * 生成版税收入报表
   */
  async generateRevenueReport(artistAddress, startDate, endDate) {
    const startBlock = await this._estimateBlockFromDate(startDate);
    const endBlock = await this._estimateBlockFromDate(endDate);

    const events = await this.contract.getPastEvents('RoyaltyDistributed', {
      filter: { recipient: artistAddress },
      fromBlock: startBlock,
      toBlock: endBlock,
    });

    const totalRevenue = events.reduce((sum, event) => {
      return sum + parseFloat(
        this.web3.utils.fromWei(event.returnValues.amount, 'ether')
      );
    }, 0);

    return {
      artist: artistAddress,
      period: `${startDate} to ${endDate}`,
      totalTransactions: events.length,
      totalRevenue: totalRevenue.toFixed(6),
      averagePerTransaction: events.length > 0
        ? (totalRevenue / events.length).toFixed(6)
        : 0,
      transactions: events.map(event => ({
        tokenId: event.returnValues.tokenId,
        amount: this.web3.utils.fromWei(
          event.returnValues.amount, 'ether'
        ),
        timestamp: event.blockNumber,
        txHash: event.transactionHash,
      })),
    };
  }

  _emit(event, data) {
    if (this.listeners.has(event)) {
      this.listeners.get(event).forEach(callback => callback(data));
    }
  }

  on(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, []);
    }
    this.listeners.get(event).push(callback);
  }

  async _estimateBlockFromDate(dateString) {
    const date = new Date(dateString);
    const timestamp = Math.floor(date.getTime() / 1000);
    // 以太坊大约每12秒出一个块
    const estimatedBlock = Math.floor((timestamp - 1609459200) / 12);
    return Math.max(estimatedBlock, 0);
  }

  _sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// 使用示例
const main = async () => {
  const CONTRACT_ABI = [
    {
      anonymous: false,
      inputs: [
        { indexed: true, name: 'tokenId', type: 'uint256' },
        { indexed: true, name: 'recipient', type: 'address' },
        { indexed: false, name: 'amount', type: 'uint256' },
      ],
      name: 'RoyaltyDistributed',
      type: 'event',
    },
    {
      inputs: [
        { name: 'tokenId', type: 'uint256' },
        { name: 'totalAmount', type: 'uint256' },
      ],
      name: 'distributeRoyalty',
      outputs: [],
      stateMutability: 'nonpayable',
      type: 'function',
    },
  ];

  const settlement = new OnChainRoyaltySettlement(
    'https://ethereum-sepolia-rpc.publicnode.com',
    '0xYourContractAddress',
    CONTRACT_ABI
  );

  // 模拟一次播放
  const result = await settlement.recordPlayback(
    1, // Song Token ID
    '0xListenerAddress',
    0.3 // 30% 平台抽成
  );
  console.log('Playback result:', result);

  // 启动实时版税监听
  await settlement.startRoyaltyListener((data) => {
    console.log('New royalty received:', data);
  });

  // 查询版税历史
  const history = await settlement.getRoyaltyHistory(1, 0, 'latest');
  console.log('Royalty history:', history);
};

main().catch(console.error);