Overview

Most DAOs in this directory govern a protocol that lives on one chain. ENS is Ethereum. Optimism is one rollup. Wormhole is the exception: it is the plumbing between chains, and it is governed by a DAO whose voting is itself spread across chains. That makes it the clearest example of the cross-chain-native governance archetype.

Wormhole is a generic message-passing protocol. An application emits a message on a source chain; Wormhole's validators attest to it; a contract on the destination chain accepts the attested message and acts on it. Token transfers are the most visible use, but the same rails carry governance votes, oracle prices, and arbitrary contract calls across more than 30 connected networks. The protocol was incubated by Jump Crypto in 2021 and is now stewarded by the Wormhole Foundation.

Because the value it moves is other protocols' value, Wormhole belongs alongside the other primitives in this section — UMA, Safe, Aragon — as infrastructure other protocols build on.

The Guardian network

Wormhole does not verify messages with a light client or a fraud proof. It verifies them with a fixed set of validators called Guardians — currently 19 established node operators. Each Guardian independently observes an emitted message and signs it. When two-thirds of them sign, the signatures bundle into a Verified Action Approval (VAA) — the credential that any destination chain accepts as proof the event really happened.

This is a deliberately simple trust model, and its honesty is a design choice worth being clear about: the whole system is only as trustworthy as those 19 signers. Wormhole's roadmap has pushed toward hardening that assumption — a larger and more diverse Guardian set, staking, and light-client verification for some routes — but at its core the network still asks users to trust that a supermajority of Guardians will not collude or be compromised.

The February 2022 exploit

What happens when the verification layer fails is not hypothetical. On 2 February 2022, an attacker exploited a deprecated signature-verification function on the Solana–Ethereum token bridge to forge the appearance of a valid deposit, minting 120,000 wrapped ETH (~$325M) out of nothing. The bug was not in the Guardians' honesty — it was in a contract that let the attacker bypass their check entirely.

Jump Crypto, which incubated the protocol, replaced the 120,000 ETH within about a day to keep the bridge solvent, and in February 2023 recovered roughly $225M from the attacker in a counter-exploit. The episode is a standing entry in the catalogue of how these systems fail: a cross-chain protocol's real attack surface is the message-verification layer, not the token contract, and a well-capitalised backstop can paper over a loss but not the trust question underneath it.

The W token

W launched on 3 April 2024 as a natively multichain token, minted directly on several chains rather than bridged from one home. Total supply is capped at 10 billion, with about 1.8 billion circulating at genesis and roughly 82% initially locked on a four-year release schedule.

The genesis allocation splits the supply across community (17%), the ecosystem and growth fund (31%), the foundation treasury (23.3%), core contributors (12%), strategic network partners (11.6%), and Guardian node operators (5.1%). The launch airdrop distributed 6.75% (about 674.8M W) to more than 400,000 wallets, weighted toward addresses that had actually used Wormhole-connected apps.

MultiGov: governing from any chain

W's defining feature is not its distribution — it is where you can vote with it. In late 2024 Wormhole, Tally, and ScopeLift shipped MultiGov, billed as the first multichain governance system, and the Wormhole DAO became its first adopter.

MultiGov uses a hub-and-spoke design. One chain is the hub, where a HubGovernor contract creates proposals, tallies votes, and executes outcomes through a timelock. Every other supported chain is a spoke: a SpokeVoteAggregator collects local votes and forwards them to the hub over Wormhole messaging, where a HubVotePool folds them into the tally. A holder on Solana or Base votes with tokens that never leave their chain, and the outcome propagates back out to spoke executors. It is on-chain governance stretched across chains instead of pinned to one.

The pattern generalises beyond Wormhole — MultiGov is offered as reusable governance tooling for any multichain DAO, in the same family as the single-chain frameworks spl-governance and Aragon. It also inherits their hard question: the votes themselves now ride the Guardian-attested rails, so the delegation and vote-counting logic is only as final as the message layer carrying it.

What the DAO governs

The Wormhole DAO steers the protocol's parameters, treasury, and the direction of its cross-chain standards, while day-to-day operation of the Guardian network and core development sit with node operators and the foundation. As with most infrastructure DAOs, the elected surface is narrower than the protocol's full footprint: token holders set policy, but they do not personally re-sign every VAA. The archetype it fills here is specific — a DAO whose subject spans every connected chain and whose voting does too, distinct from the single-chain adjudication of Kleros or the single-registry scope of ENS.

How Caper approaches this

A caper is single-ledger by construction: it lives entirely on Radix, with no cross-chain messaging and no external validator set carrying its votes. So the honest comparison is not feature-for-feature — Caper simply does not do what Wormhole does. The useful contrast is about who sits between a member and their vote.

In MultiGov, a vote cast on a spoke chain is only final once a supermajority of Guardians attests the message carrying it to the hub. In a caper there is no such layer: a member's vote weight is computed on-ledger from balances they already hold. The contract combines governance tokens held with earned, non-transferable vote tokens — verified in compute_vote_weight (contracts/logic/src/lib.rs), where the held balance enters as a multiplier, so a large bag alone cannot capture control without earned votes. And an outvoted member is not stuck arguing with the majority: exit (contracts/logic/src/lib.rs) lets them withdraw a treasury share equal to that same canonical vote weight, redeeming both their vote and governance tokens. Nothing has to be relayed or attested for either to settle.

References

• Wormhole Docs — MultiGov overview
• Wormhole Docs — MultiGov hub-and-spoke architecture
• Wormhole / Tally / ScopeLift — announcing MultiGov
• Wormhole — the W airdrop explained (allocation)
• Wormhole — W token, one year on
• The Block — Wormhole replenishes bridge after $325M exploit
• Halborn — explaining the February 2022 Wormhole hack