链上投票与内容基金：社区决策的资助分配

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

contract ContentFund {
    struct Proposal {
        string title;
        string description;
        address creator;
        uint256 requestedAmount;
        uint256 votesFor;
        uint256 votesAgainst;
        uint256 deadline;
        bool executed;
        bool active;
    }

    struct Voter {
        uint256 weight;
        bool voted;
        bool support;
    }

    mapping(uint256 => Proposal) public proposals;
    mapping(uint256 => mapping(address => Voter)) public voters;
    mapping(address => uint256) public votingPower;
    uint256 public proposalCount;
    uint256 public fundBalance;

    event ProposalCreated(uint256 id, string title, address creator, uint256 amount);
    event VoteCast(uint256 proposalId, address voter, bool support, uint256 weight);
    event FundDistributed(uint256 proposalId, address creator, uint256 amount);

    function createProposal(string calldata title, string calldata description, 
                            uint256 requestedAmount, uint256 votingDays) external {
        proposals[proposalCount] = Proposal({
            title: title,
            description: description,
            creator: msg.sender,
            requestedAmount: requestedAmount,
            votesFor: 0,
            votesAgainst: 0,
            deadline: block.timestamp + votingDays * 1 days,
            executed: false,
            active: true
        });
        proposalCount++;
        emit ProposalCreated(proposalCount - 1, title, msg.sender, requestedAmount);
    }

    function vote(uint256 proposalId, bool support) external {
        Proposal storage p = proposals[proposalId];
        require(block.timestamp < p.deadline, "Voting ended");
        require(!voters[proposalId][msg.sender].voted, "Already voted");
        require(votingPower[msg.sender] > 0, "No voting power");

        voters[proposalId][msg.sender] = Voter(votingPower[msg.sender], true, support);
        if (support) {
            p.votesFor += votingPower[msg.sender];
        } else {
            p.votesAgainst += votingPower[msg.sender];
        }
        emit VoteCast(proposalId, msg.sender, support, votingPower[msg.sender]);
    }

    function executeProposal(uint256 proposalId) external {
        Proposal storage p = proposals[proposalId];
        require(block.timestamp >= p.deadline, "Voting active");
        require(!p.executed, "Executed");
        require(p.votesFor > p.votesAgainst, "Not enough votes");
        require(fundBalance >= p.requestedAmount, "Insufficient funds");

        p.executed = true;
        fundBalance -= p.requestedAmount;
        payable(p.creator).transfer(p.requestedAmount);
        emit FundDistributed(proposalId, p.creator, p.requestedAmount);
    }
}

import random
from typing import Dict, List
import json

class FundAnalyzer:
    def simulate_fund_round(self, n_proposals: int = 10, n_voters: int = 100) -> Dict:
        proposals = []
        for i in range(n_proposals):
            votes_for = random.randint(0, n_voters)
            votes_against = n_voters - votes_for
            proposals.append({
                'id': i,
                'votes_for': votes_for,
                'votes_against': votes_against,
                'approved': votes_for > votes_against
            })
        return {
            'total_proposals': n_proposals,
            'approved': sum(1 for p in proposals if p['approved']),
            'avg_support': sum(p['votes_for'] for p in proposals) / (n_proposals * n_voters) * 100
        }


analyzer = FundAnalyzer()
results = analyzer.simulate_fund_round()
print(json.dumps(results, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const app = express();
app.use(express.json());

const FUND_ABI = [
    "function createProposal(string title, string description, uint256 requestedAmount, uint256 votingDays) external",
    "function vote(uint256 proposalId, bool support) external",
    "function executeProposal(uint256 proposalId) external",
    "event ProposalCreated(uint256 id, string title, address creator, uint256 amount)",
    "event VoteCast(uint256 proposalId, address voter, bool support, uint256 weight)"
];

class ContentFundManager {
    constructor(providerUrl, fundAddress) {
        this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
        this.fund = new ethers.Contract(fundAddress, FUND_ABI, this.provider);
    }

    async createProposal(privateKey, title, description, amount, votingDays) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const fund = this.fund.connect(wallet);
        const tx = await fund.createProposal(title, description, 
            ethers.utils.parseEther(amount.toString()), votingDays);
        return await tx.wait();
    }
}

app.post('/api/fund/proposal', async (req, res) => {
    const { privateKey, title, description, amount, votingDays } = req.body;
    const manager = new ContentFundManager(process.env.RPC_URL, process.env.FUND_ADDRESS);
    const receipt = await manager.createProposal(privateKey, title, description, amount, votingDays);
    res.json(receipt);
});

app.listen(3017, () => {
    console.log('Content Fund API running on port 3017');
});