How to Build a DAO Voting Delegation System
The problem of low participation in DAO governance is well-known: less than 5% of token holders vote. Delegation solves this but requires a robust architecture. We develop turnkey DAO governance systems, including voting delegation and secure multisig-based treasuries. Over 5+ years, we have implemented solutions for 30+ projects, including integration with Governor, Snapshot, and security modules. For DeFi protocols, governance via DAO is critical — delegation boosts community activity.
How Does Delegation Work?
Delegation is implemented via smart contracts following the ERC-20Votes standard (EIP-5805). The EIP-5805 standard describes the accounting of delegated votes. The contract tracks delegated votes. At each vote, the voting weight of a delegate equals the sum of their own tokens and all tokens delegated to them. The delegation transaction is gas-consuming but is executed once. Gas optimization is key: we use batch delegation and off-chain signatures to reduce costs. The average cost of a delegation transaction on Ethereum during peak times is ~$30-50, which is significant for active communities — gas savings from off-chain voting can reach $2000 per month.
// Example delegation contract
contract MyGovernor is Governor {
constructor(IVotes _token) Governor("MyDAO", _token) {}
function proposalThreshold() public pure override returns (uint256) {
return 10000e18; // 10,000 tokens to create a proposal
}
}Delegates can vote off-chain (Snapshot) with subsequent on-chain execution via SafeSnap, saving gas. Or fully on-chain via Governor — then each voting transaction is paid for. The choice depends on community activity and gas budget.
Why Is Multisig Treasury the Foundation of Security?
Without a multisig, the treasury is a single EOA: one private key, full control. Gnosis Safe solves this with an M-of-N scheme: a transaction is executed only with M out of N designated signatures. Safe is the de facto standard: over $100B stored in Safe wallets, top DAOs (Uniswap, ENS, Aave) use it.
Safe Architecture
Safe is a smart contract, not an EOA. Owners is a list of addresses, threshold is the minimum number of signatures. Transaction stages: propose, sign (off-chain/on-chain), execute. Off-chain signatures are cheaper — only the executor pays gas.
Configuration Parameters
| DAO Size | Owners | Threshold | Logic |
|---|---|---|---|
| Small (core team) | 5 | 3 | 3-of-5 |
| Medium | 7-9 | 5 | 5-of-7 or 5-of-9 |
| Large (subDAO) | 11-13 | 7 | 7-of-11 |
Threshold should not be too low (2-of-10 — risk) or too high (deadlock if keys are lost). Owner rotation every 6-12 months is a practice.
Guard Contracts and Modules
Guard is called before and after each transaction: allows limits, whitelist, delays. Modules (e.g., Zodiac Roles) delegate execution to restricted operators without full access.
interface IGuard {
function checkTransaction(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation
) external;
function checkAfterExecution(bytes32 txHash, bool success) external;
}How to Integrate Governor with Snapshot?
A pure Safe is only a multisig. For thousands of token holders, a Governor (proportional voting) is needed. Typical architecture: Governor → Timelock → Safe. SafeSnap (Snapshot + Safe) connects off-chain voting with on-chain execution via the Reality.eth oracle. This combines free voting with secure execution.
Example SafeSnap Configuration
Setup includes deploying a Snapshot space, a SafeSnap module, and a Reality.eth oracle. The module verifies that the voting result is confirmed by the oracle, then executes the transaction via Safe. The entire on-chain process takes ~1 hour with default settings.
Approach Comparison
| Approach | Voting | Execution | Gas Costs | Security |
|---|---|---|---|---|
| Fully on-chain | Governor on-chain | Safe | High (~$50 per tx) | Maximum |
| Snapshot + SafeSnap | Snapshot off-chain | Safe + Reality.eth | Low (~$10 per execution) | Depends on oracle |
How Does Turnkey Development Proceed?
- Analysis: assess current architecture, choose stack (Ethereum/Polygon/Arbitrum), define delegation parameters.
- Design: schema Governor → Safe, select modules, configure threshold.
- Implementation: deploy contracts, set up Snapshot, integrate SafeSnap (if needed).
- Testing: unit tests (Foundry), integration tests on testnet, security audit (Slither, Mythril).
- Deployment and documentation: mainnet deploy, owner rotation procedures, recovery passphrase, team training.
What Is Included
- Design and deployment of smart contracts (Safe, Governor, modules)
- Setup of Snapshot space and SafeSnap module
- Integration with Timelock (if needed)
- Writing and deploying custom Guards
- Full testing (testnet + audit-like checks)
- Procedure documentation (rotation, recovery, emergency actions)
- 1-month post-deployment support
Timelines and Costs
Timelines: 4 to 6 weeks depending on complexity (custom modules, audit). Costs are calculated individually — contact us for a project estimate. We guarantee schedule adherence and contract security. Get a consultation: write to us to discuss.
Common Mistakes and Recommendations
- Too low threshold: 2-of-10 — one compromised key almost doesn't hinder an attack. Recommended at least 50%+1 of owners.
- Storing seed phrases in the cloud: use hardware wallets and physically separated locations.
- Lack of owner rotation: rotation procedure must be tested in advance. Recommended every six months.
- Not using Guards: without a guard, any transaction can be executed once threshold is met. Add amount limits and whitelist.
- Ignoring social engineering: all urgent requests should be verified via official channels.
Our experience: 5+ years in Web3, 30+ implemented DAO systems, work with leading protocols. Get a consultation: contact us to discuss your project.