Web3创作者经济：从平台抽成到链上直接变现

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

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

/// @title ContentNFT - 创作者内容NFT合约
/// @notice 支持创作者铸造作品NFT并自动分账版税
contract ContentNFT is ERC721URIStorage, ERC2981, Ownable {
    uint256 private _nextTokenId;
    
    // 创作者地址 => 作品数量
    mapping(address => uint256) public creatorWorkCount;
    
    // 分账接收方列表（创作者+合作方）
    struct Payee {
        address wallet;
        uint256 share; // 百分比，总和100
    }
    
    mapping(uint256 => Payee[]) public tokenPayees;
    
    event WorkMinted(uint256 indexed tokenId, address creator, string tokenURI);
    event RoyaltyDistributed(uint256 indexed tokenId, uint256 amount);
    
    constructor() ERC721("DirectorWorks", "DRCT") Ownable(msg.sender) {}
    
    /// @notice 创作者铸造新作品
    /// @param _tokenURI 作品元数据URI（IPFS链接）
    /// @param _royaltyFee 版税比例（基点，500=5%）
    /// @param _payees 分账方列表
    function mintWork(
        string memory _tokenURI,
        uint96 _royaltyFee,
        Payee[] memory _payees
    ) external returns (uint256) {
        uint256 tokenId = _nextTokenId++;
        _safeMint(msg.sender, tokenId);
        _setTokenURI(tokenId, _tokenURI);
        _setTokenRoyalty(tokenId, msg.sender, _royaltyFee);
        
        // 存储分账方信息
        require(_payees.length > 0, "At least one payee");
        uint256 totalShare;
        for (uint256 i = 0; i < _payees.length; i++) {
            tokenPayees[tokenId].push(_payees[i]);
            totalShare += _payees[i].share;
        }
        require(totalShare == 100, "Shares must sum to 100");
        
        creatorWorkCount[msg.sender]++;
        emit WorkMinted(tokenId, msg.sender, _tokenURI);
        return tokenId;
    }
    
    /// @notice 分配版税收益给多个分账方
    /// @param _tokenId 作品ID
    function distributeRoyalty(uint256 _tokenId) external payable {
        uint256 total = msg.value;
        Payee[] storage payees = tokenPayees[_tokenId];
        
        for (uint256 i = 0; i < payees.length; i++) {
            uint256 amount = (total * payees[i].share) / 100;
            (bool success, ) = payable(payees[i].wallet).call{value: amount}("");
            require(success, "Transfer failed");
        }
        
        emit RoyaltyDistributed(_tokenId, total);
    }
    
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721URIStorage, ERC2981)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

import json
import requests
from web3 import Web3
from datetime import datetime, timedelta

