链上订阅与内容变现：Token-gated访问的创作者经济

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

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

contract TokenGatedContent is ERC721, AccessControl, ReentrancyGuard {
    using Counters for Counters.Counter;

    bytes32 public constant CREATOR_ROLE = keccak256("CREATOR_ROLE");

    Counters.Counter private _tokenIdCounter;

    enum SubscriptionTier {
        FREE,       // 免费
        BASIC,      // 基础
        PREMIUM,    // 高级
        VIP,        // VIP
        CUSTOM      // 自定义
    }

    enum ContentType {
        ARTICLE, VIDEO, AUDIO, IMAGE, COURSE, LIVE_STREAM, PODCAST, OTHER
    }

    struct Content {
        uint256 contentId;
        string title;
        string description;
        ContentType contentType;
        string ipfsCID;
        SubscriptionTier requiredTier;
        address creator;
        uint256 createdAt;
        uint256 viewCount;
        uint256 revenue;
        bool isActive;
    }

    struct Subscription {
        address subscriber;
        SubscriptionTier tier;
        uint256 startedAt;
        uint256 expiresAt;
        uint256 renewals;
        bool isActive;
    }

    struct Creator {
        address creatorAddress;
        string name;
        string bio;
        string avatarCID;
        uint256 totalContent;
        uint256 totalSubscribers;
        uint256 totalRevenue;
        SubscriptionTier[] availableTiers;
        uint256[] tierPrices;
        bool isActive;
    }

    uint256 private _contentCounter;
    uint256 private _creatorCounter;

    mapping(uint256 => Content) public contents;
    mapping(address => Creator) public creators;
    mapping(address => Subscription) public subscriptions;
    mapping(uint256 => address[]) public contentViewers;
    mapping(address => uint256) public unclaimedRevenue;

    uint256 public constant PLATFORM_FEE = 250; // 2.5%
    IERC20 public paymentToken;

    event CreatorRegistered(address indexed creator, string name);
    event ContentPublished(uint256 indexed contentId, string title, address indexed creator);
    event Subscribed(address indexed subscriber, SubscriptionTier tier);
    event ContentAccessed(uint256 indexed contentId, address indexed viewer);
    event RevenueClaimed(address indexed creator, uint256 amount);

    constructor(address _paymentToken) ERC721("TokenGatedContent", "TGC") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        paymentToken = IERC20(_paymentToken);
    }

    function registerCreator(
        string memory _name,
        string memory _bio,
        string memory _avatarCID,
        SubscriptionTier[] memory _tiers,
        uint256[] memory _prices
    ) external {
        require(creators[msg.sender].creatorAddress == address(0), "Already registered");
        creators[msg.sender] = Creator({
            creatorAddress: msg.sender,
            name: _name,
            bio: _bio,
            avatarCID: _avatarCID,
            totalContent: 0,
            totalSubscribers: 0,
            totalRevenue: 0,
            availableTiers: _tiers,
            tierPrices: _prices,
            isActive: true
        });
        _grantRole(CREATOR_ROLE, msg.sender);
        _creatorCounter++;
        emit CreatorRegistered(msg.sender, _name);
    }

    function publishContent(
        string memory _title,
        string memory _description,
        ContentType _contentType,
        string memory _ipfsCID,
        SubscriptionTier _requiredTier
    ) external onlyRole(CREATOR_ROLE) {
        Creator storage creator = creators[msg.sender];
        uint256 contentId = _contentCounter++;
        contents[contentId] = Content({
            contentId: contentId,
            title: _title,
            description: _description,
            contentType: _contentType,
            ipfsCID: _ipfsCID,
            requiredTier: _requiredTier,
            creator: msg.sender,
            createdAt: block.timestamp,
            viewCount: 0,
            revenue: 0,
            isActive: true
        });
        creator.totalContent++;
        emit ContentPublished(contentId, _title, msg.sender);
    }

    function subscribe(SubscriptionTier _tier) external payable nonReentrant {
        Creator storage creator = creators[msg.sender];
        require(creator.isActive, "Creator not active");
        uint256 price = _getTierPrice(msg.sender, _tier);
        require(msg.value >= price, "Insufficient payment");
        subscriptions[msg.sender] = Subscription({
            subscriber: msg.sender,
            tier: _tier,
            startedAt: block.timestamp,
            expiresAt: block.timestamp + 30 days,
            renewals: 0,
            isActive: true
        });
        uint256 platformFee = price * PLATFORM_FEE / 10000;
        uint256 creatorRevenue = price - platformFee;
        unclaimedRevenue[msg.sender] += creatorRevenue;
        creator.totalSubscribers++;
        emit Subscribed(msg.sender, _tier);
    }

    function _getTierPrice(address _creator, SubscriptionTier _tier) internal view returns (uint256) {
        Creator storage creator = creators[_creator];
        for (uint256 i = 0; i < creator.availableTiers.length; i++) {
            if (creator.availableTiers[i] == _tier) {
                return creator.tierPrices[i];
            }
        }
        revert("Tier not available");
    }

    function accessContent(uint256 _contentId) external returns (string memory) {
        Content storage content = contents[_contentId];
        require(content.isActive, "Content not active");
        Subscription storage sub = subscriptions[msg.sender];
        if (content.requiredTier == SubscriptionTier.FREE) {
            content.viewCount++;
            emit ContentAccessed(_contentId, msg.sender);
            return content.ipfsCID;
        }
        require(sub.isActive && sub.tier >= content.requiredTier, "Insufficient tier");
        require(block.timestamp < sub.expiresAt, "Subscription expired");
        content.viewCount++;
        content.revenue += _getTierPrice(content.creator, content.requiredTier);
        emit ContentAccessed(_contentId, msg.sender);
        return content.ipfsCID;
    }

    function claimRevenue() external nonReentrant {
        uint256 amount = unclaimedRevenue[msg.sender];
        require(amount > 0, "No revenue to claim");
        unclaimedRevenue[msg.sender] = 0;
        payable(msg.sender).transfer(amount);
        emit RevenueClaimed(msg.sender, amount);
    }

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

    function getContent(uint256 _contentId) external view returns (Content memory) {
        return contents[_contentId];
    }
}

