Laura Shin (2:54)

You a builder who needs to add on chain trading to your product? The Uniswap Trading API from Uniswap Labs offers plug and play access to some of the deepest liquidity in crypto. It's on chain execution at an enterprise level. More liquidity, less complexity. Visit hub.uniswap.org to learn more. Mantle is pioneering Blockchain for banking, a revolutionary new category at the intersection of TradFi and Web 3. Follow Mantel Official to learn more.

Podcast Host (3:24)

Hi everyone, I'm here at the Ethereum Foundation's DevConnect in Buenos Aires, Argentina. And I'm here with Marissa Posner, product on the account and chain abstraction team at the Ethereum foundation, and Yoav Weiss, research on the account and chain abstraction team at the Ethereum Foundation. Welcome Marissa and Yof.

Marissa Posner (3:40)

Thanks for having us.

Podcast Host (3:43)

So before we get into the details about your announcement, which is super exciting.

Laura Shin (3:48)

Which is about the Ethereum interop layer.

Podcast Host (3:51)

Why don't we have you just introduce yourself so give your background and talk about how you came to work at Ethereum.

Marissa Posner (3:58)

Yeah, yeah, I can start. So I studied computer science and economics and kind of was always interested in intersection of AI and blockchain. So out of college I was a machine learning engineer and then I kind of just fell in love with crypto through a data side of things. I was really interested in understanding everything that was happening on chain. So I started building some analytics tools on top of on chain data. Kind of from there did a few other startups and last year at DevConnect, at DevCon. Sorry. I heard about the role at the Ethereum Foundation. It's actually kind of a funny story. I was on a bus to see Mudang, the viral hippo, and I heard someone behind me saying that the EF kind of tracking team was looking for someone super specific that fit my exact archetype. And I was like, wait, that's me? And like 10 other people and they introduced me and from there, yeah, it was history.

Podcast Host (4:47)

And Yoav.

Yoav Weiss (4:48)

Yeah. So I started working on Ethereum on Ethereum stuff on public infrastructure in 2017 and when I started using Ethereum I. I saw the ux. The onboarding UX was terrible for me because I mean, I needed to get I just wanted to experiment. I didn't want to so I wanted to experiment with some smart contracts and I wasn't looking to make some financial stuff and yet I, I, it took me like two months to onboard because I need to pass KYC and that's no just I just want a little if to start experimenting. So I realized this is not going to work. That's not, we are never going mainstream with this. So my focus became like immediately trying to solve this onboarding problem but doing it in a trustless way. We're not adding like not through intermediaries, not through centralized exchanges. And this led me to start working on what later became account obstruction. So at some point I joined the EF and started and started building that. The focus is always improving UX and user onboarding, but without introducing intermediaries.

Podcast Host (5:54)

Okay, so yeah, let's now talk about your announcement today. The Ethereum interrupt layer. Explain what that is.

Yoav Weiss (6:02)

Right. You want to go or. Sure, yeah. So yeah, the free interop layer is a way to solve cross chain to cross L2 transactions. And also the focus here is to we want to have seamless UX and without seamless UX without introducing new trust assumptions. And the reason is we are looking at the way we look at it ethereum scale through L2S. So L tools are part of the Ethereum ecosystem and as such you shouldn't have new trust assumptions when you move between them because otherwise these trust assumptions are part of Ethereum. So we came up with this protocol that does not add trust assumptions and yet you have seamlessly it's going to feel like one chain. You're able to transact on multiple chains as if it's a single chain with the lowest latency possible and without these intermediaries because you self transact, you submit your own transactions on each of the chains. So that's eil.

Podcast Host (7:05)

And explain a little bit also about what problem you're trying to solve with it.

Marissa Posner (7:09)

Yeah, I think today in a world where we have an infinite number of chains, it's such a long tail and the users are increasingly transacting across many different chains, we need to come around a set of standards such as interoperability standards between chains, which is something that is kind of a precursor to EIL in our mind. And these interop standards are things that remove chain awareness. So I could send to an address instead of a 0x so I could send to. Let's say I'm Alice on arbitrum eth and I want to send to Bob at base Eth, I can purely just type in bobase eth and my wallet can resolve all of that and send directly to Bob. And this is just one such standard. There's other things like an onchain config that basically gives one centralized place to look for on chain information about a chain that lets the wallet be able to resolve this information without having to know the chain before. Because like, let's say I'm a user and I put in this random chain like xyz, whatever, then I like my wallet doesn't know how to resolve it. But these types of standards let wallets kind of resolve this long tail of chain and do this discovery and then pair that with eil, which is basically now you have discovery of chains, but now how do you transact across them? And that's the problem that EIL solves is like when you have all of these chains now you need a way to move assets across them. And we were looking at the interoperability space and we were looking at the existing solutions out there and we were just not impressed by the trust assumptions in many of them. And we felt that it was important and kind of our duty as builders on Ethereum to build a solution that does interoperability in a trustless way without requiring intermediaries. Which is why we built eil.

