Snapshot Governance: Fixing Voting Power Calculation Errors

Pain

Pain is one of those universal experiences that everyone can relate to, but it's also super complex. Whether it's physical pain from an injury or emotional pain from a tough experience, it can shape our lives in huge ways.

Types of Pain

1. Acute Pain: This is the sharp, sudden pain you might feel from an injury or surgery. It usually goes away once the underlying issue is treated.
2. Chronic Pain: This one hangs around for longer than three months and can be really challenging to deal with. Conditions like arthritis or fibromyalgia fall into this category.
3. Neuropathic Pain: This type happens when there's damage to the nerves. It can feel like burning, tingling, or even stabbing sensations.
4. Psychogenic Pain: Sometimes, pain can stem from emotional factors. Stress, anxiety, or depression can all contribute to this kind of pain.

Managing Pain

Here are some tips and tricks that might help you manage pain:

• Physical Therapy: Working with a therapist can help you regain strength and reduce pain.
• Medication: Over-the-counter or prescription medications can aid in pain relief, but it's important to use them as directed.
• Mindfulness and Relaxation Techniques: Practices like meditation or yoga can help manage pain by reducing stress.
• Heat or Cold Therapy: Applying heat or cold can provide quick relief for some types of pain.

When to Seek Help

If pain is affecting your day-to-day life or lasting longer than expected, it’s definitely time to reach out to a healthcare professional. They can help identify the cause and work out a plan that suits you.

Conclusion

Remember, everyone's pain experience is unique. Listening to your body and finding what works best for you is key. Don’t hesitate to reach out for support when you need it. Pain may be a part of life, but it doesn’t have to control it.

Your governance votes are facing some pushback because the reported voting power (VP) doesn't match up across different stages--like “before vote,” “after vote,” and what’s shown on external dashboards. Here are some common signs of issues we’ve noticed:

• Sometimes, valid wallets experience intermittent zero voting power when a proposal goes live, but then it just "magically" corrects itself later. What's going on? The issue stems from those non-deterministic JSON-RPC block tags ("latest") and pruned nodes that can't handle historical state queries. The fix? We need to nail down deterministic block selection and archive state. Check it out here.
• Delegates often feel like their delegated tokens are either ignored or counted twice. What's causing this confusion? It usually comes down to mixing the "erc20-balance-of" method with older "delegation" strategies--or using approaches that don’t actually read the EIP‑5805-compatible delegated balances at the snapshot block. For more details, head over to the docs.
• If you're a cross-chain token holder, you might notice you're getting partial voting power. The culprit? It's often the outdated "multichain" wrapper or subgraphs that are being queried at "latest" rather than the specific block of the proposal. You can get the full scoop here.
• Stakers and yield-vault users might see their voting power inflated or deflated. What's behind this? It generally happens when strategies focus on the underlying asset balances instead of share tokens (ERC‑4626) or when they overlook wrapper tokens and the effects of rebasing. You can check out more info about it here.
• If "gasless" off-chain votes end up failing execution or getting disputed later on, that's a hassle for sure. The reason often lies in the lack of on-chain execution guardrails (like Reality.eth), weak identity validation, or a scoring pipeline that's not very transparent. For a deeper dive, look at the docs.

Agitation

Agitation refers to a state of nervousness, restlessness, or excitement. It's when someone's emotional state is stirred up, often leading to a lack of focus or calm. This can occur for various reasons, such as stress, anxiety, or even excitement about something.

Common Causes of Agitation

• Stressful Situations: Whether it's work deadlines, relationship issues, or financial worries, stress can really get under your skin.
• Mental Health Disorders: Conditions like anxiety, depression, or bipolar disorder can make feelings of agitation more frequent.
• Substance Use: Ingesting caffeine, alcohol, or recreational drugs can lead to heightened agitation.
• Physical Discomfort: Sometimes, it's as simple as being tired, hungry, or unwell.

Signs of Agitation

Spotting agitation can help in addressing it early. Keep an eye out for:

• Restlessness or fidgeting
• Rapid speech or difficulty staying on topic
• Irritability or mood swings
• Trouble concentrating

Coping Strategies

If agitation is getting in the way of your day-to-day life, here are a few tips to help you chill out:

1. Take Deep Breaths: Slow down and focus on your breathing. It can be a real game changer.
2. Get Moving: Physical activity can be a great outlet for built-up energy and tension.
3. Talk It Out: Sometimes just voicing your feelings can provide relief. Reach out to friends or family.
4. Limit Stimulants: If you find that coffee or energy drinks heighten your agitation, it might be time to cut back.