# Token-Gated Content Platform
# Decentralized subscription model with token-gated access

import hashlib
import json
import time
from typing import List, Dict, Optional
from dataclasses import dataclass
from enum import Enum

class SubscriptionTier(Enum):
    FREE = 0
    BASIC = 1
    PREMIUM = 2
    VIP = 3
    CUSTOM = 4

class ContentType(Enum):
    ARTICLE = "article"
    VIDEO = "video"
    AUDIO = "audio"
    IMAGE = "image"
    COURSE = "course"
    LIVE_STREAM = "live_stream"
    PODCAST = "podcast"
    OTHER = "other"

@dataclass
class Content:
    content_id: str
    title: str
    description: str
    content_type: ContentType
    ipfs_cid: str
    required_tier: SubscriptionTier
    creator: str
    created_at: float
    view_count: int
    revenue: float
    is_active: bool

@dataclass
class TokenGate:
    token_address: str
    token_id: str
    tier: SubscriptionTier
    price: float
    total_supply: int
    circulating_supply: int
    staking_apy: float

@dataclass
class Creator:
    address: str
    name: str
    bio: str
    avatar_cid: str
    total_content: int
    total_subscribers: int
    total_revenue: float
    available_tiers: List[SubscriptionTier]
    tier_prices: List[float]
    is_active: bool

