DAO Development Complete Guide 2026: Decentralized Governance

DAO Structure:
┌─────────────────────────────────────────┐
│           Token Holders                  │
│     (Vote, Propose, Execute)             │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│          Governance Layer                │
│   (Proposals, Voting, Quorum)            │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│          Treasury                        │
│     (Funds, Assets, Execution)           │
└─────────────────────────────────────────┘

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

import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockCompound.sol";

contract MyDAO is 
    Governor,
    GovernorCountingSimple,
    GovernorVotes,
    GovernorVotesQuorumFraction,
    GovernorTimelockCompound
{
    constructor(
        IVotes _token,
        ICompoundTimelock _timelock
    )
        Governor("MyDAO")
        GovernorVotes(_token)
        GovernorVotesQuorumFraction(4) // 4% quorum
        GovernorTimelockCompound(_timelock)
    {}
    
    // Voting delay: delay before voting starts after proposal
    function votingDelay() public pure override returns (uint256) {
        return 1 days;
    }
    
    // Voting period: duration of the vote
    function votingPeriod() public pure override returns (uint256) {
        return 3 days;
    }
    
    // Proposal threshold: tokens required to propose
    function proposalThreshold() public pure override returns (uint256) {
        return 1000000 * 10**18; // 1M tokens
    }
    
    // Queue a proposal in the timelock
    function queue(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) public returns (uint256) {
        return _queue(targets, values, calldatas, descriptionHash);
    }
}

// Simplified GovernorBravo
contract GovernorBravo {
    struct Proposal {
        uint256 id;
        address proposer;
        uint256 eta;
        uint256 startBlock;
        uint256 endBlock;
        uint256 forVotes;
        uint256 againstVotes;
        uint256 abstainVotes;
        bool canceled;
        bool executed;
        address[] targets;
        uint256[] values;
        string[] signatures;
        bytes[] calldatas;
    }
    
    mapping(uint256 => Proposal) public proposals;
    mapping(address => uint256) public votingAmount;
    uint256 public proposalCount;
    
    uint256 public votingDelay = 1 days;
    uint256 public votingPeriod = 3 days;
    uint256 public proposalThreshold = 100000 ether;
    uint256 public quorumVotes = 400000 ether;
    
    function propose(
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas,
        string memory description
    ) public returns (uint256) {
        require(
            getVotes(msg.sender, block.number - 1) >= proposalThreshold,
            "Below threshold"
        );
        
        uint256 proposalId = ++proposalCount;
        
        Proposal storage proposal = proposals[proposalId];
        proposal.proposer = msg.sender;
        proposal.eta = block.timestamp + votingDelay;
        proposal.startBlock = block.number + votingDelay;
        proposal.endBlock = proposal.startBlock + votingPeriod;
        proposal.targets = targets;
        proposal.values = values;
        proposal.signatures = signatures;
        proposal.calldatas = calldatas;
        
        emit ProposalCreated(
            proposalId,
            msg.sender,
            targets,
            values,
            signatures,
            calldatas,
            proposal.startBlock,
            proposal.endBlock,
            description
        );
        
        return proposalId;
    }
    
    function castVote(
        uint256 proposalId,
        uint8 support
    ) public {
        return _castVote(msg.sender, proposalId, support, "");
    }
    
    function _castVote(
        address voter,
        uint256 proposalId,
        uint8 support,
        bytes memory reason
    ) internal {
        Proposal storage proposal = proposals[proposalId];
        
        require(
            state(proposalId) == ProposalState.Active,
            "Not active"
        );
        
        uint256 votes = getVotes(voter, proposal.startBlock);
        
        if (support == 0) {
            proposal.againstVotes += votes;
        } else if (support == 1) {
            proposal.forVotes += votes;
        } else if (support == 2) {
            proposal.abstainVotes += votes;
        }
        
        emit VoteCast(voter, proposalId, support, votes, reason);
    }
    
    function execute(
        uint256 proposalId
    ) public payable returns (uint256) {
        Proposal storage proposal = proposals[proposalId];
        
        require(
            state(proposalId) == ProposalState.Succeeded,
            "Not succeeded"
        );
        
        proposal.executed = true;
        
        for (uint256 i = 0; i < proposal.targets.length; i++) {
            _execute(
                proposal.targets[i],
                proposal.values[i],
                proposal.calldatas[i]
            );
        }
        
        emit ProposalExecuted(proposalId);
        
        return proposalId;
    }
}