Podcast Host (8:53)

And just explain a little bit more what a trust assumption is. Like, give an example or.

Marissa Posner (8:59)

Yeah, I think so. Trust assumptions. When I think of like trusting someone, that's a way that someone can either hurt you, rug you or do something bad to you. So that means that they could take my funds, they could block my transaction, they could front run me so I get a worse deal. They can do all of like these different things. And so I think in a lot of times we don't realize how many trust assumptions there are in what we're doing online. For example, even with RPCs, there's trust assumptions because we're an not verifying the data that comes from the rpc. This is why one of the standards that we're looking into is light client contracts where you can verify the data that you get back from the RPC so you don't have to trust them blindly. Because when you trust someone blindly, you open yourself up to getting hurt from them. And so a lot of the things that we're thinking about is how can we reduce that attack vector space. And with interoperability you're actively increasing that space just by nature of compounding different surfaces with each other. And so like we were thinking A lot about that and how to basically make the Interop solution trustless.

Podcast Host (10:06)

And for the explanation of the problem that you're trying to solve with eil, explain like what the experience is like now and why that's not optimal.

Yoav Weiss (10:17)

Yeah, so nowadays when you have to, I mean each roll up feels like, feels like its own island. I mean inside each roll up it feels like Ethereum used to be, but with a cheaper block space and like more band of block space. But once you need to transact across roll ups, the experience is that you need to bridge ETH to the other chain so that you can pay for gas, you need to bridge your assets. So it's like you sign a transaction to bridge, you send it through a bridge, you wait, you hope that you'll get funds on the other side. And I assume you know this experience. Like, you know, you wait and just hope. And then you get, once you get the funds on the other side, you sign yet another transaction. So it's like there's a lot of friction, especially if you're using a hardware wallet. So all of this friction, it doesn't feel like using one chain. It feels like you are moving between them every time. Every roll up is an island and you. And the bridges between them are complex. And what we want to have is, we want to have an experience of having one chain but with abandoned block space. So it's, I want to sign one operation regardless of how many chains are involved and then I want to send it. So I want my wallet to show me exactly what I'm going to do on each chain, but only show it once, let me sign it and then not have the friction of bridging or waiting or. And so that's the, that's a, that's a problem we're trying to solve.

Podcast Host (11:37)

Yeah, yeah, it sounds a lot more comfortable or like, like it would give you confidence in transacting. So how did you guys come to work on the eil? Like you both just talked about, you know, how you came to work at Ethereum, but how did you end up working on this particular problem?

Yoav Weiss (11:54)

So, you know, after we saw, we saw that L2s become increasingly important. A lot of the traffic has been moving to L2s and we started seeing protocols emerging for solving interoperability between them. And the trust assumptions were not great, the UX was not great. So we figured that we should start working on solving this. And I had this idea of something like the general idea of EIL is something that I've been thinking about for many years now because I mean, I'm a security researcher and I found quite a few vulnerabilities in bridges. I reported the various vulnerabilities over the years. So I know how risky bridges can be. And when I designed ELC4037, the account obstruction standard, one of the first ideas I had. Oh, sorry. So one of the first ideas that I had is that actually since we abstract the gas payment, you should be able to transact on chains where you don't hold eth. And you should be able to do it with one signature because you can abstract the validation and make it work on multiple chains. So this has been an idea around ERC4037 for several years now. And we realized that now that interoperability becomes more important, it's time to actually implement that. So that's how we came to. And it's a direct continuation of account abstraction work.

Marissa Posner (13:23)

Yeah, we're actually calling it, we're calling EIL account based interop because we're moving all of the interoperability into the user's hand, into the account or the wallet level instead of other types of interop out there, like message passing, for example.

Podcast Host (13:37)

Okay, yeah, so explain more about how it works. Exactly.

Yoav Weiss (13:41)