class TokenGatedPlatform:
    PLATFORM_FEE = 0.025

    def __init__(self):
        self.creators: Dict[str, Creator] = {}
        self.contents: Dict[str, Content] = {}
        self.content_counter = 0
        self.token_gates: Dict[str, TokenGate] = {}
        self.subscriptions: Dict[str, Dict] = {}
        self.unclaimed_revenue: Dict[str, float] = {}

    def register_creator(self, address: str, name: str, bio: str,
                        avatar_cid: str, tiers: List[SubscriptionTier],
                        prices: List[float]) -> Creator:
        if address in self.creators:
            raise ValueError(f"Creator {address} already registered")
        creator = Creator(address=address, name=name, bio=bio, avatar_cid=avatar_cid,
                         total_content=0, total_subscribers=0, total_revenue=0,
                         available_tiers=tiers, tier_prices=prices, is_active=True)
        self.creators[address] = creator
        self.unclaimed_revenue[address] = 0.0
        print(f"[CREATOR] Registered: {name}")
        return creator

    def publish_content(self, creator_address: str, title: str, description: str,
                       content_type: ContentType, ipfs_cid: str,
                       required_tier: SubscriptionTier) -> Content:
        if creator_address not in self.creators:
            raise ValueError(f"Creator {creator_address} not found")
        content_id = f"content_{self.content_counter}"
        self.content_counter += 1
        content = Content(content_id=content_id, title=title, description=description,
                         content_type=content_type, ipfs_cid=ipfs_cid,
                         required_tier=required_tier, creator=creator_address,
                         created_at=time.time(), view_count=0, revenue=0, is_active=True)
        self.contents[content_id] = content
        self.creators[creator_address].total_content += 1
        print(f"[CONTENT] Published: {title} by {self.creators[creator_address].name}")
        return content

    def create_token_gate(self, creator_address: str, token_address: str,
                         token_id: str, tier: SubscriptionTier, price: float,
                         total_supply: int) -> TokenGate:
        gate = TokenGate(token_address=token_address, token_id=token_id, tier=tier,
                        price=price, total_supply=total_supply,
                        circulating_supply=0, staking_apy=0.05)
        self.token_gates[token_id] = gate
        print(f"[TOKEN] Created gate for {tier.name} at ${price}")
        return gate

    def subscribe(self, subscriber: str, creator_address: str, tier: SubscriptionTier) -> Dict:
        if creator_address not in self.creators:
            raise ValueError(f"Creator {creator_address} not found")
        creator = self.creators[creator_address]
        tier_index = creator.available_tiers.index(tier)
        price = creator.tier_prices[tier_index]

        platform_fee = price * self.PLATFORM_FEE
        creator_revenue = price - platform_fee
        self.unclaimed_revenue[creator_address] += creator_revenue
        creator.total_subscribers += 1
        creator.total_revenue += price

        subscription = {
            "subscriber": subscriber,
            "creator": creator_address,
            "tier": tier.name,
            "price": price,
            "started_at": time.time(),
            "expires_at": time.time() + 30 * 86400,
            "is_active": True
        }
        self.subscriptions[f"{subscriber}_{creator_address}"] = subscription
        print(f"[SUBSCRIBE] {subscriber} subscribed to {creator.name} ({tier.name})")
        return subscription

    def access_content(self, content_id: str, user: str) -> Optional[str]:
        if content_id not in self.contents:
            raise ValueError(f"Content {content_id} not found")
        content = self.contents[content_id]
        if not content.is_active:
            raise ValueError("Content not active")

        if content.required_tier == SubscriptionTier.FREE:
            content.view_count += 1
            return content.ipfs_cid

        sub_key = f"{user}_{content.creator}"
        if sub_key not in self.subscriptions:
            raise PermissionError("No active subscription")
        sub = self.subscriptions[sub_key]
        if not sub["is_active"]:
            raise PermissionError("Subscription inactive")
        if time.time() > sub["expires_at"]:
            sub["is_active"] = False
            raise PermissionError("Subscription expired")
        if SubscriptionTier[sub["tier"]].value < content.required_tier.value:
            raise PermissionError("Insufficient tier")

        content.view_count += 1
        return content.ipfs_cid

    def claim_revenue(self, creator_address: str) -> float:
        if creator_address not in self.unclaimed_revenue:
            raise ValueError(f"Creator {creator_address} not found")
        amount = self.unclaimed_revenue[creator_address]
        self.unclaimed_revenue[creator_address] = 0
        print(f"[REVENUE] {creator_address} claimed ${amount:.2f}")
        return amount

    def get_creator_stats(self, address: str) -> Optional[Dict]:
        if address not in self.creators:
            return None
        creator = self.creators[address]
        return {"name": creator.name, "total_content": creator.total_content,
                "total_subscribers": creator.total_subscribers,
                "total_revenue": creator.total_revenue,
                "unclaimed": self.unclaimed_revenue[address]}

# Example
platform = TokenGatedPlatform()
creator = platform.register_creator("0xCREATOR", "Wang Sentao", "Film & Blockchain",
                                   "ipfs://avatar", [SubscriptionTier.BASIC, SubscriptionTier.PREMIUM],
                                   [10.0, 25.0])

content1 = platform.publish_content("0xCREATOR", "Blockchain for Filmmakers",
                                   "A comprehensive guide", ContentType.ARTICLE,
                                   "ipfs://QmArticle1", SubscriptionTier.BASIC)
content2 = platform.publish_content("0xCREATOR", "NFT Filmmaking Masterclass",
                                   "Advanced techniques", ContentType.VIDEO,
                                   "ipfs://QmVideo1", SubscriptionTier.PREMIUM)

platform.create_token_gate("0xCREATOR", "0xTOKEN", "token_basic",
                          SubscriptionTier.BASIC, 10.0, 1000)

sub = platform.subscribe("0xUSER", "0xCREATOR", SubscriptionTier.BASIC)
cid = platform.access_content(content1.content_id, "0xUSER")
print(f"Accessed content: {cid}")

stats = platform.get_creator_stats("0xCREATOR")
print(f"Creator stats: {json.dumps(stats, indent=2)}")

revenue = platform.claim_revenue("0xCREATOR")
print(f"Claimed revenue: ${revenue:.2f}")

// Token-Gated Content Access API
// Decentralized subscription and content monetization

const crypto = require('crypto');