// Aragon DAO creation and management
const aragon = require('@aragon/os');

class AragonDAO {
    constructor(daoAddress, aclAddress) {
        this.dao = aragon.dao.at(daoAddress);
        this.acl = aragon.acl.at(aclAddress);
    }
    
    // Create a new DAO
    static async create(name, tokenSettings) {
        // Deploy token
        const token = await aragon.token.new(
            tokenSettings.name,
            tokenSettings.symbol,
            tokenSettings.decimals,
            { from: tokenSettings.holder }
        );
        
        // Deploy MiniMe token ( Aragon's standard )
        const miniMe = await aragon.minime.new(
            token.address,
            0,
            'DAO Token',
            18,
            'TKN',
            true,
            { from: tokenSettings.holder }
        );
        
        // Create DAO
        const dao = await aragon.dao.new();
        
        // Set up permissions
        await this.setupPermissions(dao, miniMe.address);
        
        return dao;
    }
    
    // Grant permission to an app
    async grantPermission(app, role, entity) {
        await this.acl.createPermission(
            entity,
            app,
            aragon.utils.hash(role),
            entity
        );
    }
    
    // Vote on a proposal
    async vote(daoAddress, proposalId, supports) {
        const voting = await aragon.voting.at(
            await this.getVotingApp(daoAddress)
        );
        
        await voting.vote(proposalId, supports, false);
    }
}

// Quadratic Voting implementation
contract QuadraticVoting {
    mapping(uint256 => mapping(address => uint256)) public votes;
    mapping(uint256 => uint256) public totalVotes;
    
    // Cost of voting scales quadratically
    function vote(uint256 proposalId, uint256 weight) external {
        // Quadratic cost: votes^2
        uint256 cost = weight * weight;
        
        // Deduct voting power
        votingPower[msg.sender] -= cost;
        
        votes[proposalId][msg.sender] = weight;
        totalVotes[proposalId] += weight;
    }
    
    // Calculate results with quadratic weighting
    function getQuadraticResults(uint256 proposalId) public view returns (
        uint256 forVotes,
        uint256 againstVotes
    ) {
        // Sum of sqrt of votes for each side
        // This gives more weight to more voters
    }
}

# Conviction voting implementation
class ConvictionVoting:
    """
    Continuous voting where conviction accumulates over time
    """
    
    def __init__(self, proposal_duration):
        self.proposals = {}
        self.votes = {}
        self.proposal_duration = proposal_duration
    
    def vote(self, proposal_id, voter, amount, stake):
        """
        Add conviction to a proposal
        """
        if proposal_id not in self.votes:
            self.votes[proposal_id] = {}
        
        # Calculate conviction with time decay
        conviction = self.calculate_conviction(
            amount=amount,
            stake_time=stake,
            elapsed=self.get_elapsed(proposal_id)
        )
        
        self.votes[proposal_id][voter] = conviction
    
    def calculate_conviction(self, amount, stake_time, elapsed):
        """
        Conviction = stake * sqrt(time)
        """
        return amount * math.sqrt(elapsed / stake_time)
    
    def execute_if_passed(self, proposal_id):
        """
        Execute proposal when conviction threshold reached
        """
        total_conviction = sum(
            self.votes[proposal_id].values()
        )
        
        if total_conviction >= self.threshold:
            self.execute_proposal(proposal_id)

