LayerZero

The Ultra Light Node (ULN) is LayerZero's core on-chain client. It is a lightweight, gas-efficient smart contract that verifies transaction proofs from source chains without running a full node. It works by:

• Requesting a block header from an Oracle (e.g., Chainlink).
• Requesting a transaction proof from a Relayer.
• Verifying the proof against the validated header. This separation of duties (Oracle for block headers, Relayer for proofs) creates a trust-minimized environment where security depends on the honesty of at least one party.

LayerZero employs a decoupled security model where the roles of providing block headers (Oracle) and transaction proofs (Relayer) are separated and can be independently configured. This design means:

• Security is not dependent on a single entity. A transaction is only validated if both the Oracle's header and the Relayer's proof are correct and correspond to the same block.
• Applications can choose their own Oracle and Relayer (e.g., using a permissionless public relayer or running their own for maximum security).
• This model reduces trust assumptions compared to bridges that rely on a single, monolithic validator set.

A key innovation is configurable trust, allowing dApp developers to tailor their security model. Developers can select:

• The Oracle service (e.g., Chainlink, Band Protocol).
• The Relayer (e.g., the default LayerZero Relayer, a third-party service, or their own self-hosted relayer).
• The execution endpoint on the destination chain. This flexibility enables a spectrum from convenience (using default, audited services) to maximum security (self-operating the Relayer), making the protocol adaptable for different risk profiles.

For token transfers, LayerZero introduced the Omnichain Fungible Token (OFT) standard. Unlike traditional bridging which locks and mints wrapped tokens, OFT enables:

• True omnichain tokens that exist natively across multiple chains.
• Burning tokens on the source chain and minting them on the destination chain via a standardized messaging call, preserving the canonical supply.
• Composability as OFT contracts are also messaging endpoints, enabling complex cross-chain logic beyond simple transfers. The OFTv2 extension added support for delegate-based tokens like staked assets.

At its base, LayerZero is a generic message passing layer. It can transmit any arbitrary data payload between smart contracts on different chains. This enables use cases far beyond asset bridging, such as:

• Cross-chain lending: using collateral on Chain A to borrow on Chain B.
• Cross-chain governance: voting on one chain to execute actions on another.
• Cross-chain DEXes: performing swaps where liquidity resides on separate chains.
• Cross-chain NFTs: moving or using NFTs across ecosystems. The protocol provides the transport layer, while the logic is defined entirely by the connected smart contracts (Endpoints).

Communication occurs through standardized Endpoint smart contracts deployed on each supported blockchain. Each Endpoint provides a universal interface for dApps and contains the Ultra Light Node. The flow is:

1. A dApp's source chain contract calls its local Endpoint with a message and destination chain ID.
2. The Endpoint emits an event containing the message and its payload hash.
3. The configured Oracle and Relayer observe this event.
4. The Oracle sends the block header, and the Relayer sends the proof to the destination chain's Endpoint (ULN).
5. The ULN verifies the proof and delivers the message to the target dApp contract. This creates a uniform developer experience across all connected chains.

The core innovation of LayerZero is the Ultra Light Node (ULN), a lightweight on-chain client that validates cross-chain messages. It works by requesting block headers from a decentralized oracle (like Chainlink) and transaction proofs from an independent relayer network. This separation of duties creates a trust-minimized verification system without requiring a full node on the destination chain.

• Oracle: Provides the block header to prove the source transaction was finalized.
• Relayer: Provides the Merkle proof that the transaction is included in that block.
• Destination Contract: Verifies both proofs match, then executes the payload.

Every blockchain in the LayerZero network has a canonical, immutable Endpoint smart contract. This is the universal entry point for all cross-chain communication. Developers interact with the Endpoint via the LayerZero Messaging Library, which abstracts the complexity of the underlying protocol.

• Send Function: Packages a message with destination chain ID, destination address, and a payload.
• Receive Function: The counterpart on the destination chain that processes the verified message.
• Nonce & Path: Ensures message ordering and prevents replay attacks across chains.

LayerZero employs a decentralized executor-verifier model where two independent entities (Relayer and Oracle) must collude to compromise security.

• Relayer: An off-chain service run by anyone (often the dApp itself) that submits transaction proofs. It is responsible for gas fees on the destination chain.
• Oracle: A decentralized network (initially Chainlink) that submits block headers. Its role is purely to attest to chain state finality.
• Security Model: This design means a malicious message can only be delivered if both the Relayer and the Oracle are compromised, making it more secure than a single trusted intermediary.

