Adel Akbar I LayerZero Workshop I ETHGlobal Prague 2025

[Music] Hey everyone, welcome to Intro to Layer Zero. My name is uh Adele. I'm an integrations engineer at Layer Zero Labs. You can follow me over there on Twitter. Um I know I don't look like my profile picture, but that's me.

Um cool. So let's start off with what Layer Zero is. So layer 0ero is basically an interoperability protocol that lets you send messages across from one chain to the other. Um to first think about it, let's take a step back. How did we get to this point of crosschain and where it kind of just started?

So initially when people started building applications on the blockchain, they started thinking about which blockchain they wanted to deploy apps on. So if they wanted to deploy stuff on Bitcoin, I guess you can do on Bitcoin, but like if you wanted to deploy stuff on smart contracts on uh Ethereum, you can do that. There's better security there. But now it's getting expensive there. So people that's when L2s came up.

So we had optimism, base chain, all that to make things simpler. So then people were deploying all these applications on all these different blockchains. The problem is now that things are kind of like staggered all over the place, there was a need to start like messaging across. Um we found that over time that uh because of new chains coming up liquidity in different chains like right now abstract is really big for gaming and people who are making made games in different chains they want to go to abstract or if you are in like hyperl and you want liquidity from hyperlquid. Uh so people started expanding their um assets or tokens or whatever to different chains.

As you can see the data shows that people the more apps that are coming out they're actually being deployed in more than one chain. And so how does crosschain state transfer work? Um normally you have two uh blockchains. Let's say there's Lana on the side and Ethereum on the other side. For you to transfer stuff uh like uh value across you have to first uh debited on your side.

So you have to either lock it up or burn it on the destination side and then on the receiving end it has to be uh sent to the receiver. So it's kind of credited over. But how does this actually happen between two blockchains? Well, the the old way of doing things were monolithic bridge security. So, you would have some sort of centralized service over here, right?

This was uh normally like a custodian or like some centralized service there um which would store all that value. So, if you're let's say you're transferring ETH over that ETH would be stored here and then it kind of credited over to the destination side. Now, we know that's we all know that's kind of bad because what if things go wrong here? So if for whatever reason some uh they found a vulnerability and some malicious actor is able to take over then they can actually basically just call LZ re the receive end as many times as they want and like basically take all the liquidity out of the protocol. Um and that's not new.

We have seen this happen. So four of the five largest um hacks in crypto has been in this because of this. we had all these monolithic structures where millions and millions of dollars as you can see that there are hundreds of millions of dollars that were taken out of um the ecosystem through exploits right so that's where layer zero kind of came in so we kind of started off with these early isolated chains then we had these brid bridging infrastructure which eventually faced the high there was a high risk of exploits there right so 2.1 billion that was kind of just gone and that's kind of where layer zero stepped in we came in with this mod modular approach so we wanted security security to be configurable. Um we wanted the end pole uh the endpoints to be uh permissionless and immutable and right now it is the most uh widely adopted interop solution in the market.

Um so we can you can think about um layer zero um oh and it's it's basically as an infrastructure a bridge infrastructure that's built upon three principles. The first one is that it is permissionless. So our endpoint protocols anyone can call those contracts. Um we have security layers called DVNs. Anyone can host those contracts or like those DVNs.

We don't uh centralize it. We don't own anything here. Uh the second part is that it's censorship resistant. So we can't stop anyone from interacting with the endpoint contracts. Anyone can just call it.

And finally, it's immutable. Our endpoint contracts are um connected with different chains and it's fully immutable. We won't be upgrading that anytime soon. So uh we can start thinking about this with our first application that we kind of um formalized. uh we call it the OAP.

OAP is the simplest primitive that we have. The idea of an OAP is that you can send any bits of data from one chain to the other. It could be anything. It could just be a message that says hi. So we basically AI encoded in one chain and AI decoded on the other end.

So let's look at quickly and the send and message workflow, right? So you in chain A over there you'll have your message. It could be any uh data that you basically could send alongside with some configuration. So in that uh or the metadata I guess the params you're passing in would be the destination chain you want to send it to and some config. The config over here kind of like helps us uh figure out what the security stack is going to look like and what the executive is.

Um and let's jump into the verification. So the security stack over here these uh this is a modular security stack that's not owned by us. We call these DVNs. Any third party can host a DVN. um and BA and that basically um verifies like the payload hash that's being sent across and you can add as many as you want or as little as you want based on the amount of security.

So this is how we get past the problem with a monolithic structure. It's no longer monolithic. There's multiple DVNs. Um once that's kind of done uh the verification, we have this exeutor. Again, this is a perm permissionless um um uh exeutor.

