Decentralized Verifier Networks (DVNs) Overview

LayerZero is an interoperability protocol that enables secure and seamless communication between different blockchain networks. At the core of LayerZero’s security model are Decentralized Verifier Networks (DVNs).

What are DVNs?

DVNs are independent entities that validate the authenticity and integrity of messages sent across blockchains within the LayerZero ecosystem. They ensure that a message sent from a source chain arrives untampered at its destination. In the context of the LayerZero protocol, DVNs provide:

Verification: Verifying the hash (a unique digital fingerprint) of a LayerZero message emitted on a source chain.
Customizable Security: Applications built on LayerZero can select any number or type of DVNs to achieve their desired level of cross-chain security. This flexibility allows for tailored security postures.

How DVNs Work

A DVN is essentially a smart contract paired with off-chain infrastructure that provides its own inherent trust mechanism. When a message is sent via LayerZero:

The message is picked up by the chosen DVN(s) via the PacketSent event.
The DVN(s) independently verify the message hash using their unique security logic.
Upon successful verification, the DVN calls verify on the destination chain’s Message Library.
Once all required DVNs have verified, the message can be committed and executed.

LayerZero is agnostic to how a DVN is implemented. This design allows for diverse verification approaches that can be tailored to specific security requirements.

DVN Implementation Types

DVNs can use various verification methods to confirm message authenticity including, but not limited to:

Implementation Type	Description	Example
Multisignature	Requires multiple parties to sign off on a message hash	Custom multisig contracts
Zero-Knowledge Proofs	Uses cryptographic proofs to verify message validity	Polyhedra
Decentralized Oracles	Leverages existing oracle networks for verification	Chainlink
Protocol Adapters	Wraps existing interoperability protocols	Axelar, Wormhole
Light Clients	Verifies using blockchain consensus proofs	Native bridge adapters

DVN Operator Responsibilities

Regardless of implementation approach, DVN operators are responsible for:

Chain Coverage: Deploying DVN contracts on every chain they want to support
Event Monitoring: Listening for PacketSent and DVNFeePaid events on source chains
Verification Logic: Implementing secure verification of message hashes
Transaction Submission: Submitting verification proofs to destination chains
Gas Management: Maintaining sufficient gas tokens across all supported chains (unless using Gasolina)
Fee Configuration: Setting appropriate fees via DstConfig for each destination chain

Implementation Paths

When building or operating a DVN, you have two primary implementation paths:

Traditional DVN Implementation

The traditional approach gives you full control over your DVN but requires managing wallets, gas tokens, and transaction infrastructure across all supported chains. This path is ideal for organizations that need complete control over every aspect of their DVN operation. Best for:

Organizations with existing multi-chain infrastructure
Custom verification logic requirements
Full operational autonomy

Build DVNs

Learn more about building a traditional DVN implementation

Gasolina DVN

LayerZero Labs offers a simplified DVN implementation using Gasolina. This approach separates the security function (verification and signing) from the operational complexities (gas management and transaction submission), allowing DVN operators to focus purely on security while LayerZero’s Essence service handles transaction delivery. Best for:

Security providers without multi-chain infrastructure
Rapid deployment scenarios
Teams wanting to focus on verification rather than operations

Gasolina Overview

Learn more about the Gasolina DVN approach

Protocol Integration

DVNs integrate with LayerZero through standardized interfaces that work across all supported virtual machines.

EVM Interface

All EVM DVNs must implement the ILayerZeroDVN interface:

interface ILayerZeroDVN {
    struct AssignJobParam {
        uint32 dstEid;
        bytes packetHeader;
        bytes32 payloadHash;
        uint64 confirmations;
        address sender;
    }

    function assignJob(AssignJobParam calldata _param, bytes calldata _options)
        external payable returns (uint256 fee);

    function getFee(
        uint32 _dstEid,
        uint64 _confirmations,
        address _sender,
        bytes calldata _options
    ) external view returns (uint256 fee);
}

