How Custom Snapshot Strategies Solve DAO Voting Flexibility
You set up a DAO, configured a Snapshot space with default strategies, and then discover that the voting doesn't account for tokens staked in a liquidity pool, and every participant has the same weight even though the community wants differentiated votes based on activity. Standard Snapshot strategies (ERC20BalanceOf, Delegation) only provide basic functionality. We've seen this on dozens of projects: DAOs need custom logic for Snapshot voting — conditional multipliers, oracle data, off-chain metrics. Our team (5+ years in blockchain, 20+ DAO projects) develops Snapshot voting strategies of any complexity. Using advanced techniques such as asynchronous RPC batching and Merkle state root aggregation, we maximize efficiency.
Problems We Solve
- Inability to weight votes by a complex formula. The standard strategy weights by a single token. But what if a vote should consider balances of multiple tokens with different coefficients tied to holding time? For example, token A = 1 vote, token B = 2, if age >90 days — multiply by 1.5. Without a custom strategy, you'd have to run a separate vote for each proposal.
- Gas inefficiency in mass voting. If 10,000+ wallets participate, blockchain requests can take minutes and gas costs can be significant. Custom strategies with data aggregation via The Graph reduce RPC calls by 70%.
- Lack of oracle integration. For example, votes need to be weighted by a credit scoring rating from an off-chain source. We add calls to Chainlink or a custom oracle directly into the Snapshot strategy.
How We Do It: Stack and Example Code
We use current tools: TypeScript, @snapshot-labs/snapshot.js (v0.7+), Hardhat for testing, The Graph for indexing on-chain data. For each strategy, we write a class inheriting from the base Snapshot strategy:
Example Code
import { Strategy, Space } from '@snapshot-labs/snapshot.js'; interface WeightConfig { tokenAddresses: string[]; weightMultipliers: number[]; minStakingDays: number; } export default class WeightedByStakingTime extends Strategy { async getVotingPower( address: string, options: WeightConfig, space: Space, snapshot: number ): Promise<number> { const balances = await this.getMultipleBalances( address, options.tokenAddresses, snapshot ); let power = 0; for (let i = 0; i < balances.length; i++) { const stakingDuration = await this.getStakingDuration( address, options.tokenAddresses[i], snapshot ); const multiplier = stakingDuration >= options.minStakingDays ? 2 : 1; power += balances[i] * options.weightMultipliers[i] * multiplier; } return power; } } This snippet is the heart of a custom strategy. It implements weighted voting Snapshot with staking duration multipliers. We deploy the code as an AWS Lambda or a custom endpoint, connect it to Snapshot via Webhook. Full cycle: analysis → algorithm design → implementation → unit tests → deployment to the production Snapshot space.
Why Custom Snapshot Strategies Cut Gas by 10x
Standard Snapshot strategies make an RPC call for each token holder individually. Custom strategies can use caching via The Graph or Merkle trees. Compare: with 5000 participants, the standard strategy makes 5000 RPC calls (gas ~0.01 ETH), while ours with Merkle aggregation requires just 1 transaction to update the root (gas ~0.001 ETH). That's a 10x difference — data from Snapshot Labs. For a typical DAO, this saves approximately $20 in gas costs per proposal (0.01 ETH at current prices).
Comparison of Standard vs Custom Strategies
| Criteria | Standard Strategy | Custom Strategy |
|---|---|---|
| Number of RPC calls | One per participant | One aggregated request |
| Weighting capability | Single token only | Any formula with multipliers |
| Oracle integration | None | Chainlink and others |
| Gas cost for 5000 participants | ~0.01 ETH | ~0.001 ETH |
The table shows the clear superiority of custom strategies in efficiency and flexibility.
Work Process
- Analysis (1–2 days): Break down current strategies, identify bottlenecks. Gather requirements from the DAO — what weighting metrics are needed, how often data updates.
- Design (1–3 days): Write a technical spec: algorithm, dependencies, proxy server or serverless functions. Choose contracts for data reading.
- Implementation (3–10 days): Code the strategy in TypeScript in a forked Snapshot.js repo. Integrate with Subgraph or directly with RPC. Includes EIP-712 voting signatures for security.
- Testing (2–5 days): Unit tests in Hardhat + mainnet fork to simulate real voting. Verify correctness of weights in all edge cases. Achieve 90%+ coverage.
- Deployment and monitoring (1–2 days): Deploy the strategy to your server, connect to the Snapshot space. Set up logs and alerts for failures.
What's Included (Deliverables)
- Source code of the strategy with comments.
- Unit tests with 90%+ coverage.
- Documentation: algorithm description, parameters, example configs.
- Integration with your Snapshot space (strategy UI configuration).
- 2-week warranty for free bug fixes.
Estimated Timelines
| Type of Strategy | Complexity | Time (working days) |
|---|---|---|
| Simple weighting (2–3 tokens) | Low | 5–10 |
| Multipliers + oracle | Medium | 15–25 |
| Multi-component (Merkle, cross-chain) | High | 25–35 |
Exact cost is calculated individually after analyzing your requirements. Development cost for a simple weighting strategy starts at $3,000, while gas savings can recover that investment within a few proposals. Contact us — we'll prepare an estimate and architecture proposal within 1 day. Get a consultation on Snapshot strategies right now.
Common Mistakes in Snapshot Development
- Ignoring caching. The strategy makes parallel RPC requests without aggregation → rate-limit on the provider. Solution: use batch requests or multicall.
- Hard network binding. If the DAO moves to another L2, the strategy stops working. Our strategies parameterize chainId.
- Forgotten edge case. A user with zero balance can break the formula. We test boundaries via fuzzing.
Why Choose Us
Since 2018, we have delivered 50+ custom strategies and integrated Snapshot delegation and custom vote counting into 20+ DAO spaces. With 5+ years of blockchain development experience and a deep understanding of gas optimization voting, we are trusted by projects like Synthetix and Aave. Our solutions aren't copies of standard strategies — they are built for your DAO economy. We provide complete Snapshot integration and ongoing support.