Welcome to the 200 newly Not Boring people who have joined us since last week! If you haven’t subscribed, join 217,532 smart, curious folks by subscribing here:

Hi friends 👋,

Happy Thursday!

Crypto, pronounced dead in 2022, has come back to life. If you’ve been reading Not Boring through that period, you would have known that it would come back eventually.

But just because token prices are back up doesn’t mean that crypto is anywhere close to doing the things that I think it will be able to do. Better infrastructure will need to translate into better applications, which will demand better infrastructure, and on and on. It’s a never-ending project.

LayerZero Labs is building foundational infrastructure for crypto all the way at the foundation… LayerZero. It’s an omnichain messaging protocol, a transport layer that allows applications to send messages containing bytes of information from one chain to another. If it succeeds, each blockchain will be like a node in one larger, more performant network.

Today, it’s rolling out v2 of its protocol. I got an early look, and I’m excited to explain what it is and why I think it’s going to be important. Apologies for the late send — v2 is hot off the presses.

This essay is a Sponsored Deep Dive. While the piece is sponsored, these are all my real and genuine views. I haven’t written as many of them this year as I have before because I’m only writing them on companies that I think have a chance to be really important in an area I care about, and LayerZero Labs fits that bill.

I’ve been a fan of LayerZero since I had LayerZero Labs CEO Bryan Pellegrino on Not Boring Founders in early 2022, and I’m impressed with the improvements they’ve made in v2 and the potential of the business model.

You can read more about how I choose which companies to do deep dives on, and how I write them here.

As always, please, please for the love of God note that this is not investment advice. LayerZero doesn’t have a token, but it will at some point. When that time comes: please do not look back at this piece as investment advice. If you’re reading this from that future time, please note the following: I am a terrible trader. This is a sponsored piece. a16z, where I’m an advisor, is an investor in LayerZero Labs. I have no idea where ZRO will be priced when trading starts.

I just think it’s important infrastructure for crypto, and that crypto infrastructure is important.

Let’s get to it.

LayerZero: The Language of the Omnichain

In the beginning, there was Bitcoin. 

Bitcoin did one thing well. “A purely peer-to-peer version of electronic cash would allow online payments to be sent directly from one party to another without going through a financial institution.”

Soon, however, people wanted to do other things peer-to-peer without going through institutions. 

Enter Ethereum. 

Ethereum was designed to do many things. “What Ethereum intends to provide is a blockchain with a built-in fully fledged Turing-complete programming language that can be used to create ‘contracts’ that can be used to encode arbitrary state transition functions.”

With Ethereum, developers could theoretically build all sorts of things on blockchains: decentralized applications, domain names, exchanges, lending protocols, NFTs, DAOs. Turing-complete means that, theoretically, they could build anything onchain. 

The challenge was, when they tried to build those things in practice, it was slow and expensive. When users used those things, it jammed up the system and drove up costs.

So two things happened. 

First, right around 2018, a tsunami of new “Layer 1” blockchains emerged to either take Ethereum on directly or to focus on doing a specific thing better than the more general Ethereum could. 

Second, a number of founders built Layer 2 (L2) chains that handle the execution of a lot of transactions faster and more cheaply and settle them in batches on Ethereum. 

Each L1 and L2 – the serious ones, at least – attempts to improve on Ethereum in one or more ways. They might be faster, cheaper, more scalable, more private, or more custom-built for specific use cases, from DeFi to payments to NFTs. 

If you think that sounds confusing, imagine what it feels like for a user trying to figure out where to do things onchain. Worse, imagine what it’s like for a developer trying to figure out which chain to build on!

If you want to build an application that uses crypto, there’s all sorts of complexity and trade-offs you have to make. Do you want to build something that’s cheaper and faster? Cool, if you do, it might be less secure and there may be fewer users and less liquidity on that faster, cheaper chain. 

All told, there are hundreds of Layer 1s and Layer 2s. Each makes different trade-offs, each has strengths and weaknesses. And each, for all intents and purposes, operates in a silo. 

If you view each blockchain as its own competing network, it’s a messy state of affairs: confusing for users, brutal for developers, and results in fragmented user bases and liquidity. 

I don’t think that’s the right way to view blockchains though. 

In May 2021’s Own The Internet, I wrote:

There are a lot of Something Maxis, people who believe their thing is the one and only solution, but I subscribe to the idea that each successful L1 or L2 will focus on what it does best and interoperate with others who do something else best. I’m a Maximalist Minimalist.

I think the right way to view blockchains is as nodes in one larger Omnichain network.

In that view, competitors become complements. Each chain can focus on doing one thing really, really well. As more chains enter the fray, instead of becoming more confusing and fragmented, the Omnichain becomes more capable. 

It’s a nice idea, if you just assume that all the chains can easily interoperate. But they don’t. Go try bridging tokens from one chain to another if you don’t believe me. Blockchains don’t natively communicate with each other; many don’t even speak the same language.

What’s needed in this world is a way for all of these nodes to speak with each other swiftly and securely. What’s needed is a common language for the Omnichain. 

That’s what LayerZero Labs is building.

LayerZero Labs is the company developing the LayerZero protocol, an open-source messaging protocol that allows developers to build omnichain, interoperable applications. Messaging here doesn’t mean SMS – it means sending any arbitrary packet of bytes from one chain to another, so that a smart contract on Chain A can tell a smart contract on Chain B to do something. 

Note: I’ll use LayerZero Labs when referring to the company and LayerZero when referring to the protocol. 

At its simplest, it means that developers can build products that interoperate with more chains to reach more users, and that those users can more easily move value from chain-to-chain. 

At its wildest, it means that developers can choose to build products that use different chains for different features, and that users never have to think about which chain they’re on. 

Bryan Pellegrino, Ryan Zarick, and Caleb Banister founded the company almost accidentally in 2021 when the long-time friends and multiple-time co-founders caught wind of Binance Smart Chain’s (BSC) growing popularity and tried to build a game that worked across BSC and Ethereum. They were horrified with the state of bridges – which have since been hacked for at least $2.5 billion – and attracted to the very hard problem of building foundational infrastructure for crypto. 

They made a bet that blockchains would behave more like nodes in a larger network than as their own competing networks, and that if that were the case, there would need to be a TCP/IP for blockchains. 

Just as TCP/IP enabled the internet by allowing different computers running different operating systems on different networks to communicate with each other, LayerZero allows smart contracts operating on different blockchains to communicate with each other. 

It’s core crypto infrastructure, operating a layer below everything else, hence… LayerZero. 

