The data shows a single address cast 1,247 votes in NexusDAO’s first governance proposal. That’s not a bug. It’s a structural flaw.

I spent last week auditing the quadratic voting contract deployed by NexusDAO, a project that raised $40M on the promise of “democratic on-chain governance.” Their whitepaper read like a manifesto: quadratic voting, sybil resistance via zero-knowledge proofs, and a treasury allocation mechanism designed to outlive its founders. The market ate it up. Token price tripled in a month.

But code does not lie. It does leave traces.

Context

NexusDAO launched in Q1 2026 as a derivative of Compound governance, but with a twist: every vote is weighted by the square root of the token holdings, not linear. The idea is textbook quadratic voting (QV)—a mechanism that amplifies minority voices while diluting whales. Their implementation uses a zk-SNARK to prove holdings without revealing the actual balance, preserving privacy. The team claimed this would “eliminate plutocracy while maintaining censorship resistance.”

I’ve seen this before. In 2024, I designed a quadratic voting framework for a mid-sized DAO. The results were encouraging—40% increase in minority participation—but only because we controlled for sybil attacks via a bonded curation market. NexusDAO skipped that step.

Core Analysis

The vulnerability lives in the vote submission function. Below is a simplified version of what I found:

function castVote(uint256 _proposalId, uint256 _support, bytes calldata _proof) external {
    require(_proveBalance(msg.sender, _proof), "Invalid proof");
    uint256 weight = sqrt(_getBalance(msg.sender));
    _proposal.votes[_support] += weight;
    _hasVoted[msg.sender][_proposalId] = true;
}

The proof validates the voter’s current token balance at the time of submission. But there is no check on whether the same balance can be used to vote multiple times from different addresses. The zk proof is stateless—it doesn’t tie the voter’s identity to a unique, non-transferable credential. So an attacker can:

1. Split 10,000 tokens across 1,000 fresh addresses.
2. Generate a valid zk proof for each address.
3. Cast 1,000 votes, each with weight sqrt(10) ≈ 3.16.
4. Total voting power: 3,160 vs. a single honest voter with 10,000 tokens who gets sqrt(10,000) = 100.

The attacker’s power is 31.6x higher.

This isn’t theoretical. In the first proposal—allocating 500,000 tokens to a marketing fund—the vote passed with 12,847 “yes” against 2,103 “no.” I traced the yes votes: 87% came from addresses funded by a single Ethereum account that received tokens from the same contract within three blocks.

Yield is a symptom, not the cure. The attacker didn’t need to exploit a smart contract bug. They exploited a design assumption: that quadratic voting inherently prevents sybil attacks. It does not. It only makes them marginally more expensive, and only if paired with identity verification.

I shared this finding with the NexusDAO team. Their response was polite but dismissive: “The proof system uses recursion to prevent double-voting.” That’s technically true—the zk proof prevents a single address from voting twice. But nothing prevents one person from using multiple addresses. Recursive proofs don’t solve identity.

Let me be clear: this is not a failure of ZK technology. It is a failure of governance architecture. The team optimized for privacy and claimed fairness without testing the boundary conditions. In the red, we find the structural truth.

Contrarian Angle

The mainstream narrative says quadratic voting is the holy grail for DAOs. VCs love it because it sounds mathematically rigorous. Developers love it because it’s a clean equation. But I argue the opposite: QV, in its pure form, is dangerous for small to medium DAOs. It creates a false sense of security that leads teams to skip the hard work of building anti-sybil systems.

Consider the trade-offs. NexusDAO chose privacy over accountability. By hiding vote weights, they prevented voters from noticing the sybil attack in real time. If votes were public (linear), anyone could have seen that 1,247 addresses appeared out of nowhere. But with QV, the weight is calculated off-chain and the proof only shows validity, not magnitude. The attack was invisible until I reconstructed the on-chain transaction graph.

Governance is the art of managing disagreement. Quadratic voting was designed for small groups (tens to hundreds) where identity can be established via reputation or stake. In a pseudonymous, permissionless DAO with thousands of participants, it becomes a tool for attack, not fairness.

The NexusDAO team is now considering a fork that implements a soulbound token for identity. But that introduces centralization—who issues the token? How do you prevent collusion? They are discovering that governance is an engineering problem, not a political manifesto.

I’ve written before that stability is a bug in a volatile system. The same applies here: the stability of the QV mechanism is contingent on assumptions that break in real-world conditions. The market, predictably, is celebrating NexusDAO’s governance as “the future.” They haven’t audited the code.

Takeaway

We build frameworks, not just tokens. The NexusDAO episode is a warning to every team rushing to deploy “democratic” governance without understanding the underlying incentive structures. Quadratic voting is not a magic wand. It’s a scalpel that requires careful hand—and a robust anti-sybil layer.

Trust is verified, never assumed. The next wave of DAO innovation will come from teams that merge economic design with practical security, not from those who hide behind math. NexusDAO can still recover: implement a staking-based voting credential, limit quadratic weighting to proposals above a quorum threshold, and open-source their simulation models for public audit.

But first, they need to admit that their revolution was rigged from day one.

— Ryan Lee

Code does not lie, but it does leave traces.