Key Insights

• Wormhole is an interoperability protocol that connects 40+ blockchains, allowing applications, developers, institutions, and users to send messages, move assets, and perform actions across networks.
• Its architecture uses onchain core contracts to emit and verify messages and an offchain validator network (called Guardians) to observe events, produce signed attestations, and deliver them to destination chains via relayers.
• Wormhole powers a comprehensive product suite, including Messaging, Portal (token bridge), NTT (Native Token Transfers), Settlement (intent-based execution), Queries, CCTP Integration (native USDC transfers), MultiGov (multichain governance), Connect (frontend integration widget), and a robust set of developer tools (SDKs, CLI, and WormholeScan).
• Various asset managers and tokenization platforms including Securitize (on behalf of BlackRock, Apollo, VanEck, and Hamilton Lane), as well as Centrifuge and Mercado Bitcoin have integrated Wormhole to enable cross-chain transfers and multichain access for tokenized treasury and credit funds.
• The project supports ecosystem growth through programs like its $250 million Cross-Chain Ecosystem Fund, Sigma Startup Program, Wormhole Fellowship, and the Wormhole Foundation Grant Program to fund developers and startups.

Introduction

Blockchains largely remain isolated systems, limiting the development of applications that require interoperability across multiple execution environments. Existing cross-chain solutions have primarily relied on liquidity networks (e.g., Hop Protocol) or complex state verification systems (e.g., zkBridge), each introducing security, composability, and scalability tradeoffs.

Wormhole takes a different route by separating data verification from execution. Instead of verifying state across chains directly, it uses a permissioned set of validator nodes (Guardians) to observe events on one chain and produce attestations (VAAs) that can be submitted and verified on any other chain. This architecture allows a wide range of multichain behaviors (e.g., message passing, token transfers, governance execution, and data queries) without requiring each application to implement full cross-chain logic.

Website / X (Twitter) / Discord

Background

Wormhole, founded in 2020 by Certus One (later acquired by Jump Trading in 2021 before separating from Jump Crypto in 2023), is a multichain messaging protocol that enables secure interoperability across multiple blockchains. Originally launched as a ERC-20 ⇄ SPL token bridge between Ethereum and Solana, Wormhole has since evolved into a generalized message-passing platform supporting a broad set of applications, including (i) core Messaging for arbitrary cross-chain data; (ii) multichain governance via MultiGov; (iii) multichain native token deployment through Native Token Transfers (NTT); and additionally offers a suite of interoperability products including (iv) Connect, a developer integration widget; (v) Queries for on-demand cross-chain data retrieval; (vi) Settlement for intent-based transfers and swaps; (vii) Token Bridges, including the CCTP Bridge integrating Circle’s protocol for native USDC transfers; and (viii) Developer Tooling (SDKs, CLIs, explorer) to build and monitor multichain applications. Today, Wormhole connects 40+ blockchains and is an interoperability infrastructure for a wide range of decentralized protocols and ecosystem platforms.

The Wormhole Foundation, Wormhole Labs, Asymmetric Research, and xLabs are supported by a core group of contributors. Specifically, the Foundation’s leadership includes Dan Reecer (Co-Founder), previously with Acala and the Polkadot Foundation; Robinson Burkey (Co-Founder), formerly at Jump Crypto and Acala. Wormhole Labs, an independent core development team, is led by Saeed Badreg (Co-Founder and CEO), Tony Jin (Co-Founder and CTO), and Anthony Ramirez (Co-Founder and COO), all of whom previously held roles at Jump. Asymmetric Research is the core security contributor to Wormhole, led by Jonathan Claudius, former Chief Security Officer at Jump Crypto and previously Head of Security at Mozilla. The xLabs team is another independent core contributor focused on infrastructure and engineering, and is led by Michel Dahdah and Gabriel Zimmermann.

In 2023, Wormhole completed a $225 million funding round at a $2.5 billion valuation, backed by Multicoin Capital, Jump, Brevan Howard, Coinbase Ventures, and ParaFi, among others.