While there are other messaging protocols on the market, including Wormhole and Axelar, LayerZero is a pure transport layer that allows applications to choose their own entities to verify and execute messages; the others compete as verification layers themselves. 

To build at that layer, LayerZero Labs believes, you need a protocol that is immutable, censorship-resistant, and permissionless. 

The team’s bet on TCP/IP for an omnichain future seems more in the money with every new chain launched. 

In February of this year, in the middle of Crypto Winter, LayerZero Labs raised a $120 million Series B from a16z crypto (where I’m an advisor), Sequoia, and a host of other funds at a $3 billion valuation. It’s handled over 87 million messages and $40 billion across more than 50 chains in under two years since launching, far more than any competitor, without a single dollar lost. 

I first met Bryan in April 2022 when he came on the Not Boring Founders podcast. A few weeks ago, he emailed me to ask if I wanted a sneak peek at the v2 they’d been working on for the past 18 months and maybe even to write a deep dive – “If you're into it would obviously be no bias / write whatever you'd like, would love to explore.” I jumped at it. 

While rising token prices might increase the chance that you read a long deep dive on a crypto company, LayerZero Labs is building the kind of thing that excites me personally whether it’s a bull market or a bear. In the last crypto piece I wrote in November – Blockchains as Platforms – I wrote:

Blockchains are platforms on top of which developers can build products…

When choosing which platforms to build on top of, developers need to weigh trade-offs. What benefits does the platform offer the product, and ultimately its users, and what drawbacks does the platform present? 

Different developers will make different trade-offs depending on what they’re building. 

Over time, as infrastructure improves, the trade-off calculus will come out in blockchains’ favor for more use cases.

LayerZero makes it easier for developers to choose among the benefits of particular chains when building their products, improving the trade-off calculus. And it operates at a beautiful place in the stack – as any new chain comes online and offers improvements in one area, LayerZero Labs can incorporate it as easily as deploying an endpoint. 

Just as TCP/IP turned a novel but limited set of local networks into one of humanity’s greatest achievements – the Internet – LayerZero has the potential to do the same for web3, at a time when baking decentralized ownership, governance, and control into the fabric of the web is as important as it’s ever been. 

LayerZero Labs is my kind of company in a lot of ways: 

• I’m a maximalist minimalist: I don’t think there will or should be one chain to rule them all, and LayerZero’s existence will encourage chains to focus on their strengths and differentiation.

• It will help make capitalism more effective: value flowing more efficiently from chain-to-chain and project-to-project will make onchain capitalism smoother. 

• It’s enabling technology: products will be developed because LayerZero infrastructure exists that wouldn’t have been otherwise, and what those are is unpredictable. 

• It’s a hell of a business: by building the hard stuff, LayerZero has earned the right to take a small fee on every message that gets sent over its rails. 

• Protocols should make money: one of the things that first got me excited about crypto was the opportunity to build better open source infrastructure by rewarding developers.  

But LayerZero v1 didn’t make its value proposition as clear as it could have been.

Bryan told me that when they launched, the popular Crypto Twitter personality Cobie gave him some good advice: write a refutation article getting ahead of the things that sucked about the practical implementation of LayerZero in its early form. He didn’t. 

“We just launched and left it at that. The first time, we said, ‘Here’s how everything works,’ but not the why behind the seemingly simple things that we’d spent months debating.” 

The things they cared most about – immutability, permissionlessness, and censorship-resistance – they viewed and still view as non-negotiable. They’re baked into the architecture. But the other things – like how verification and execution work on the protocol – were meant to be a work-in-progress. 

After 18 months cooking in the lab, LayerZero Labs is launching its v2 with improved an verification and execution model today. This time, we’ll cover the why as well as the what: 

• Parallels with TCP/IP 

• How LayerZero Works

• LayerZero v1: From Bridges to Oracles and Relayers  

• How Interoperability Protocols Compete 

• LayerZero v2

• Default Refutation

• Protocols that Make Money

• Increasing the GDP of the Omnichain

To start, let’s go back to the early days of the very internet on which you’re reading this right now, no matter what computer or operating system you happen to be running. 

Parallels with TCP/IP

I don’t want to lose you with talk of TCP/IP stuff so early in the piece, but if you want to understand LayerZero, there’s no better place to begin. 

In my research, Perplexity served up a PDF of the first chapter in this 2002 gem: TCP/IP: The Ultimate Protocol Guide by Philip Miller. It begins: 

Two people can communicate effectively when they agree to use a common language. They could speak English, Spanish, French, or even sign language, but they must use the same language.

Computers work the same way. Transmission Control Protocol/Internet Protocol (TCP/IP) is like a language that computers speak. More specifically, TCP/IP is a set of rules that defines how two computers address each other and send data to each other. This set of rules is called a protocol. Multiple protocols that are grouped together form a protocol suite and work together as a protocol stack.

TCP/IP is a strong, fast, scalable, and efficient suite of protocols. This protocol stack is the de facto protocol of the Internet. As information exchange via the Internet becomes more widespread, more individuals and companies will need to understand TCP/IP. 

That last sentence is particularly interesting because it was written 28 years after internet godfathers Vince Cerf and Bob Kahn published “A Protocol for Packet Network Interconnection,” in which they first described TCP and its potential to upgrade ARPANet, the predecessor to the internet. When the piece was published, there were 558 million internet users in the world, exactly 10% of the 5.5 billion people who use the internet today. 

Miller was right that information exchange via the internet would become more widespread, but wrong that more individuals and companies would need to understand TCP/IP. 

Soon after he published the book, web 2.0 companies built products that abstracted away the complexity of the underlying protocols so that most people and companies never had to think about them. 

If you want to send an email, you don’t need to know anything about the Simple Mail Transfer Protocol (SMTP). You just open up Gmail. If you want to transfer a file, you don’t need to understand the File Transfer Protocol (FTP). You just drag the little file icon into Dropbox. 

And if you want to use the internet, you don’t need to understand the first thing about TCP/IP. 

When I made that graphic a couple of years ago, for my first piece on crypto, The Value Chain of the Open Metaverse, I didn’t think to include TCP/IP because it operates so far from the user, a layer below protocols like HTTP, SMTP, and FTP. But it’s the most critical layer in the stack. Without TCP/IP coordinating the flow of data from one computer to another, there would be no HTTP, SMTP, or FTP. 

What exactly does TCP/IP do? Miller continues: 

TCP/IP is a set of protocols that enable communication between computers. There was a time when it was not important for computers to communicate with each other. There was no need for a common protocol. But as computers became networked, the need arose for computers to agree on certain protocols.

