What Is DeFi Governance? On-Chain Voting and DAOs

core-concepts

Core Concepts of DeFi Governance

Foundational mechanisms and structures that enable decentralized decision-making and protocol evolution.

Governance Tokens

Governance tokens are fungible assets that confer voting rights within a protocol. They are typically distributed to users, liquidity providers, and early contributors.

Represent voting power proportional to holdings.
Used to propose changes or vote on proposals.
Often have secondary utility like fee discounts or staking rewards.
Their value is tied to the perceived success of the governed protocol.

On-Chain Proposals

On-chain proposals are executable code or parameter changes submitted directly to the blockchain for a vote.

Changes are implemented automatically if the vote passes.
Requires a formal process: discussion, temperature check, consensus check.
Examples include adjusting interest rate models or adding new collateral assets.
Provides transparency and immutability to the decision-making process.

Voting Mechanisms

Voting mechanisms define how token holders express preferences and how votes are tallied.

Common models include token-weighted voting and quadratic voting.
May involve vote delegation to experts or representatives.
Snapshot voting uses off-chain signatures to gauge sentiment without gas costs.
The mechanism impacts plutocracy risks and voter participation rates.

Treasury Management

Treasury management involves the oversight and allocation of a protocol's accumulated assets, often held in a multi-signature wallet or smart contract.

Funds come from protocol fees, token sales, or yield.
Used for grants, development, liquidity incentives, or insurance.
Spending requires governance approval via specific treasury proposals.
Critical for long-term sustainability and strategic growth.

Delegation & Representatives

Delegation allows token holders to assign their voting power to other addresses, often experts or organized groups known as delegates.

Enables participation for users lacking time or expertise.
Delegates publish voting histories and manifestos to build trust.
Systems like Compound's Governor Bravo formalize this process.
Mitigates voter apathy but centralizes influence among active delegates.

Forking as Governance

Forking is the ultimate governance mechanism, where a community copies a protocol's code and launches a new version with different parameters or direction.

Serves as a credible exit threat for dissatisfied stakeholders.
Requires social coordination and liquidity migration.
Historical examples include the SushiSwap fork of Uniswap and the creation of Lido from the original StakeWise protocol.
Highlights the open-source and permissionless nature of DeFi.

The Standard Governance Lifecycle

Process overview

Proposal Creation and Submission

Draft and formally submit a governance proposal to the protocol.

Detailed Instructions

A governance proposal begins with a formal draft, typically a Governor Bravo-style proposal, which includes a title, description, and executable on-chain actions. The proposer must hold a minimum threshold of governance tokens, such as 65,000 UNI or 40,000 COMP, to submit. This step involves writing the proposal payload, which can call specific functions in the protocol's timelock controller or other smart contracts.

Sub-step 1: Draft the proposal specification, including target addresses, function signatures, and calldata.
Sub-step 2: Ensure your wallet holds the required proposal submission threshold of governance tokens.
Sub-step 3: Interact with the governance contract's propose function, providing the list of targets, values, and calldata.

solidity
// Example of calling the propose function
function propose(
    address[] memory targets,
    uint256[] memory values,
    string[] memory signatures,
    bytes[] memory calldatas,
    string memory description
) public returns (uint256 proposalId);

Tip: Use a dedicated forum or snapshot for community discussion before submitting an on-chain proposal to gauge sentiment and refine the draft.

Voting Period and Delegation

Token holders review the proposal and cast their votes, often via delegation.

Detailed Instructions

Once a proposal is live, it enters a fixed voting period, commonly lasting 3 to 7 days. Voting power is determined by the number of governance tokens held or delegated to a voter's address at a specific block snapshot. Voters typically choose between For, Against, and Abstain. Many voters delegate their voting power to knowledgeable community members or delegate platforms to participate passively.

Sub-step 1: Check the governance portal for active proposals and review the full discussion and code changes.
Sub-step 2: If you have delegated votes, your delegate will vote on your behalf. To vote directly, ensure your tokens are self-delegated.
Sub-step 3: Cast your vote by calling the castVote function on the governance contract before the voting deadline.

solidity
// Example of casting a vote
function castVote(uint256 proposalId, uint8 support) public returns (uint256);
// Where support: 0=Against, 1=For, 2=Abstain

Tip: The voting snapshot is taken at the proposal creation block. Acquiring tokens after this block does not grant voting power for that proposal.

Quorum and Vote Execution

The proposal must meet minimum participation thresholds before it can be executed.

Detailed Instructions

After the voting period ends, the proposal is evaluated against two key metrics: the quorum and the majority vote. The quorum is the minimum percentage of total circulating supply that must participate (e.g., 4% of total COMP). A proposal fails if it does not meet quorum, regardless of the vote margin. If quorum is met, the proposal passes if the "For" votes exceed "Against" votes. Successful proposals then enter a timelock period before execution.

Sub-step 1: After voting ends, verify the proposal status on-chain by checking the state() function.
Sub-step 2: Confirm that the total votes cast meet or exceed the protocol's defined quorum requirement.
Sub-step 3: Verify the final tally shows a majority in favor (For > Against).