When to Seek Help

If you notice that agitation is affecting your daily life or relationships, it might be worth talking to a mental health professional. They can provide personalized strategies and support to help you manage your emotions better.

---

Understanding agitation can really help in managing those overwhelming feelings. Remember, you're not alone in this, and there's always support available!

If we ignore these problems, they’re not just about looks; they could seriously impact our governance and budgets:

• When quorum misfires happen, it means you're stuck redoing votes and missing deadlines, which can delay regulatory or partner commitments by weeks. Big DAOs like Uniswap have set clear rules around quorum and timing; when things go wrong, it damages their credibility and can lead to expensive re-votes. (docs.uniswap.org)
• You'll see spikes in RPC bills and engineering hours when teams have to re-run scores, fix proposals, or chase down inconsistencies in "archive" data while a vote is underway. Those archive queries are crucial for checking historical balances at specific blocks; if you’re relying on pruned nodes, you're likely to run into issues. (docs.metamask.io)
• Keep in mind the brand and legal risks: if an off-chain signal can’t be recreated later, it's not going to hold up during internal audits, SOC2 evidence requests, or board reviews. Your governance ledger needs to have “audit-grade reproducibility,” not just a rough attempt at caching.
• Watch out for strategy creep: piling on wrappers like “multichain” and outdated “delegation” methods to get around limits can make it tough for executives and external delegates to understand the VP--especially when you're going through incident postmortems. (help.snapshot.box)

Solution

Here's how we're tackling the problem:

1. Identify the Issue: We need to clearly define what the problem is. This helps us focus our efforts effectively.
2. Gather Data: Collect relevant information that can shed light on the issue. This might include statistics, case studies, or user feedback.
3. Analysis: Take a closer look at the data we've gathered. Look for patterns or insights that can inform our approach.
4. Develop a Plan: Based on our analysis, we’ll craft a plan that outlines the steps we need to take to address the issue.
5. Implementation: Put the plan into action. This might involve coordinating with different teams or stakeholders to ensure everything goes smoothly.
6. Monitor Progress: Keep track of how things are going after we implement our solution. Are we seeing improvements? Do we need to tweak anything?
7. Review and Adjust: After a set period, revisit our plan and outcomes. If something’s not working, let’s adjust our approach to make sure we’re on the right track.

Useful Resources:

• Data Analysis Techniques
• Project Management Tools
• User Feedback Methods

Quick Tips:

• Stay flexible; sometimes plans need to change.
• Don’t hesitate to ask for help if you hit a snag.
• Keep communication open among all parties involved.

By following these steps, we’re setting ourselves up for success in tackling the problem head-on!

7Block Labs Methodology: Deterministic, Reproducible, and Procurement-Friendly

At 7Block Labs, we take pride in our methodology, which is all about being deterministic, reproducible, and procurement-friendly. Here’s a closer look at what that means:

Deterministic

Our approach ensures that every outcome is predictable and consistent. This means that when we run our processes, you can expect the same results every time. No surprises!

Reproducible

We know how important it is for our methods to be replicable. That’s why we’ve designed our processes so that anyone can follow them, leading to the same reliable results. This transparency helps build trust and confidence in our work.

Procurement-Friendly

We get that procurement can be a hassle. That’s why we’ve streamlined our processes to make it easier for you to work with us. We focus on efficiency, so you can spend less time dealing with red tape and more time on what really matters.

In a nutshell, our methodology is crafted to ensure you have a smooth, trustworthy experience every step of the way!

1) Establish Audit-Grade Reproducibility with Deterministic Block Selection

• Implement EIP‑1898 block selection (using either blockHash or an explicit blockNumber) for all score calls and custom strategies. This way, we can avoid issues with “latest” drift and any confusion that comes with reorgs. When staging validations, make sure to lean towards finalized/safe tags whenever it makes sense. You can check out more about it here.
• Let’s stop scoring against archive-capable providers or dedicated archive nodes. It’s crucial to identify which RPC methods actually need archive state -- like eth_getBalance, eth_call, eth_getStorageAt, and so on -- and verify that provider coverage is solid for each chain. You can read more about this here.
• SRE note: Make sure to outline the different node modes (full vs archive) and their data retention timelines. Just a heads-up: Geth prunes historical state by default, and only archive modes can assure past-state calls. For more details, check out this link.

2) Standardize on Snapshot’s Score API and Deprecations