Yeah. So we are pushing the logic into the wallet. We want to make the wallet the user's. The wallet should be the user agent as opposed to trusting a third party instead of having a server operate on your behalf. All the logic lives in your own wallet. And so no matter how many chains you're going to transact on, you're going to generate your own, your, your own transactions in your own wallet and send them directly. Northwind intermediary now, of course the complex part is who pays for the gas and how do you have your assets on, on. On another chain? So when, so for that we use the, we used Paymaster contracts. That's a part of ELC4037 where it's a contract that can pay for your gas and this. And so we created a crosschain paymaster which gives you a way to move assets and to pay for gas across chains. And this works by. I mean, for this you actually need someone, you need someone to give you funds on the other side. But we didn't want this someone to be involved directly in your transaction. We didn't want to go through that someone. So instead we have liquidity providers. But the liquidity providers provide you liquidity through an atomic swap by giving you some on the source chain. When you want to transact, you send a request and you don't expose your intention. You don't say I'm going to mint this NFT on that chain. What you say is I need the so I need one ETH on that chain. So I need one eth on the chain to pay for something and for gas. And they give you a voucher. Now this voucher is an atomic swap. So it's a by they claim your 1 ETH on the source chain by giving you this signed voucher and then this the same voucher, you can use it yourself with the payments at the destination. So it's atomic. Like either they give it to you or they don't. And if they give it to you, then they already gave you the funds on the other side. So there's no risk that you don't have the, that you end up without the funds. And this allows you to self transact. So you buy a voucher for gas and for funds on another chain without exposing your intention, without exposing your IP address. Because this is fully on chain. There is no direct connection. Like they don't know your IP address. You don't connect to some server. Instead you send a request on chain, you immediately get the response which in a competitive landscape is going to happen in the same block because they're going to sit in the mempool. So someone is going to bundle, someone is going to bundle your request with their, with a voucher because they want to be the first one to claim the, to claim the fee. And by claiming the fee they gave you the voucher that you're going to use like in the next block on the destination chain to submit your own transaction. So that's basically how EIL works.

Marissa Posner (16:38)

Can I. I'd like to illustrate an example that I have kind of related to what Yoav was saying in kind of the difference between a lot of the existing models, which are a lot of solver based models and eil. So I brought these envelopes with me. This one says user's intention and inside the envelope, so this is so I as the user would give this to the solver. The solver takes this envelope and they open it and they read what is in it. And I can see it says to swap 100usdc to eth on Arbitrum. Send that ETH to my friend on base Bob at base eth. So I as a solver, in order to move this from one chain to the other, I need to open the envelope, I need to see the full user intention of what is inside. Now that means that I as the solver can front run the user, I can censor the user, I can decide not to pass this. And I know if they're going to do so I have a lot of information about them like IP address, so I can choose not to pass that. So this has a lot of trust assumptions in it. And so that was something that when we were designing EIL we wanted to avoid. And so I'm now going to give the example of eil. So eil, I have an empty envelope. And I have an empty envelope because there's no message in it. What is passed, what is passed to the voucher is I have a fee like a stamp of 0.02 cents of USDC. This could be USDC because it could be a non native gas token. It doesn't have to be eth because of 4337 paymasters I have to base, I'm saying who it is sent to and the amount which is 100 USDC and all that. So I don't know who my friend is. I don't need to know what I'm doing on that, on the destination. All I need to know is the amount and who I'm sending it to. It's kind of like if you were going to. If I was the who on each.

Yoav Weiss (18:28)

Chain, you don't excuse which who on this chain you're going to send it to.

Marissa Posner (18:32)

Exactly. And so I now as the liquidity provider, which in our case is kind of like the solver, except that I don't know anything about the user, I am only providing liquidity. So if you were kind of thinking about this, let's say I'm going on a trip, right? I'm going from Buenos Aires to Patagonia. I could take a bus, right? And I could get on this bus. I buy my ticket, the driver knows where I'm going, he knows I'm getting off at Patagonia, he can decide to reroute, he could stop the bus, he can do all of these different things that would prevent me from getting to Patagonia. But let's say I'm driving my car and I, and I go to a gas station, I need to fill up on gas. That gas station is like the liquidity provider in our example. And that gas station doesn't know where I'm going after. It doesn't know what I'm doing. All it knows is I need this amount of money and it can choose to give me the gas or not and, and it is completely atomic. And then I can go on my way and do, and like do the rest of my trip myself and I don't need to rely on someone else. So that's kind of like one of the big advantages that we're thinking of with Ethereum interop layer and kind of how it relates back to trustlessness and, and designing this whole system around it.

Podcast Host (19:39)

So it's so interesting hearing the, these descriptions because also I'm sure you're aware that Near Intense has kind of taken off with the whole zcash craze recently. So can you explain how this is similar or different from that?

Yoav Weiss (19:55)

