链上社区与粉丝经济：从粉丝到DAO成员

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

/**
 * @title 粉丝DAO合约
 */
contract FanDAO {
    struct Member {
        address wallet;
        uint256 joinedAt;
        uint256 contribution;
        uint256 votingPower;
        bool isActive;
    }
    
    struct Proposal {
        uint256 id;
        string title;
        string description;
        uint256 forVotes;
        uint256 againstVotes;
        uint256 endTime;
        bool executed;
        ProposalType pType;
        address target;
        uint256 value;
        bytes data;
    }
    
    enum ProposalType { FUNDING, CONTENT, GOVERNANCE, PARTNERSHIP }
    
    mapping(address => Member) public members;
    mapping(uint256 => Proposal) public proposals;
    mapping(uint256 => mapping(address => bool)) public hasVoted;
    
    address[] public memberList;
    uint256 public nextProposalId;
    uint256 public quorum;
    uint256 public votingPeriod;
    
    event MemberJoined(address indexed member);
    event ProposalCreated(uint256 indexed id, string title);
    event ProposalExecuted(uint256 indexed id);
    event VoteCast(uint256 indexed proposalId, address voter, bool support);
    
    constructor(uint256 _quorum, uint256 _votingPeriod) {
        quorum = _quorum;
        votingPeriod = _votingPeriod;
    }
    
    function joinDAO() external {
        require(!members[msg.sender].isActive, "Already member");
        members[msg.sender] = Member({
            wallet: msg.sender,
            joinedAt: block.timestamp,
            contribution: 0,
            votingPower: 1,
            isActive: true
        });
        memberList.push(msg.sender);
        emit MemberJoined(msg.sender);
    }
    
    function createProposal(
        string memory title,
        string memory description,
        ProposalType pType,
        address target,
        uint256 value,
        bytes memory data
    ) external returns (uint256) {
        require(members[msg.sender].isActive, "Not member");
        
        uint256 id = nextProposalId++;
        proposals[id] = Proposal({
            id: id,
            title: title,
            description: description,
            forVotes: 0,
            againstVotes: 0,
            endTime: block.timestamp + votingPeriod,
            executed: false,
            pType: pType,
            target: target,
            value: value,
            data: data
        });
        emit ProposalCreated(id, title);
        return id;
    }
    
    function vote(uint256 proposalId, bool support) external {
        require(members[msg.sender].isActive, "Not member");
        require(!hasVoted[proposalId][msg.sender], "Already voted");
        require(block.timestamp < proposals[proposalId].endTime, "Voting ended");
        
        hasVoted[proposalId][msg.sender] = true;
        uint256 votes = members[msg.sender].votingPower;
        
        if (support) {
            proposals[proposalId].forVotes += votes;
        } else {
            proposals[proposalId].againstVotes += votes;
        }
        
        emit VoteCast(proposalId, msg.sender, support);
    }
    
    function executeProposal(uint256 proposalId) external {
        Proposal storage proposal = proposals[proposalId];
        require(!proposal.executed, "Already executed");
        require(block.timestamp >= proposal.endTime, "Voting not ended");
        require(proposal.forVotes > proposal.againstVotes, "Proposal rejected");
        require(proposal.forVotes + proposal.againstVotes >= quorum, "Quorum not met");
        
        proposal.executed = true;
        (bool success, ) = proposal.target.call{value: proposal.value}(proposal.data);
        require(success, "Execution failed");
        
        emit ProposalExecuted(proposalId);
    }
    
    function getMemberCount() external view returns (uint256) {
        return memberList.length;
    }
}

from typing import Dict, List
import json

class CommunityAnalyzer:
    """社区分析工具"""
    
    def analyze_engagement(self, members: List[Dict]) -> Dict:
        """分析社区参与度"""
        active = sum(1 for m in members if m.get('active'))
        total_votes = sum(m.get('votes_cast', 0) for m in members)
        return {
            'total_members': len(members),
            'active_members': active,
            'engagement_rate': active / len(members) if members else 0,
            'total_votes': total_votes,
            'avg_votes_per_member': total_votes / max(len(members), 1)
        }
    
    def analyze_treasury(self, transactions: List[Dict]) -> Dict:
        """分析社区资金"""
        total_in = sum(t['amount'] for t in transactions if t['type'] == 'in')
        total_out = sum(t['amount'] for t in transactions if t['type'] == 'out')
        return {
            'total_in': total_in,
            'total_out': total_out,
            'balance': total_in - total_out,
            'transaction_count': len(transactions)
        }

analyzer = CommunityAnalyzer()

class CommunityDashboard {
  constructor(contractAddress, providerUrl) {
    this.contract = new ethers.Contract(contractAddress, FanDAOABI,
      new ethers.providers.JsonRpcProvider(providerUrl));
  }

  async getMemberInfo(address) {
    return this.contract.members(address);
  }

  async getProposals() {
    const total = await this.contract.nextProposalId();
    const proposals = [];
    for (let i = 1; i < total.toNumber(); i++) {
      const proposal = await this.contract.proposals(i);
      proposals.push(proposal);
    }
    return proposals;
  }
}

const dashboard = new CommunityDashboard('0xContractAddress', 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');