Any anyone can host it. So anyone can call that to do the receiving logic. So the executor is kind of like responsible for calling the receive functionality on the destination chain. So that's where like things get credited. So omni chain uh transfers um this is kind of where we went after.

Um just a little quick. Okay. Yeah. So building on top of that logic what I explained o OAPS being able to send messages across. We realized if you can send messages across you can basically encode everything you need for uh your C20 tokens.

And basically we build the OFT standard. And the OFT standard essentially lets you just like send tokens across using the same uh concept. Um on the destin on the source side when you're sending you burn the token and on the destination side it is credited so it is minted on on that destination chain. So we essentially simplified the entire omni chain um transfers. Um again with that modular security you see in the middle like there's no central service.

One of the DVNs could fail. There's three other DVNs or like however you configure it. You can also have optional DVNs and we have a lot of other customization that you can do such as number of confirmations um and all that. Cool. Um okay so from all that we kind of have like this whole stack that we built.

Um this is um you can have any application in any of the space if it's like a gaming NFT social and uh we have a bunch of contract standards. The OFT standards is for like tokens. Um we have the OA app for very simple uh messaging and we also have OFT that's uh for sending NFTs back and forth with like um and this is kind of how we look. We have the all the custom configurations on the side that let uh that makes security one of the most important part of this protocol. Cool.

Um I'm going to skip this. So, um, uh, one of the new things that, um, I'm going to talk about right now real quick is LZ read. Um, uh, in our prizes right now for our hackathon, uh, we have three tracks. The first track is, uh, LZ Compose. Um, I'm going to quickly talk about LZ Compose real quick here.

Um, LZ Compose is this idea of, um, you send a message from one chain to the other chain, but the time it gets to the destination chain, if you want to do some action on that chain. So let's say you were to send tokens across from base to ETH, but on ETH ETH you want to do a swap or you want to deposit that token on a different um on a vault or something. Um so that's kind of like where LZ compos comes into play. It's like a it's a send and an action. So that's where one of our prizes is right now.

That's one of the main tracks we're looking for. And finally this and the second one is LZ read and that's a new primitive that we kind of uh made which is kind of working with the same security logic we had uh in the other ones but uh basically you can query data from any other chain um and yeah crosschain querying um for any like public onchain data um that's like pretty much sums up should sum up like the this entire flow here um and I'm going to jump straight into a demo okay um So, I want to make I want to make sure it's like super easy for you guys to kind of like start. So, okay. Uh maybe I'll just do this. So, to get started with our documentation, you guys just go to Google, search up layer zero docs.

You'll be taken to this page where everything is really. So, just go to EVM because it's the easiest setup. And we'll go just straight to the case or actually just even the CLI setup guide here. I think that should have. So you kind of just want this guy over here.

And um essentially here you can go to like um your terminal and just do npx create lapp and that will let you like make the um that's how I do this, right? What was that? Sure. Um okay. And then you can just like name your app over here like let's say app.

And you can choose which standard you want to work with. So, we could just do like an OFT or an OA app. Uh, for now, I'll just select OFT. And then the package manager is PNPM. So, let's go with that.

It will install dependencies and all all that. Uh, for the sake of this demo, I'm going to kind of like skip that a little bit. Um, I'll let this happen, but I I'm going to go to what it will look like after you've kind of deployed. You'll get like a a page that will sort of kind of look like this. Um, let me zoom in a bit maybe so it makes sense.

Okay, Ignore my cursor questions on the side. Um I don't use AI to code and I um but uh yeah so you will have the OFT contract. This is the OFT standard um that kind of just comes within um and this is what's kind of will be deployed on different chains. So essent uh here I'm just forcing a mint over here. Um and then um we the most important parts once you have this kind of ready I would say just go over there look at the readme and just open preview.

Um you're able to follow all the instructions we have to kind of set it up and going. So you'll notice the first thing you have to do is make sure everything's installed. Then you're like compiling it. Um and we have a bunch of tests here as well which I can quickly run through it really fast. that we have simple tests that like foundry test that will explain how the send OFT is kind of working.

Um and you can see how you have to construct a send param here with like the destination and all that. Um again come to our boots after and we'll kind of explain how all that kind of work here. Um, and that explains how like a send logic works. And there's also another example which explains how the compose logic works over here. But, uh, we can dig into that a bit later.

But essentially, if we go back to the readme, so the most important part is once you have all that kind of ready, um, the first thing you want to do is have your env file. I'm not going to open that for obvious reasons. Um, my private keys are all going to be exposed on YouTube, but uh, yeah. But so first of all, based on the chains you want to deploy to, you want to go to the hard hat config. You want to put in the networks over here in this kind of format.

