加密支付卡交易量激增：创作者经济的链上收银台

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

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

contract CreatorPaymentCard is ERC20, AccessControl, ReentrancyGuard {
    bytes32 public constant CREATOR_ROLE = keccak256("CREATOR_ROLE");
    bytes32 public constant CARD_ISSUER_ROLE = keccak256("CARD_ISSUER_ROLE");

    struct CreatorProfile {
        address creator;
        string name;
        uint256 totalEarnings;
        uint256 totalTips;
        uint256 subscriberCount;
        uint256 royaltyRate;  // 0-1000 (0.1% granularity)
        bool isVerified;
        uint256 lastPayoutTime;
    }

    struct TipTransaction {
        uint256 tipId;
        address from;
        address to;
        uint256 amount;
        uint256 timestamp;
        string contentUrl;
        string message;
        bool isRefunded;
    }

    struct Subscription {
        address subscriber;
        address creator;
        uint256 amount;
        uint256 startTime;
        uint256 endTime;
        bool isActive;
    }

    uint256 private _tipCounter;
    uint256 private _subscriptionCounter;
    uint256 public constant MIN_TIP = 0.01 ether;
    uint256 public constant PLATFORM_FEE = 25; // 0.25%
    uint256 public constant REWARD_POOL = 1000000 * 10**18;

    mapping(address => CreatorProfile) public creators;
    mapping(uint256 => TipTransaction) public tips;
    mapping(address => Subscription[]) public subscriptions;
    mapping(address => uint256) public pendingWithdrawals;
    mapping(bytes32 => bool) public usedNonces;

    event TipSent(uint256 indexed tipId, address indexed from, address indexed to, uint256 amount);
    event SubscriptionCreated(address indexed subscriber, address indexed creator, uint256 amount);
    event WithdrawalProcessed(address indexed creator, uint256 amount);

    constructor() ERC20("Creator Token", "CREATOR") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(CARD_ISSUER_ROLE, msg.sender);
        _mint(address(this), REWARD_POOL);
    }

    function registerCreator(string memory _name, uint256 _royaltyRate) external {
        require(creators[msg.sender].creator == address(0), "Already registered");
        require(_royaltyRate <= 1000, "Invalid royalty rate");

        creators[msg.sender] = CreatorProfile({
            creator: msg.sender,
            name: _name,
            totalEarnings: 0,
            totalTips: 0,
            subscriberCount: 0,
            royaltyRate: _royaltyRate,
            isVerified: false,
            lastPayoutTime: block.timestamp
        });

        _grantRole(CREATOR_ROLE, msg.sender);
    }

    function sendTip(
        address _creator,
        uint256 _amount,
        string memory _contentUrl,
        string memory _message
    ) external payable nonReentrant {
        require(creators[_creator].isVerified, "Creator not verified");
        require(msg.value >= MIN_TIP, "Tip too small");
        require(_amount <= msg.value, "Insufficient payment");

        _tipCounter++;
        uint256 tipId = _tipCounter;

        // Calculate platform fee
        uint256 fee = _amount * PLATFORM_FEE / 10000;
        uint256 creatorAmount = _amount - fee;

        // Transfer to creator
        payable(_creator).transfer(creatorAmount);
        creators[_creator].totalEarnings += creatorAmount;
        creators[_creator].totalTips++;

        tips[tipId] = TipTransaction({
            tipId: tipId,
            from: msg.sender,
            to: _creator,
            amount: creatorAmount,
            timestamp: block.timestamp,
            contentUrl: _contentUrl,
            message: _message,
            isRefunded: false
        });

        emit TipSent(tipId, msg.sender, _creator, creatorAmount);
    }

    function createSubscription(
        address _creator,
        uint256 _amount,
        uint256 _durationDays
    ) external payable nonReentrant {
        require(creators[_creator].isVerified, "Creator not verified");
        require(msg.value >= _amount, "Insufficient payment");

        _subscriptionCounter++;
        uint256 subId = _subscriptionCounter;

        uint256 fee = _amount * PLATFORM_FEE / 10000;
        uint256 creatorAmount = _amount - fee;

        payable(_creator).transfer(creatorAmount);
        creators[_creator].totalEarnings += creatorAmount;
        creators[_creator].subscriberCount++;

        subscriptions[msg.sender].push(Subscription({
            subscriber: msg.sender,
            creator: _creator,
            amount: creatorAmount,
            startTime: block.timestamp,
            endTime: block.timestamp + (_durationDays * 1 days),
            isActive: true
        }));

        emit SubscriptionCreated(msg.sender, _creator, creatorAmount);
    }

    function processWithdrawal() external onlyRole(CREATOR_ROLE) nonReentrant {
        uint256 amount = pendingWithdrawals[msg.sender];
        require(amount > 0, "No pending withdrawal");

        pendingWithdrawals[msg.sender] = 0;
        payable(msg.sender).transfer(amount);

        emit WithdrawalProcessed(msg.sender, amount);
    }

    function verifyCreator(address _creator) external onlyRole(CARD_ISSUER_ROLE) {
        creators[_creator].isVerified = true;
    }

    function getCreatorStats(address _creator) 
        external view returns (CreatorProfile memory) {
        return creators[_creator];
    }

    function getTip(uint256 _tipId) 
        external view returns (TipTransaction memory) {
        return tips[_tipId];
    }

    function getSubscriptionCount(address _subscriber) 
        external view returns (uint256) {
        return subscriptions[_subscriber].length;
    }

    function getActiveSubscriptions(address _subscriber) 
        external view returns (Subscription[] memory) {
        uint256 activeCount = 0;
        for (uint256 i = 0; i < subscriptions[_subscriber].length; i++) {
            if (subscriptions[_subscriber][i].endTime > block.timestamp) {
                activeCount++;
            }
        }

        Subscription[] memory active = new Subscription[](activeCount);
        uint256 index = 0;
        for (uint256 i = 0; i < subscriptions[_subscriber].length; i++) {
            if (subscriptions[_subscriber][i].endTime > block.timestamp) {
                active[index] = subscriptions[_subscriber][i];
                index++;
            }
        }

        return active;
    }
}