Technology

Every Wormhole product is built atop the same architectural foundation. The protocol comprises two interconnected layers: (i) onchain components that emit, verify, and execute cross-chain messages within each blockchain’s native environment, and (ii) offchain infrastructure that observes blockchain events, performs validation, and coordinates message delivery across networks. This division keeps the onchain logic lightweight and secure, while offloading complexity and consensus to robust offchain systems.

Specifically, the onchain core contracts (i) verify a signed message (i.e., the Verifiable Action Approval (VAA)), (ii) ensure this VAA has not been processed before, aka “replay,” and (iii) trigger the corresponding action (i.e., minting tokens or invoking a contract callback) on said target chain. Offchain, a decentralized set of 19 validator nodes, known as Guardians, continuously observe all supported chains. When an onchain core contract emits a Wormhole message on the source chain, Guardians can validate the events, and once a quorum agrees (⅔ of the 19), they each sign/generate a hash. These 13 individual hash signatures are then combined into a VAA, which acts as proof that the event was observed and approved by the validators. Relayers then submit this VAA to the destination chain’s Core Contract, which verifies it again and executes the intended action. Meanwhile, “Spys” monitor the chains and VAAs to provide observability for developers and apps. Below, each component, split between offchain and onchain, is described in detail, followed by how they interact in a core workflow.

Offchain Components

Guardians

A set of 19 Guardians (validation nodes) serves as the core attestation (validation) layer for Wormhole’s cross-chain messaging system, allowing secure message flow from source to destination chains. Specifically, each Guardian (i) runs full nodes for every supported blockchain to monitor onchain activity and observe messages emitted from Wormhole’s Core Contracts, (ii) independently validates those messages and signs/approves them, and (iii) broadcasts its signature to the Guardian network to reach the 13/19 signature threshold. Guardians also (iv) sign governance messages that allow contract upgrades, protocol parameter changes, or Guardian set rotation.

Notably, while Guardians do not follow a slashing incentive model, Wormhole assumes that at least ⅔ operate honestly. If more than ⅓ collude or go offline, they can delay message delivery or censor specific flows, but cannot produce fraudulent VAAs. Overall trust in the Guardian set is rooted in reputation, transparency (as they are all publicly documented), and the ability for governance to rotate out underperforming or malicious participants.

This design effectively mirrors a Proof-of-Authority (PoA) consensus model, where trusted, publicly accountable entities are authorized to validate and sign off on protocol-critical messages. Circle’s Cross-Chain Transfer Protocol (CCTP) similarly uses a PoA architecture to facilitate secure and efficient native USDC transfers across chains. Future plans also include eventually transitioning to a ZK-based trustless attestation system.

Verified Action Approvals (VAAs)

A Verified Action Approval (VAA) is essentially Wormhole’s proof for any cross-chain action (e.g., a token transfer, arbitrary message, or governance instruction). Specifically, when a dApp or contract emits a Wormhole event on the source chain, an offchain set of Guardians observes and “validates” that event. Once at least ⅔ of the 19 Guardians agree that the event is “valid,” they each sign a hash, which combines into a single signature called a VAA. The VAA is then bundled with a message body containing (i) the source chain ID, (ii) emitter address, (iii) sequence number, (iv) timestamp, (v) finality/consistency level, and (vi) any application specific data.

Additionally, because a VAA encodes “this contract on XYZ said this payload” without hardcoding a single target destination chain, it can be submitted to any supported chain’s core contract for verification. This lets a single VAA be reused across multiple chains, where gas is only paid on chains where the VAA is submitted. VAAs also remain valid indefinitely unless a governance change rotates out the Guardians. Therefore, multiple attempts to deliver a VAA can occur in case of failure (e.g., a gas issue).

Relayers