So intents in general are a. Intents are a high level construct. It's a different level of abstraction where transactions are, transactions are very prescriptive. You say exactly, this is my call data, this is a contact address. I want to make exactly this call. Whereas with intents you don't say how to do it, you just say what you want to achieve. Like okay, I want to have one eth on that chain or I want to have this NFT and then I let someone, I let the solver figure it out. Now the problem with this model, it's great, it's very flexible and if we could have it trustlessly, it would really be awesome. But there is room for interpretation, right? I mean you are not telling the solver how to do it, only what you want to achieve, which gives them a lot of leeway. And the more leeway you give a third party, the more they can also hurt you. So you have to introduce some trust assumptions. So we chose to have eil. So EIL is a transport layer that works at transaction level. When you use a DAPP that needs to do something, it actually tells the wallet exactly. This is the call I want to make on this chain and also make that call on the chain, but with an intent. It will just state what it wants achieved and let this third party, let this third party figure out how to do it. And this is really hard to decentralize. I mean having spent a few years on these problems, I can tell you that decentralizing something like intents, there are a lot of ways where the user can, the user can grief the solver. There are a lot of ways that the solver can sensor the user. So making it a, I mean having a mutual distrust between solvers and users is a really hard problem. And we chose to like, instead of having to deal with this problem that I'm not sure how easy it would be to solve, we just say let's use transactions. Because DAPPS generally know what they want to execute?

Marissa Posner (21:54)

No.

Yoav Weiss (21:54)

It is possible to build an intent framework on top of EIR by having like a local solving. So you could implement some of this logic locally and instead of having this black box that you send the intent to, you can have this transparent box on your own computer that will apply some of this logic. But this requires a lot more research, so maybe we'll get there in the future.

Laura Shin (22:18)

Hey founders and developers. If you're looking to bring on chain trading to your product or wallet or platform, check out the new Uniswap Trading API from Uniswap Labs. It's your plug and play gateway to global on chain liquidity. No deep crypto experience required and no need to manage complex integrations or ongoing maintenance. With the Uniswap Trading API, you'll get enterprise grade on chain execution, combining both on chain and off chain sources for the most competitive prices. Simply put, more liquidity, less complexity. And this isn't just any API, it connects directly to the Uniswap protocol which has securely processed over $3.3 trillion in total volume with zero hacks. So stop worrying about liquidity infrastructure and focus on building your product. Get access to the same liquidity that powers billions in swaps through one powerful API. Visit hub.uniswap.org to learn more. Mantle leads the establishment of Blockchain for Banking as the next frontier UR is the access layer that transforms Mantle Network into a purpose built vertical platform. The blockchain for banking that enables financial services on chain. UR unifies and vertically aligns Mantle's focus on payments, trading and assets. MI4 Functions FBTC supported by developer grants, ecosystem incentives and the industry leading distribution platform through the UR App Rewardstation and BYBIT launch pool. All economic activity within UR will be captured by Mantle Network to further drive value to token holders and establish its significance in blockchain for banking. Follow MantleOfficial to learn more.

Podcast Host (24:02)

Okay, and then as you mentioned, so it's built on account abstraction and that is, you know, something that enables smart contracts to initiate transactions in an externally owned account which traditionally has been kind of manually operated by a human. So are there any security risks in this, you know, setup?

Yoav Weiss (24:23)

So account obstruction, I mean regardless of intro of account obstruction, it gives you a lot of new powerful tools but also a lot of a lot of risk. Like for example now you have on chain code that manages your assets. It's your, it's your account. But if there's a bug in your account then of course there's risk. But it's not that it's riskier, it's different kinds of risk. Because, for example, with an eoa, with an eoa, you could lose your key or someone could steal your keys, or if you lose your key, you lose your asset. If you, if someone steals your key, they have full control over your account. Now, with account obstruction, it can be more nuanced. You can apply access controls like, you can have spending limits, can have different keys for different operations. You can have session keys that are temporary. So account obstruction improves your security in many ways, but you need the contract to be, well, audited. So of course, don't go use. Put your asset in an account that you don't. An account that you don't trust. I mean, you should check that it's been audited. But once you have that, the security advantages, in my opinion, fall outweigh the far. Weighing the, the risks. And at some point we'll have to get there anyway because of things like quantum resistance, because Ethereum enshrines ecdsa. But ECDSA is not a quantum, is not a quantum safe. So at some point we're going to have to switch to other signature schemes. With account obstruction, you can implement any scheme. So this allows us to start migrating accounts to a, to different schemes. So that's a bullet we'll have to bite in any case.

Podcast Host (25:58)

Okay, and so in order to implement this, is this something where each chain has to individually integrate it or. No, no.

Marissa Posner (26:07)

Okay, yeah, Explain how that works.

Yoav Weiss (26:09)