Today, a network administrator can choose from many protocols, but the TCP/IP protocol is the most widely used. Part of the reason is that TCP/IP is the protocol of choice on the Internet—the world’s largest network. If you want a computer to communicate on the Internet, it’ll have to use TCP/IP.

Another reason for TCP/IP’s popularity is that it is compatible with almost every computer in the world. The TCP/IP stack is supported by current versions of all the major operating systems and network operating systems—including Windows 95/98, Windows NT, Windows 2000, Windows XP, Linux, Unix, and NetWare.

Unlike proprietary protocols developed by hardware and software vendors to make their equipment work, TCP/IP enjoys support from a variety of hardware and software vendors. Examples of companies that have products that work with TCP/IP include Microsoft, Novell, IBM, Apple, and Red Hat. Many other companies also support the TCP/IP protocol suite.

TCP/IP is sometimes referred to as “the language of the Internet.” 

My editor/brother Dan hates when I use block quotes, and here I’ve done it twice, and from an old manual on TCP/IP. But I did it for a reason, promise. In both sections, if you find-and-replace “TCP/IP” for “LayerZero,” “computer” for “blockchain,” and specific operating system and company names for blockchains it works almost perfectly! 

LayerZero is a protocol that enables communication between blockchains. There was a time when it was not important for blockchains to communicate with each other. There was no need for a common protocol. But as blockchains became networked, the need arose for blockchains to agree on certain protocols. 

Today, a developer can choose from many protocols, but the LayerZero protocol is the most widely used. Part of the reason is that LayerZero is the protocol of choice on the Omnichain–the world’s largest blockchain network. If you want a blockchain to communicate on the Omnichain, it’ll have to use LayerZero. 

Another reason for LayerZero’s popularity is that it is compatible with almost every blockchain in the world. LayerZero is supported by current versions of (mostly) all of the major blockchains and layer 2’s – including Ethereum, BNB Chain, Aptos, Avalanche, Polygon, Optimism, Arbitrum, and Base. 

You get the point. LayerZero might be referred to as “the language of the Omnichain.” 

If TCP/IP was the enabling protocol for the Internet, I think that LayerZero can be the enabling protocol for the Omnichain – a network of blockchains, each leaning into its own points of differentiation. 

As value exchange via the Omnichain becomes more widespread, most individuals and companies won’t need to understand LayerZero, but smart, curious people like you should anyway. 

This is one of the hardest and most important problems in crypto, one that, if solved, unlocks a ton of value for everything built on top and makes capitalism flow more efficiently onchain. 

How LayerZero Works

OK, so how do you build TCP/IP for blockchains? How does LayerZero actually work? What does it do? And if you want to create infrastructure that lasts as long as TCP/IP has, what decisions do you need to make upfront? 

We’ll need to get a little technical here, but I’ll try to make it as simple as possible for now and then dive into details later. 

You can think of the LayerZero protocol as a series of pipes that deliver messages between blockchains, transport layer infrastructure that runs below the cities.

These are modern, highly technical pipes. If TCP/IP is plumbing, LayerZero is Pipedream.

Over time, if everything goes just right, these pipes might be the pipes through which the global economy runs, so the LayerZero Labs team believes that the pipes must have three core characteristics: 

• Permissionless: Anyone can build on top of LayerZero without approval from the team, no matter where they are or what they’re building, and and anyone can run the infrastructure necessary to verify and execute messages. 

• Immutable: Once an endpoint or library is in place, it can’t be changed, only appended. The protocol will exist in perpetuity, even if development on LayerZero stopped today (though breaking changes at the change level would disrupt endpoints).

• Censorship-Resistant: Even if someone had a gun to Bryan’s head, there would be no way for them to alter a message or prevent it from being sent. Neither governments nor financial institutions looking to front run can ever access a message. 

If you don’t think about those three things upfront, Bryan told me, “the whole world will be built on rails that are corruptible.” 

In order to build incorruptible rails that can adapt, extend, and stand the test of time, LayerZero Labs needs to balance security where needed and flexibility where possible. 

From the beginning, LayerZero Labs (the developer) split LayerZero (the protocol) into components ranging from “completely locked down” to “flexible.” In v2, that split shows up as four components: 

Endpoints and Validation Libraries are the core of the LayerZero protocol.

Endpoints are low surface-area, open source smart contracts that live on each chain and can’t be changed once they’re in place. Validation Libraries are responsible for sending packets from one chain and validating them on the other and define how communication should be handled on each chain. 

They’re the immutable pipes through which messages flow. 

Verification and execution of messages are up to the application to decide; they can hook any set of verifiers and any executor they choose into the protocol. 

Verification provides the security for the messages being sent; some entity or entities verify that each message is legitimate. Execution essentially means paying gas so that smart contracts on each end can process the transaction described in the messages. 

In v1, verification and execution were provided by Oracles and Relayers. In v2, they’re provided by Decentralized Verifier Networks (DVNs) and Executors. 

Importantly, in v2, LayerZero Labs has totally decoupled security from execution in order to guarantee censorship-resistance without impacting liveness, or the ability of the protocol to continue functioning and processing transactions without interruption. You don’t want anyone to be able to mess with your messages, and you always want them to go through. 

Don’t worry. I’ll explain what all of this means in detail. Getting there is going to take a journey through LayerZero’s history, the theory and practice of LayerZero v1, and the why behind the v2 upgrades. 

What hasn’t changed between v1 and v2 is that endpoints are immutable and validation libraries are append-only. The deepest layers of the protocol remain unchanged, because they were built to be unchangeable from the beginning. 

Security and execution are still modular and up to the application, too, but what has changed in v2 is exactly how that happens. To understand that, we need to understand why it was harder for applications to choose in practice than it was in theory. 

LayerZero v1: From Bridges to Oracles and Relayers  

LayerZero started out as a side project for Bryan, Ryan Zarick, and Caleb Banister. 

After leaving a successful poker career behind in 2014, Bryan kept his brain spinning on a series of hard projects. He tried bitcoin mining in 2014, built an AI model to measure pitchers’ performance that he sold to MLB teams in 2016, launched a platform to let people launch their own tokens, OpenToken, in 2018, and built the world’s best poker AI, Supremus, with Ryan, Caleb, and Meta AI researcher Noam Brown (the creator of CICERO) in 2020. 

“All my life, I’ve just liked to work on hard problems,” he told an interviewer for Sequoia. “More than anything else, that’s what attracts me.”