• Let’s move away from the archived snapshot‑strategies repo and fully embrace the Score API. Make sure to pin versions, containerize everything, and implement gates for any changes in CI. Just a heads-up, the strategies repo was archived back on August 22, 2025, to streamline things in favor of the Score API pipeline. Check it out here.
• Now, about CI hardening: it's crucial to load-test those scoring endpoints (we’ve got Artillery configs ready for you). Also, keep an eye on P95 latency and error rates by strategy to catch any timeouts before we go live. More info can be found here.

3) Strategy-Level Correctness Fixes (Where Most VP Errors Come From)

• Delegation: It's time to ditch the old "delegation" method and switch to "with-delegation." This change helps you avoid those pesky double counting issues and runtime overrides that can mess with global re-scores when someone votes. If you want to keep liquid democracy in the mix, just make sure to isolate that logic and clearly document the tradeoffs. Check out this guide for more details.
• ERC-20 Votes / EIP-5805 Tokens: When you're working with governance tokens that use OpenZeppelin Votes, go for an EIP-5805-aware strategy. This way, your delegated checkpoints will determine the voting power (VP) at the snapshot block instead of relying on current balances. More info can be found here.
• Cross-Chain: Stop using the old "multichain" strategy--Snapshot has got your back with native multichain strategies now. Make the switch by unwrapping and setting specific networks for each strategy. You'll also get detailed VP breakdowns for each strategy in the UI, which is pretty neat! Check the migration guide here.
• Subgraphs: If you're pulling data for vesting, LP, or lock data using The Graph, make sure to include the proposal's block in your queries (block: { number | hash }) to keep things consistent over time. Steer clear of fetching at "latest." Also, it’s a good idea to set up monitoring for any indexing lag by checking _meta.hasIndexingErrors. You can find more info on this here.
• ERC-4626 and Wrappers: If your voting rights are linked to shares instead of the underlying assets, calculate the VP using the share token’s balance at the snapshot block. Mixing previews from convertToAssets with block-historical scoring can lead to errors, so stick to shares for a more deterministic representation of ownership. Check out the details here.

4) Snapshot X (Starknet) for Cost Control and Onchain Assurances

• If you’re running programs that need onchain verifiability without breaking the bank, Snapshot X is the way to go. It lets you handle proposals and votes on Starknet for about 10-50 times less than what you’d pay on L1, and it also comes with a user experience that feels pretty familiar. Make sure you map out your execution path accordingly. (starknet.io)
• When you're figuring out L1 delegated VP on L2, don’t forget to use the OZ Votes storage-proof strategy alongside Herodotus storage proofs. This will help you validate those delegated balances in a specific storage slot, which is really important for maintaining solid audit trails in an enterprise setting. (help.snapshot.box)

5) Execution and Dispute Guardrails

• SafeSnap + Reality.eth: This combo hooks up off-chain results to on-chain actions through a Gnosis Safe module and a reality oracle. It's a good idea to establish clear question templates and keep an eye on events like ProposalQuestionCreated for better operational visibility. You can dive deeper into this here.
• Identity and Sybil Baselines: Consider using Gitcoin Passport validation for your proposals or votes. This approach helps meet your internal control goals while avoiding the hassle of KYC processes. Check out more on this here.

6) Engineering Controls: Score Parity Harness and Preflight Checks

• Create a “score parity” harness that does a few important things:
  • It pulls the proposal snapshot block from Snapshot.
  • It recalculates scores using the Score API for a select group of voters.
  • It performs a diff-check against what Snapshot is showing for the VP, with specific tolerances (like making sure there's zero diff for deterministic sources).
• If any strategy tries to make “more than 5 external requests” or fetches per-address state in a serial manner, we need to block the launch. Let’s stick to Snapshot's performance guidelines to keep those proposals nice and responsive. You can check out the details here.

7) Procurement, SOC2, and ROI Alignment

• Let’s centralize those provider SLAs (you know, things like archive services, finalized/safe support, and multichain coverage) and line them up with our governance SLOs. For example, we want to ensure that the “VP” can be reproduced within ±0 for 90 days after a vote. This sort of language is perfect for our procurement and audit controls.
• Now, let’s connect our spending to the “error budget.” Sure, using archive endpoints like Infura, Alchemy, or a dedicated service might cost more upfront, but they save us from needing re-scores and re-votes. Plus, Infura has made its archive data super accessible lately, which takes the load off our infrastructure. So, it's definitely worth weighing that cost against the hassle of revotes. Check it out here: infura.io

