社交Token与粉丝经济：从明星代言到社区代币

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

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

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

    enum TokenTier {
        BRONZE, SILVER, GOLD, PLATINUM, DIAMOND
    }

    enum AccessType {
        CONTENT, EVENT, MERCHANDISE, VOTE, CHAT, EXCLUSIVE
    }

    struct CreatorInfo {
        address creator;
        string name;
        string description;
        string ipfsCID;
        uint256 totalSupply;
        uint256 price;
        uint256 revenue;
        uint256 fanCount;
        bool isActive;
    }

    struct FanInfo {
        address fan;
        uint256 balance;
        TokenTier tier;
        uint256 joinedAt;
        uint256 totalSpent;
        uint256 lastAccess;
        AccessType[] accessRights;
    }

    struct TokenGate {
        uint256 gateId;
        string name;
        AccessType accessType;
        uint256 requiredBalance;
        uint256 requiredTier;
        string contentURI;
        bool isActive;
    }

    mapping(address => CreatorInfo) public creators;
    mapping(address => FanInfo) public fans;
    mapping(uint256 => TokenGate) public tokenGates;
    mapping(address => mapping(AccessType => bool)) public accessRights;

    uint256 public gateCount;
    uint256 public totalRevenue;
    uint256 public creatorCount;
    uint256 public fanCount;
    uint256 public basePrice = 0.01 ether;

    event TokenPurchased(address indexed fan, address indexed creator, uint256 amount);
    event TokenGateCreated(uint256 indexed gateId, string name, AccessType accessType);
    event RevenueDistributed(address indexed creator, uint256 amount);
    event TierUpgraded(address indexed fan, TokenTier newTier);

    constructor() ERC20("Social Token", "SOCIAL") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function registerCreator(
        string memory _name,
        string memory _description,
        string memory _ipfsCID
    ) external {
        require(creators[msg.sender].creator == address(0), "Already registered");
        creatorCount++;

        creators[msg.sender] = CreatorInfo({
            creator: msg.sender,
            name: _name,
            description: _description,
            ipfsCID: _ipfsCID,
            totalSupply: 0,
            price: basePrice,
            revenue: 0,
            fanCount: 0,
            isActive: true
        });

        _grantRole(CREATOR_ROLE, msg.sender);
    }

    function purchaseToken(address _creator) external payable nonReentrant {
        CreatorInfo storage creator = creators[_creator];
        require(creator.isActive, "Creator not active");
        require(msg.value >= creator.price, "Insufficient payment");

        uint256 tokenAmount = msg.value / creator.price;
        _mint(msg.sender, tokenAmount);
        creator.totalSupply += tokenAmount;
        creator.revenue += msg.value;
        totalRevenue += msg.value;

        if (fans[msg.sender].fan == address(0)) {
            fans[msg.sender] = FanInfo({
                fan: msg.sender,
                balance: 0,
                tier: TokenTier.BRONZE,
                joinedAt: block.timestamp,
                totalSpent: 0,
                lastAccess: block.timestamp,
                accessRights: new AccessType[](0)
            });
            fanCount++;
            creator.fanCount++;
            _grantRole(FAN_ROLE, msg.sender);
        }

        FanInfo storage fan = fans[msg.sender];
        fan.balance += tokenAmount;
        fan.totalSpent += msg.value;
        fan.lastAccess = block.timestamp;

        // Update tier based on balance
        if (fan.balance >= 10000) {
            fan.tier = TokenTier.DIAMOND;
        } else if (fan.balance >= 5000) {
            fan.tier = TokenTier.PLATINUM;
        } else if (fan.balance >= 1000) {
            fan.tier = TokenTier.GOLD;
        } else if (fan.balance >= 100) {
            fan.tier = TokenTier.SILVER;
        }

        emit TokenPurchased(msg.sender, _creator, tokenAmount);
    }

    function createTokenGate(
        string memory _name,
        AccessType _accessType,
        uint256 _requiredBalance,
        uint256 _requiredTier,
        string memory _contentURI
    ) external onlyRole(CREATOR_ROLE) returns (uint256) {
        gateCount++;
        tokenGates[gateCount] = TokenGate({
            gateId: gateCount,
            name: _name,
            accessType: _accessType,
            requiredBalance: _requiredBalance,
            requiredTier: _requiredTier,
            contentURI: _contentURI,
            isActive: true
        });

        emit TokenGateCreated(gateCount, _name, _accessType);
        return gateCount;
    }

    function checkAccess(uint256 _gateId) external view returns (bool) {
        TokenGate storage gate = tokenGates[_gateId];
        FanInfo storage fan = fans[msg.sender];

        if (fan.balance < gate.requiredBalance) return false;
        if (uint256(fan.tier) < gate.requiredTier) return false;
        return true;
    }

    function distributeRevenue(address _creator, uint256 _amount) external onlyRole(CREATOR_ROLE) {
        CreatorInfo storage creator = creators[_creator];
        require(creator.isActive, "Creator not active");

        uint256 fanShare = _amount / 2;
        uint256 creatorShare = _amount - fanShare;

        // Distribute to fans based on token holdings
        creator.revenue += creatorShare;
        payable(_creator).transfer(creatorShare);

        emit RevenueDistributed(_creator, _amount);
    }

    function getFanTier(address _fan) external view returns (TokenTier) {
        return fans[_fan].tier;
    }

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

