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:

📋 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:

  1. Are your tokens in an address you control? If not, start with Phase 1.
  2. Does the DAO vote through an on-chain Governor, through Snapshot, or both?
  3. Will you self-delegate, delegate to someone else, or mix the two? (Phase 2)
  4. 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 familyExamplesCurrent votesHistorical votes
OpenZeppelin ERC20VotesENS, ARB, OPgetVotes(address)getPastVotes(address, timepoint)
Compound-styleUNI, COMP, GTCgetCurrentVotes(address)getPriorVotes(address, blockNumber)
Aave governance tokensAAVE, stkAAVE, aAAVEgetPowerCurrent(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.

balance change ──▶ delegate() ──▶ PROPOSAL CREATED ──▶ [voting delay] ──▶ 📸 SNAPSHOT ──▶ voting period ──▶ timelock
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 primaryType is 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.

DimensionOn-chain / Governor (Tally, Agora, native portals)Snapshot delegation (Delegate Registry)
Where it livesIn the token contract itself (delegate())In a separate Delegate Registry contract (setDelegate(id, delegate)), scoped by space ID
Gas costOne transaction on the token's chain, or gasless through delegateBySig if the front end offers a relayerSetting the delegation is also an on-chain transaction to the registry. Only voting on Snapshot is gasless.
Binding or signalingBinding. 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)
ScopePer 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 revokedelegate(self), or delegate to a different addressclearDelegate, or remove it in the Snapshot UI
Typical DAOsUniswap, Arbitrum, ENS, Compound, Gitcoin, Optimism Token HouseSnapshot 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

  1. Get the token address from official docs, such as Uniswap, Arbitrum DAO, or ENS DAO.
  2. Open it on the correct explorer and go to Contract → Read Contract. For upgradeable tokens such as ARB, use Read as Proxy.
  3. Call delegates(yourAddress). A result of 0x0000…0000 means you have never delegated.
  4. Call getVotes(yourAddress), or getCurrentVotes() for Compound-style tokens.
  5. 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:

TokenChainLocationDelegatable?Current delegateAction
e.g., ARBArbitrum OneHardware walletYes0x0Self-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.

FactorSelfDelegateHybrid
Time availableHighLowModerate
Stake sizeConcentrated in one DAOSmall and spread outOne large, several small
ConvictionStrong, specific viewsBroad alignment is enoughStrong views in one DAO only
Number of DAOs1–2ManyMany

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).

CriterionWeightScore (1–5)Points
Participation25
Published rationales20
Values alignment20
Conflicts and disclosure15
Concentration (inverse)10
Responsiveness10

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).

  1. Open the DAO from a bookmarked Tally link.
  2. Click Connect Wallet and switch to the token's chain (Arbitrum One for ARB).
  3. Open Delegates, filter the list, and apply your Phase 3 scorecard to each profile you're considering.
  4. Click Delegate on the profile you chose, or choose the option to delegate to yourself.
  5. 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.
  6. 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)

  1. Check the space's voting strategies to confirm that delegation is counted (see the comparison table above).
  2. In the official Snapshot app, linked from Snapshot's docs, open the space's delegate page.
  3. Choose this space only (scoped to the space ID) or all spaces (global).
  4. Enter the delegate's address or ENS name.
  5. Confirm the setDelegate transaction to the Delegate Registry, on the network the UI specifies.
  6. 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.

  1. Open the official Aave app, go to Governance, and choose to set up delegation.
  2. Select which tokens to delegate.
  3. Choose voting power, proposition power, or both. Enter an address for each; they can be different.
  4. 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.

  1. Copy the token address from the DAO's official docs or GitHub, and cross-check it against the explorer's verified token page.
  2. Go to Contract → Write Contract. For upgradeable tokens such as ARB, use Write as Proxy.
  3. Click Connect to Web3 and make sure your wallet is on the correct chain.
  4. Expand delegate (for Aave you can use delegateByType).
  5. Paste your own address to self-delegate, or the address of the delegate you vetted.
  6. Click Write. The wallet should show a contract interaction with the token, the selector 0x5c19a95c (delegate(address)), and a value of 0.
  7. 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 = delegate
    • 0xc3cda520 = delegateBySig
  • Stop if you see 0x095ea7b3 (approve), 0xa22cb465 (setApprovalForAll), or EIP-2612 Permit typed data.
  • For EIP-712 prompts, check that primaryType is Delegation and that verifyingContract is 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 DelegateVotesChanged event for each affected delegate, showing their old and new vote totals. The field names are previousVotes/newVotes in OpenZeppelin tokens and previousBalance/newBalance in 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 0approve(spender, amount) or increaseAllowance
EIP-712 primaryType: Delegation on the official token domainEIP-712 Permit (EIP-2612) typed data
delegateByType() (Aave), or setDelegate() on the Snapshot RegistrysetApprovalForAll, or any request to send ETH
  1. Only sign delegation calls. That means delegate(), delegateByType(), a Delegation signature that a relayer submits through delegateBySig, or setDelegate() on the Snapshot Registry.
  2. Reject every approval-type request without exception: approve, increaseAllowance, Permit, and setApprovalForAll.
  3. Bookmark the official front ends listed in each DAO's docs, and check the domain before connecting.
  4. Cross-check token addresses against official docs and the explorer's verified page.
  5. Use a hardware wallet, read every prompt, and confirm the value is 0.
  6. 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:

  1. Audit your holdings using the Phase 1 table.
  2. Choose self, delegate, or hybrid.
  3. Score two or three candidates with the scorecard.
  4. Delegate.
  5. Verify with delegates() and getVotes().
  6. 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:

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