governance-attacks

Governance Attacks

Flash Loan Voting

Borrow governance tokens → acquire voting power → vote → return tokens. All in one transaction.

1. Flash borrow 10M GOV tokens
2. Delegate to self (if not already delegated)
3. Cast vote on active proposal
4. Return tokens

Defense: Snapshot-Based Voting

contract SafeGovernor {
    // Voting power is snapshotted BEFORE proposal voting begins
    function propose(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        string memory description
    ) public returns (uint256 proposalId) {
        uint256 snapshot = block.number + votingDelay;
        // votingDelay ensures tokens must be held before voting starts
        proposals[proposalId].snapshot = snapshot;
        proposals[proposalId].deadline = snapshot + votingPeriod;
        // ...
    }

    function _getVotes(address account, uint256 blockNumber)
        internal
        view
        returns (uint256)
    {
        // Historical balance — flash loans have zero effect
        return token.getPastVotes(account, blockNumber);
    }
}

Key Parameters

uint256 public votingDelay = 1 days;     // blocks between propose and vote start
uint256 public votingPeriod = 1 weeks;   // duration of voting
uint256 public proposalThreshold = 100_000e18; // tokens needed to propose

Vote Buying / Dark DAOs

Off-chain vote buying markets where token holders sell their voting power.

1. Attacker deploys contract: "Deposit GOV tokens, vote my way, earn rewards"
2. Token holders delegate to attacker's contract
3. Attacker controls large voting block

Defense: Vote Escrow (veToken)

// Voters must lock tokens for extended periods to gain voting power
// Makes vote buying expensive (capital must be locked, not just held momentarily)
struct LockInfo {
    uint256 amount;
    uint256 unlockTime;
}

function getVotingPower(address account) public view returns (uint256) {
    LockInfo memory lock = locks[account];
    if (lock.unlockTime <= block.timestamp) return 0;

    // Voting power decays linearly toward unlock
    uint256 timeRemaining = lock.unlockTime - block.timestamp;
    uint256 maxLockDuration = 4 * 365 days;

    return lock.amount * timeRemaining / maxLockDuration;
}