Snapshot Governance Integration

Snapshot Integration (Voting)

Snapshot is the standard for off-chain voting in Web3. Most DAOs with active governance use it: Uniswap, Aave, ENS, Gitcoin, Compound. The reason is simple: on-chain voting via Governor costs gas for each participant; with thousands of voters this becomes a significant barrier.

Snapshot solves this through signatures: a vote is a cryptographic signature, not a transaction. Verification happens off-chain; results are published to IPFS. For most DAOs this is sufficient.

What's Needed for Integration

Integrating Snapshot takes 1–2 weeks and includes three parts: Space setup, displaying proposals in your interface, and a voting button.

Space setup: created at snapshot.org, configured via JSON file in ENS record. Key parameters — voting strategy (which tokens and on which networks count) and minimum proposal threshold.

// Example getting proposals via Snapshot GraphQL API
const SNAPSHOT_HUB = 'https://hub.snapshot.org/graphql';

async function getProposals(spaceId) {
    const query = `
        query Proposals($space: String!) {
            proposals(
                where: { space: $space, state: "active" }
                orderBy: "created"
                orderDirection: desc
            ) {
                id
                title
                body
                choices
                start
                end
                snapshot
                state
                scores
                scores_total
                votes
                author
            }
        }
    `;
    
    const response = await fetch(SNAPSHOT_HUB, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ query, variables: { space: spaceId } })
    });
    
    const { data } = await response.json();
    return data.proposals;
}

// Cast vote via Snapshot SDK
import { Web3Provider } from '@ethersproject/providers';
import Client from '@snapshot-labs/snapshot.js';

async function castVote(proposalId, choiceIndex, provider) {
    const client = new Client.Client('https://hub.snapshot.org');
    const web3 = new Web3Provider(provider);
    const [account] = await web3.listAccounts();
    
    const result = await client.vote(web3, account, {
        space: 'yourspace.eth',
        proposal: proposalId,
        type: 'single-choice',
        choice: choiceIndex,    // 1-based choice index
        reason: '',
        app: 'your-app'
    });
    
    return result;
}

Voting Strategies

Snapshot supports flexible strategies: erc20-balance-of (vote = token balance), erc20-votes (delegated voting power from Governor), delegation (passed votes), whitelist. Multiple strategies can be combined with weight coefficients. Snapshot block is used for balance snapshot — voting weight is fixed at proposal creation; buying tokens during voting is useless.

When Snapshot Isn't Enough

Snapshot suits governance signals but not execution. If voting results should automatically change protocol parameters — need on-chain execution via Governor + Timelock. In that case Snapshot is first stage: off-chain signal → on-chain vote → execution. ENS uses this pattern.

Integration Timeline

Basic UI with viewing proposals and voting — 1 week. Full integration with notifications, user vote history, and delegation — 2–3 weeks.