// Rage quit - exit with your share
contract RageQuit {
    mapping(address => uint256) public shares;
    mapping(address => uint256) public depositedAt;
    uint256 public totalShares;
    uint256 public exitWindow = 2 days;
    
    event RageQuit(address indexed user, uint256 share);
    
    function deposit() external payable {
        uint256 share = (msg.value * totalShares) / address(this).balance;
        shares[msg.sender] += share;
        totalShares += share;
        depositedAt[msg.sender] = block.timestamp;
    }
    
    function rageQuit() external {
        require(
            block.timestamp - depositedAt[msg.sender] >= exitWindow,
            "Too early"
        );
        
        uint256 share = shares[msg.sender];
        uint256 payout = (share * address(this).balance) / totalShares;
        
        shares[msg.sender] = 0;
        totalShares -= share;
        
        payable(msg.sender).transfer(payout);
        
        emit RageQuit(msg.sender, share);
    }
}

// Governance token with delegation and snapshots
contract GovernanceToken is ERC20, ERC20Votes, ERC20Permit {
    uint256 public constant MAX_SUPPLY = 1000000000 * 10**18;
    
    constructor() 
        ERC20("GovernanceToken", "GOV")
        EIP712("GovernanceToken", "1")
        ERC20Permit("GovernanceToken")
    {
        _mint(msg.sender, MAX_SUPPLY);
    }
    
    function mint(address to, uint256 amount) external onlyMinter {
        _mint(to, amount);
    }
    
    // Snapshots for voting power at specific blocks
    function snapshot() external onlyMinter {
        _snapshot();
    }
    
    // Get voting power at a specific block
    function getVotes(address account) public view override returns (uint256) {
        return super.getVotes(account);
    }
    
    // Delegate voting power
    function delegate(address delegatee) public override {
        super.delegate(delegatee);
    }
}

// Token vesting with cliff and linear unlock
const VestingSchedule = {
    totalAmount: 1_000_000,
    startTimestamp: Date.now(),
    cliffDuration: 365 * 24 * 60 * 60, // 1 year
    vestingDuration: 4 * 365 * 24 * 60 * 60, // 4 years
    
    calculateVestedAmount(timestamp) {
        if (timestamp < this.startTimestamp + this.cliffDuration) {
            return 0; // Nothing during cliff
        }
        
        if (timestamp >= this.startTimestamp + this.vestingDuration) {
            return this.totalAmount; // Fully vested
        }
        
        const timeVested = timestamp - this.startTimestamp - this.cliffDuration;
        const vestingSpan = this.vestingDuration - this.cliffDuration;
        
        return (this.totalAmount * timeVested) / vestingSpan;
    },
    
    getClaimableAmount(timestamp, claimedAmount) {
        const vested = this.calculateVestedAmount(timestamp);
        return Math.max(0, vested - claimedAmount);
    }
};

// Multi-sig treasury with spending limits
contract DAOTreasury {
    mapping(address => bool) public signers;
    mapping(bytes32 => Transaction) public transactions;
    mapping(bytes32 => mapping(address => bool)) public confirmed;
    mapping(address => uint256) public nonces;
    
    uint256 public requiredSignatures;
    uint256 public dailyLimit;
    mapping(uint256 => uint256) public spentToday;
    
    struct Transaction {
        address to;
        uint256 value;
        bytes data;
        uint256 confirmations;
        bool executed;
        uint256 timestamp;
    }
    
    event TransactionProposed(
        bytes32 indexed txHash,
        address indexed to,
        uint256 value
    );
    event TransactionExecuted(bytes32 indexed txHash);
    
    constructor(address[] memory _signers, uint256 _required) {
        requiredSignatures = _required;
        for (uint256 i = 0; i < _signers.length; i++) {
            signers[_signers[i]] = true;
        }
    }
    
    function proposeTransaction(
        address to,
        uint256 value,
        bytes memory data
    ) external onlySigner returns (bytes32) {
        bytes32 txHash = keccak256(
            abi.encode(to, value, data, nonces[msg.sender]++)
        );
        
        transactions[txHash] = Transaction({
            to: to,
            value: value,
            data: data,
            confirmations: 1,
            executed: false,
            timestamp: block.timestamp
        });
        
        confirmed[txHash][msg.sender] = true;
        
        emit TransactionProposed(txHash, to, value);
        return txHash;
    }
    
    function confirmTransaction(bytes32 txHash) external onlySigner {
        require(!confirmed[txHash][msg.sender], "Already confirmed");
        
        Transaction storage tx = transactions[txHash];
        tx.confirmations++;
        confirmed[txHash][msg.sender] = true;
        
        if (tx.confirmations >= requiredSignatures) {
            executeTransaction(txHash);
        }
    }
    
    function executeTransaction(bytes32 txHash) internal {
        Transaction storage tx = transactions[txHash];
        require(!tx.executed, "Already executed");
        
        // Check daily limit
        uint256 day = block.timestamp / 1 days;
        if (tx.value > 0) {
            require(
                spentToday[day] + tx.value <= dailyLimit,
                "Daily limit exceeded"
            );
            spentToday[day] += tx.value;
        }
        
        tx.executed = true;
        
        (bool success, ) = tx.to.call{value: tx.value}(tx.data);
        require(success, "Execution failed");
        
        emit TransactionExecuted(txHash);
    }
}

