DAO Governance — Token Voting, Quadratic Voting, and Treasury Management

// SimpleDAO.sol
// ERC-20 based governance contract
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract GovernanceToken is ERC20, Ownable {
    constructor() ERC20("DodaDAO", "DDAO") Ownable(msg.sender) {
        _mint(msg.sender, 1000000 * 10**18);  // 1M initial supply
    }
    
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

contract SimpleDAO {
    struct Proposal {
        uint256 id;
        string description;
        address proposer;
        uint256 forVotes;
        uint256 againstVotes;
        uint256 endBlock;
        bool executed;
        bool passed;
    }
    
    GovernanceToken public token;
    mapping(uint256 => Proposal) public proposals;
    mapping(uint256 => mapping(address => bool)) public hasVoted;
    uint256 public proposalCount;
    uint256 public votingPeriod = 17280;  // ~3 days at 15s blocks
    
    constructor(address _token) {
        token = GovernanceToken(_token);
    }
    
    function createProposal(string memory description) external returns (uint256) {
        proposalCount++;
        proposals[proposalCount] = Proposal({
            id: proposalCount,
            description: description,
            proposer: msg.sender,
            forVotes: 0,
            againstVotes: 0,
            endBlock: block.number + votingPeriod,
            executed: false,
            passed: false
        });
        return proposalCount;
    }
    
    function vote(uint256 proposalId, bool support) external {
        Proposal storage p = proposals[proposalId];
        require(block.number < p.endBlock, "Voting ended");
        require(!hasVoted[proposalId][msg.sender], "Already voted");
        
        uint256 votes = token.balanceOf(msg.sender);
        require(votes > 0, "No voting power");
        
        hasVoted[proposalId][msg.sender] = true;
        
        if (support) {
            p.forVotes += votes;
        } else {
            p.againstVotes += votes;
        }
    }
    
    function executeProposal(uint256 proposalId) external {
        Proposal storage p = proposals[proposalId];
        require(block.number >= p.endBlock, "Voting not ended");
        require(!p.executed, "Already executed");
        
        p.passed = p.forVotes > p.againstVotes;
        p.executed = true;
    }
}

# voting_power.py
# Simulate token-based voting distribution
import random

class DAOVoteSimulator:
    def __init__(self, total_supply=1_000_000):
        self.total_supply = total_supply
        self.voters = {}
    
    def add_voter(self, address: str, tokens: int):
        self.voters[address] = tokens
    
    def simulate_vote(self, proposal: str):
        total_for = 0
        total_against = 0
        voter_records = []
        
        for voter, tokens in self.voters.items():
            # Rich voters have more influence
            support = random.random() < 0.6  # 60% support rate
            votes = tokens
            
            if support:
                total_for += votes
            else:
                total_against += votes
            
            voter_records.append({
                "voter": voter[:8],
                "tokens": tokens,
                "support": support,
                "voting_power": votes
            })
        
        print(f"Proposal: {proposal}")
        print(f"For: {total_for:,} ({total_for/(total_for+total_against)*100:.1f}%)")
        print(f"Against: {total_against:,} ({total_against/(total_for+total_against)*100:.1f}%)")
        print("\nTop 5 Voters by Power:")
        voter_records.sort(key=lambda x: x['tokens'], reverse=True)
        for v in voter_records[:5]:
            print(f"  {v['voter']}: {v['tokens']:,} tokens, voted {'FOR' if v['support'] else 'AGAINST'}")
        
        return total_for > total_against

sim = DAOVoteSimulator()

# Simulate a DAO with whale distribution
sim.add_voter("0xWhale1", 500_000)  # Single voter with 50%
sim.add_voter("0xWhale2", 200_000)
sim.add_voter("0xVcFund", 100_000)

# 100 small holders
for i in range(100):
    sim.add_voter(f"0xSmall{i}", random.randint(100, 5000))

result = sim.simulate_vote("Increase treasury spending by 10%")
print(f"\nProposal {'PASSED' if result else 'FAILED'}")

# quadratic_voting.py
# Quadratic voting simulation
import math

class QuadraticDAO:
    def __init__(self):
        self.proposals = {}
        self.credits_used = {}  # voter -> total credits spent
    
    def vote_cost(self, votes: int) -> int:
        """Cost in tokens for N votes (quadratic)."""
        return votes ** 2
    
    def max_votes(self, tokens: int) -> int:
        """Maximum votes a voter can cast given their tokens."""
        return int(math.sqrt(tokens))
    
    def cast_vote(self, voter: str, proposal: str, votes: int, tokens: int):
        cost = self.vote_cost(votes)
        assert cost <= tokens, f"Insufficient tokens: need {cost}, have {tokens}"
        
        if proposal not in self.proposals:
            self.proposals[proposal] = {"for": 0, "against": 0}
        
        self.proposals[proposal]["for"] += votes
        print(f"{voter[:8]} casts {votes} votes for '{proposal}' at cost {cost} tokens")
        return votes
    
    def simulate(self):
        # Whale with 500K tokens
        whale_votes = self.max_votes(500000)
        self.cast_vote("0xWhale1", "Prop 1: Raise fees", whale_votes, 500000)
        
        # Small holder with 100 tokens
        small_votes = self.max_votes(100)
        self.cast_vote("0xAlice", "Prop 1: Raise fees", small_votes, 100)
        
        print("\n--- Comparison ---")
        print("Token-based: Whale = 500,000 votes, Alice = 100 votes (5000x)")
        print("Quadratic: Whale = " + str(whale_votes) + " votes, Alice = " + str(small_votes) + " votes (5000x tokens but only " + str(round(whale_votes/small_votes, 1)) + "x votes)")

qd = QuadraticDAO()
qd.simulate()

// Delegation.sol
// Voting delegation example
contract DelegatableDAO {
    mapping(address => address) public delegates;  // voter -> delegate
    mapping(address => uint256) public delegatedPower;  // delegate -> total power
    
    function delegate(address delegate) external {
        require(delegate != address(0), "Invalid delegate");
        require(delegate != msg.sender, "Cannot delegate to self");
        
        // Remove previous delegation
        address previousDelegate = delegates[msg.sender];
        if (previousDelegate != address(0)) {
            delegatedPower[previousDelegate] -= token.balanceOf(msg.sender);
        }
        
        // Set new delegate
        delegates[msg.sender] = delegate;
        delegatedPower[delegate] += token.balanceOf(msg.sender);
    }
    
    function votingPower(address voter) public view returns (uint256) {
        address delegate = delegates[voter];
        if (delegate == address(0)) {
            return token.balanceOf(voter);  // Self-vote
        }
        return 0;  // Power transferred to delegate
    }
}

// treasury_management.js
// Gnosis Safe interaction
import Safe from '@safe-global/protocol-kit';
import { ethers } from 'ethers';

async function manageTreasury() {
  // Connect to Gnosis Safe
  const safe = await Safe.init({
    provider: 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY',
    signer: '0xYourSignerAddress',
    safeAddress: '0xDAO_Safe_Address',
  });
  
  // Check Safe configuration
  const config = await safe.getOwners();
  const threshold = await safe.getThreshold();
  console.log('Safe owners:', config);
  console.log('Required confirmations:', threshold.toString());
  
  // Create a transaction (requires 3/5 signatures)
  const transaction = {
    to: '0xRecipient',
    value: ethers.parseEther('100.0').toString(),
    data: '0x',
  };
  
  const safeTransaction = await safe.createTransaction({ transactions: [transaction] });
  const safeTxHash = await safe.getTransactionHash(safeTransaction);
  
  // Sign with current owner
  const signature = await safe.signTransaction(safeTransaction);
  console.log('Transaction hash:', safeTxHash);
  console.log('Waiting for', threshold.toString() - 1, 'more signatures...');
  
  // Execute when threshold reached
  const executeResponse = await safe.executeTransaction(safeTransaction);
  console.log('Executed:', executeResponse.transactionHash);
}

// Treasury diversification recommendations:
// 60% Stablecoins (USDC, USDT) — operational budget
// 25% Blue-chip (ETH, BTC) — long-term holdings
// 10% Protocol-owned liquidity — DeFi yields
// 5% Strategic investments — ecosystem grants

# governance_sim.py
# Simulate a full governance proposal lifecycle
from datetime import datetime, timedelta
import random

class GovernanceProposal:
    def __init__(self, title: str, description: str, proposer: str):
        self.title = title
        self.description = description
        self.proposer = proposer
        self.created = datetime.now()
        self.voting_start = self.created + timedelta(days=2)
        self.voting_end = self.voting_start + timedelta(days=5)
        self.executed = False
        self.passed = False
        self.for_votes = 0
        self.against_votes = 0
        self.status = "Discussion"

class DAOSimulator:
    def __init__(self, total_supply: int, quorum_pct: float = 0.04):
        self.total_supply = total_supply
        self.quorum = int(total_supply * quorum_pct)
        self.holders = {}
        self.proposals = []
    
    def add_holder(self, address: str, tokens: int):
        self.holders[address] = tokens
    
    def create_proposal(self, title: str, proposer: str):
        prop = GovernanceProposal(title, "Detailed description...", proposer)
        self.proposals.append(prop)
        print(f"[{prop.created.strftime('%Y-%m-%d %H:%M')}] Proposal created: '{title}' by {proposer[:8]}")
        return prop
    
    def simulate_vote(self, proposal: GovernanceProposal):
        print(f"\n--- Voting on: {proposal.title} ---")
        print(f"Period: {proposal.voting_start.strftime('%m/%d')} - {proposal.voting_end.strftime('%m/%d')}")
        print(f"Quorum required: {self.quorum:,} tokens\n")
        
        for voter, tokens in self.holders.items():
            if random.random() < 0.4:  # 40% participation
                support = random.random() < 0.65  # 65% support rate
                if support:
                    proposal.for_votes += tokens
                    print(f"  {voter[:8]}: {tokens:>8,} tokens -> FOR")
                else:
                    proposal.against_votes += tokens
                    print(f"  {voter[:8]}: {tokens:>8,} tokens -> AGAINST")
        
        total_votes = proposal.for_votes + proposal.against_votes
        quorum_met = total_votes >= self.quorum
        majority = proposal.for_votes > proposal.against_votes
        proposal.passed = quorum_met and majority
        
        print(f"\nResults:")
        print(f"  For: {proposal.for_votes:,}")
        print(f"  Against: {proposal.against_votes:,}")
        print(f"  Total votes: {total_votes:,} ({total_votes/self.total_supply*100:.1f}% of supply)")
        print(f"  Quorum met: {'YES' if quorum_met else 'NO'}")
        print(f"  Proposal {'PASSED' if proposal.passed else 'DEFEATED'}")
        
        return proposal.passed

sim = DAOSimulator(total_supply=10_000_000, quorum_pct=0.04)

sim.add_holder("0xDAO_Treasury", 2_000_000)
sim.add_holder("0xTeam_Vesting", 1_500_000)
sim.add_holder("0xInvestor_A", 1_000_000)
sim.add_holder("0xInvestor_B", 500_000)
for i in range(500):
    sim.add_holder(f"0xHolder_{i:04d}", random.randint(100, 10000))

prop = sim.create_proposal("Upgrade Protocol to v2", "0xTeamLead")
sim.simulate_vote(prop)