Um I'm not going going to be doing like a live demo right now. But um you basically like specify like the networks. Uh we have this concept of like endpoint ID. So which from Sapoleia to like let's say Avalanche and you can just put in your RPC URLs over here. Um and once you do that you um you run LZ Npx hardax LZ deploy.

This will let you deploy the OFD contracts on the different destinations. Um, and then finally, we need to wire up the contracts. So to do that, we will just keep going down down down. Yeah. So um after once you set up the hard hat with all the different um chains you want to be on, you simply invoke the uh npx hardack uh LZ OAP config in it.

Pass in the contract name and the um OAP config. I think actually wait no maybe maybe not. Maybe don't do this. Um, you'll come up with the layer zero config file over here. Um, we have this concept of a simplified uh config generator.

Um, you basically pass in the contract name of the contract you're going to deploy. In our case, that contract's actually in the contracts myo over here and yeah, you define the endpoints, kind of have the contract set up. Um, you don't need this. Um yeah, but basically just go into the two-way config path and um have it the chains you wanted uh in place and we simply just want to run this after. So if I go back to the readme, you will basically want to run this command.

So the npx hard hat wire command, this will wire up the two chains together. Your can actually be sent across. Now um yeah, I'm not doing the live demo to completely show you that whole thing, but this will basically allow you to do that. And um after you kind of do that, you have like the uh send task that um I if it's not here, you'll be able to find it on this guy. We have a calling send which kind of gives you like a hard hat task.

So um and that's just how you invoke the send command. And in my case, I could probably just do this. Uh yeah. So you can just call the send command using a param like this after you invoke that over. And this will let you send, let's say, 10 um mock OFT token from one chain to the other.

Right now it's failing for reasons that I don't want to go into. Um oh yeah, insufficient funds. Okay, maybe I've used used up all of it. Oh, actually no, this I just changed my EVM keys. But yeah, essentially this is how you would simply set up like an O of a very simplified use case of layer zero.

Um and yeah with that I think I wanted to go through most of what I wanted um from this but yeah so for the hackathon the main important things that I guess you guys should focus on is um how you can use uh compose logic which is a bit more of the more advanced use cases or how you can use the LZ read. Again we do have the general track. the general track is like if you were building a simple of for whatever um like to send things across or on um yeah but um yeah this kind of opens up like uh everything and I guess like the whole point of layer zero is that we built this primitive so anyone can build anything on top of it so it's really up to your imaginations to see where we can go with that um and for this hackathon if you guys can try to build on mainet just just in advance because not everything's always connected so not all our chains are fully connected in test net at all times but uh yeah Yeah, I think I can sum that up. Um, do you guys have any questions? You have like an OFD guide and like at the bottom of the page is how to deploy the NFTs from an existing collection to other chains as well.

Do you have like a guide for like doing the NFDS from scratch from a new collection? Yeah, so we have most of our guides will actually be to build something from scratch like it will be like the NFD contract that you can deploy. But if you already have a pre-existing thing, we call those adapters. And the way the adapter will work is instead of minting, instead of yeah, burning and minting, it will just be a lock box in one chain and on the other chains, it will mint it. If that kind of makes sense.

Yeah. So, on the website, it'll be on the website and if not, if you can't find it, just come to our desk and we can just show you after. Yeah. Awesome. Yeah.

Um, I had a question. I'm curious. These DVNs I assume they also are connected with each other and have their own consensus kind of or how this uh no the the DVNs are all like kind of separate entities like it could be like um anyone like Google has a DVN with us, Nethermind has a DVN. So these are like um anyone can host them and uh basically when you're sending messages we're paying a fee as well which is calculated through our uh price feeds and the DVNs get paid a little bit. So uh even you can spin up a DVN today if you want.

Um yeah so then I have to trust this one instance of a DVN. So but but you can configure it. It's modular security, right? So you can have multiple DVMs from different like entities. Okay.

Yeah. But if I want to send the message across the chain, then I send it to one DVN and that makes sure that it's anchored on on the other blockchain or or is it multiple DVNs that kind of uh that Yeah. So So again, I guess I have to repeat the question here, but the question is do I need uh just like is there only going to be one DVN that's verifying it? Um but the answer for one specific message but uh then that's where your um config file kind of comes in. So over here we use something called um simple config generator but there's actually if you read the um docs there it'll show you how to expand this out and not use the simple gener uh config generator.

There you can specify the exact devian you want to use and it could be like five DVNs that you would like to use. So it's really about how you kind of set it up. um for each message, right? And yeah, and the cost will also go up and down based on how many DVNs you kind of use here. Yeah.

Yeah. Any other questions? Cool. Um well, we'll be in our booth. Um yeah, and uh yeah, so I guess I hope like this kind of like sparks your imagination, but the idea is like crosschain anything.

Um, we can help you basically build it. Yeah. Cool. [Music]