Okay. You want to answer?

Marissa Posner (26:10)

Sure, yeah. So EIL works out of the box on all EVM chains that settle to the L1. So. No, a chain doesn't have to implement anything, actually.

Podcast Host (26:23)

Oh, it's sort of like I, I in the blog post they talked about it being similar to HTTP. So can you explain? Yeah, just.

Yoav Weiss (26:31)

Oh, yeah, yeah, that's a. So, yeah, that's a different analogy because, I mean, but just to answer the question first. Yeah. So EVM is, it's. Any EVM chain can use it because it's just a smart contract. EAL is a set of smart contracts which you can just deploy. It's permissionless. Anyone can deploy it on any chain. You don't need the team that manages the chain today.

Marissa Posner (26:53)

Currently it's deployed on testnet. So we're on Sepolia Arbitrum, Sepolia Base, Sepolia and Optimism. Sepolia.

Yoav Weiss (26:59)

Yeah, that's an important distinction to make. There's not a. We are not, we are nowhere near mainnet yet. It's, it's A testnet. It's testnet grade right now and we let people start experimenting and integrating, but it's not launched officially yet. Now, the HTTP analogy, that's something I like to use. I mean, being old enough to have used the Internet before the mid-90s, I know that. I mean, Ethereum feels a lot like the pre HTTP Internet. So before HTTP we had the Internet and it wasn't very usable. I could telnet to a server and I could telnet to a server and run commands, I could FTP to a server to download a file, could IRC to yet another server and chat with my friends. We had all of this, but the friction of switching between them. I mean, each application was an island, which each server was an island. And all of these use cases required talking to a single server. So I have one server where I download files, but I don't have any usability like chatting with people there. And the friction of moving between them was actually closing one application on a computer, starting another one, authenticating myself to yet another server. And this is what Ethereum feels like when you move between L2s right now. Now what changed it and made the Internet what it is today is the web. This is HTTP. So with the HTTP protocol you can have an application that spans across multiple servers. You can have like load the HTML from one place, the images from another, JavaScript code from yet another, and even have things like managing your identity on another server, like authenticating to one server to use an application or another. So you have your data in one place and you can have a secure payment server. So now E commerce becomes possible. All of this composability made it possible for developers not to reinvent the wheel, but to reuse existing services and build upon them. And what we're thinking is that EIL can do the same for Ethereum, because once you can easily compose with one operation that feels like making one transaction, you can actually use app chains and like you can combine different app chains to achieve one result, then it opens up all this design space, which is what HTTP did for the Internet. So that's where I'm interesting.

Podcast Host (29:18)

But it's only for L2s, right? Like, because there's so many EVM chains that are layer ones, but it won't work for them, right?

Yoav Weiss (29:25)

Yeah, because that. So one trust the assumption in order to avoid trusting an oracle, you need to have a single shared source of truth. And Ethereum has that. In ethereum we have L1, which acts as a. I mean everyone settles to Ethereum. So ultimately you have a way to settle any disputes. There is only one truth. Once you have alt L1s, now you need some intermediary to tell you the state of this L1 is that and you have to trust that someone. There is no way to prove it on chain. Like you can vote on it or you can. But we chose not to have these trust assumptions but Instead to use L1 for any resolution.

Podcast Host (30:09)

Okay, so what types of transactions do you think will use EIL and what types of new behaviors will emerge from its implementation?

Marissa Posner (30:21)

Yeah, I think we're really excited to see what people are going to build. There are so many different use cases. So today we came out, we demoed our demo app Stytch that lets you do cross chain composable transactions using Ethereum interop layer. And some of those examples could be like I could lend 100 USDC to AAVE and then I could bet yes on a specific prediction market in limitless. And all of these are on chain things. I can then batch them like I could batch five different actions into one. I could even like, let's say I want to like swap 100usdc to eat and then like stake it for example. But I don't know how much eth I'm going to get back right like this value because like the, the rate might change. It's kind of a dynamic value. But then I'm staking that result so I can chain all of these things and the like primitives that you can build on or like what you could build on top of these primitives is a really like interesting concept and I think we're excited to see that. I think, I don't know that like at the beginning of like HTTP, like if people could even conceptualize what the Internet is today. And so I think we're really looking forward to what people are going to build.

Podcast Host (31:24)

And what are examples of transactions that it wouldn't make sense to use EIL for?

Marissa Posner (31:29)

Yes, that's a great question. So for EIL is perfect for single user transactions. When you have a case of multiparty. When you need multiple people, such as like Cal Swap for example, you need multiple users like in the same transaction. EIL isn't the best fit for that or is not a fit for that at all because EIL is just a single user and there's no intermediary or like AMM in the middle.