"""
创作者经济链上支付系统 - 模拟加密支付卡和打赏系统
实现创作者收入管理、粉丝打赏和订阅机制
"""

import asyncio
import random
import hashlib
import time
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass, field
from enum import Enum
import statistics

class CreatorCategory(Enum):
    FILMMAKER = "filmmaker"       # 电影制作人
    MUSICIAN = "musician"         # 音乐人
    ARTIST = "artist"             # 数字艺术家
    WRITER = "writer"             # 作家
    STREAMER = "streamer"         # 主播
    EDUCATOR = "educator"         # 教育者

class PaymentMethod(Enum):
    CRYPTO_CARD = "crypto_card"   # 加密支付卡
    DIRECT_CHAIN = "direct_chain" # 直接链上支付
    L2_TIP = "l2_tip"            # Layer 2 打赏
    NFT_MEMBERSHIP = "nft_membership"  # NFT会员

@dataclass
class Creator:
    creator_id: str
    name: str
    category: CreatorCategory
    wallet_address: str
    total_earnings: float
    monthly_earnings: float
    fan_count: int
    subscriber_count: int
    royalty_rate: float
    is_verified: bool
    payment_methods: List[PaymentMethod]

@dataclass
class Fan:
    fan_id: str
    wallet_address: str
    total_spent: float
    monthly_spent: float
    favorite_creators: List[str]
    preferred_payment: PaymentMethod

@dataclass
class Transaction:
    tx_id: str
    from_address: str
    to_address: str
    amount: float
    fee: float
    payment_method: PaymentMethod
    timestamp: float
    content_url: str
    status: str  # pending, confirmed, failed
    creator_id: str
    fan_id: str