import json
import hashlib
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime
from web3 import Web3
import random

@dataclass
class Creator:
    address: str
    name: str
    token_symbol: str
    total_supply: int
    price: float
    fan_count: int
    revenue: float

@dataclass
class Fan:
    address: str
    balance: int
    tier: str
    total_spent: float
    joined_at: str

class SocialTokenPlatform:
    def __init__(self):
        self.creators: Dict[str, Creator] = {}
        self.fans: Dict[str, Fan] = {}
        self.token_holders: Dict[str, Dict[str, int]] = {}
        self.token_gates: Dict[str, Dict] = {}

    def register_creator(self, address: str, name: str, symbol: str, initial_price: float) -> Creator:
        creator = Creator(
            address=address,
            name=name,
            token_symbol=symbol,
            total_supply=0,
            price=initial_price,
            fan_count=0,
            revenue=0
        )
        self.creators[address] = creator
        self.token_holders[address] = {}
        return creator

    def purchase_token(self, fan_address: str, creator_address: str, amount: float) -> Dict:
        creator = self.creators.get(creator_address)
        if not creator:
            raise ValueError("Creator not found")

        token_amount = int(amount / creator.price)
        creator.total_supply += token_amount
        creator.revenue += amount
        creator.fan_count += 1

        if fan_address not in self.token_holders[creator_address]:
            self.token_holders[creator_address][fan_address] = 0
        self.token_holders[creator_address][fan_address] += token_amount

        if fan_address not in self.fans:
            self.fans[fan_address] = Fan(
                address=fan_address,
                balance=0,
                tier='bronze',
                total_spent=0,
                joined_at=datetime.now().isoformat()
            )

        fan = self.fans[fan_address]
        fan.balance += token_amount
        fan.total_spent += amount
        fan.tier = self._calculate_tier(fan.balance)

        return {
            'fan': fan_address,
            'creator': creator_address,
            'tokens': token_amount,
            'price': creator.price,
            'total': amount
        }

    def _calculate_tier(self, balance: int) -> str:
        if balance >= 10000: return 'diamond'
        if balance >= 5000: return 'platinum'
        if balance >= 1000: return 'gold'
        if balance >= 100: return 'silver'
        return 'bronze'

    def create_token_gate(self, creator_address: str, name: str, required_balance: int,
                          required_tier: str, content_uri: str) -> Dict:
        gate_id = hashlib.sha256(f"{creator_address}{name}{datetime.now()}".encode()).hexdigest()[:8]
        gate = {
            'gate_id': gate_id,
            'creator': creator_address,
            'name': name,
            'required_balance': required_balance,
            'required_tier': required_tier,
            'content_uri': content_uri,
            'is_active': True
        }
        self.token_gates[gate_id] = gate
        return gate

    def check_access(self, fan_address: str, gate_id: str) -> Dict:
        gate = self.token_gates.get(gate_id)
        if not gate:
            return {'access': False, 'reason': 'Gate not found'}

        fan = self.fans.get(fan_address)
        if not fan:
            return {'access': False, 'reason': 'Fan not found'}

        tier_values = {'bronze': 0, 'silver': 1, 'gold': 2, 'platinum': 3, 'diamond': 4}
        fan_tier_value = tier_values.get(fan.tier, 0)
        required_tier_value = tier_values.get(gate['required_tier'], 0)

        if fan.balance < gate['required_balance']:
            return {'access': False, 'reason': 'Insufficient balance'}
        if fan_tier_value < required_tier_value:
            return {'access': False, 'reason': 'Insufficient tier'}

        return {'access': True, 'content_uri': gate['content_uri']}

    def distribute_revenue(self, creator_address: str, amount: float) -> Dict:
        creator = self.creators.get(creator_address)
        if not creator:
            raise ValueError("Creator not found")

        fan_share = amount * 0.5
        creator_share = amount * 0.5
        total_tokens = sum(self.token_holders[creator_address].values())

        if total_tokens == 0:
            return {'creator': creator_address, 'creator_share': creator_share, 'fan_distributions': []}

        distributions = []
        for fan_address, token_balance in self.token_holders[creator_address].items():
            share = (token_balance / total_tokens) * fan_share
            distributions.append({'fan': fan_address, 'amount': share})

        creator.revenue += creator_share
        return {
            'creator': creator_address,
            'creator_share': creator_share,
            'fan_share': fan_share,
            'fan_distributions': distributions
        }

    def get_creator_stats(self, creator_address: str) -> Dict:
        creator = self.creators.get(creator_address)
        if not creator:
            return {}
        return {
            'name': creator.name,
            'token_symbol': creator.token_symbol,
            'total_supply': creator.total_supply,
            'price': creator.price,
            'fan_count': creator.fan_count,
            'revenue': creator.revenue,
            'market_cap': creator.total_supply * creator.price
        }

    def get_fan_stats(self, fan_address: str) -> Dict:
        fan = self.fans.get(fan_address)
        if not fan:
            return {}
        return {
            'balance': fan.balance,
            'tier': fan.tier,
            'total_spent': fan.total_spent,
            'joined_at': fan.joined_at
        }