A key feature is dApp-level configurability. Each application can choose and customize its own security stack.

• Default Relayer: LayerZero Labs provides a basic, permissionless relayer.
• Custom Relayer: dApps can run their own relayer for maximum control over liveness and gas management.
• Oracle Selection: While Chainlink is the default, the protocol is designed to support multiple oracle networks.
• DVN (Decentralized Verifier Network): Future upgrades allow dApps to use a network of verifiers instead of a single oracle for enhanced security.

The OFT Standard is LayerZero's native token standard for native cross-chain transfers, enabling tokens to move between chains without wrapping or liquidity pools.

• Native Burning/Minting: Tokens are burned on the source chain and minted on the destination chain, preserving total supply.
• Composable: OFT contracts can be combined with other standards (e.g., ERC-20, ERC-721).
• Examples: Stargate Finance's STG token and Trader Joe's JOE token use the OFT standard for seamless omnichain movement.

LayerZero enables a wide range of omnichain applications beyond simple token transfers.

• Cross-Chain DEXs & Bridges: Stargate Finance is a canonical liquidity bridge built on LayerZero.
• Omnichain NFTs: Projects like Gh0stly Gh0sts deploy a single NFT collection across multiple chains.
• Cross-Chain Lending: A user could collateralize assets on Ethereum and borrow on Avalanche.
• Unified Governance: DAOs can conduct voting that aggregates sentiment across multiple chain deployments.
• Data Messaging: Arbitrary data payloads can be sent to trigger smart contract logic on another chain.

LayerZero's core innovation is the Ultra Light Node (ULN) design. Instead of relying on intermediate chains or consensus, it enables on-chain light clients that are cost-efficient.

• How it Works: A Relayer submits the block header, and an independent Oracle submits the transaction proof. The destination chain contract verifies them match.
• Trust Assumptions: Security is derived from the underlying chain's consensus and the assumption that the Oracle and Relayer do not collude.
• Configurable: dApps can choose or run their own Oracle and Relayer for enhanced security.

The LayerZero ecosystem is governed by the ZRO token and includes a wide network of supported chains and partners.

• Supported Chains: Ethereum, Arbitrum, Optimism, Polygon, BNB Chain, Avalanche, Aptos, Sui, and many others (over 50+).
• Governance: ZRO facilitates protocol upgrades, fee management, and ecosystem incentives.
• Partners: Includes major wallets (MetaMask), infrastructure providers (Google Cloud, AWS), and hundreds of integrated dApps building cross-chain functionality.

LayerZero's core security innovation is the separation of data availability (provided by an Oracle) and transaction proof delivery (provided by a Relayer). These are independent, permissionless entities. A message is only accepted by the destination chain when both components submit matching information, creating a fault-tolerant system where both must collude to forge a transaction.

Applications built with LayerZero can configure their own security stack, choosing their preferred Oracle (e.g., Chainlink, Pyth) and Relayer (default, custom, or self-operated). This is enabled by Ultra Light Nodes (ULNs), which are smart contracts that verify block headers on-demand. Instead of syncing an entire chain, the ULN requests and validates a minimal proof for a specific transaction, making cross-chain verification gas-efficient and customizable.

Introduced as a security upgrade, DVNs are a network of independent nodes that verify and attest to the validity of cross-chain messages before they are executed. The application's Security Stack can require attestations from multiple DVNs (e.g., 3 of 5), moving beyond reliance on a single Oracle/Relayer pair. This creates a multi-party verification system, significantly raising the cost of a successful attack.

Security depends on the chosen components:

• Oracle/Relayer Collusion: The primary risk is if both the selected Oracle and Relayer are malicious and coordinate.
• DVN Consensus Failure: If the required threshold of DVNs is compromised.
• Chain-Specific Risks: Underlying blockchain security (51% attacks, reorgs) can affect message finality.
• Application Logic Flaws: Bugs in the destination chain's smart contract that processes the message.

Executors are a separate layer responsible for paying gas fees and executing the verified message on the destination chain. They are distinct from Relayers and DVNs. While they cannot alter the message content (as it's already verified), they are responsible for timely execution. Applications can use default executors or run their own to ensure liveness and avoid execution censorship.

To disincentivize malicious behavior, key network participants like DVNs and Executors are expected to be economically bonded. A slashing mechanism can penalize these actors for provably malicious actions (e.g., signing invalid messages) or prolonged downtime. This aligns the security of the network with financial stakes, a critical component for long-term decentralization and robustness.