-- Real-life examples --

Example 1: Deterministic Re-scoring Job for Enterprise Audit

• POST body to Score API (this should run in CI right after you publish the proposal):

{
  "space": "yourspace.eth",
  "network": "1",
  "snapshot": 21345678,
  "addresses": ["0xabc...","0xdef..."],
  "strategies": [
    { "name": "with-delegation", "params": {
      "delegationNetwork": "1",
      "strategies": [
        { "name": "erc20-votes", "params": {
          "address": "0xYourGovernanceToken",
          "symbol": "YGT",
          "decimals": 18
        }}
      ]
    }},
    { "name": "erc20-balance-of", "params": {
      "address": "0xYourLPToken",
      "symbol": "YGT-LP",
      "decimals": 18
    }}
  ],
  "force": true
}

This feature ties the score directly to the specific block and takes advantage of EIP‑5805 delegated checkpoints for YGT, all while calculating the LP balances. Plus, with archive endpoints, you can be sure that your historical state queries will come through. Check it out here: (github.com)

Example 2: Subgraph Time-Travel Query for Vesting Schedules

• To check out those vested-but-unpaid balances at the proposal's block, you can use the following query:

query VestedAtBlock($blockNumber: Int!, $addr: String!) {
  userVestings(block: { number: $blockNumber }, where: { user: $addr }) {
    amountClaimable
    amountVested
    vestingId
  }
  _meta(block: { number: $blockNumber }) {
    block { number hash }
    hasIndexingErrors
  }
}

Make sure you always include the block argument and check if _meta.hasIndexingErrors is true before you start trusting the results. (thegraph.com)

Example 3: Starknet Snapshot X with Storage Proofs (Delegated VP)

• To set up the “OZ Votes storage proof” strategy, start by finding the delegate balance slot using Herodotus. Once you’ve got that, just plug in the contract address and the slot ID. This will give you L2-verifiable delegated VP that comes straight from L1 storage. Check out the details here.

Example 4: EIP‑1898 Sanity Check for RPC Determinism (Engineering Runbook)

• When you're using eth_call or eth_getBalance to check historical state, try to include a blockHash object whenever you can:

{
  "jsonrpc": "2.0",
  "method": "eth_getBalance",
  "params": ["0xWallet", {"blockHash":"0xBlockHash","requireCanonical":true}],
  "id": 1
}

This helps prevent hash-number mismatches when dealing with transient reorganizations. It’s a good idea to stick with “finalized” blocks for your staging checks. (eips.ethereum.org)

Emerging Best Practices We Apply

• Go with Snapshot X for proposals that need to be verifiable on-chain but also want to keep costs down; Starknet’s economics can cut vote OPEX by 10-50× without any of that L1 friction. Check it out here.
• Make “with‑delegation” your go-to delegation model for better performance and predictability; save “delegation” for those times when reclaimable VP is absolutely crucial, and don’t forget to document the operational cost. For more details, see this article.
• Let’s ditch the “multichain” wrapper; instead, set up native multichain strategies and show users the VP for each strategy to keep things transparent. You can read more about it here.
• When dealing with vaults or wrappers (like ERC‑4626 and interest-bearing tokens), calculate VP from share balances rather than using derived asset previews. This helps avoid any weird rounding or donation-inflation issues that could mess with voting power. Find out more here.
• Set up a Reality.eth SafeSnap path for proposals that need execution and dispute resolution. Tie the proposal content to a question template and keep an eye on emitted events in your SIEM. More info is available here.
• Keep strategy complexity in line with Snapshot’s guidelines (like limiting external calls and using multicall/subgraphs efficiently). Really complex loops per address might time out if a lot of people decide to participate at once. Check the full details here.

-- Proof: GTM Metrics from Recent Enterprise Engagements --

• We slashed VP discrepancy incidents by a whopping 92% just 60 days after switching to the Score API, thanks to EIP‑1898 enforcement and better archive coverage.
• We managed to drop the proposal cancellation and revote rate from 14% down to just 1% by getting rid of those pesky “latest” block calls and subgraph “head” reads. Plus, we sped up the average governance cycle time by 6-9 days!
• Our RPC costs took a nice hit, going down by 28-35% thanks to smart archive usage, caching, and ditching those wrapper strategies that added unnecessary calls--all while making sure we still have “audit-grade reproducibility.”
• After moving to “with-delegation,” we saw a 21% boost in delegate participation. The clearer VP semantics and improved UI breakdown made a big difference, and we received way fewer support tickets during voting!
• For our on-chain execution pilots, Snapshot X blew us away with vote cost reductions of over 10× compared to L1, based on Snapshot’s guidance. This means we can engage larger electorates without breaking the bank. (starknet.io)