solidity
// Example of checking a proposal's state
enum ProposalState { Pending, Active, Canceled, Defeated, Succeeded, Queued, Expired, Executed }
function state(uint256 proposalId) public view returns (ProposalState);

Tip: The timelock period, often 2 days, provides a safety window for users to react to passed proposals before they affect the live protocol.

Timelock and Final Execution

The approved proposal's actions are queued and then executed after a mandatory delay.

Detailed Instructions

A passed proposal does not execute immediately. Its actions are queued in a Timelock contract, which enforces a mandatory delay (e.g., 48 hours). This delay is a critical security mechanism, allowing users to exit positions or prepare for changes. After the delay expires, any address can call the execute function to run the proposal's encoded transactions. Execution involves the Timelock contract calling the target contracts with the specified calldata.

Sub-step 1: Once a proposal succeeds, call the queue function on the governance contract to move it to the Timelock.
Sub-step 2: Wait for the full timelock duration to pass. Monitor the getTimestamp function on the Timelock for the ETA.
Sub-step 3: Call the execute function on the governance contract, which will relay the transaction through the Timelock to the target.

solidity
// Example sequence for execution (pseudocode)
// 1. governance.queue(proposalId);
// 2. timelock.getTimestamp(proposalId); // Check ETA
// 3. governance.execute(proposalId);

Tip: Keep track of the eta (estimated time of availability) returned when queuing. Execution will revert if attempted before this timestamp.

Comparing Governance Models

A comparison of on-chain, off-chain, and hybrid governance mechanisms used by leading DeFi protocols.

Governance Feature	On-Chain (e.g., Compound)	Off-Chain (e.g., Uniswap)	Hybrid (e.g., MakerDAO)
Proposal Threshold	65,000 COMP	10,000,000 UNI	0 MKR (Executive Vote only)
Voting Period Duration	3 days	7 days	Executive: 3 days, Governance Poll: 3 days
Quorum Requirement	400,000 COMP	40,000,000 UNI	Governance Poll: No formal quorum, Executive: Majority
Vote Delegation	Native, on-chain	Native, on-chain via snapshot	Native, on-chain for Executive Votes
Upgrade Mechanism	Timelock-controlled admin (2 days)	Upgrade via Governor Alpha/Bravo contracts	Decentralized governance module (DSS) with spell contracts
Gas Cost for Proposal	~$500-$1500 (high)	$0 (gasless via Snapshot)	~$200-$800 (varies by spell)
Typical Voter Participation	5-15% of circulating supply	2-8% of delegated supply	30-50k MKR for major executive votes

Governance Considerations and Challenges

Understanding Governance Basics

On-chain governance refers to a system where token holders directly vote on protocol changes using their tokens. This is a core innovation in DeFi, moving power from a central team to a distributed community. The primary challenge is ensuring broad and informed participation, as low voter turnout can lead to decisions made by a small, potentially unrepresentative group.

Key Challenges for New Participants

Voter Apathy: Many token holders do not vote due to complexity or lack of incentives, leading to centralization of power among large holders (whales).
Information Overload: Proposals are often highly technical, making it difficult for average users to evaluate risks and benefits effectively.
Gas Costs: On Ethereum, voting transactions require paying gas fees, which can be prohibitively expensive for small holders, disincentivizing participation.

Real-World Example

When Compound introduced Proposal 62 to adjust COMP token distributions, it required token holders to delegate votes and cast them on-chain. Many users found the multi-step process confusing, and the final vote saw participation from only a fraction of the total token supply, highlighting the engagement challenge.

How to Participate in DeFi Governance

Process overview

Acquire Governance Tokens

Obtain the voting power required to participate.

Detailed Instructions

Governance tokens represent voting rights and are typically earned through protocol interaction or purchased on exchanges. For example, to vote on a Compound proposal, you need COMP tokens. You can acquire them by supplying or borrowing assets on the Compound protocol to earn COMP as a liquidity mining reward, or purchase them directly on a decentralized exchange like Uniswap.

Sub-step 1: Identify the correct token contract address (e.g., COMP: 0xc00e94Cb662C3520282E6f5717214004A7f26888).
Sub-step 2: Use a DEX aggregator to find the best price and execute a swap from ETH or stablecoins.
Sub-step 3: Transfer the tokens to a secure, self-custodied wallet you control, as you will need to sign messages from it.

solidity
// Example: Checking a user's token balance via an Ethereum node call
function getBalance(address token, address user) public view returns (uint256) {
    return IERC20(token).balanceOf(user);
}

Tip: Consider the token's vesting schedule or lock-up periods, as some protocols require tokens to be staked or locked to vote.

Delegate Your Voting Power

Assign your voting rights to yourself or a delegate.

Detailed Instructions

Delegation is the mechanism by which token holders assign their voting weight to an Ethereum address. On many platforms like Uniswap and Compound, you must actively delegate your tokens to participate; merely holding them in your wallet is insufficient. You can delegate to your own address (self-delegate) to vote directly, or to a trusted community member or service that will vote on your behalf.