Next, Relayers pick up where the Guardians leave off, ensuring that validated VAAs are successfully “delivered” and executed on their target chains. Specifically, after the Guardians sign a VAA, relayers are responsible for (i) monitoring the offchain Guardian network or public endpoints for new, fully-signed VAAs; (ii) verifying the VAA’s validity, including its threshold signature and message payload; and (iii) submitting the VAA to the appropriate Wormhole Core Contract on the destination chain. This submission triggers the onchain processing of the message (e.g., minting a native token, executing a smart contract call, or applying a governance change).

Of note, there are multiple ways to implement a relayer, depending on the end application’s needs. These include (i) client-side relayers, which rely on the user’s frontend to retrieve and submit VAAs manually; (ii) custom relayers, which are developer-run backend services that submit VAAs with added logic or optimizations; and (iii) Wormhole-deployed relayers, which standardize VAA delivery without requiring developers to maintain infrastructure. All three types are equally trustless yet offer different UX, efficiency, and customization tradeoffs.

Spys

Lastly, while Guardians attest to cross-chain events and Relayers submit them onchain, Spys act as passive observers that provide real-time visibility into Wormhole’s messaging activity. They are responsible for (i) subscribing to the message streams within the Guardian Network to track published and signed messages as they move across chains; (ii) exposing developer-friendly interfaces (i.e., gRPC and WebSocket APIs) for consuming this message stream in dashboards, monitoring tools, or custom indexing pipelines, and (iii) filtering messages by chain, emitter, or protocol (e.g., Token Bridge, NTT, CCTP) to help integrators (those building dashboards, monitoring tools, or cross-chain applications) track specific dApps or categories of activity.

Though Spys do not submit or verify VAAs themselves, they are crucial for transparency and debugging across chains, especially for developers who want real-time visibility into multichain activity without running a full Guardian node.

Onchain Components

While the offchain components handle much of the heavy lifting, the protocol cannot exist without its onchain components.

Core Contracts

At the heart of it all is a single Core Contract deployed to each supported blockchain. This contract is responsible for (i) emitting a standardized onchain event that signals a cross-chain message; (ii) confirming Guardian signatures (via the threshold) and validating replay protection; (iii) maintaining Guardian public keys, chain IDs, and authorized emitters, and; (iv) governance execution (i.e., applying protocol updates when valid governance VAAs are submitted). Here is an example of how they work:

• When a dApp calls the Core Contract’s “publish” function, the contract emits a Wormhole specific event to the transaction log, which includes the emitter address, a sequence number, a finality/consistency level, and the payload to be attested.
• Guardians observe this event offchain and, after reaching a ⅔ consensus, produce a VAA.
• On the destination chain, a relayer submits the VAA to that chain’s Core Contract.
• The contract verifies the threshold signature (i.e., a multisignature requiring approval from ⅔ of the Guardians) using its stored Guardian public keys.
• The contract then checks for replay using the unique (emitter address + sequence number) pair, ensuring that each VAA is only processed once. This prevents malicious actors from resubmitting or duplicating previously executed messages.
• It routes the message to the appropriate logic (e.g., minting tokens or invoking a smart contract callback).

Fee modules and other extensible logic may be added via governance-controlled hooks.

Emitter & Transaction Logs

Before any core contract is executed, a smart contract or dApp must want to initiate a Wormhole message; these initiators are called emitters. Instead of sending data directly across chains, the emitter calls the Core Contract’s “publish” function, which, as explained above, emits a standardized event into the blockchain’s transaction log. This event contains (i) the emitter’s address, (ii) an incrementing sequence number, (iii) a consistency level indicating how many block confirmations are required before Guardians act to mitigate reorg risk (which can cause different Guardians to see different histories and produce conflicting VAAs), and (iv) the message payload itself.

Specifically, Guardians monitor transaction logs in real time using full nodes, waiting for sufficient block confirmations before acting. These logs contain critical metadata (i.e., timestamps, block heights, and message payloads) used to validate message emissions. The same metadata supports Spys and indexers in tracking a message’s full lifecycle (i.e., from emission to attestation to execution). This log-based architecture keeps onchain contracts lightweight, while allowing reliable and efficient operation of Wormhole’s offchain components.