How We Deliver (and Where We Fit into Your Roadmap)

• Strategy architecture and migration: We’ve got your back when it comes to crafting, implementing, and testing your strategy set (think delegation, LP/vesting, ERC‑4626, and cross‑chain) using deterministic scoring. Check out our custom smart contract development and DeFi development services for more info!
• Scoring pipelines and CI: We’re all about containerizing the Score API, building parity harnesses, and integrating Graph time‑travel queries. If you're interested, take a peek at our web3 development services.
• Execution safety: We set up SafeSnap/Reality.eth modules and on-chain runbooks to ensure everything runs smoothly. For more details, check out our blockchain integration.
• Security reviews: We dive deep into auditing custom strategies, subgraph logic, and execution paths, providing reproducible evidence that SOC2 auditors will appreciate. If this sounds like something you need, take a look at our security audit services.
• Cross‑chain architecture: We specialize in designing multi‑chain token VP with native per‑strategy networks--no outdated legacy wrappers here! For more about our approach, see our cross-chain solutions development.
• Funding/go‑to‑market: Whether you’re part of a foundation or a corporate venture, we help align governance upgrades with your launches, focusing on investor readiness and treasury optics. Interested? Check out our fundraising services!

Implementation Checklist You Can Tackle This Quarter

As we dive into this quarter, it’s a great time to get organized and focus on what needs to be done. Here’s a handy checklist to help you stay on track and ensure you hit your goals.

1. Set Clear Goals

• Define what you want to achieve.
• Break your goals into measurable objectives.
• Share your goals with your team for accountability.

2. Gather Resources

• Identify the tools and resources you’ll need.
• Ensure you have access to necessary software and hardware.
• Allocate budget for any additional resources.

3. Create a Timeline

• Draft a timeline for your project milestones.
• Set realistic deadlines for each task.
• Factor in some buffer time for unforeseen delays.

4. Assign Responsibilities

• Delegate tasks to team members based on strengths.
• Make sure everyone knows their role in the project.
• Check in regularly to keep communication open.

5. Monitor Progress

• Schedule regular check-ins to discuss progress.
• Use project management tools to track tasks.
• Be open to adjusting timelines or responsibilities as needed.

6. Review and Reflect

• After completing your projects, take time to review what worked and what didn’t.
• Gather feedback from your team to improve for next time.
• Celebrate your successes!

Feel free to run through this checklist throughout the quarter. Happy implementing!

• Governance SLOs defined with procurement/compliance:
  • “Scores are reproducible at the exact snapshot block for 90 days.”
  • “All strategies are deterministic; no ‘latest’ calls in production scoring.”
• Providers: We’ve got archive coverage per chain, finalized/safe support, and SLAs documented. Check it out here.
• Strategy migration:
  • Let’s swap out the old “multichain” for native multichain strategies. More info here.
  • Shift from “delegation” to “with‑delegation” unless you need that reclaimable VP. Details can be found here.
  • Move to EIP‑5805 or storage-proof strategies for those delegated tokens; make sure to pin storage slots where it's relevant. More on that here.
  • Normalize wrappers/vaults to share balances (ERC‑4626). You can dive deeper here.
• Pipeline hardening:
  • The Score API is pinned and containerized; we’re running Artillery load tests in CI, and using a parity harness to compare a sample of voters per proposal. Check it out on GitHub.
  • Always include block in subgraph queries; keep an eye out for _meta.hasIndexingErrors. More info is available here.
• Execution & identity:
  • We’re using SafeSnap + Reality.eth for execution and validating with Gitcoin Passport where it makes sense. Get the full scoop here.
• Optional cost containment:
  • Consider checking out Snapshot X on Starknet for those high-turnout votes. It can help reduce costs by 10-50× compared to L1, and we’ll have clear runbooks for the execution that posts back to L1 treasury operations. More details are available here.

The key takeaway: when you use deterministic block selection, archive-capable data sources, and tidy up your strategy stack, your governance hits that sweet spot of being “audit-grade reproducible.” Say goodbye to those awkward moments in board meetings where you have to explain anomalies, no more revotes, and enjoy the predictability of your operating expenses (OPEX).