DAO Delegation: How to Delegate Your Governance Votes
Open your UNI, ARB, ENS or OP token contract on a block explorer and call getVotes() on your own address. For Compound-style tokens such as UNI and COMP, the function is getCurrentVotes(). If you have never delegated, not even to yourself, the result is very likely 0. Your tokens are in your wallet, but none of them count as votes. Most governance tokens follow OpenZeppelin's ERC20Votes design or Compound's checkpointed design, and both only count votes after the holder points them at a delegate. DAO delegation works like an ignition key: everything is in place, but nothing runs until you turn it.
Before your wallet asks you to sign anything, here is what delegation actually does. Delegation does not move your tokens, lock them, or give anyone permission to spend them. The delegate() function writes one pointer in the token contract ("my votes go to address X") and updates vote checkpoints. It never touches balanceOf or allowance. It works like a shareholder's proxy card: you hand over the vote, not ownership of the shares, and you can take it back in a single transaction.
This guide treats delegation as capital allocation for your governance power, in four stages: Activate → Choose → Execute → Monitor. Each step comes with a way to confirm it on-chain. Start where your situation fits:
- "My tokens show zero votes." Go to Phase 1, then self-delegate using any option in Phase 4 (Option E works even if the front ends are down).
- "I want someone more active to vote for me." Go to the Phase 3 delegate scorecard.
- "I want to become a delegate." Go to Becoming a Delegate Yourself.
📋 What You'll Learn
- How ERC20Votes checkpoints and the proposal snapshot decide whether your vote counts
- Why on-chain Governor delegation and Snapshot delegation are two separate systems
- A "leak audit" that finds tokens that cannot vote (on exchanges, in LPs, in wrappers, or on the wrong chain)
- A weighted delegate scorecard and a red-flag checklist
- Step-by-step delegation on Tally, Agora, Snapshot, the Aave app, and directly on Etherscan
- How to verify on-chain with
delegates(),getVotes(), and event logs - A quarterly routine for monitoring and re-delegating
⏱️ Estimated Time: About 25 minutes to read, then 5–10 minutes per DAO to delegate and verify
📊 Difficulty: Advanced (●●●○, 3 of 4)
Process map: Phase 1: Audit → Phase 2: Decide → Phase 3: Evaluate → Phase 4: Execute → Phase 5: Verify → Phase 6: Monitor
Foundation for all six phases: How DAO Delegation Actually Works
Decision tree:
- Are your tokens in an address you control? If not, start with Phase 1.
- Does the DAO vote through an on-chain Governor, through Snapshot, or both?
- Will you self-delegate, delegate to someone else, or mix the two? (Phase 2)
- Which platform? A: Tally · B: Agora · C: Snapshot · D: Aave · E: Etherscan
Before You Start
To follow this guide, you'll need:
- Working knowledge of governance tokens and the proposal lifecycle: discussion → temperature check → on-chain proposal → voting delay → voting period → timelock → execution. Ethereum.org's DAO overview describes a DAO as "a collectively-owned organization working towards a shared mission," and a primer on governance tokens is on the way (coming soon).
- The ability to read a transaction and its event logs on Etherscan, Arbiscan, or the OP Mainnet explorer.
- An understanding of the two ways a wallet asks you to sign. An EIP-712 typed-data signature is an off-chain message that someone else can submit. A transaction is something you broadcast yourself and pay gas for.
- A self-custody wallet. A hardware wallet with clear signing, or at least visible calldata, is strongly recommended.
- Gas on the chain where the token contract lives:
- ETH on Ethereum mainnet for UNI, ENS, AAVE, COMP, and GTC
- ETH on Arbitrum One for ARB. Arbitrum One settles to Ethereum and has its own documentation.
- ETH on OP Mainnet for OP
- Bookmarked official governance front ends, taken from each DAO's own documentation. Never use links from search ads or DMs.
- Tokens in an address you control. Tokens on an exchange, in an LP, in a lending market, or in a staking wrapper that does not pass votes through usually cannot vote from your address. Phase 1 shows how to check.
How DAO Delegation Actually Works (Under the Hood)
Every step later in this guide depends on four facts about the token contract. Once you understand them, you can verify every claim yourself instead of trusting a front end.
Voting power is not the same as token balance
ERC20Votes tokens (see OpenZeppelin's docs) and Compound-style tokens (see Compound Governance) keep two separate ledgers:
- Balances, recorded for each holder
- Votes, recorded for each delegate
An address with no delegate passes its balance to nobody, so those votes go unused. ERC-5805 standardizes this interface as delegate(), delegates(), getVotes(), getPastVotes(), and delegateBySig().
The function names differ depending on which design a token follows:
| Token family | Examples | Current votes | Historical votes |
|---|---|---|---|
| OpenZeppelin ERC20Votes | ENS, ARB, OP | getVotes(address) | getPastVotes(address, timepoint) |
| Compound-style | UNI, COMP, GTC | getCurrentVotes(address) | getPriorVotes(address, blockNumber) |
| Aave governance tokens | AAVE, stkAAVE, aAAVE | getPowerCurrent(address, type) | See Aave's docs |
Checkpoints and the snapshot block
Every change to delegation, or to a delegated balance, writes a checkpoint: a pair of (block number or timestamp, vote total). Governors do not read live balances. They call getPastVotes(account, proposalSnapshot) or its Compound equivalent.
A proposal takes a photograph of everyone's voting power at one moment. If you delegate after that moment, you are not in the picture.
In OpenZeppelin's Governor, the snapshot is the proposal's creation time plus the votingDelay. Compound's GovernorBravo works the same way using a start block. This means:
- A delegation mined during the voting delay still counts.
- A delegation mined after the snapshot counts only for later proposals.
Snapshot.org proposals fix a snapshot block when they are created, so the same rule applies.
Only the state at 📸 counts for this proposal. Any change after 📸 applies to the next proposal.
This design exists for a reason. In the Beanstalk governance exploit, an attacker used a flash loan to borrow enough tokens to gain voting power and pushed a malicious proposal through within a single transaction (see Beanstalk's post-mortem). Reading votes from a past checkpoint blocks that pattern, because borrowed tokens cannot appear in a photograph that was taken before they were borrowed. A dedicated guide on governance attacks is coming soon.
Delegation is non-custodial and revocable
delegate(address) changes only the _delegates mapping and the vote checkpoints. It creates no allowance, so your delegate cannot call transferFrom on your tokens. They cannot sell, stake, bridge, or approve anything on your behalf.
The arrangement works like a revocable power of attorney that covers voting only. You can point it at someone else, or reclaim it with delegate(yourAddress), whenever you like.
What happens to delegated votes when you transfer tokens
Voting power follows the tokens. When tokens leave your address, your delegate loses those votes. The recipient's delegate gains them, or nobody does if the recipient never delegated. Tokens you receive automatically add to your current delegate's weight, so you never need to re-delegate after buying more.
Hypothetical example: Suppose you hold 1,000 tokens delegated to Delegate A, and you send 100 tokens to a friend who has never delegated. Delegate A's votes from you drop to 1,000 − 100 = 900. The 100 tokens now carry no votes until your friend delegates. All figures are illustrative.
Signature-based delegation (delegateBySig / EIP-712) and gasless relayers
With delegateBySig, you sign EIP-712 typed data of the form Delegation(address delegatee,uint256 nonce,uint256 expiry). Anyone can then submit that signature and pay the gas, which is often the front end's relayer. This is safe when two things are true:
- The
primaryTypeis Delegation. - The domain (
name,chainId,verifyingContract) matches the official token.
A "gasless delegation" that shows a Permit struct is an approval, not a delegation. The Security section covers this in detail. Aave adds a further twist by splitting power into two types, covered in Option D.
On-Chain vs Off-Chain Delegation: Comparison Table
Treat these as two independent switchboards. Flipping a switch on one does not flip anything on the other.
| Dimension | On-chain / Governor (Tally, Agora, native portals) | Snapshot delegation (Delegate Registry) |
|---|---|---|
| Where it lives | In the token contract itself (delegate()) | In a separate Delegate Registry contract (setDelegate(id, delegate)), scoped by space ID |
| Gas cost | One transaction on the token's chain, or gasless through delegateBySig if the front end offers a relayer | Setting the delegation is also an on-chain transaction to the registry. Only voting on Snapshot is gasless. |
| Binding or signaling | Binding. Passed proposals execute on-chain, usually through a timelock. | Usually signaling or temperature checks, unless the DAO commits to executing the result (for example by multisig or oSnap) |
| Scope | Per token. Applies to every Governor proposal that reads that token. | Per space, or global ("all spaces"). A space-specific delegation normally takes precedence in that space. |
| Carries across DAOs? | No. Each token needs its own delegation. | A global delegation can cover many spaces, but only those whose strategy reads delegations |
| How to revoke | delegate(self), or delegate to a different address | clearDelegate, or remove it in the Snapshot UI |
| Typical DAOs | Uniswap, Arbitrum, ENS, Compound, Gitcoin, Optimism Token House | Snapshot spaces across many DAOs, including temperature checks |
Key caveat: some Snapshot spaces use an erc20-votes-style strategy that reads on-chain delegations. In those spaces, your Governor delegate also votes for you on Snapshot. Other spaces use a balance strategy combined with the "delegation" strategy, so only Registry delegations count. Check each space's listed voting strategies (usually in its About or Settings view) rather than assuming. See Snapshot's docs on delegation and strategies.
Phase 1: Audit Where Your Voting Power Is Leaking
Voting power flows through delegation like water through pipes. Tokens sitting on an exchange or in an LP are water in someone else's tank, so they cannot reach your delegate. Find those leaks before you spend gas on a delegation.
Tokens on exchanges
A centralized exchange's address holds the balance, so any votes follow the exchange's delegation choices, if it makes any. You have no vote. Fix: withdraw to self-custody before you delegate.
Tokens in LPs, lending markets and staking wrappers
When you deposit governance tokens into a Uniswap pool, a lending market, or a vault, the pool contract holds them. Your LP or receipt token usually has no delegate() function.
To check, open the wrapper's contract on the explorer, go to Contract → Read Contract and Write Contract, and search for delegate or delegates. If neither appears, the wrapper cannot pass voting power through to you.
Exceptions depend on the protocol, so never generalize from one to another. For example, in Aave's governance v3, stkAAVE and aAAVE do carry voting power that you can delegate. A guide on liquid staking and governance rights is coming soon.
Multi-chain balances (L1 vs L2 token versions)
Governance usually reads only one canonical token:
- ARB votes on Arbitrum One.
- OP votes on OP Mainnet.
- UNI, ENS, AAVE, and COMP vote on Ethereum mainnet.
Bridged copies on other chains generally carry no on-chain voting power. Confirm the canonical deployment in each DAO's docs before you bridge back.
Quick self-check: read getVotes() / delegates() on the block explorer
- Get the token address from official docs, such as Uniswap, Arbitrum DAO, or ENS DAO.
- Open it on the correct explorer and go to Contract → Read Contract. For upgradeable tokens such as ARB, use Read as Proxy.
- Call
delegates(yourAddress). A result of0x0000…0000means you have never delegated. - Call
getVotes(yourAddress), orgetCurrentVotes()for Compound-style tokens. - Compare the result with
balanceOf(yourAddress).
Reading the results:
delegates= 0x0: you need to delegate now.delegates= your address and votes ≈ balance: you are active.delegates= another address and your own votes = 0: this is expected. Your power sits with that delegate.- Votes higher than your balance: other people delegate to you.
- Balance = 0, but you know the tokens are "somewhere": look for a wrapper or the wrong chain.
Audit template:
| Token | Chain | Location | Delegatable? | Current delegate | Action |
|---|---|---|---|---|---|
| e.g., ARB | Arbitrum One | Hardware wallet | Yes | 0x0 | Self-delegate |
Phase 2: Decide: Self-Delegate or Delegate to Someone Else?
Once you know which tokens can vote, decide who should vote with them.
When self-delegation makes sense
Self-delegate if any of these apply:
- You have time to read proposals.
- You hold a meaningful stake or have professional exposure to the DAO.
- You have strong views you don't want filtered through someone else.
- You want to keep the option of voting directly.
Self-delegation is still a delegate() call, just with your own address as the target.
When delegating to an active delegate makes sense
Delegate to someone else when you hold small positions across several DAOs, cannot follow forum debates, or want your weight to count on every vote, including the ones you would miss. Handing your vote to an engaged, vetted person is participation, not abdication.
Unused tokens make quorum harder to reach. Research on delegation and voter apathy, including a16z crypto's governance writing, discusses this problem.
Hybrid strategy: self-delegate in your core DAO and delegate the rest of your DAOs
Self-delegate in the one or two DAOs you know well, and delegate the rest to vetted delegates. Revisit the split every quarter (Phase 6).
Under standard ERC20Votes, once you delegate elsewhere you cannot vote directly with those tokens in Governor proposals. To vote yourself, you must re-delegate to yourself before the next snapshot. Some Governor and Snapshot setups behave differently, so check the DAO's docs.
| Factor | Self | Delegate | Hybrid |
|---|---|---|---|
| Time available | High | Low | Moderate |
| Stake size | Concentrated in one DAO | Small and spread out | One large, several small |
| Conviction | Strong, specific views | Broad alignment is enough | Strong views in one DAO only |
| Number of DAOs | 1–2 | Many | Many |
Phase 3: How to Evaluate a Delegate (Due-Diligence Framework)
Treat a delegate profile like a fund factsheet. Participation is the track record, the delegate statement is the strategy, and funding sources are the fees and conflicts. Score each candidate from 1 to 5 on every criterion, then convert using points = weight × (score ÷ 5).
| Criterion | Weight | Score (1–5) | Points |
|---|---|---|---|
| Participation | 25 | ||
| Published rationales | 20 | ||
| Values alignment | 20 | ||
| Conflicts and disclosure | 15 | ||
| Concentration (inverse) | 10 | ||
| Responsiveness | 10 |
Hypothetical example: Suppose a candidate scores 5, 4, 4, 3, 2, 4 on the six criteria in order. The points are 25 × 5/5 = 25; 20 × 4/5 = 16; 20 × 4/5 = 16; 15 × 3/5 = 9; 10 × 2/5 = 4; 10 × 4/5 = 8. Total = 25 + 16 + 16 + 9 + 4 + 8 = 78 out of 100. The low concentration score suggests comparing them against a similarly rated mid-tier delegate. All scores are illustrative.
The six criteria are explained below.
Participation rate and voting history (Tally, Karma, Boardroom)
Measure votes cast as a share of eligible proposals over the last 6–12 months, counting both on-chain and Snapshot votes. Useful sources are delegate profiles on Tally, Karma dashboards (which add forum activity and delegate scores where available), and Boardroom. Set your minimum participation bar before you look at anyone's numbers, and weight binding votes more heavily than signaling votes.
Whether they publish voting rationales
Look for forum posts that explain each vote, linked from the vote itself. Pay particular attention to AGAINST and ABSTAIN votes that come with reasons. Rationales let you audit how a delegate thinks, not just what they chose.
Delegate statement and stated values
Compare the delegate's stated values with their actual votes on two or three contested proposals. Good candidates are treasury spending, incentive programs, fee switches, or constitutional changes. Check that their positions stay consistent over time.
Conflicts of interest and where their funding comes from
Ask these questions:
- Is the delegate a service provider paid by the DAO, a VC fund with portfolio exposure, a grantee, or a competing protocol?
- Are they paid through a delegate incentive program?
- Do they disclose these ties and recuse themselves when relevant?
Funding alone is not disqualifying. Undisclosed funding is.
Concentration risk: avoid adding power to delegates who are already dominant
Check how much voting power the top delegates hold on Tally or Karma. Adding to an already dominant delegate increases the risk of capture and makes quorum depend on a few people. If a mid-tier delegate scores about the same, prefer them.
Red flags checklist
- Long gaps in voting
- Votes with no rationale on contested proposals
- Undisclosed affiliations
- Vote-buying or bribe-market activity they haven't disclosed
- Delegate statements copied word for word across DAOs
- Popularity based only on follower count or fame
- Pressure to delegate through an unofficial link
- Any request for token approvals
Phase 4: Choose Your Delegation Path (Interactive Choice)
Which platform does your DAO use?
Tally | Agora | Snapshot | Native Portal (Aave) | Direct Contract Call
For on-chain tokens, every front end writes to the same delegate() state in the token contract. A delegation made on Tally shows up the same way on Agora. Many DAOs appear on more than one front end, so use the one the DAO's own docs link to.
Option A: Delegating via Tally
Tally serves Governor DAOs such as Arbitrum, ENS, Compound, and Gitcoin (see the Tally docs).
- Open the DAO from a bookmarked Tally link.
- Click Connect Wallet and switch to the token's chain (Arbitrum One for ARB).
- Open Delegates, filter the list, and apply your Phase 3 scorecard to each profile you're considering.
- Click Delegate on the profile you chose, or choose the option to delegate to yourself.
- Check the wallet prompt. It should call
delegate(address), the "to" address should be the official token contract, and the value should be 0. If you use a gasless option, confirm the typed data is a Delegation struct. - Confirm, then save the transaction hash for Phase 5.
Option B: Delegating via Agora (including partial delegation where supported)
Agora powers Optimism's Token House front end and a Uniswap governance front end. The steps mirror Option A, on OP Mainnet or Ethereum mainnet as appropriate.
For OP, Agora has at times offered partial delegation, which splits your voting power across several delegates. Partial delegation may run through separate contracts rather than the plain delegate() function, so your wallet prompt can look different. Check the current Optimism governance docs before relying on it.
Option C: Snapshot delegation (space-specific vs global)
- Check the space's voting strategies to confirm that delegation is counted (see the comparison table above).
- In the official Snapshot app, linked from Snapshot's docs, open the space's delegate page.
- Choose this space only (scoped to the space ID) or all spaces (global).
- Enter the delegate's address or ENS name.
- Confirm the
setDelegatetransaction to the Delegate Registry, on the network the UI specifies. - Remember that this does nothing for the on-chain Governor. If you want both covered, also complete Option A, B, or E.
Option D: Aave-style native portals (voting vs proposition power)
AAVE, stkAAVE, and aAAVE each carry two separate dials:
- Voting power, used to vote on proposals
- Proposition power, used to create proposals
Each dial can point to a different delegate. According to Aave's documentation, your balance counts for you by default, so on Aave delegation is mainly for handing power to someone else.
- Open the official Aave app, go to Governance, and choose to set up delegation.
- Select which tokens to delegate.
- Choose voting power, proposition power, or both. Enter an address for each; they can be different.
- Sign. The portal may batch several signatures, and each one must be delegation typed data, never a Permit.
The contract-level equivalent is delegateByType(delegatee, 0) for voting and delegateByType(delegatee, 1) for proposition, or delegate() to set both at once.
Option E: Calling delegate() directly on Etherscan
Use this route when front ends are down, unreliable, or suspected of being compromised. A guide to reading smart contracts on Etherscan is coming soon.
- Copy the token address from the DAO's official docs or GitHub, and cross-check it against the explorer's verified token page.
- Go to Contract → Write Contract. For upgradeable tokens such as ARB, use Write as Proxy.
- Click Connect to Web3 and make sure your wallet is on the correct chain.
- Expand
delegate(for Aave you can usedelegateByType). - Paste your own address to self-delegate, or the address of the delegate you vetted.
- Click Write. The wallet should show a contract interaction with the token, the selector
0x5c19a95c(delegate(address)), and a value of 0. - Confirm and copy the transaction hash.
Hardware wallet signing tips that apply to every option
- Prefer clear signing. If you only see raw calldata, check the first 4 bytes:
0x5c19a95c=delegate0xc3cda520=delegateBySig
- Stop if you see
0x095ea7b3(approve),0xa22cb465(setApprovalForAll), or EIP-2612 Permit typed data. - For EIP-712 prompts, check that
primaryTypeis Delegation and thatverifyingContractis the official token. - Don't turn on blind signing just to get a delegation through.
- Gas depends on how many checkpoints the call writes, so rely on your wallet's estimate rather than a fixed figure.
Phase 5: Verify Your Delegation On-Chain
Don't trust the green checkmark in the UI. Confirm the result in the contract itself.
Confirm the DelegateChanged and DelegateVotesChanged events
Open your transaction hash and go to Logs. You should see:
DelegateChanged, with delegator = you, fromDelegate = your old delegate or 0x0, and toDelegate = your new delegate.- One
DelegateVotesChangedevent for each affected delegate, showing their old and new vote totals. The field names arepreviousVotes/newVotesin OpenZeppelin tokens andpreviousBalance/newBalancein Compound-style tokens.
Aave emits DelegateChanged with a delegationType field. Snapshot's Registry emits SetDelegate.
Check delegates(yourAddress) and getVotes(delegatee)
Call delegates(you). It should return the new delegate. Then call getVotes(delegatee), or getCurrentVotes() for UNI, COMP, and GTC. It should have risen by roughly your balance. On Aave, use getPowerCurrent(user, 0) for voting power or getPowerCurrent(user, 1) for proposition power.
Confirm the change appears in the platform UI
Refresh Tally, Agora, Snapshot, or the Aave app and look for your "delegated to" field. Indexers can lag behind the chain. If the UI disagrees with the contract, the contract is the source of truth.
Troubleshooting:
- Votes didn't rise: your tokens are probably in a wrapper or on another chain. Go back to Phase 1.
- The transaction went to the wrong chain: repeat it on the canonical chain.
- No change on a live proposal: your delegation landed after that proposal's snapshot. It will count from the next proposal.
Phase 6: Monitor, Re-Delegate and Revoke
A delegation you never review goes stale. Delegates go quiet, change jobs, or pick up new conflicts.
Set a review cadence (quarterly) and alerts
Every quarter:
- Re-score each delegate with the Phase 3 scorecard.
- Check their participation since your last review.
- Read their rationales on the two or three biggest votes.
- Re-check concentration.
Keep a governance portfolio sheet with one row per DAO. For alerts, follow your delegates on Tally or Karma, subscribe to each forum's governance category, and optionally add your delegate's address to an explorer watch list.
How to re-delegate or reclaim your votes (delegate to self)
To switch delegates, call delegate(newAddress). The old delegate loses your weight in the same transaction, so there is no separate revoke step. To take your votes back, call delegate(yourAddress). On Snapshot, change or clear the delegation in the UI.
Timing re-delegation around upcoming proposals
Check the proposal calendar on Tally, Agora, or the forum. To affect a proposal, your change must be mined before that proposal's snapshot.
Hypothetical example: Suppose a Governor proposal is created on Monday and the DAO's voting delay is two days, so the snapshot falls on Wednesday. A re-delegation mined Tuesday counts. One mined Thursday, during voting, counts only from the next proposal. The days are illustrative; voting delays vary by DAO.
If your delegate votes against your views, re-delegate before the next snapshot and consider explaining your reasons on the forum. Accountability works through both voice and exit.
Becoming a Delegate Yourself (Brief Advanced Section)
If you'd rather receive votes than hand them out, start by self-delegating so that your own tokens count toward your weight.
Writing a delegate statement
A strong statement covers:
- Who you are and any affiliations
- Your values and governance priorities
- A full disclosure of conflicts
- A commitment to vote and publish rationales
- How delegators can reach you
- When you will recuse yourself
Post it on the DAO forum and on your Tally or Karma profile. A dedicated guide to writing a delegate statement is coming soon.
Delegate incentive programs and accountability expectations
Some DAOs, including Arbitrum through its Delegate Incentive Program, have paid delegates who meet participation and rationale thresholds. These programs often require a minimum amount of voting power. Check the current status and terms in the DAO's docs.
Whether or not you're paid, delegators will expect consistent participation, timely rationales, availability, and disclosure whenever a vote touches your interests.
Security Best Practices
Every rule below follows from one fact: delegation never needs an allowance and never needs ETH sent to a contract.
| ✅ Legitimate delegation prompt | ❌ Malicious prompt disguised as "delegation" |
|---|---|
delegate(address) sent to the official token, value 0 | approve(spender, amount) or increaseAllowance |
EIP-712 primaryType: Delegation on the official token domain | EIP-712 Permit (EIP-2612) typed data |
delegateByType() (Aave), or setDelegate() on the Snapshot Registry | setApprovalForAll, or any request to send ETH |
- Only sign delegation calls. That means
delegate(),delegateByType(), a Delegation signature that a relayer submits throughdelegateBySig, orsetDelegate()on the Snapshot Registry. - Reject every approval-type request without exception: approve, increaseAllowance, Permit, and setApprovalForAll.
- Bookmark the official front ends listed in each DAO's docs, and check the domain before connecting.
- Cross-check token addresses against official docs and the explorer's verified page.
- Use a hardware wallet, read every prompt, and confirm the value is 0.
- If you've already signed something suspicious, revoke stray approvals with a tool such as revoke.cash. A guide on token approvals and how to revoke them is coming soon.
A separate hot wallet for governance isn't necessary. Your cold wallet only needs to sign once to point its votes at someone else.
⚠️ Common Mistakes to Avoid
- Never self-delegating. Symptom: you hold tokens but have zero votes. Fix: call
delegate(self)(Phase 4). - Assuming Snapshot delegation covers Governor votes, or the reverse. Symptom: your delegate votes in one venue but not the other. Fix: set both switchboards (see the comparison table).
- Delegating after the snapshot. Symptom: no effect on a live proposal. Fix: plan changes around snapshot timing (Phase 6).
- Delegating while tokens sit in an LP or a wrapper that doesn't pass votes through. Symptom: you paid gas and votes are still zero. Fix: withdraw first (Phase 1).
- Delegating on the wrong chain, such as ARB on mainnet or bridged UNI on an L2. Fix: use the canonical chain.
- Choosing delegates by follower count. Symptom: power concentrates in a few hands. Fix: use the Phase 3 scorecard.
- Setting it and forgetting it. Fix: review every quarter.
- Using a "delegation" link from a Discord DM or a search ad. Fix: use bookmarked official URLs only.
Frequently Asked Questions
Does delegating my governance tokens transfer them or give the delegate custody?
No. delegate() updates a pointer in the token contract and the vote checkpoints, and nothing else. Your balance stays at your address, and no allowance is created. The delegate gets your voting weight but cannot move your tokens. You can confirm this in the transaction logs, which show no Transfer or Approval event, only DelegateChanged and DelegateVotesChanged.
Can I delegate my voting power to multiple people at once?
Not with standard ERC20Votes, which allows one delegate per address. There are three workarounds. You can use partial delegation where a platform supports it (Agora has offered it for OP at times). You can split your tokens across several wallets you control, each with its own delegate. On Aave, you can point voting power and proposition power at different delegates.
Can a delegate steal, sell or stake my tokens?
No. Moving tokens on someone else's behalf requires an allowance through approve or permit, and delegation creates neither. Your delegate can only cast votes using your weight. If a "delegation" site asks you to approve anything, treat it as an attack.
Do I need to re-delegate after buying or receiving more tokens?
No. Tokens that arrive at your address automatically add to your current delegate's vote total through the checkpoint logic. You only need a new transaction if you want to change delegates.
How much gas does delegation cost, and is gasless (delegateBySig) delegation safe?
Delegation is a single, typically inexpensive transaction on the token's chain. The exact cost depends on network conditions and how many checkpoints are written, so rely on your wallet's estimate. Gasless delegation is safe when the typed data's primaryType is Delegation and the domain matches the official token. Reject anything that shows a Permit.
What happens if my delegate votes against my views?
Votes that have already been cast stand. Re-delegate before the next proposal's snapshot so your weight moves to someone better aligned. Consider posting your reasons on the forum, because public feedback helps hold delegates accountable.
Does delegation affect my staking rewards or airdrop eligibility?
It depends entirely on the protocol. Some programs have rewarded governance activity, while others ignore delegation. Read the specific DAO's docs and any program's published criteria, and don't assume either way.
Can I still vote myself after delegating to someone else?
Under standard ERC20Votes, not for Governor proposals unless you re-delegate to yourself before the relevant snapshot. Some Governor variants and Snapshot strategies behave differently, so check the DAO's documentation.
What is the difference between voting power and proposition power on Aave?
Voting power counts toward votes on proposals. Proposition power counts toward the threshold for creating proposals. Aave's tokens track the two separately, and you can delegate each one to a different address.
Does Snapshot delegation also delegate my on-chain Governor votes?
No. Snapshot delegations live in a separate Registry contract. The reverse can happen in some spaces, though: if a space's strategy reads on-chain delegations, your Governor delegate may also vote for you on Snapshot. Check the space's strategies.
Why does my delegation not count on a proposal that is already live?
Governors read your voting power at the proposal's snapshot, which is the creation time plus the voting delay. A delegation mined after that point applies from the next proposal onward.
My tokens are in a liquidity pool or on an exchange: can I still delegate them?
Usually not. The pool or exchange holds the tokens, so any voting power belongs to that contract or custodian. A few wrappers pass delegation through, such as Aave's stkAAVE and aAAVE. Check the wrapper for delegate functions, or withdraw to self-custody first.
What's Next?
Now that you've completed this guide, run this action checklist:
- Audit your holdings using the Phase 1 table.
- Choose self, delegate, or hybrid.
- Score two or three candidates with the scorecard.
- Delegate.
- Verify with
delegates()andgetVotes(). - Put a quarterly review in your calendar.
Related guides that are coming soon:
- How to Vote on Snapshot (coming soon)
- How to Create a DAO Proposal (coming soon)
- Governance Attacks Explained (coming soon)
- Token Approvals and How to Revoke Them (coming soon)
- Bridging Tokens to Arbitrum and Optimism (coming soon)
- Liquid Staking and Governance Rights (coming soon)
- Writing a Delegate Statement (coming soon)
- Multisig vs Governor Execution (coming soon)
Official references:
- OpenZeppelin Governor
- ERC-5805
- EIP-712
- Compound Governance
- Tally
- Snapshot delegation
- Optimism governance
- Aave
- Arbitrum DAO
- Uniswap governance
- ENS DAO
- Karma
DAO delegation is capital allocation for your governance power. Turn it on, assign it deliberately, and review it with the same discipline you apply to the rest of your portfolio.
Sources
- Decentralized Exchange — primary documentation
- CoinGecko — Arbitrum
- L2Beat — Arbitrum One
- DefiLlama — Arbitrum Bridge
- GitHub — ArbitrumFoundation/docs
- Ethereum.org: Decentralized applications (dapps)
- Arbitrum One — official documentation site
- Ethereum.org - Decentralized autonomous organizations (DAOs)
- Decentralized applications and DEXs - ethereum.org
- Uniswap V2 Whitepaper
- DefiLlama — DAO Swap
- Decentralized Finance (DeFi) - ethereum.org
- EIP-4824: Common Interfaces for DAOs
- Ethereum.org: Smart contracts
- EIP-1337: DAO Standard
- Introducing UNI - Uniswap Blog
- Ethereum.org: What are DAOs?
- ERC-20 Token Standard
- Ethereum.org: Smart Contracts
- Ethereum.org: Decentralized Autonomous Organizations (DAOs)