Skip to main content
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:
  1. The message is picked up by the chosen DVN(s) via the PacketSent event.
  2. The DVN(s) independently verify the message hash using their unique security logic.
  3. Upon successful verification, the DVN calls verify on the destination chain’s Message Library.
  4. 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 TypeDescriptionExample
MultisignatureRequires multiple parties to sign off on a message hashCustom multisig contracts
Zero-Knowledge ProofsUses cryptographic proofs to verify message validityPolyhedra
Decentralized OraclesLeverages existing oracle networks for verificationChainlink
Protocol AdaptersWraps existing interoperability protocolsAxelar, Wormhole
Light ClientsVerifies using blockchain consensus proofsNative bridge adapters

​
DVN Operator Responsibilities

Regardless of implementation approach, DVN operators are responsible for:
  1. Chain Coverage: Deploying DVN contracts on every chain they want to support
  2. Event Monitoring: Listening for PacketSent and DVNFeePaid events on source chains
  3. Verification Logic: Implementing secure verification of message hashes
  4. Transaction Submission: Submitting verification proofs to destination chains
  5. Gas Management: Maintaining sufficient gas tokens across all supported chains (unless using Gasolina)
  6. 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);
}
FunctionTypeDescription
assignJobPayableCalled by the Message Library when a packet is sent, paying the DVN for verification
getFeeViewReturns 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:
InstructionProgramDescription
init_verifyReceiveULNInitializes a confirmations account to store DVN verification state
invokeDVNExecutes DVN verification logic (signature validation, multisig checks)
verifyReceiveULNFinalizes 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

​
For Application Developers

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.