class CreatorRevenueTracker:
    """追踪创作者链上收益并生成报告"""
    
    def __init__(self, rpc_url, contract_address, contract_abi):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.contract = self.w3.eth.contract(
            address=Web3.to_checksum_address(contract_address),
            abi=contract_abi
        )
        self.creator_address = None
    
    def get_creator_works(self, creator_address):
        """获取创作者所有作品的链上ID"""
        self.creator_address = creator_address
        work_count = self.contract.functions.creatorWorkCount(
            Web3.to_checksum_address(creator_address)
        ).call()
        
        works = []
        for token_id in range(work_count):
            try:
                owner = self.contract.functions.ownerOf(token_id).call()
                token_uri = self.contract.functions.tokenURI(token_id).call()
                royalty_info = self.contract.functions.royaltyInfo(
                    token_id, 10000
                ).call()
                
                works.append({
                    'token_id': token_id,
                    'owner': owner,
                    'uri': token_uri,
                    'royalty_receiver': royalty_info[0],
                    'royalty_rate_bps': royalty_info[1]
                })
            except Exception as e:
                print(f"读取作品 {token_id} 失败: {e}")
        
        return works
    
    def fetch_transfer_events(self, from_block, to_block):
        """获取作品转移事件（二次交易）"""
        transfer_filter = self.contract.events.Transfer.create_filter(
            fromBlock=from_block,
            toBlock=to_block
        )
        events = transfer_filter.get_all_entries()
        
        transfers = []
        for event in events:
            transfers.append({
                'token_id': event['args']['tokenId'],
                'from': event['args']['from'],
                'to': event['args']['to'],
                'block': event['blockNumber'],
                'tx_hash': event['transactionHash'].hex()
            })
        return transfers
    
    def generate_revenue_report(self, creator_address, days=30):
        """生成最近N天的创作者收益报告"""
        current_block = self.w3.eth.block_number
        # 估算days天前的区块（以太坊约12秒一个块）
        blocks_per_day = 7200
        from_block = max(0, current_block - days * blocks_per_day)
        
        works = self.get_creator_works(creator_address)
        transfers = self.fetch_transfer_events(from_block, current_block)
        
        # 筛选该创作者作品的二次交易
        creator_token_ids = {w['token_id'] for w in works}
        secondary_sales = [
            t for t in transfers 
            if t['token_id'] in creator_token_ids
            and t['from'] != self.w3.to_checksum_address('0x' + '0'*40)
        ]
        
        report = {
            'creator': creator_address,
            'period_days': days,
            'total_works': len(works),
            'secondary_sales_count': len(secondary_sales),
            'works_detail': works,
            'recent_transfers': secondary_sales[-20:],
            'generated_at': datetime.utcnow().isoformat()
        }
        
        return report
    
    def export_report(self, report, filename):
        """导出报告为JSON文件"""
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(report, f, ensure_ascii=False, indent=2)
        print(f"报告已保存至 {filename}")


# 使用示例
if __name__ == "__main__":
    RPC_URL = "https://polygon-rpc.com"
    CONTRACT_ADDR = "0x..."  # ContentNFT合约地址
    
    with open('abi.json', 'r') as f:
        abi = json.load(f)
    
    tracker = CreatorRevenueTracker(RPC_URL, CONTRACT_ADDR, abi)
    
    creator = "0xCreatorAddress..."
    report = tracker.generate_revenue_report(creator, days=30)
    
    print(f"创作者 {creator}")
    print(f"总作品数: {report['total_works']}")
    print(f"近30天二次交易次数: {report['secondary_sales_count']}")
    
    tracker.export_report(report, f"revenue_report_{creator[:8]}.json")

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

// 分账合约ABI
const SPLITTER_ABI = [
  "function split(address token, uint256 amount) external",
  "function addPayee(address account, uint256 share) external",
  "function getPayees() view returns (tuple(address account, uint256 share)[])",
  "function release(address token) external",
  "event PaymentSplit(address token, uint256 amount, address indexed sender)",
  "event PayeeAdded(address account, uint256 share)"
];

class RevenueSplitter {
  constructor(providerUrl, contractAddress, privateKey) {
    this.provider = new ethers.JsonRpcProvider(providerUrl);
    this.wallet = new ethers.Wallet(privateKey, this.provider);
    this.contractAddress = contractAddress;
    this.contract = new ethers.Contract(
      contractAddress,
      SPLITTER_ABI,
      this.wallet
    );
  }
  
  /**
   * 初始化一部作品的分账方
   * @param {Array} payees - 分账方列表 [{account, share}]
   */
  async setupSplit(payees) {
    console.log(`正在设置分账方，共 ${payees.length} 人...`);
    
    const totalShare = payees.reduce((sum, p) => sum + p.share, 0);
    if (totalShare !== 10000) {
      throw new Error(`分账比例总和必须为10000(100%)，当前为${totalShare}`);
    }
    
    for (const payee of payees) {
      const tx = await this.contract.addPayee(
        ethers.getAddress(payee.account),
        payee.share
      );
      console.log(`添加分账方 ${payee.account} (${payee.share/100}%) - TX: ${tx.hash}`);
      await tx.wait();
    }
    console.log("所有分账方设置完成");
  }
  