Bringing It All Together

Now that each component has been explained, here is a detailed example of how Wormhole’s messaging system works end-to-end:

• A user initiates a cross-chain action (e.g., token transfer, governance vote, or app interaction) through a frontend interface that integrates Wormhole Connect.
• A dApp or wrapper contract acts as the emitter by calling the Core Contract’s “publishMessage” function on Chain A, emitting an onchain event containing the payload, emitter address, and an incrementing sequence number. This event is stored in the chain’s transaction log.
• Guardians independently watch Chain A using full nodes. They wait for a specified consistency level (e.g., a certain number of confirmations) before observing the event.
• Once a block is finalized, each Guardian (i) validates the emitter’s identity and payload formatting, and (ii) derives a message body from the event.
• Then, each Guardian signs the message hash and shares its partial signature. Once at least 13 of the 19 Guardians have signed, a threshold signature is formed and bundled with the message to create a Verified Action Approval (VAA).
• A relayer (or any actor) submits the VAA to Chain B by calling the destination Core Contract’s “verifyAndExecute” function. The contract (i) verifies the threshold signature against its stored Guardian public keys, (ii) checks replay protection using the emitter address and sequence number pair, and (iii) invokes the callback logic (e.g., minting tokens or calling a destination dApp).
• Once processed, the Core Contract emits an event noting success or failure. Monitoring tools like Spys or indexers track these logs to update dashboards, developer tools, or alert systems.
• The user or dApp's original intent is fulfilled on the destination chain. From the user’s point of view, this typically appears as a seamless cross-chain experience, such as seeing funds appear on another chain, an NFT bridged, or an action confirmed via a frontend UI.

With the core architecture and message flow established, the following briefly lists the specific products built atop this system:

• Messaging: Core framework for arbitrary cross-chain payloads; used by all applications to send and receive messages between chains.
• Portal: Token bridge for wrapping assets from one chain to another, allowing assets to move across ecosystems without liquidity fragmentation.
• NTT (Native Token Transfers): Framework allowing a token to exist natively across multiple chains, avoiding the wrapped token model.
• Settlement: Intent-based protocol for atomic, cross-chain execution. It decouples intent expression (what you want to do) from fulfillment (who does it), as often used in DEX or payment use cases.
• Queries: A lightweight mechanism for fetching read-only data from one chain to another without needing full state verification.
• CCTP Integration: Support for Circle’s Cross-Chain Transfer Protocol, allowing native USDC transfers using Wormhole’s messaging rails.
• MultiGov: Wormhole’s cross-chain governance framework for executing protocol upgrades, Guardian rotations, and parameter changes via signed governance VAAs.
• Connect: A developer widget and frontend integration layer that abstracts the relaying and submission logic for end users.
• Developer Tooling: A comprehensive suite of resources designed to support seamless multichain dApp development, including an SDK, CLI tools, and a block explorer.

W Token

Token Functions

The W token has both live and planned functions within the Wormhole network, including: (i) staking to participate in governance and, over time, support protocol security or economic mechanisms; and (ii) earning a share of protocol revenue through fee switch models that are planned but not yet implemented.

Governance

Wormhole governance is a tokenholder-led system where W holders can propose and vote on protocol decisions across supported chains. Decisions include:

• Adding or removing supported blockchains connected to Wormhole;
• Upgrading or modifying Wormhole’s smart contract systems;
• Adjusting fee structures across Wormhole products;
• Expanding or modifying the Guardian set;
• Updating protocol security parameters; and
• Directing token utility design, incentive structures, and grant programs.

W Token Allocations

The W token has a total token supply of 10 billion, with an initial circulating supply of 1.80 billion (18.0%) at launch (valued at ~$126 million, as of June 16, 2025, with W priced at $0.07). The token distribution, as pictured above, is broken down as follows:

• Ecosystem & Incubation: 31.0% (3.10 billion W, ~$217 million)
• Foundation Treasury: 23.3% (2.33 billion W, ~$163.1 million)
• Community & Launch: 17.0% (1.70 billion W, ~$119 million)
  • Of this, 6.75% (674.8 million W) was allocated for the initial W airdrop across 400,000+ wallets, rewarding users and developers from Wormhole-connected ecosystems (e.g., Wormhole Discord, NFT communities, Monad, and Pyth stakers).
• Core Contributors: 12.0% (1.20 billion W, ~$84 million)
• Strategic Network Participants: 11.6% (1.16 billion W, ~$81.2 million)
• Guardian Nodes: 5.1% (510 million W, ~$35.7 million)

Vesting

Vesting schedules for each category are as follows and can be tracked here:

• Ecosystem & Incubation: 5% unlocked at TGE; 26.0% unlocking linearly over four years.
• Foundation Treasury: 2% unlocked at TGE; 21.3% unlocking linearly over four years.
• Community & Launch: 11% unlocked at TGE; 6% unlocking after four months.
• Core Contributors: Fully locked at TGE; unlocking linearly over four years.
• Strategic Network Participants: Fully locked at TGE; unlocking linearly over four years.
• Guardian Nodes: Fully locked at TGE; unlocking linearly over four years.

State of the Wormhole Ecosystem

Key Projects

Wormhole has a deep and expansive ecosystem of projects. Key ones that highlight the variety of benefits of Wormhole include:

• Uniswap: Uses Wormhole Messaging and governance infrastructure to deploy v3 to Sei and other chains, with DAO control retained on Ethereum.
• Sky: MakerDAO’s rebranded ecosystem, which integrates USDS and SKY tokens via Wormhole NTT to support multichain stablecoin circulation and governance.
• Pyth: A financial oracle network that leverages Wormhole Messaging to broadcast real-time price feeds to over 30 blockchains.
• Ripple: A financial infrastructure network that integrated Wormhole to enable multichain interoperability for the XRP Ledger and upcoming XRPL EVM sidechain.
• Infinex: The team integrated Wormhole Connect and Queries to allow seamless multichain transfers and stranded asset recovery across EVM chains.
• Lido: A liquid staking protocol that uses Wormhole’s Native Token Transfers (NTT) framework to natively bridge wstETH across multiple chains.
• Pendle: A yield derivatives platform that uses Wormhole’s messaging layer to enable composable, cross-chain interest rate strategies.

Institutional Partnerships

Wormhole continuously deepens its role as a core interoperability layer for tokenized assets, institutions, and real-world finance. Recent partnerships include:

• Apollo’s Diversified Credit Securitize Fund (ACRED) is onchain via Securitize, with Wormhole powering cross-chain transfers between Ethereum, Avalanche, Polygon, and Ink.
• Centrifuge selected Wormhole as the official multichain infrastructure partner for its V3 protocol, powering tokenized asset issuance and cross-chain fund management in collaboration with asset manager Anemoy and Janus Henderson.
• Brazilian exchange Mercado Bitcoin partnered with Wormhole to scale its $200+ million tokenized asset platform globally, starting with private credit offerings.
• BlackRock and Securitize expanded their tokenized treasury fund (BUIDL) to Solana using Wormhole’s messaging infrastructure, enabling institutional-grade multichain liquidity and composability.
• Hamilton Lane’s SCOPE private credit fund is onchain via Securitize, with Wormhole supporting instant subscriptions, redemptions, and DeFi integrations across chains.
• VanEck’s tokenized U.S. Treasury fund (VBILL) is onchain via Securitize, with Wormhole powering interoperability across Ethereum, Solana, BNB Chain, and Avalanche.

Cross-Chain Ecosystem Fund

Launched on May 18, 2023, this $50 million fund, managed by Borderless Capital and backed by over 20 industry leaders, including Jump Crypto, P2 Ventures (formerly Polygon Ventures), and Solana Foundation, is designed to support startups building cross-chain applications using Wormhole.