Yoav Weiss (31:55)

Yeah, I will say that any, any case where there is information asymmetry inherited to the use case, such as the example of cowswaps where someone has an order book and you as a user do not have that same level of information. This is where intents excel. So with intents you can talk to someone who has more information than you like knowing about the entire order book and they can match you with counterparties and get your best deal. But as long as you know exactly what you want to do and you have all the information, you don't need to trust a remote server. There's no need to go to a cloud server and add this dependency. If you have all the information, just do it on your own computer. And I think just this morning we had this. I don't know if you noticed that, I mean many things here were not working because of, because Cloudflare had an outage. Now the notion that you're unable to access your crypto because Cloudflare is down, it doesn't make sense to me. I mean that's not why we are building Ethereum. So for any use case where you can operate locally on your own computer without adding intermediary, I think you should.

Podcast Host (33:07)

Okay, so I did also want to ask. Oh just when you talked about how this is going to be a wallet level capability instead of like an app by app integration, you know what, what do you think that unlocks like why is that significant?

Marissa Posner (33:25)

Yeah, I guess just to clarify. So apps, apps can integrate EIL as well, but when we call it wallet based Interop because like the interop itself, like what the moving of money is occurring in within the user's wallet at the, with the user itself. Wait, sorry, what was the rest of your question?

Podcast Host (33:44)

Oh, just like why is that significant? I don't know if it will like unlock new behaviors or just make certain things possible that aren't possible now.

Yoav Weiss (33:53)

Yeah so and I would say that if we go back to the HTTP analogy, the Wallet is your browser. And what made a browser special is before that we had an application for, we had an application for each use case but then with the browser you have, the browser is much, much more complex than these applications. It's basically an operating system and this is the only thing you need as a user. I mean how, how much, how much work do you do outside your browser? Nowadays your browser is one app with infinite use cases and it just, it does everything you need. And I think the Wallet can become the browser. We empower the wallet to not need, to not need any, not have dependencies on any third parties. And now the wallet itself can, now the wallet itself can run any multi chain, can any multi chain operation no matter how complex and the way it works for DAPPS is. So now the application, the application doesn't need to know much about eil, it just needs to tell the wallet. Here are the calls I want to execute on Optimism and then I want to execute this on Arbitrum and I want to move the tokens that resulted from this call to that call on the other chain. And so the DAPP only needs to communicate that not knowing how it's going to work and the wallet is going to figure it out for you. So that's the. So by empowering the wallet you enable all of these applications. Because now, now the application doesn't need to worry about plumbing. Currently applications have a lot of plumbing work to do for Interop. Yeah. Instead just tell the wallet and let the wallet figure it out.

Marissa Posner (35:24)

Yeah, this part of the like, bigger vision I would say with like the Interop standards plus eil, like allowing for I guess the greater discoverability and like letting the wallet power a lot of the things on chain. It also one additional benefit is that it kind of reduces the attack vector when you're not depending on so many different types of intermediaries. You've now reduced the scope and now if, when you concentrate a lot in the wallet side of things like with the user, it's much easier to add I guess, verification and to check things like I was talking about with like light client contracts earlier to verify the RPC calls and to standardize things around the wallets. There's a lot of standardization work going on about that.

Podcast Host (36:02)

Okay, and so earlier you mentioned that right now you're on testnet. So what is the timeline for?

Marissa Posner (36:08)

Yeah, well, we don't want to commit to a timeline, but we are currently released all of the protocol docs to the public today. There's an eth research post up that people can check out and the code is also I think going live later. So people can we encourage people to build on EIL to test it out? We want to test out. There's a lot of crypto economic guarantees and mechanisms behind it. So we just want to make sure that those are solid before releasing to Mainnet. So yes, I would say sometime in 2026 is when we will go to Mainnet.

Yoav Weiss (36:44)

But in the meantime people can start experimenting since the code is out there and it's both on testnet. And we have this, we have a setup based on a mainnet forks of various rollups so you can actually try it out with existing protocols without risking funds. And we want to see what people start Building and get feedback. And maybe this feedback will also make EIL better. Maybe we can learn from this feedback. So, for example, so we're going to offer prizes at ETH Global later this week and we want to see what people build on this network on these mainnet forks that are now live so people can start building and telling us how it's going and we learn from it. And this will take us closer to mainnet. Then we need to get an audit, of course, as security is important here and then mainnet.

Marissa Posner (37:36)

Yeah.

Podcast Host (37:36)

Okay, so once it's implemented, how do you think it will impact activity on Ethereum?