  /**
   * 监听并处理收益分配事件
   * @param {number} fromBlock - 起始区块
   */
  async listenToSplits(fromBlock) {
    console.log(`开始监听分账事件，从区块 ${fromBlock}...`);
    
    const filter = this.contract.filters.PaymentSplit();
    const events = await this.contract.queryFilter(filter, fromBlock);
    
    const splits = events.map(event => ({
      token: event.args.token,
      amount: ethers.formatEther(event.args.amount),
      sender: event.args.sender,
      txHash: event.transactionHash,
      block: event.blockNumber
    }));
    
    console.log(`\n=== 分账记录 (${splits.length} 笔) ===`);
    splits.forEach((split, idx) => {
      console.log(`[${idx + 1}] 代币: ${split.token}`);
      console.log(`    金额: ${split.amount} ETH`);
      console.log(`    发起: ${split.sender}`);
      console.log(`    区块: ${split.block}`);
      console.log("---");
    });
    
    return splits;
  }
  
  /**
   * 分配收益给所有分账方
   * @param {string} tokenAddress - 代币地址(0x0表示ETH)
   * @param {string} amount - 金额(ETH)
   */
  async distributeRevenue(tokenAddress, amount) {
    const zeroAddr = "0x0000000000000000000000000000000000000000";
    const token = tokenAddress || zeroAddr;
    const amountWei = ethers.parseEther(amount);
    
    console.log(`准备分配 ${amount} ETH 给各分账方...`);
    
    const tx = await this.contract.split(token, amountWei, {
      value: token === zeroAddr ? amountWei : 0
    });
    
    console.log(`分账交易已提交: ${tx.hash}`);
    const receipt = await tx.wait();
    console.log(`交易确认，区块: ${receipt.blockNumber}`);
    
    return receipt;
  }
  
  /**
   * 生成月度分账报表
   */
  async generateMonthlyReport(month, year) {
    const now = Math.floor(Date.now() / 1000);
    const monthStart = new Date(year, month - 1, 1).getTime() / 1000;
    const monthEnd = new Date(year, month, 1).getTime() / 1000;
    
    const startBlock = await this.estimateBlockAtTimestamp(monthStart);
    const endBlock = await this.estimateBlockAtTimestamp(monthEnd);
    
    const splits = await this.listenToSplits(startBlock);
    const monthlySplits = splits.filter(s => s.block <= endBlock);
    
    const totalRevenue = monthlySplits.reduce(
      (sum, s) => sum + parseFloat(s.amount), 0
    );
    
    const payees = await this.contract.getPayees();
    
    const report = {
      month: `${year}-${String(month).padStart(2, '0')}`,
      totalRevenueETH: totalRevenue.toFixed(4),
      splitCount: monthlySplits.length,
      payees: payees.map(p => ({
        address: p.account,
        sharePercent: (Number(p.share) / 100).toFixed(2),
        estimatedEarnings: (totalRevenue * Number(p.share) / 10000).toFixed(4)
      })),
      splits: monthlySplits
    };
    
    const filename = `revenue_report_${year}_${String(month).padStart(2,'0')}.json`;
    fs.writeFileSync(filename, JSON.stringify(report, null, 2));
    console.log(`\n月度报告已生成: ${filename}`);
    
    return report;
  }
  
  async estimateBlockAtTimestamp(timestamp) {
    const currentBlock = await this.provider.getBlockNumber();
    const currentBlockData = await this.provider.getBlock(currentBlock);
    const avgBlockTime = 2; // Polygon约2秒
    const diff = currentBlockData.timestamp - timestamp;
    return Math.max(0, currentBlock - Math.floor(diff / avgBlockTime));
  }
}

// 使用示例：独立短片《城市夜归人》的分账配置
const SPLITTER_CONFIG = {
  director:  { account: "0xDirector...",  share: 4000 },  // 40%
  writer:    { account: "0xWriter...",    share: 2000 },  // 20%
  camera:    { account: "0xCameraman...", share: 1500 },  // 15%
  editor:    { account: "0xEditor...",     share: 1500 },  // 15%
  composer:  { account: "0xComposer...",   share: 1000 }   // 10%
};

module.exports = { RevenueSplitter, SPLITTER_CONFIG };