platform = SocialTokenPlatform()
creator = platform.register_creator('0xCreator', 'SATOSHI FILM', 'SFILM', 0.1)
result = platform.purchase_token('0xFan1', '0xCreator', 100)
print(f"Fan purchased {result['tokens']} tokens at ${result['price']}")

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

class SocialTokenClient {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.creators = new Map();
    this.fans = new Map();
    this.tokenHolders = new Map();
    this.tokenGates = new Map();
  }

  async registerCreator(address, name, symbol, initialPrice) {
    const creator = {
      address,
      name,
      symbol,
      totalSupply: 0,
      price: ethers.utils.parseEther(initialPrice.toString()),
      fanCount: 0,
      revenue: ethers.BigNumber.from(0),
      isActive: true
    };
    this.creators.set(address, creator);
    this.tokenHolders.set(address, new Map());
    return creator;
  }

  async purchaseToken(fanAddress, creatorAddress, amount) {
    const creator = this.creators.get(creatorAddress);
    if (!creator) throw new Error('Creator not found');

    const amountWei = ethers.utils.parseEther(amount.toString());
    const tokenAmount = amountWei.div(creator.price).toNumber();

    creator.totalSupply += tokenAmount;
    creator.revenue = creator.revenue.add(amountWei);
    creator.fanCount++;

    if (!this.tokenHolders.get(creatorAddress).has(fanAddress)) {
      this.tokenHolders.get(creatorAddress).set(fanAddress, 0);
    }
    this.tokenHolders.get(creatorAddress).set(
      fanAddress,
      this.tokenHolders.get(creatorAddress).get(fanAddress) + tokenAmount
    );

    if (!this.fans.has(fanAddress)) {
      this.fans.set(fanAddress, {
        address: fanAddress,
        balance: 0,
        tier: 'bronze',
        totalSpent: ethers.BigNumber.from(0),
        joinedAt: Math.floor(Date.now() / 1000)
      });
    }

    const fan = this.fans.get(fanAddress);
    fan.balance += tokenAmount;
    fan.totalSpent = fan.totalSpent.add(amountWei);
    fan.tier = this.calculateTier(fan.balance);

    return {
      fan: fanAddress,
      creator: creatorAddress,
      tokens: tokenAmount,
      price: ethers.utils.formatEther(creator.price),
      total: amount
    };
  }

  calculateTier(balance) {
    if (balance >= 10000) return 'diamond';
    if (balance >= 5000) return 'platinum';
    if (balance >= 1000) return 'gold';
    if (balance >= 100) return 'silver';
    return 'bronze';
  }

  async createTokenGate(creatorAddress, name, requiredBalance, requiredTier, contentURI) {
    const gateId = ethers.utils.keccak256(
      ethers.utils.toUtf8Bytes(`${creatorAddress}${name}${Date.now()}`)
    ).slice(0, 10);

    const gate = {
      gateId,
      creator: creatorAddress,
      name,
      requiredBalance,
      requiredTier,
      contentURI,
      isActive: true
    };

    this.tokenGates.set(gateId, gate);
    return gate;
  }

  async checkAccess(fanAddress, gateId) {
    const gate = this.tokenGates.get(gateId);
    if (!gate) return { access: false, reason: 'Gate not found' };

    const fan = this.fans.get(fanAddress);
    if (!fan) return { access: false, reason: 'Fan not found' };

    const tierValues = { bronze: 0, silver: 1, gold: 2, platinum: 3, diamond: 4 };
    const fanTierValue = tierValues[fan.tier] || 0;
    const requiredTierValue = tierValues[gate.requiredTier] || 0;

    if (fan.balance < gate.requiredBalance) {
      return { access: false, reason: 'Insufficient balance' };
    }
    if (fanTierValue < requiredTierValue) {
      return { access: false, reason: 'Insufficient tier' };
    }

    return { access: true, contentURI: gate.contentURI };
  }

  async distributeRevenue(creatorAddress, amount) {
    const creator = this.creators.get(creatorAddress);
    if (!creator) throw new Error('Creator not found');

    const amountWei = ethers.utils.parseEther(amount.toString());
    const fanShare = amountWei.div(2);
    const creatorShare = amountWei.sub(fanShare);

    const holders = this.tokenHolders.get(creatorAddress);
    let totalTokens = 0;
    for (const balance of holders.values()) {
      totalTokens += balance;
    }

    const distributions = [];
    if (totalTokens > 0) {
      for (const [fanAddress, tokenBalance] of holders) {
        const share = fanShare.mul(tokenBalance).div(totalTokens);
        distributions.push({ fan: fanAddress, amount: ethers.utils.formatEther(share) });
      }
    }

    creator.revenue = creator.revenue.add(creatorShare);
    return {
      creator: creatorAddress,
      creatorShare: ethers.utils.formatEther(creatorShare),
      fanShare: ethers.utils.formatEther(fanShare),
      distributions
    };
  }

  getCreatorStats(creatorAddress) {
    const creator = this.creators.get(creatorAddress);
    if (!creator) return null;
    return {
      name: creator.name,
      symbol: creator.symbol,
      totalSupply: creator.totalSupply,
      price: ethers.utils.formatEther(creator.price),
      fanCount: creator.fanCount,
      revenue: ethers.utils.formatEther(creator.revenue),
      marketCap: ethers.utils.formatEther(creator.price.mul(creator.totalSupply))
    };
  }
}

const client = new SocialTokenClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
client.registerCreator('0xCreator', 'Satoshi Film DAO', 'SFILM', 0.1)
  .then(c => console.log('Creator:', c.name));