Marissa Posner (37:43)

Oh, I think it's going to completely change activity actually. Because the moment that you remove the concept of what a chain is from the what a chain is, what a bridge is, like what gas fees are, you've just made it so much easier to transact on chain and you've removed so much friction. So by removing this friction you've like opened the floodgates, I would say to like a whole new set of like use cases. Like, I know there's been times where I've wanted to do things on chain. I'm like, oh, to bridge and then swap. And I'm like, okay, never mind. I'm like, I don't need to do that. But if I could just click with one button like sign this transaction and all of that would move at once, like I would have made many more transactions. So we are just hoping that other users agree with this and do the same in the future.

Yoav Weiss (38:23)

I think it also unlocks. I mean, since before rollups you were able to make transactions on Ethereum the same way because it was one chain but you did not have enough block space. And we all remember paying insane gas fees. So not many use cases were possible because we were just outpriced. Any application that is not financial in nature was outpriced on Ethereum and moved to maybe to alt chains. Now rollups made it. Rollups made abundant block space but on each rollup separately. So now you could not compose it. Now what we are doing here is it unlocks it by having abundant block space but also being able to use it like a single chain. And that's the unlock we expect to see. I don't know what use cases we'll see, but I'm excited to find out.

Podcast Host (39:19)

Well, in my head it sort of feels like this is going to supercharge defi because it's like the whole little money legos thing that sort of temporarily became not fully possible. The Composability now, if it works correctly, will actually come to fruition.

Yoav Weiss (39:37)

Yeah, that's correct. But something that I have to like. I mean, if I'm allowed to get a bit technical. There is one distinction to make here, that you'll be able to make seamless transactions that use multiple protocols, like swap in one place, then stake it in another chain. But you are not able to make synchronous calls from a chain, from a contract on one chain to another. That's not possible due to finale to L2 finality, which is not. You don't have this in sync. So it's not that contracts themselves can become composable. Like, you know, it's like having one, like having one protocol make direct calls to the contract on another. That doesn't become possible with EIL and not with any other protocol right now. But what becomes possible is that you can combine them in a single user flow.

Podcast Host (40:28)

Oh yeah, yeah.

Marissa Posner (40:30)

And technically, I guess on the back end. Just to clarify, for anyone listening, that means that while I as the end user, I am signing one transaction in the backend. Like what is happening is a transaction. Let's say I'm going from base to optimism. There's a transaction sent to base and a transaction sent to optimism. But I as the user do not see that, nor feel that.

Podcast Host (40:51)

Okay, okay, yeah, I'm just thinking. So it'll be one user flow. But essentially what I'm thinking about is, do you remember, I guess this was like in the 2020 era when we would see these crazy hacks where they just combine so many transactions in one block. And I don't remember all the attacks, but some of them may be like, also did some economic manipulation. And anyway, point is. So this will not enable that type of behavior again, right? Because if, if, if each chain like still has to have its own finality for each step, then you can't just like string together a bunch of transactions in one block that enable somebody to steal a bunch of money.

Marissa Posner (41:39)

Is that.

Yoav Weiss (41:41)

So? If I understand correctly, I mean there is. You do have the finality risk of each of these chains. So yeah, when, when you're interacting across, across multiple chains. And if one of these chains, for example, has, if one of these chains reorgs and then like it undoes some part of your transaction, you are exposed to it, there's no way around it because urm. I mean, you have to trust the chains you use and the operation is always as weak as the weakest link. So let's say you have, you are using in the same operation, you are using three different chains and one of these chains, one of these chains is not as good as the other ones and something bad happens there. So you should be aware and let's say you don't want to, at the end of the operation, try not to leave your funds on that chain so you don't have exposure for. I mean, after you move your funds out, you don't have exposure because now your funds are in the, at the destination. But if your destination, like if your funds land that land on a chain that where it's not safe, then EIR is not going to protect you. It is as weak as the weakest chain that you are using for this transaction. Yeah, I don't know if that's what you meant, but that's the. I mean.

Podcast Host (43:01)

Okay. Yeah, I guess, I guess what I'm realizing is I do think though it will like increase the attack surface area to some extent or.

Yoav Weiss (43:10)

No, I don't see how it's. We are not. Since we are not introducing new trust assumptions. Just. I mean if you, if you're going to use this network, then using it with EAL does not increase your risk. It's. You are still. You would be transact. I mean, if you, if you breached your asset to this network, it is strictly worse because now you trust the bridge, you trust the bridge operator and you trust the network. With ein, we remove the bridge operator, you still trust the network you are going to execute the call on.

Podcast Host (43:39)