Later in 2020, when Binance Smart Chain launched and started to pick up real adoption, a rarity then among non-Bitcoin or Ethereum chains, he got the band back together. Bryan, Ryan, and Caleb built a game in which gladiators fought to the death on the cheaper, faster BSC, the winning gladiator was minted as an NFT, and the NFT was stored on the more secure Ethereum. It was a toy model to test the chains, and the test was fruitful. 

In the process of moving the NFT from BSC to Ethereum, they hit a problem: bridges.

Just as physical bridges connect two landmasses, bridges connect two blockchains. They’re how you send tokens – fungible or NFT – between chains. 

Because different chains have different ways of doing things, a token that works on one might not work on the other. So if you wanted to send your tokens from say, Ethereum to Polygon, in order to use an app on Polygon, you’d go to a bridge and the bridge would do a few things:

1. Lock the Original Asset. Essentially, the bridge sends your ETH to a smart contract that holds it “securely.” 

2. Create a Wrapped Version. The bridge issues a “wrapped” version of your ETH, WETH, that represents your original ETH but works with Polygon’s rules.

3. Give You the Wrapped Version. The bridge puts the WETH in your wallet on Polygon, which you can use to do things on Polygon. 

4. Redeem the Original Asset. To redeem your original ETH on Ethereum, you send your WETH back to the bridge, the bridge burns it, unlocks your original ETH, and puts it in your Ethereum wallet, where you can use it to do things on Ethereum. 

As Bryan, Ryan, and Caleb discovered, though, Bridges have a couple of major problems.

First, they’re a security nightmare. All of that locked ETH (or whatever locked token) is a gigantic flashing sign that there’s a pot of money hackers can try to break into. In 2022, hackers exploited the Wormhole Bridge between Solana and Ethereum for $326 million and the Ronin Bridge between Ronin and Ethereum for $624 million. The US Treasury Department alleged that the North Korean hacking group Lazarus was behind the Ronin hack, highlighting that these systems need to be robust against state-level actors. 

Second, they’re slow, painful, and a little bit scary. Bridging tokens means figuring out how to get the native token of the chain you’re bridging to in order to pay gas fees for that end of the transaction, putting your valuable tokens into a website, signing them away, and then waiting for a painfully long time. More than once, I’ve worried if my tokens were lost forever while I waited. 

At launch, Bryan did a video comparing LayerZero to bridges that shows how slow bridging can be: 

So the trio realized that they’d need to go deeper into the stack to solve the problem. They’d need to build foundational infrastructure on top of which bridges could be built. They’d need to build a protocol that would transport arbitrary messages across blockchains. 

LayerZero was born. 

By building a messaging protocol instead of a bridge, LayerZero Labs eliminated the idea of locking and wrapping tokens, got rid of the honeypot, bundled a bunch of steps into one message, and removed the need to worry about gas. 

Chain A sends a message containing bytes to Chain B, and Chain B executes whatever instructions are contained in the bytes. 

For times when that message contains instructions to transfer tokens, LayerZero Labs introduced the Omnichain Fungible Token (OFT) Standard. According to the docs, “This standard works by burning tokens on the source chain whenever an omnichain transfer is initiated, sending a message via the protocol and delivering a function call to the destination contract to mint the same number of tokens burned, creating a unified supply across both networks.” 

With OFT, there is no pot of tokens sitting somewhere – tokens are burned on one side and re-minted on the other. 

LayerZero launched on St. Patrick’s Day, March 17, 2022. Alongside the launch, the LayerZero Founders built a bridge, Stargate, to show it off. (It’s now governed by a DAO.) Stargate uses the LayerZero protocol to move native assets instead of locking and wrapping, and raises an important distinction. 

LayerZero is the messaging rails that operate underneath liquidity transfers. Bridges, like Stargate, operate on top of LayerZero. Those bridge smart contracts still have locked liquidity in them for non-OFT tokens, and hackers can still target the bridge’s liquidity pools. The more protocols adopt standards like OFT, and the Ethereum community’s similar xERC20, the less opportunity there is for hackers. 

Since launch day, LayerZero has delivered over 87 million messages, with over 31,000 smart contracts live on Mainnet, and Bryan tells me that over $40 billion has moved through its pipes… all without a hack. 

LayerZero also allows for messages to be composed across chains. For example, a user could move OFT X from Chain A, swap it on chain B for OFT Y, and then use OFT Y to purchase an NFT on chain B. All of this can be paid for in the source chain’s token and handled in a single transaction from the user’s perspective. Applications can use composability to create magical experiences that abstract away complexity. 

LayerZero v1 created a new architecture for messaging between chains: a locked down transport layer protocol with modular security and execution on top. 

The v1 Whitepaper introduced the concepts of immutable endpoints and append-only libraries that are still in place today, but it handled message verification and execution differently than v2 does. 

Where v2 has DVNs and executors, v1 had Oracles and Relayers. 

Oracles and Relayers made sense on paper. 

The Oracle’s job is to fetch block headers – like a summary of each block on the blockchain – from Chain A and send it to Chain B so that each chain can verify the other’s current state and integrity. At launch, Chainlink, a leading oracle, was the most popular option, and in September, LayerZero Labs announced that Google Cloud would become the default Oracle. 

In theory, applications could choose their Oracle, and Bryan told me the team assumed that someone would make a meta-oracle that combines a number of different oracles – bridges, oracles, and attestation services. In practice, most applications stuck with the default, and no one created a meta-oracle.

The Relayer’s job, on the other hand, is to provide the necessary proof that a particular event or transaction happened on Chain A, which Chain B could then act upon. For example, it could say, “Yes, the user approved sending 10 ETH from Ethereum to Polygon, and we, Chain A, have burnt the 10 ETH. Your turn.”  Crucially, the Relayer was responsible for both security and execution. It handled things like quoting pricing pairs across 40+ different chains in real-time, sending 50-80 billion RPC calls per month to get information, writing millions of messages to chain, and abstracting gas payments away from the user. 

In theory, anyone could build and deploy their own Relayer. In practice, Bryan told me, “A Relayer is impossibly hard to run. We had to build an internal custodian, real-time n^2 pricing, write more messages to chain than anyone in the world, and essentially run Alchemy internally.” So no one built Relayers. 

And because no one built Relayers, LayerZero Labs was a potential chokepoint. If LayerZero Labs’ Relayer went down, the whole network would have a liveness issue – transactions wouldn’t go through – until someone, likely the App itself, came in and picked up transactions. That’s bad from an operational perspective, and it’s equally bad from a censorship-resistance perspective. If the government wanted to temporarily shut down the protocol, all they’d have to do is shut down LayerZero Labs’ Relayer. 