Sigma Startup Program

Announced on Sept. 4, 2024, the Sigma Startup Program is a comprehensive initiative to foster innovation in the Web3 ecosystem, comprising three components: (i) Sigma Sprint, a global multichain builder competition with $1+ million in prizes and seed funding; (ii) Sigma Accelerate, a program offering mentorship and strategic guidance to help projects scale; and (iii) Sigma Seed, which provides seed funding to promising startups within the Web3 ecosystem. Projects that have come from this program include Splyce, Polyquest, Bolarity, and Altverse, among others.

Wormhole Fellowship

Launched on June 26, 2023, the Wormhole fellowship is a community-driven program that empowers individuals to contribute to and grow the Wormhole ecosystem. Fellows of various levels can engage in content creation, technical contributions, and community support.

Wormhole Foundation Grant Program

Launched on Feb. 15, 2023, the XGrant Program is an ecological funding program designed to provide financial support, guidance, and resources to innovative projects integrating with Wormhole. Grants are divided into four tiers based on project needs and goals, with funding amounts up to $200,000 or higher for exceptional submissions.

Roadmap

Looking forward, Wormhole released its roadmap on Aug. 14, 2024, outlining a multi-era product evolution, while acknowledging past accomplishments.

Specifically, Era 4 (2025) consists of the following:

• Launched MultiGov: An industry-first multichain governance platform built in collaboration with Tally and Scopelift.
• Launched Settlement: Introduced intent-based cross-chain transfers for institutional swaps.
• Launched Wormhole DAO, governance participation for W tokenholders (Pending).
• A portal brand refresh and new interface for improved cross-chain swaps and transfers (In Progress).
• The launch of community incentive campaigns for W stakers and ecosystem participants (Pending).
• Planned ZK upgrades with light client support for Ethereum, Near, and Aptos (Pending).

Era 5 (2025+) will consist of:

• Expanding interoperability infrastructure across governments, institutions, enterprises, AI agents, and tokenized RWAs.
• Scaling support for institutional tokenization as capital markets move onchain.
• Developing monetization and fee-switch mechanisms to distribute protocol revenue to W stakers.

Closing Summary

Wormhole provides a generalized multichain messaging infrastructure that enables interoperability across over 40 blockchains. Its architecture comprises lightweight onchain contracts and offchain infrastructure that coordinate the observation, attestation, and execution of cross-chain messages. When a message is emitted on a source chain, a permissioned set of validator nodes, called Guardians, observes and validates it. Once a quorum is reached, they collectively produce a Verifiable Action Approval (VAA). Relayers then submit the VAA to the destination chain, where the Core Contract verifies the signatures, ensures replay protection, and triggers the appropriate logic. Meanwhile, Spys monitor message flow to support observability and developer tooling. This core design powers Wormhole’s product suite, including Messaging (arbitrary payloads), Portal (token bridging), Native Token Transfers (NTT), Settlement (intent execution), Queries (read-only data retrieval), MultiGov (cross-chain governance), and CCTP integration (native USDC transfers). Developer resources such as SDKs, CLI tools, Wormhole Connect, and WormholeScan streamline integration and monitoring.

This architectural base supports a growing ecosystem of multichain applications across sectors such as DeFi, staking, oracles, and tokenized assets. Adoption includes Uniswap, Lido, Sky, Pyth, and institutional partners like Securitize, Centrifuge, and Apollo that are building cross-chain frameworks for tokenized real-world assets. To accelerate ecosystem development, Wormhole backs builders through four support programs: the Cross-Chain Ecosystem Fund, Sigma Startup Program, Wormhole Fellowship, and Wormhole Foundation Grant Program. Looking ahead, Wormhole is expanding its governance capabilities and exploring cryptographic proof systems, continuing to serve as critical infrastructure for developers building generalized, multichain applications.