// Protection against flash loan attacks
contract SecureGovernance {
    uint256 public votingDelay = 1 days; // Votes start 1 day after proposal
    
    // Snapshot of votes at proposal time
    mapping(uint256 => mapping(address => uint256)) public proposalVotes;
    
    function castVote(uint256 proposalId, uint8 support) external {
        // Only count votes that were delegated BEFORE proposal
        uint256 proposalStartBlock = proposalStartBlocks[proposalId];
        
        // This prevents flash loan attacks
        require(
            delegations[msg.sender].delegationBlock < proposalStartBlock,
            "Recently delegated"
        );
        
        // Record votes
        proposalVotes[proposalId][msg.sender] = getVotesAtBlock(
            msg.sender,
            proposalStartBlock
        );
    }
    
    // Delay before voting starts
    function _afterProposalCreated(
        uint256 proposalId,
        address proposer,
        uint256 startBlock,
        uint256 endBlock
    ) internal override {
        // Ensure minimum delay passes
        require(
            block.number >= startBlock + votingDelay / 12, // ~12 sec/block
            "Voting delay not met"
        );
    }
}

const daoDesign = {
    name: "MyDAO",
    purpose: "Build and fund DeFi infrastructure",
    token: {
        name: "MyDAO Token",
        symbol: "MDAO",
        totalSupply: "1B",
        allocation: {
            community: "60%",
            team: "20%",
            investors: "15%",
            treasury: "5%"
        },
        vesting: {
            team: "4 year cliff 1 year",
            investors: "2 year linear",
            treasury: "3 year linear"
        }
    },
    governance: {
        votingDelay: "1 day",
        votingPeriod: "5 days",
        proposalThreshold: "1% supply",
        quorum: "4% supply",
        executionDelay: "2 days"
    },
    treasury: {
        signers: 5,
        required: 3,
        dailyLimit: "100 ETH"
    }
};

# Using OpenZeppelin contracts
npm install @openzeppelin/contracts @openzeppelin/contracts-upgradeable

# Deploy governance token
npx hardhat run scripts/deploy-token.js

# Deploy governor
npx hardhat run scripts/deploy-governor.js

# Deploy treasury
npx hardhat run scripts/deploy-treasury.js

const setupDAO = async () => {
    // Set up governance parameters
    await governor.setVotingDelay(1 days);
    await governor.setVotingPeriod(5 days);
    await governor.setProposalThreshold(parseEther("1000000"));
    await governor.setQuorum(parseEther("400000"));
    
    // Set up timelock
    await timelock.setDelay(2 days);
    
    // Grant roles
    await token.grantRole(MINTER_ROLE, governor.address);
    await token.grantRole(BURNER_ROLE, governor.address);
};

const distributeTokens = async () => {
    // Airdrop to community
    await token.batchMint(airdropRecipients, airdropAmounts);
    
    // Team vesting
    await token.mint(teamVesting.address, teamAmount);
    
    // Treasury
    await token.mint(treasury.address, treasuryAmount);
};

// Inter-DAO cooperation
interface IDAO {
    function voteOnMembershipProposal(
        bytes32 proposalId,
        bool approval
    ) external;
    
    function joinAlliance(
        bytes32 allianceId,
        uint256 stake
    ) external payable;
}