“It goes against everything we believed in,” he told me. 

In theory, LayerZero v1 was trustless – developers could plug in the Oracle and Relayer of their choice. In practice, it isn’t, really. It requires trusting Chainlink, Google Cloud, or Polyhedra, a zk light client that essentially inherits security from source chains, and LayerZero Labs itself. 

That’s a pretty safe bet, especially with the addition of Polyhedra, and fortunately, in terms of security and censorship-resistance, that hasn’t been an issue yet. LayerZero hasn’t been hacked. There haven’t been major liveness issues. LayerZero is the leading messaging protocol by a wide margin. 

But in the long-term, if you want to build foundational infrastructure that lasts fifty years or more, like TCP/IP has, there can’t be any room for error. 

And in the short-term, even the perception of potential pitfalls leaves room for confusion and competition. 

How Interoperability Protocols Compete 

To get widespread adoption and become the TCP/IP for blockchains, LayerZero has to do two things, each of which reinforces the other:

1. Hook into More Chains. Deploy endpoints on more chains so that the protocol can serve developers and users wherever they want to operate. 

2. Integrate with More Apps and Protocols. Convince more applications and protocols to build on LayerZero to build omnichain apps or bridge their tokens by adopting the OFT Standard. 

The more chains LayerZero is on, the more compelling the value prop for more apps and protocols. 

Currently, LayerZero is live on 45+ chains including Ethereum, Optimism, Arbitrum, zkSync, BNB Chain (the successor to BSC), Aptos, Celo, Scroll, Polygon, Avalanche, Fantom, and Base, with more coming soon. 

The most eagerly anticipated is the darling of this cycle so far: Solana. “Solana is basically done and has been in security check / final stages for a bit,” Bryan told me. It's meaty though so we've been super cautious with it. Security first has meant speed is abysmal in this case, we'll get there.” 

As LayerZero Labs lays the infrastructure, it also needs to convince developers to use it. This being crypto, that sales process plays out a little differently than it might for a traditional tech company. 

Exhibit A: Uniswap. 

In December 2022, Plasma Labs CEO Ilia Maksimenka put forward a proposal in the governance forum of the popular DEX, Uniswap. Ilia believed that Uniswap should deploy its protocol on BNB Chain, “the second-largest blockchain infrastructure by volume and user base.” He proposed that his company, Plasma Labs, deploy the Uniswap protocol to BNB Chain using its Hyperloop protocol, “a generalized cross-chain message-passing protocol inspired by roll-ups.” 

If you’ve read this far in the post, you might be interested enough in this stuff to find the full forum discussion as fascinating as I did. It’s business development and technical sales, out in the open, with debate among participants and observers, meant to convince a community instead of a single buyer. 

As the conversation continued over the next month, the community seemed to agree that launching on Binance was a good idea, but weren’t convinced that Hyperloop was the solution. So more bridges and messaging protocols threw their hat in the ring: first deBridge, then Celer, and then, on January 24th, Wormhole. 

After the $326 million hack in 2022, Wormhole upgraded itself. It shifted its architecture from bridge to cross-chain messaging, spent $2.5 million on bug bounties, and underwent a number of audits. 

The day after Wormhole entered the fray, LayerZero did too. 

With Wormhole and LayerZero in the ring, the competition pretty quickly became a choice between these two heavyweights, each backed by heavier-weights. LayerZero was backed by a16z crypto, also an early Uniswap investor and large UNI tokenholder, and Wormhole was backed by high-frequency trading firm and crypto market maker Jump Trading, which incubated the project and which also owns a significant amount of UNI tokens (and therefore votes). 

Over the next week, there was a lot of back and forth among UNI community members, including university blockchain clubs from Stanford, Penn, Michigan, and Berkeley. The conversation covered a few different topics simultaneously: whether there should even be a vote on a single bridge provider, what the process for decisions like this would be going forward, and whether Uniswap should wait and use a multi-bridge or multi-message aggregation solution. 

But there was a time constraint. As a16z crypto’s Porter Smith wrote, “Given the expiration of Uniswap V3’s BUSL license in early April, we’re generally in favor of deploying Uni V3 to other chains before that date to avoid the copy-paste rush that will likely ensue otherwise.”

So a choice needed to be made quickly, and for the purposes of our discussion, it came down to verification models: 

• Wormhole: secured by 19 Guardians, 13 of whom must attest to a message for it to go through. The validator set is comprised of independent validators, chosen by Wormhole.

• LayerZero: secured by an Oracle, with Chainlink as the default but configurable by the application, in this case, Uniswap. 

The fact that this is how the battle shaped up was an error in communication on LayerZero Labs’ part, Bryan told me. It became a contest of whose validation set or verification model was more trusted by the market; he wishes they’d made it more clear that LayerZero doesn’t compete at that level, that as a transport and messaging protocol, it’s verification agnostic. If they’d messaged it right, he thinks the choice should have come down to: 

• Wormhole: trust Wormhole’s validator set and verification model, which is locked in 

• LayerZero: choose whichever validator set and verification model Uniswap wants, with the freedom to swap out Oracles at any point.

But they didn’t message it well, and initially, community members like Kydo from Stanford Blockchain leaned in favor of Wormhole, “because of its diverse validator set.” Kydo was concerned that LayerZero relied heavily on Chainlink’s oracle relay service. 

LayerZero spoke with Stanford Blockchain and clarified its proposal, recommending that Uniswap switch out Chainlink for a “gasless oracle run by a minimum of 5+ significant Uniswap delegates.” Kydo responded: 

Thank you for posting this updated proposal, LayerZero.

We believe this proposal addresses a lot of the questions we have raised before. And their ability to change Chainlink with a set of Uniswap-aligned oracle validators is very promising.

For total transparency, LayerZero reached out to us and addressed most of our technical concerns.

One thing we believe we undervalued, in our initial assessment, is the immutability of the bridge. Many hacks happen because of simple upgrades. Under LayerZero’s design, the underlying infrastructure (LayerZero protocol) is immutable. The changeable parts, the Oracle (header sync) and Relayer (MIP), can only be changed by Uniswap governance.

Given the immutability and LayerZero’s new proposed Oracle, we would like to signal to the community that we have tentatively moved LayerZero as our preferred bridge provider for BNB.

We would also love to see more documentation provided from LayerZero’s side, especially around the oracle and relayer services.

There’s an important distinction in there, which Kydo alluded to but didn’t call out specifically: LayerZero and Wormhole are fundamentally different products. 