class CreatorPaymentSystem:
    """
    创作者链上支付系统
    模拟加密支付卡、打赏和订阅的完整流程
    """
    
    def __init__(self):
        self.creators: Dict[str, Creator] = {}
        self.fans: Dict[str, Fan] = {}
        self.transactions: List[Transaction] = []
        self.platform_fee_rate = 0.0025  # 0.25%
        self.total_volume = 0.0
        self.total_fees = 0.0
        
    def register_creator(
        self,
        name: str,
        category: CreatorCategory,
        royalty_rate: float = 0.05
    ) -> str:
        """注册创作者"""
        creator_id = hashlib.sha256(
            f"creator_{len(self.creators)}_{name}_{time.time()}".encode()
        ).hexdigest()[:12]
        
        creator = Creator(
            creator_id=creator_id,
            name=name,
            category=category,
            wallet_address=f"0x{hashlib.sha256(creator_id.encode()).hexdigest()[:40]}",
            total_earnings=0.0,
            monthly_earnings=0.0,
            fan_count=0,
            subscriber_count=0,
            royalty_rate=royalty_rate,
            is_verified=False,
            payment_methods=[PaymentMethod.CRYPTO_CARD, PaymentMethod.DIRECT_CHAIN]
        )
        
        self.creators[creator_id] = creator
        return creator_id
    
    def register_fan(self, wallet_address: str) -> str:
        """注册粉丝"""
        fan_id = hashlib.sha256(
            f"fan_{len(self.fans)}_{wallet_address}_{time.time()}".encode()
        ).hexdigest()[:12]
        
        fan = Fan(
            fan_id=fan_id,
            wallet_address=wallet_address,
            total_spent=0.0,
            monthly_spent=0.0,
            favorite_creators=[],
            preferred_payment=PaymentMethod.L2_TIP
        )
        
        self.fans[fan_id] = fan
        return fan_id
    
    async def send_tip(
        self,
        fan_id: str,
        creator_id: str,
        amount: float,
        payment_method: PaymentMethod,
        content_url: str = ""
    ) -> Transaction:
        """发送打赏"""
        if fan_id not in self.fans:
            raise ValueError("粉丝未注册")
        if creator_id not in self.creators:
            raise ValueError("创作者未注册")
        
        fan = self.fans[fan_id]
        creator = self.creators[creator_id]
        
        # 计算费用
        fee = amount * self.platform_fee_rate
        if payment_method == PaymentMethod.CRYPTO_CARD:
            fee += 0.30  # 固定手续费
        elif payment_method == PaymentMethod.L2_TIP:
            fee = 0.001  # Layer 2 低费用
        
        creator_amount = amount - fee
        
        # 模拟链上交易延迟
        await asyncio.sleep(random.uniform(0.1, 0.5))
        
        # 创建交易记录
        tx_id = hashlib.sha256(
            f"tx_{len(self.transactions)}_{fan_id}_{creator_id}_{time.time()}".encode()
        ).hexdigest()[:16]
        
        tx = Transaction(
            tx_id=tx_id,
            from_address=fan.wallet_address,
            to_address=creator.wallet_address,
            amount=amount,
            fee=fee,
            payment_method=payment_method,
            timestamp=time.time(),
            content_url=content_url,
            status="confirmed",
            creator_id=creator_id,
            fan_id=fan_id
        )
        
        self.transactions.append(tx)
        
        # 更新状态
        creator.total_earnings += creator_amount
        creator.monthly_earnings += creator_amount
        creator.fan_count += 1
        
        fan.total_spent += amount
        fan.monthly_spent += amount
        if creator_id not in fan.favorite_creators:
            fan.favorite_creators.append(creator_id)
        
        self.total_volume += amount
        self.total_fees += fee
        
        return tx
    
    async def create_subscription(
        self,
        fan_id: str,
        creator_id: str,
        monthly_amount: float,
        months: int = 1
    ) -> List[Transaction]:
        """创建订阅"""
        txs = []
        for _ in range(months):
            tx = await self.send_tip(
                fan_id, creator_id, monthly_amount,
                PaymentMethod.CRYPTO_CARD,
                content_url=f"subscription_{creator_id}_{int(time.time())}"
            )
            txs.append(tx)
            self.creators[creator_id].subscriber_count += 1
            await asyncio.sleep(0.1)
        
        return txs
    
    def calculate_platform_comparison(self) -> Dict:
        """计算平台费用对比"""
        total_volume = sum(t.amount for t in self.transactions)
        
        # 传统平台费用
        traditional_fees = {
            "youtube": total_volume * 0.45,      # 45% 抽成
            "twitch": total_volume * 0.50,        # 50% 抽成
            "onlyfans": total_volume * 0.20,      # 20% 抽成
            "patreon": total_volume * 0.12,       # 12% 抽成
            "stripe": total_volume * 0.029 + 0.30 * len(self.transactions),  # 2.9%+0.30
        }
        
        chain_fees = {
            "ethereum_l1": total_volume * 0.0025 + 2.50 * len(self.transactions),  # 高Gas
            "arbitrum": total_volume * 0.0025 + 0.02 * len(self.transactions),      # L2低Gas
            "polygon": total_volume * 0.0025 + 0.01 * len(self.transactions),       # 低费用
            "solana": total_volume * 0.0025 + 0.0002 * len(self.transactions),      # 极低费用
        }
        
        return {
            "traditional": traditional_fees,
            "chain": chain_fees,
            "savings_vs_youtube": {
                "arbitrum": traditional_fees["youtube"] - chain_fees["arbitrum"],
                "solana": traditional_fees["youtube"] - chain_fees["solana"]
            }
        }
    
    def get_creator_ranking(self) -> List[Dict]:
        """获取创作者收入排名"""
        ranking = []
        for creator_id, creator in self.creators.items():
            ranking.append({
                "name": creator.name,
                "category": creator.category.value,
                "total_earnings": creator.total_earnings,
                "monthly_earnings": creator.monthly_earnings,
                "fan_count": creator.fan_count,
                "subscriber_count": creator.subscriber_count,
                "avg_tip": creator.total_earnings / max(creator.fan_count, 1)
            })
        
        return sorted(ranking, key=lambda x: x["total_earnings"], reverse=True)
    
    def get_system_stats(self) -> Dict:
        """获取系统统计"""
        return {
            "total_creators": len(self.creators),
            "total_fans": len(self.fans),
            "total_transactions": len(self.transactions),
            "total_volume": round(self.total_volume, 2),
            "total_fees": round(self.total_fees, 2),
            "avg_transaction": round(
                self.total_volume / len(self.transactions), 2
            ) if self.transactions else 0,
            "effective_fee_rate": round(
                self.total_fees / self.total_volume * 100, 2
            ) if self.total_volume > 0 else 0
        }