Function	Type	Description
`assignJob`	Payable	Called by the Message Library when a packet is sent, paying the DVN for verification
`getFee`	View	Returns the fee for verifying a message to a specific destination

Solana Interface

Solana DVNs use a multi-step CPI (Cross-Program Invocation) based verification flow rather than a single interface. The verification process involves three key instructions:

Instruction	Program	Description
`init_verify`	ReceiveULN	Initializes a confirmations account to store DVN verification state
`invoke`	DVN	Executes DVN verification logic (signature validation, multisig checks)
`verify`	ReceiveULN	Finalizes verification and emits `PayloadVerifiedEvent`

The core verification instruction signature:

impl Verify<'_> {
    pub fn apply(ctx: &mut Context<Verify>, params: &VerifyParams) -> Result<()> {
        ctx.accounts.confirmations.value = Some(params.confirmations);

        emit_cpi!(PayloadVerifiedEvent {
            dvn: ctx.accounts.dvn.key(),
            header: params.packet_header,
            confirmations: params.confirmations,
            proof_hash: params.payload_hash,
        });

        Ok(())
    }
}

For complete Solana DVN implementation details, see the Solana Protocol Overview.

X-of-Y-of-N Security Model

OApps configure DVNs as part of their Security Stack, using an X-of-Y-of-N model:

struct UlnConfig {
    uint64 confirmations;        // Block confirmations required
    uint8 requiredDVNCount;      // X - all of these must verify
    uint8 optionalDVNCount;      // N - total optional DVNs
    uint8 optionalDVNThreshold;  // Y - threshold of optional DVNs
    address[] requiredDVNs;      // Addresses of required DVNs
    address[] optionalDVNs;      // Addresses of optional DVNs
}

This configuration allows applications to require:

All required DVNs to verify (X)
At least Y of the optional DVNs (N) to verify

Summary

DVNs are LayerZero’s flexible and customizable security layer for cross-chain communication. They enable applications to choose their security parameters while maintaining decentralization and trust minimization. Whether you choose the traditional implementation path for full control or the Gasolina approach for operational simplicity, DVNs provide the critical verification layer that makes secure cross-chain messaging possible.

Next Steps

For DVN Operators

Review the DVN Contract Reference for methods, events, and errors
See Build Decentralized Verifier Networks for full implementation details
Review the Gasolina Overview for the simplified approach
Follow the Implementation Guide to deploy Gasolina

For Application Developers

Learn how to configure DVNs in your OApp
Understand DVN pricing and fee structures
Explore existing DVN providers available on each chain

If you’re new to operating DVNs, we recommend starting with the Gasolina approach. You can always migrate to a traditional implementation later as your needs evolve.

Workers

DVN Overview

Gasolina DVN

Build Custom DVNs & Executors

Reference

Decentralized Verifier Networks (DVNs) Overview

What are DVNs?

How DVNs Work

DVN Implementation Types

DVN Operator Responsibilities

Implementation Paths

Traditional DVN Implementation

Build DVNs

Gasolina DVN

Gasolina Overview

Protocol Integration

EVM Interface

Solana Interface

X-of-Y-of-N Security Model

Summary

Next Steps

For DVN Operators

For Application Developers

​What are DVNs?

​How DVNs Work

​DVN Implementation Types

​DVN Operator Responsibilities

​Implementation Paths

​Traditional DVN Implementation

Build DVNs

​Gasolina DVN

Gasolina Overview

​Protocol Integration

​EVM Interface

​Solana Interface

​X-of-Y-of-N Security Model

​Summary

​Next Steps

​For DVN Operators

​For Application Developers

What are DVNs?

How DVNs Work

DVN Implementation Types

DVN Operator Responsibilities

Implementation Paths

Traditional DVN Implementation

Gasolina DVN

Protocol Integration

EVM Interface

Solana Interface

X-of-Y-of-N Security Model

Summary

Next Steps

For DVN Operators

For Application Developers