Sub-step 1: Navigate to the governance portal (e.g., Compound Governance Dashboard or Tally).
Sub-step 2: Connect your Web3 wallet (e.g., MetaMask) containing the governance tokens.
Sub-step 3: Enter the delegatee's Ethereum address and sign the delegation transaction, which is a gas-paid on-chain call.

javascript
// Example using ethers.js to delegate COMP tokens
const contract = new ethers.Contract(compAddress, compAbi, signer);
const tx = await contract.delegate(delegateeAddress);
await tx.wait();

Tip: Delegation is not a transfer of tokens; you retain ownership. You can change your delegate at any time.

Review Active Proposals

Analyze governance proposals before casting a vote.

Detailed Instructions

Proposal analysis is critical for informed voting. Proposals are posted on the protocol's governance forum (e.g., Commonwealth, Discourse) and later formalized on-chain. You must review the proposal's specification, discussion thread, and any audit reports. Key elements to evaluate include the target contract addresses, calldata for execution, and the proposed change's impact on system parameters like interest rates or fee structures.

Sub-step 1: Monitor the official governance forum for Temperature Checks and formal proposals.
Sub-step 2: Examine the on-chain proposal details, including the proposalId, targets, values, and calldatas arrays.
Sub-step 3: Assess the voting timeline: proposal creation, voting delay, voting period (often 3-7 days), and execution ETA.

bash
# Example: Fetching a proposal's details from the Compound Governor Bravo contract using cast
cast call 0xc0da01a04c3f3e0be433606045bb7017a7323e38 \
  "proposals(uint256)(uint256,address,uint256,string,uint256,uint256,uint256,bool,bool)" 42

Tip: Use block explorers and governance dashboards to track proposal state and voter sentiment.

Cast Your Vote On-Chain

Submit your voting decision to the blockchain.

Detailed Instructions

On-chain voting finalizes your decision. After a proposal is live in its voting period, connected delegates can vote For, Against, or Abstain. Voting weight is calculated from the delegate's token balance at the specific block number when the proposal was created (snapshot block). The vote is submitted via a transaction that calls the castVote function on the governance contract, consuming gas.

Sub-step 1: Ensure your delegated address has sufficient ETH for gas fees.
Sub-step 2: On the governance interface, select the proposal and choose your vote (1 For, 0 Against, 2 Abstain).
Sub-step 3: Sign the transaction and monitor its confirmation. Your vote is immutable once included in a block.

solidity
// Example: Core voting function from OpenZeppelin's Governor contract
function castVote(uint256 proposalId, uint8 support) public virtual returns (uint256) {
    address voter = _msgSender();
    return _castVote(proposalId, voter, support, "");
}

Tip: Voting transactions are public. Use a voting privacy tool like Aztec or Tornado Cash for the gas payment if desired.

Monitor Execution and Outcomes

Track the proposal's lifecycle post-vote.

Detailed Instructions

Proposal execution occurs after a successful vote, provided the quorum (minimum voting power) and vote differential thresholds are met. A time lock period often precedes execution to allow users to react to changes. You must verify the execution transaction on a block explorer. Failed proposals may be revised and re-submitted. Monitoring outcomes is essential to understand the protocol's evolving parameter state and treasury movements.

Sub-step 1: After the voting period ends, check if the proposal succeeded via the governance dashboard or by querying the contract's state() function.
Sub-step 2: If successful, note the execution ETA. The timelock contract will queue the proposal.
Sub-step 3: Once executed, verify the transaction hash and confirm the state changes on the target contracts (e.g., a new interest rate model).

javascript
// Querying a proposal's state using ethers.js
const proposalState = await governorContract.state(proposalId);
// States: 0=Pending, 1=Active, 2=Canceled, 3=Defeated, 4=Succeeded, 5=Queued, 6=Expired, 7=Executed

Tip: Set up notifications for governance events using a service like OpenZeppelin Defender or Tenderly.

DeFi Governance FAQ

On-chain governance executes proposals directly via smart contract code, with token voting automatically triggering changes. Off-chain governance uses social consensus on forums like Discord before developers implement changes manually. On-chain is more automated but can be rigid, while off-chain is flexible but relies on trusted actors. For example, Compound's COMP token votes directly on-chain for parameter changes, while early Ethereum Improvement Proposals (EIPs) are debated off-chain before core devs implement them in a client release.

Further Resources on DeFi Governance

Uniswap Governance Documentation

Details on UNI token governance, proposal lifecycle, delegation, quorum requirements, and onchain voting mechanics used by Uniswap protocols.

Visit resource

Compound Governance Docs

Technical explanation of Compound’s governance system including COMP token mechanics, proposal thresholds, timelocks, and Governor contracts.

Visit resource

Aave Governance Documentation

Covers Aave DAO structure, AIP process, voting strategies, Snapshot usage, and onchain execution through governance smart contracts.

Visit resource

Onchain Governance

Ethereum Foundation article explaining onchain governance models, tradeoffs, and real protocol examples relevant to DeFi systems.

Visit resource