# 运行模拟
async def main():
    system = CreatorPaymentSystem()
    
    print("=== 创作者经济链上支付系统模拟 ===\n")
    
    # 注册创作者
    print("注册创作者...")
    creators_data = [
        ("王森涛 (Film Director)", CreatorCategory.FILMMAKER, 0.08),
        ("Luna Chen (Digital Artist)", CreatorCategory.ARTIST, 0.10),
        ("DJ Resonance (Musician)", CreatorCategory.MUSICIAN, 0.05),
        ("TechTutor (Educator)", CreatorCategory.EDUCATOR, 0.03),
        ("GameStreamer (Streamer)", CreatorCategory.STREAMER, 0.06),
        ("NovelWriter (Writer)", CreatorCategory.WRITER, 0.07),
    ]
    
    creator_ids = {}
    for name, category, royalty in creators_data:
        cid = system.register_creator(name, category, royalty)
        system.creators[cid].is_verified = True
        creator_ids[name] = cid
        print(f"  {name}: {cid[:8]}")
    
    # 注册粉丝
    print("\n注册粉丝...")
    fan_ids = {}
    for i in range(20):
        wallet = f"0x{hashlib.sha256(f'fan_{i}'.encode()).hexdigest()[:40]}"
        fid = system.register_fan(wallet)
        fan_ids[f"fan_{i}"] = fid
    
    print(f"  已注册 {len(fan_ids)} 个粉丝")
    
    # 模拟打赏活动
    print("\n=== 模拟打赏活动 ===\n")
    
    payment_methods = [
        PaymentMethod.CRYPTO_CARD,
        PaymentMethod.DIRECT_CHAIN,
        PaymentMethod.L2_TIP,
        PaymentMethod.NFT_MEMBERSHIP
    ]
    
    for i in range(50):
        # 随机选择粉丝和创作者
        fan = random.choice(list(fan_ids.values()))
        creator = random.choice(list(creator_ids.values()))
        
        # 随机金额
        if random.random() < 0.7:  # 70% 小额打赏
            amount = round(random.uniform(0.5, 20), 2)
        else:  # 30% 大额打赏
            amount = round(random.uniform(20, 500), 2)
        
        # 随机支付方式
        method = random.choice(payment_methods)
        
        # 发送打赏
        tx = await system.send_tip(
            fan, creator, amount, method,
            content_url=f"https://bcu.lat/content/{i}"
        )
        
        creator_name = system.creators[creator].name
        fan_id_short = fan[:8]
        print(f"  打赏 #{i+1}: {fan_id_short} → {creator_name[:12]} "
              f"${amount:.2f} ({method.value})")
    
    # 模拟订阅
    print("\n=== 模拟订阅 ===\n")
    
    for i in range(5):
        fan = random.choice(list(fan_ids.values()))
        creator = random.choice(list(creator_ids.values()))
        monthly = round(random.uniform(5, 50), 2)
        
        txs = await system.create_subscription(fan, creator, monthly, 1)
        creator_name = system.creators[creator].name
        print(f"  订阅: fan_{fan[:8]} → {creator_name[:12]} "
              f"${monthly}/月")
    
    # 统计
    print("\n=== 支付系统统计 ===")
    stats = system.get_system_stats()
    for key, value in stats.items():
        print(f"  {key}: {value}")
    
    # 创作者排名
    print("\n=== 创作者收入排名 ===")
    ranking = system.get_creator_ranking()
    for i, creator in enumerate(ranking[:5], 1):
        print(f"  #{i} {creator['name'][:15]}: "
              f"${creator['total_earnings']:.2f} 总收入, "
              f"${creator['monthly_earnings']:.2f}/月, "
              f"{creator['fan_count']} 粉丝")
    
    # 费用对比
    print("\n=== 费用对比 (传统平台 vs 链上) ===")
    comparison = system.calculate_platform_comparison()
    
    print("传统平台费用:")
    for platform, fee in comparison["traditional"].items():
        print(f"  {platform}: ${fee:.2f}")
    
    print("\n链上费用:")
    for chain, fee in comparison["chain"].items():
        print(f"  {chain}: ${fee:.2f}")
    
    print("\n节省对比 (vs YouTube):")
    for chain, savings in comparison["savings_vs_youtube"].items():
        print(f"  使用 {chain}: 节省 ${savings:.2f}")

if __name__ == "__main__":
    asyncio.run(main())