LayerZero is solely the transport layer, and Wormhole is also the verification layer. Because of that, Uniswap could swap out Chainlink for its own verifier set. With Wormhole, if you want the pipes, you also need to use its 13-of-19 Guardian model. 

“We felt like the Uniswap forum was more of a failure on our part to properly message the protocol and the role it plays,” Bryan told me. “They expected us to be a Wormhole or an Axelar and we just fundamentally aren’t.” 

Despite the miscommunication, the momentum seemed to be shifting towards LayerZero, but when a “Temperature Check” vote among the solutions went live, a16z was unable to vote its 15 million tokens “due to infrastructure limitations with the custodian on short notice,” and Wormhole won the vote. 

It was an unusual situation: the first and only binding temp check in Uniswap governance history. Typically, the process would move to an official on-chain vote after the temp check. 

But this time, it didn’t. 

After the temp check, Uniswap governance moved to a new and final vote: whether to deploy Uniswap on BNB Chain with the protocol that won the temp check, Wormhole, or hold off on deploying. Given the time sensitive nature of the decision, the community voted to deploy with Wormhole. 

In a follow-up Bridge Assessment Report, the Uniswap DAO assessed a number of providers, including Wormhole and LayerZero. It approved Wormhole “for use in all cross-chain deployments,” but recommended reassessment for LayerZero “based on pending upgrades.” It wrote: 

After assessing the current version of the LayerZero protocol, the Committee has concluded that it does not currently satisfy the full breadth of the requirements of the Uniswap DAO's cross-chain governance use case as outlined in the assessment framework, but is on a path to do so. LayerZero employs a combination of two types of validators to secure the protocol: Oracles and Relayers. However, currently, the available options for Oracles and Relayers do not offer the level of decentralization and security required for Uniswap's use case. LayerZero has a planned upgrade to its oracle and relayer set that would likely address these concerns. 

Between the conversation in the BNB Chain governance forum and the Bridge Assessment Report, it seems that the takeaway was this: 

The immutability of the LayerZero protocol and the potential for applications to choose their own Oracles are both advantages over Wormhole in theory, but in practice, its security model looked too much like a 2-of-2 multisig with Chainlink and LayerZero Labs as the signers. While Wormhole contracts are upgradeable, which introduces risk, and while Wormhole doesn’t allow applications to configure their own validator sets, a 13-of-19 Guardians model appeared to be more decentralized. 

The thing is… Bryan agrees. LayerZero v1 has been safe and has successfully handled a ton of messages and assets, but in practice, the messaging around Oracles was too confusing, and building a Relayer was too hard, for most projects to move beyond the defaults. 

So for the past 18 months, the team has been cooking up something new and improved. 

LayerZero v2

Without the background we’ve covered, you might not have been able to recognize the shade in the whitepaper LayerZero Labs dropped today on v2. From the abstract (emphasis mine): 

The paradigm shift from crosschain to omnichain interoperation has created a secondary problem where applications are siloed into a single communication protocol. Exacerbating this predicament is the fact that crosschain messaging systems are often mutable and provide a single configuration for security. Thus, applications are not given a choice in the timing with which they adopt network protocol updates, and must use a one-size-fits-all configuration for offchain infrastructure. 

The LayerZero protocol solves these problems, and is the first intrinsically secure messaging protocol. By using an immutable base protocol, append-only validation contracts, and fully-configurable offchain verifiers, LayerZero provides unparalleled flexibility and extensibility. LayerZero’s security modules give complete ownership of protocol security, liveness, and cost to applications, and the modular design enables the protocol to scale to all blockchains and applications.

In the whitepaper, LayerZero Labs makes a distinction between crosschain messaging systems, like Wormhole, and omnichain messaging systems, like LayerZero. 

LayerZero’s architecture is based on the belief that you can’t construct an omnichain messaging system by stringing together a number of crosschain messaging systems. Crosschain messaging systems work well if you’re connecting chains that handle execution and consensus in similar ways, like EVM-compatible chains, they argue, but not if you want to connect chains across different compatibility groups, like connecting Solana and Ethereum. 

They propose an omnichain messaging protocol (OMP) that leverages “foundational invariants underlying all blockchains to create a chain-agnostic protocol that semantically unites interoperation between onchain contracts, between chains in the same compatibility group, and between different chain groups.” 

In other words, like TCP/IP created a “language of the Internet,” LayerZero Labs is attempting to create a “language of the Omnichain.” 

LayerZero Labs writes that an OMP has two responsibilities: 

1. Intrinsic Security

2. Scalability

Scalability is simpler and less involved, so we’ll hit it first. It means that the OMP should be able to support any arbitrary new blockchain, security algorithms, or features, now or in the future, and that lower-risk feature extensions should be separated from the security-critical components. This requires one language that works across all blockchains, present and potential, instead of overspecialization based on today’s blockchains and use cases.

Specifically, LayerZero uses a “standardized interface for omnichain composition - lzCompose” to allow developers to use the same code to compose contracts regardless of what the destination blockchain is or which language it speaks. If you want to dig in on this, check out section 4.1 in the whitepaper. 

Intrinsic security is a new framing of the transport layer’s security in v2. This is the security that LayerZero, the protocol, is responsible for: liveness, censorship-resistance, and long-term stability. Applications need to be able to use the protocol anytime, no matter who’s trying to stop it, for a long time. 

To do that, it’s separating the security the protocol is responsible for from the security that the application and underlying blockchain are responsible for. 

The intrinsic security, the infrastructure, needs to work reliably and predictably over time, but the extrinsic security needs to be modular and controlled by the application so that it can evolve as technology advances. As better validators or zero-knowledge clients, like Polyhedra, enter the market, applications should be able to plug them in. 

Applications should also be able to choose how much extrinsic security they need versus how much they’re willing to pay; a DeFi application responsible for billions of dollars and a gaming application responsible for a bunch of $1 NFTs shouldn’t be forced to use the same level of security: such a model would either be too insecure for the DeFi protocol or too expensive for the gaming protocol. 

The best way to illustrate this point is with the Pareto Frontier. Modular extrinsic security provides benefits on two dimensions: choice and time. 

In the present, allowing applications to set their own DVNs lets them choose the right point on the cost-security frontier for their specific need instead of locking them into one likely suboptimal point. 

Over time, the ability to change the DVN allows applications to reap the benefits as technology and competition push out the Pareto Frontier. 

This is one of the most important changes in v2, and the first that Bryan highlighted when we spoke: instead of Oracles and Relayers, which were good in theory but hard in practice, there are Decentralized Verifier Networks and Executors, which are which are permissionless to run, easier to implement (open sourced examples exist), and endlessly configurable.