class TokenGatedPlatform {
    constructor() {
        this.creators = new Map();
        this.contents = new Map();
        this.subscriptions = new Map();
        this.tokenGates = new Map();
        this.unclaimedRevenue = new Map();
        this.contentCounter = 0;
        this.PLATFORM_FEE = 0.025;
    }

    registerCreator(address, name, bio, avatarCid, tiers, prices) {
        if (this.creators.has(address)) throw new Error('Already registered');
        const creator = {
            address, name, bio, avatarCid, totalContent: 0,
            totalSubscribers: 0, totalRevenue: 0, availableTiers: tiers,
            tierPrices: prices, isActive: true
        };
        this.creators.set(address, creator);
        this.unclaimedRevenue.set(address, 0);
        console.log(`[CREATOR] Registered: ${name}`);
        return creator;
    }

    publishContent(creatorAddress, title, description, contentType, ipfsCid, requiredTier) {
        if (!this.creators.has(creatorAddress)) throw new Error('Creator not found');
        const contentId = `content_${this.contentCounter++}`;
        const content = {
            contentId, title, description, contentType, ipfsCid,
            requiredTier, creator: creatorAddress, createdAt: Date.now(),
            viewCount: 0, revenue: 0, isActive: true
        };
        this.contents.set(contentId, content);
        this.creators.get(creatorAddress).totalContent++;
        console.log(`[CONTENT] Published: ${title}`);
        return content;
    }

    subscribe(subscriber, creatorAddress, tier) {
        const creator = this.creators.get(creatorAddress);
        if (!creator) throw new Error('Creator not found');
        const tierIndex = creator.availableTiers.indexOf(tier);
        const price = creator.tierPrices[tierIndex];
        const platformFee = price * this.PLATFORM_FEE;
        const creatorRevenue = price - platformFee;
        this.unclaimedRevenue.set(creatorAddress, (this.unclaimedRevenue.get(creatorAddress) || 0) + creatorRevenue);
        creator.totalSubscribers++;
        creator.totalRevenue += price;

        const sub = {
            subscriber, creator: creatorAddress, tier,
            price, startedAt: Date.now(),
            expiresAt: Date.now() + 30 * 86400000,
            isActive: true
        };
        this.subscriptions.set(`${subscriber}_${creatorAddress}`, sub);
        console.log(`[SUBSCRIBE] ${subscriber} -> ${creator.name} (${tier})`);
        return sub;
    }

    accessContent(contentId, user) {
        const content = this.contents.get(contentId);
        if (!content) throw new Error('Content not found');
        if (!content.isActive) throw new Error('Content not active');

        if (content.requiredTier === 'FREE') {
            content.viewCount++;
            return content.ipfsCid;
        }

        const subKey = `${user}_${content.creator}`;
        const sub = this.subscriptions.get(subKey);
        if (!sub) throw new Error('No active subscription');
        if (!sub.isActive) throw new Error('Subscription inactive');
        if (Date.now() > sub.expiresAt) {
            sub.isActive = false;
            throw new Error('Subscription expired');
        }

        const tierValues = {FREE: 0, BASIC: 1, PREMIUM: 2, VIP: 3, CUSTOM: 4};
        if (tierValues[sub.tier] < tierValues[content.requiredTier]) {
            throw new Error('Insufficient tier');
        }

        content.viewCount++;
        return content.ipfsCid;
    }

    claimRevenue(creatorAddress) {
        const amount = this.unclaimedRevenue.get(creatorAddress) || 0;
        this.unclaimedRevenue.set(creatorAddress, 0);
        console.log(`[REVENUE] ${creatorAddress} claimed $${amount.toFixed(2)}`);
        return amount;
    }

    getCreatorStats(address) {
        const creator = this.creators.get(address);
        if (!creator) return null;
        return {
            name: creator.name, totalContent: creator.totalContent,
            totalSubscribers: creator.totalSubscribers,
            totalRevenue: creator.totalRevenue,
            unclaimed: this.unclaimedRevenue.get(address) || 0
        };
    }
}

// Example
const platform = new TokenGatedPlatform();
platform.registerCreator('0xCREATOR', 'Wang Sentao', 'Film & Blockchain',
    'ipfs://avatar', ['BASIC', 'PREMIUM'], [10, 25]);

platform.publishContent('0xCREATOR', 'Blockchain for Filmmakers',
    'A comprehensive guide', 'article', 'ipfs://QmArticle1', 'BASIC');

platform.subscribe('0xUSER', '0xCREATOR', 'BASIC');
const cid = platform.accessContent('content_0', '0xUSER');
console.log('Accessed:', cid);
console.log('Stats:', platform.getCreatorStats('0xCREATOR'));
platform.claimRevenue('0xCREATOR');