Right, Right. But actually what I'm talking about is more the composability of different smart contracts on different chains. Like if you're combining them in different ways. So I'm not talking about the bridge itself, you mean using things.

Yoav Weiss (43:51)

So since we are not, since we are not actually adding composability between contracts, the composability happens at the wallet. So like, it's not like it's. Let's say I'm swapping in Uniswap on one chain and then like putting the resulting funds in AAVE on another. So it's not that we added composability between AAVE on one chain and Uniswap on the other. They don't trust each other and they could not affect each other. The user just created with this one flow, this single signature operation where initially did something on Uniswap, then took the resulting tokens to and deposited it to AAVE on the other chain. But now if something bad happens on one of these chains, let's say one of these contact get hacked it does not affect the contract on the other. Because even if we wanted to, we could not introduce dependencies between this contract everything. This composability happens at the wallet and it only affects the operation for that current user at that current time.

Podcast Host (44:54)

Okay.

Yoav Weiss (44:54)

Yeah.

Podcast Host (44:55)

Okay. Well, so you know, as we just mentioned, so bridges are some of the least secure aspects of crypto infrastructure. So do you feel like now multi chain transactions will just become inherently more secure? But then also what does it mean for the bridges? Like are. Do you expect that they'll continue or.

Marissa Posner (45:15)

I mean I think canonical bridges definitely still have a place we use canonical bridges. So I think it depends on like what type of bridge. I think that yes, there's a lot of trust assumptions in bridges these days and we would hope that people would migrate towards safer ways of moving money across chain and we hope that EIL enables that.

Yoav Weiss (45:39)

So yeah, I would say that with bridges, so not all bridges are created equal. You have the canonical bridges that are as safe as the underlying chain because in rollups the bridge is a part of the rollup. And then you have bridges, you have some bridges that have some proof mechanisms. And the worst kind is the kind where you don't have any and you just send funds to an operator. Now the problem right now is that they are not held accountable. So users just pick the cheapest one. They pick the cheapest one and it gets obstructed away. They don't even realize that it's riskier. And the way to fix that is with something like L2BIT. That also gives you like a. It gives you the information. It says, yeah, if you're going to use this bridge, this is the risk you are taking. And just today, so Bartek from L2BIT, we have the trustless event and Bartek just gave a talk where he presented this new framework they're working on which will do. They're going to do for Interop what they did for L2s. With L2s, you know that this L2 is a. So let's say this one is a stage 2 or stage 1 and this other L2 is like stage 0 or worse. So, so now you get, you get this red warning telling you, no, this actually you are going. You are using a chain that is not as safe. And we want the same for Interop protocols, we want the same for bridges. If you're going to send funds with something insecure, maybe you're okay with it because it's just $10, but you should at least be aware because if it's $100,000. Maybe you should reconsider. So the user should be able to make an informed choice. And L2BIT is going to help with that.

Marissa Posner (47:14)

Yeah.

Podcast Host (47:15)

Okay, great. Is there anything that I didn't ask you that you feel we should mention in this pod?

Marissa Posner (47:23)

I don't know if you want to talk about the Trustless Manifesto at all.

Podcast Host (47:26)

Oh yeah, yeah, talk about that.

Marissa Posner (47:28)

You.

Podcast Host (47:28)

You talked about how or you wrote about how the manifesto was like infusing or you're infusing the values of it into this implementation. So.

Laura Shin (47:36)

Yeah, explain that.

Marissa Posner (47:38)

Yeah, I think that we wrote the Trustless Manifesto because we felt that it was. We were, we were looking at all these like, interop protocols and we were just seeing all of these crazy trust assumptions and we wrote the manifesto to kind of bring people back and remind people of Ethereum's values and kind of what Ethereum stands for. You know, I think that we wanted to lay out the groundwork with like, rules for the road, like laws that people have to abide by and like, what builders should be doing in order to build trust, the systems and like, how they should be letting their users know of those, like, trust assumptions. And I think, you know, we kind of. The Trust Manifesto was a largely inspirational piece. I think, like, at least in the past few days I've been thinking a lot about like, okay, what is the action oriented thing that we can give builders going forward? And that's not something that we've written yet. But I do think that like, I guess giving builders some more type of guide of how to concretely implement recommendations to improve trustlessness within their systems is something that, like, would be very helpful going forward.

Podcast Host (48:43)

All right, well, it's been such a pleasure having you both on Unchained. Thanks so much.

Marissa Posner (48:48)

Thanks for.

Laura Shin (48:51)

Unchained is produced by Laura Shin, with help from Juan Aranovich, Margaret Curia and Pam Majumdar. Thanks for listening.