Now, any external network can be a DVN, and applications can choose any combination of them to approve messages. At launch, Animoca, Blockdaemon, Delegate, Gitcoin, Nethermind, Obol, P2P, StableLab, Switchboard, Tapioca, SuperDuper, Polyhedra, and Google Cloud are confirmed DVN options, and adapters have been built to hook in Axelar and Chainlink’s CCIP. Adapters for other bridges, including Wormhole, are on the roadmap. 

Application A might choose to go very secure and expensive, and have a 15 of 21 threshold and include Chainlink, Polyhedra, Google Cloud, and even would-be LayerZero competitors like Wormhole and Axelar, plus validate messages themselves. Application B, built on Ethereum and Arbitrum, might go with a 3 of 5 and include the Arbitrum native bridge, Google Cloud, and themselves. A verification model that allows you to plug in Wormhole or Axelar’s validator set as just one of a number of other DVNs is strictly superior to those validator sets alone. 

Or if you’re say, JP Morgan, which is building its asset management blockchain project, Onyx, with LayerZero, you can choose to grant write access to a 3rd party validation set, or you can deploy one endpoint at JP Morgan, another at Goldman, and “they can verify directly, handshake themselves,” Bryan explained.  

Applications are responsible for their own extrinsic security, and for selecting an Executor. 

Instead of Relayers, applications choose their own Executors, which live outside of the security of the protocol. These Executors are mainly responsible for quoting prices and gas and handling all of the complexities of transactions for applications and their users. In exchange, they’ll charge a small fee on top of the cost of gas. 

LayerZero Labs will run an optional Executor that applications can choose to run, and that will be the default out of the box, but it encourages applications to set up their own configurations. LayerZero Labs will have to compete on price and service. Importantly, Executors are much simpler to run than Relayers, because v2 decouples security and execution, so LayerZero Labs expects there to be strong competition. If needed, applications can even execute easily onchain or users can self-execute. 

Importantly, v2 also improves liveness. In v1, if the LayerZero Labs Relayer went down, liveness would be compromised. Now, once a message is verified, anyone can execute a transaction on LayerZero Scan or directly onchain. Applications can choose whether to execute them in order – which might be important for a DeFi app – or in whatever way achieves maximum throughput – which you might choose if you’re building a game. If one executor goes down, you can swap in another and the show goes on. 

All told, LayerZero Labs lays the infrastructure, the things that should never change, and applications are free to choose whatever configurations work best for their needs on top of that (and change those over time). The application’s unique configuration of DVNs and Executors is its Security Stack.

In this model, LayerZero Labs doesn’t care what applications choose. They provide the hooks, and with v2, make it as easy as possible to hook them into whatever chain, verifier, or executor the application wants to choose. 

But they do set defaults… 

Default Refutation

While v2 addresses the concerns highlighted in the Uniswap governance forum – it makes LayerZero’s verification and execution more practically decentralized – Bryan told me that he still expects there to be pushback on one thing in particular: defaults.

What are defaults? When you start building with LayerZero, it comes with default DVNs, executors, and libraries. They’re proxy contracts that let LayerZero Labs select things on behalf of the application. For example, if you stick with the defaults, then if there’s any issue with, say, a library, LayerZero Labs can automatically switch you to an updated library. If you statically select your configuration, you need to choose to switch yourself. Since v2 is launching to testnet only for now, the defaults haven’t been set. 

Earlier I said that Cobie suggested writing a refutation ahead of time, calling out the things that suck with the current model that could and should change over time. Bryan told me that he knows that a few vocal critics will be unhappy they’re keeping defaults because they evaluate LayerZero as though defaults were the only option, but that it’s worth the heat because they’re the only way to create a magical developer experience out of the box. 

But he also said: 

“If you’re using defaults, you’re fully trusting LayerZero Labs – don’t.” 

Still, to give developers a good experience, they chose to keep defaults despite the pushback they know they’ll get. He also pointed out that while competitors like to give them pushback on defaults, every other protocol only has defaults. They’re not configurable. “The worst case for LayerZero,” Bryan said, “is the best case for any other messaging protocol, because at least developers always have the choice to change the parameterization.”

I asked the team whether the decision to set defaults was consistent with the idea of creating TCP/IP for blockchain. They told me that just as TCP/IP is a standard and your computer comes with all sorts of built-in decisions on the implementation of the standard in order to make it usable, the LayerZero protocol is the standard and defaults are implementation. Defaults don’t impact the protocol itself in any way, shape, or form, they just make it easier to implement. 

And if you want to build the TCP/IP for blockchains, you need developers to implement it. And one big difference between standards and protocols is that if you can become the TCP/IP for blockchains, that can be a really good business. 

Protocols that Make Money

Earlier this month, Union Square Ventures’ Fred Wilson wrote a blog post titled Why Monetize Protocols? 

Traditional web protocols like SMTP, HTTP, RSS, etc are not monetized. They are free to use and build on and maintained as open standards that anyone can use for free. That has worked reasonably well in the web era so the question arises why we would want to monetize the new protocols that are emerging in web3.

The answer, according to Wilson, “lies in securing the governance of protocols and managing bad actors/applications built on them.” 

A decentralized protocol is governed by tokenholders. The more valuable the token is, the harder it is for any one entity to acquire a large enough stake to control governance and the easier it is for the token holders to incentivize the kind of behavior they want to see. Monetizing the protocol by charging fees that flow to the treasury should make the token more valuable. 

Currently, that’s not a concern. LayerZero is owned, operated, and governed by LayerZero Labs. Last week, however, the team announced that there will be a LayerZero token, likely in the first half of 2024. 

Even after that happens, the LayerZero protocol will always be able to be used without LayerZero’s token – there is no token now and applications can use it, and the endpoint code is immutable. Token holders might, however, use a token to incentivize verifiers, applications, or users to verify, build, and transact on the protocol, or do any number of things that are good for the development and implementation of the protocol. 

So how will value accrue to that token? 

To be clear: the team hasn’t said anything about this, either publicly or to me. My last call with Bryan was the day before they announced the token, and when I asked how a token played into everything, he said: “From the scope of the technology, nobody needs to care. We very specifically have not said anything ever to date about a token.” 

To be double-clear: this is not financial advice. I’m an idiot, I have no idea what the token supply will be, I don’t know what fee amounts the protocol will take on messages. There’s no way to analyze the value of the token with currently available information, and I’m not going to try. 

With that said, I can appreciate the potential of the business model without taking a view on the token. It seems as if the model is to take a small fee on a whole lot of transactions. 

Their docs have a section on Estimating Message Fees, with code that lays out three fees: Relayer Fee, Oracle Fee, and LayerZero Fee. 

The Relayer Fee might contain the price of gas on the sending and receiving chain with a small fee on top, the Oracle fee pays the Oracles for verifying messages, and the LayerZero Fee goes to the protocol. 

Today, LayerZero Labs earns Relayer Fees where it’s the Relayer and the LayerZero Fee. Presumably, these will be replaced with Verifier Fees, Executor Fees, and LayerZero Fees in v2. Once LayerZero Labs decentralizes governance of the protocols, it’s safe to assume that the Verifier Fees will go to participants in the relevant DVN, Executor Fees will go to the Executor, and LayerZero Fees will go to the protocol’s treasury. 

These fees likely represent small markups over costs, and as more Verifiers and Executors compete for business, it may drive their margins down. The killer business here over the long-term is the protocol. 

By operating below and connecting all the chains, LayerZero sits in the flow of funds of the Omnichain. Every time a message moves from one chain to another, it collects a small fee. Over millions and eventually billions of messages, those fees add up. 

From a product perspective, LayerZero is like TCP/IP. From a business perspective, it’s like VISA. 

When I ran this analogy by Bryan, he disagreed, pointing out that VISA is a hub and spoke model: it sits in the middle of a global network of banks, merchants, and customers. “It’s low friction,” he agreed, “if you’re willing to take on the assumption that they’re benevolent.” 

Bryan compared the VISA network to the state of cross-chain messaging when they started building. There’s a middle chain – Cosmos, Axelar, Wormhole, whoever – that listens to events, says “yes/no” to validity, and sends a message. Everyone trusts the middle thing, and if that’s corrupt for even a matter of blocks, it can corrupt everything that touches it. 

He and the team architected LayerZero precisely to avoid that model, to ensure that applications had a way to send a message from one chain to another without anything in the middle: “We were convinced that model wouldn’t scale.” 

But while LayerZero’s architecture is different from VISA’s, I still think there are similarities in the business. By allowing a bunch of entities that couldn’t communicate before to communicate, and enabling value to flow among them, it’s in a position to take a very small cut of a very large number of transactions. 

That’s a good thing. It means that LayerZero Labs, and eventually ZRO token holders, are incentivized to build infrastructure and attract third-parties that increase the flow of value among chains. Ultimately, that means building financial rails that applications and users can trust and access: rails that are immutable, censorship-resistant, and permissionless.

If Stripe’s mission is to increase the GDP of the internet, LayerZero’s might be to increase the GDP of the Omnichain.

Increasing the GDP of the Omnichain

In the beginning of the piece, I said that LayerZero was my kind of company in a lot of ways. It’s a hybrid of the last two pieces I’ve written on crypto. 

In Blockchains as Platforms, I argued that as crypto infrastructure improves, developers will need to make fewer trade-offs in order to build onchain, and as that trade-off gap shrinks, an increasing percentage of developers will choose to do so. 

LayerZero is crypto infrastructure that explicitly lowers trade-offs developers need to make. Instead of building on one chain or another, they can build on both. Instead of choosing an extrinsic security model that’s either too expensive or too insecure, they can choose the right spot for their product on the Security-Cost Pareto Frontier. 

Why does that matter?

In Capitalism Onchained, I wrote that “Crypto’s ideal state is to make capitalism more effective.” 

Just as TCP/IP allowed information to flow freely from computer to computer, LayerZero might allow value to flow freely from computer to computer. It will speed up transaction times, increase liquidity, allow assets to move to the best opportunities more easily, increase competition, and open trade and capital flow among blockchains and their communities. 

If you’re still not convinced that crypto, even in its ideal state, is a valuable thing, than nothing I’ve written today will convince you; but if you believe that crypto can make capitalism more effective, then LayerZero may be an important piece in making that happen. 

Of course, there’s a long way to go to make that happen. LayerZero Labs has to successfully launch v2 and convince a new wave of applications and protocols to build on it. It needs to hook its endpoints into more chains, like Solana. It needs to maintain its sterling security record while significantly increasing volume. It will certainly need to fend off competitors who also recognize how valuable a position it is to be at layer zero in the stack, providing infrastructure that lasts a very long time. 

But it has some advantages baked into the architecture. The beautiful thing about building flexible infrastructure in the way that LayerZero has is that it improves as the ecosystem around and on top of it improves.

As new Verifiers come into the network and compete for business, the Security-Cost Pareto Frontier shifts. As new Executors come into the network and compete for business, execution gets tighter. As new chains come online, each with improvements to previous models, the Omnichain gets stronger. 

The thing that I think will be most fascinating to watch play out if LayerZero succeeds is that L1s and L2s will need to push further to the extremes on certain capabilities. If you’re trying to compete directly with Ethereum, you might be tempted to try to do what Ethereum does, but better. That’s bad strategy. 

Good strategy means leaning into your differentiation. Let Ethereum have the settlement layer, and optimize for speed, price, storage, or particular use cases. Experiment with bolder trade-offs. Do one thing really well, and plug that thing into the larger network, so that the Omnichain gets more capable, and more developers choose to build applications onchain. 

Good technology reduces the trade-offs that people need to make. Instead of this or that, it’s:  

That’s what LayerZero enables. Developers can pair the security of Ethereum with the speed of an L2, tap into liquidity across chains, and build apps that are composable no matter where the best Lego blocks happen to live. 

And as for you? If you haven’t played around with crypto for the past year, I think you’ll be surprised at how much better it’s getting. Go bridge some ETH to Optimism or Base on Stargate and bridge it back to Ethereum mainnet. It’s a smoother experience than you might remember from the last cycle. 

LayerZero still has a long way to go. It’s live in a number of use cases, including DEXes (Trader Joe), stablecoins (MIM), and games (Parallel), but developers have barely scratched the surface of the omnichain app design space. Even with a better product, it will have to hook into more chains, win BD battles, and clearly communicate to developers why and how they can build better products on top of its infrastructure. 

But wherever we are in the price cycle, that’s the cycle that excites me most: better infrastructure enabling better applications that bring more people onchain without forcing them to sacrifice security or performance. I think LayerZero v2 is a big step in that cycle, and I’m excited to see what developers build on it. 

Thanks to Bryan and the LayerZero Labs team for working with me and answering my dumb questions, and to Dan for editing!

That’s all for today! We’ll be back in your inbox tomorrow with a Weekly Dose.

Thanks for reading,

Packy