yoav.eth

804 posts

yoav.eth

yoav.eth

@yoavw

Katılım Mayıs 2009
75 Takip Edilen4.8K Takipçiler
yoav.eth retweetledi
bartek.eth
bartek.eth@bkiepuszewski·
It's increasingly clear that L2BEAT's future is ANYBEAT. Looking for a good new name for the only trusted source of truth regarding public blockchains, not just ETH L2s. Even more needed in the AI era where virtually all news you consume are AI generated
donnoh.eth 💗@donnoh_eth

English
11
1
89
10.5K
yoav.eth retweetledi
L2BEAT 💗
L2BEAT 💗@l2beat·
The Ethereum Foundation’s new Mandate is the right document at the right time. The core argument is very simple: self-sovereignty only counts if it's real. The commitment to CROPS (the principles that made Ethereum credible in the first place and the same principles we prioritize in our assessments) does not define a specific roadmap, it defines the values of the foundation, a cultural North Star. Whatever direction Ethereum's development takes, these principles don't get traded away. We also value EF’s commitment to the "walkaway test" - striving to make itself less necessary over time so the protocol remains decentralized. We believe Ethereum’s strength lies in this shared commitment to an open, neutral, and resilient commons. And we’re proud to be fellow travelers in building this machinery of freedom!
Ethereum Foundation@ethereumfndn

Today, the Foundation’s Board released the EF Mandate. This document, which was first intended for EF members, reaffirms the promise of Ethereum, and the role of EF within this ecosystem.

English
0
7
39
2.6K
yoav.eth
yoav.eth@yoavw·
@khamenei_ir How's life in the bunker treating you? One day you'll hear a buzzing sound from above, then... Nothing
English
1
0
1
145
Khamenei.ir
Khamenei.ir@khamenei_ir·
Today, our enemy, the Zionist regime, is the most despised regime in the world.
English
1.3K
4.9K
38.6K
993.1K
yoav.eth retweetledi
sudo rm -rf --no-preserve-root /
sudo rm -rf --no-preserve-root /@pcaversaccio·
guys, writing _simple_ software is becoming a true lost art. We are all so fucking addicted to dependency bloated, hyper composable Frankenstein systems where every tiny diff triggers a transitive verification nightmare. Oh and we keep pretending abstraction is free. Well guess what it is fucking NOT. Every layer introduces more state, more edge cases, more undefined behaviour, and more emergent interactions that nobody really fully models. Remember: observability decreases as indirection increases. I mean, formal reasoning effectively collapses when the effective system boundary is the entire ecosystem. Oh and then you guys vibe code even more dependency stuffed software and implicitly feed it back into the same LLM, great. Can we stop this insanity for a second? Fewer dependencies (or even better _no_ dependencies). Smaller trusted computing base. Deterministic builds. Reproducibility. Code you can actually read, reason about, and audit e2e. Simplicity is not nostalgia. It is the only thing standing between us and a fucking systemic collapse.
English
22
33
234
10.7K
yoav.eth
yoav.eth@yoavw·
I’ve worked with Bastian for years. He’s a thoughtful, principled strategist who seeks to understand and truly cares about Ethereum’s long-term success. After years quietly solving hard problems behind the scenes, it’s great to see him step forward. Excited for what’s ahead.
Aerugo@aerugoettinea

I am stepping into the role of interim co-ED @ethereumfndn to continue the progress that Tomasz has made over the last year. Tomasz brought an energy and urgency that the EF needed at a critical time, and I join the community in thanking him for his work on behalf of the Foundation and the network. This task isn't something that I take on lightly, knowing the weight of responsibility of the role through seeing it up close for some time, but it is one that I am prepared to handle. I've served in a management position at the EF over many years, working closely with Hsiao-Wei, Tomasz, Josh Stark, Danny Ryan, Aya, and Vitalik at different points in time. My focus has been deliberately on illegible but essential work, helping management try to make well-informed decisions, working with EF's team leads, considering budgets, articulating strategy, setting priorities, and more. The decisions I make will be guided by a principled insistence on the properties of what we're building (censorship resistance, open source, privacy, security). These properties are what make Ethereum relevant and competitive, and they are the foundation of Ethereum's value proposition to the world and everything the world builds on it; just as Ether is the foundational store-of-value that underpins every transaction across it; and just as both are indispensable to the EF's own treasury. The mandate of the EF is to make sure that real permissionless infrastructure, cypherpunk at its core, is what gets built. Ethereum should outlast us, and it has been our job from the beginning to make sure it is robust enough to do so. I, and the rest of the EF, will work alongside other members of the community - core protocol contributors, researchers and client implementers, auditors and whitehats, incident responders, spec authors, solo stakers and validator operators, node runners, MEV gremlins, rollup and L2 teams, bridge and interoperability integrators, UX and product builders, infra providers and tooling maintainers, educators, community organizers, forum crews, lurkers, and free software advocates, grant-givers and culture-makers, artists, memers, cypherpunks, cyberanarchists, Landian accelerationists, financepunks, femboys, soundcloud rappers, transgenders, disinformationalists, cyborgs, anons, revolutionaries, shitposters, trolls, federal lists, hypebeasts, pirates, preppers, the bros, incels - to make it last 1000 years or more.

English
1
1
42
5.5K
yoav.eth
yoav.eth@yoavw·
Safe module integrates EIL for cross-chain operations. Kudos @heymarcopolox @candidelabs
marc@heymarcopolox

We lost a valued customer last year. They needed chain abstraction. Managing Safe accounts across multiple chains, and the signing overhead was killing their UX. Every key rotation meant six separate ceremonies. Every guardian update, same thing. Their users were drowning in signatures. They asked if we had a solution. We said no. Not because we couldn't build it. Chain abstraction was the 2025 narrative. Everyone was shipping it. We could have done it in weeks. Feature velocity, customer win, done. But every solution we looked at had the same problem: trusted intermediaries. Relayers you had to trust. Wrapped assets. New points of failure. For infrastructure that secures savings, checking accounts and treasuries? No. So we told them we didn't have it. They went with someone else. That one stung. You second guess it. Maybe we're being too pure. Maybe we're just slow. But the teams we work with are building neobanks. Real money, real users. If a relayer goes down, if a bridge gets hacked, it's not our problem to solve. It's their users' funds. We can't sell infrastructure we don't control. Then EIL was announced at Devconnect. I was skeptical at first. But I read @yoavw's post on how EIL work under the hood. L1 as source of truth. Voucher system with economic guarantees. No trusted relayers. No new intermediaries. It clicked. Suddenly we had a way to build chain abstraction without compromising on what matters. So we built Safe Unified Account. Here's what it does: • Sign once for operations across multiple L2s (Merkle proof verification) • Atomic cross-chain via EIL integration (L1-anchored, not trust-based) • No bridges, no relayers, pure cryptographic verification The flow: 1. Construct UserOps for each chain 2. Arrange in Merkle tree 3. Sign root once 4. Submit with proofs to bundlers 5. Each chain verifies independently For atomic operations, EIL's voucher system provides economic guarantees through XLP staking/slashing. Same signed voucher that claims funds on source releases funds on destination. Guaranteed by L1, not by trust. The module is feature complete. Audit pending. We're sharing now to get feedback before we lock it down. I don't know if we'll get that customer back. Maybe they're happy with what they chose. Maybe the trusted relayer approach works fine for them. But I know we can finally offer chain abstraction to the teams building on Safe without asking their users to trust what they shouldn't have to trust. Sometimes saying no is just buying time until you can say yes the right way.

English
1
0
5
615
yoav.eth retweetledi
LI.FI
LI.FI@lifiprotocol·
The Ethereum Interop Layer (EIL) Explained 🎙 Ethereum is pushing toward a UX that feels single-chain. Is the Ethereum Interop Layer (EIL) the missing piece? In our latest episode, @ThewizardofPOS and @yoavw from the Ethereum Foundation break down how lessons from Account Abstraction are being extended to enable trustless multi-chain execution with the EIL. Key timestamps: 00:00 Meet the team working on EIL at the EF 8:20 What is the Ethereum Interop Layer? 16:50 Solvers vs XLPs — the censorship risk in intents 29:05 What EIL means for bridges 32:20 EIL vs OIF: how they fit together 43:00 Mainnet timeline & how builders can get involved
English
7
17
64
10.8K
yoav.eth retweetledi
bartek.eth
bartek.eth@bkiepuszewski·
> Our job should be to make it clear to users what guarantees they have, and to build up the strongest Ethereum that we can The market is changing but the original mission of @l2beat is the same. We will keep the projects accountable with ever-expanding scope. Today L2s, tomorrow interop and in the future, hopefully, all DeFi and token issuers
vitalik.eth@VitalikButerin

There have recently been some discussions on the ongoing role of L2s in the Ethereum ecosystem, especially in the face of two facts: * L2s' progress to stage 2 (and, secondarily, on interop) has been far slower and more difficult than originally expected * L1 itself is scaling, fees are very low, and gaslimits are projected to increase greatly in 2026 Both of these facts, for their own separate reasons, mean that the original vision of L2s and their role in Ethereum no longer makes sense, and we need a new path. First, let us recap the original vision. Ethereum needs to scale. The definition of "Ethereum scaling" is the existence of large quantities of block space that is backed by the full faith and credit of Ethereum - that is, block space where, if you do things (including with ETH) inside that block space, your activities are guaranteed to be valid, uncensored, unreverted, untouched, as long as Ethereum itself functions. If you create a 10000 TPS EVM where its connection to L1 is mediated by a multisig bridge, then you are not scaling Ethereum. This vision no longer makes sense. L1 does not need L2s to be "branded shards", because L1 is itself scaling. And L2s are not able or willing to satisfy the properties that a true "branded shard" would require. I've even seen at least one explicitly saying that they may never want to go beyond stage 1, not just for technical reasons around ZK-EVM safety, but also because their customers' regulatory needs require them to have ultimate control. This may be doing the right thing for your customers. But it should be obvious that if you are doing this, then you are not "scaling Ethereum" in the sense meant by the rollup-centric roadmap. But that's fine! it's fine because Ethereum itself is now scaling directly on L1, with large planned increases to its gas limit this year and the years ahead. We should stop thinking about L2s as literally being "branded shards" of Ethereum, with the social status and responsibilities that this entails. Instead, we can think of L2s as being a full spectrum, which includes both chains backed by the full faith and credit of Ethereum with various unique properties (eg. not just EVM), as well as a whole array of options at different levels of connection to Ethereum, that each person (or bot) is free to care about or not care about depending on their needs. What would I do today if I were an L2? * Identify a value add other than "scaling". Examples: (i) non-EVM specialized features/VMs around privacy, (ii) efficiency specialized around a particular application, (iii) truly extreme levels of scaling that even a greatly expanded L1 will not do, (iv) a totally different design for non-financial applications, eg. social, identity, AI, (v) ultra-low-latency and other sequencing properties, (vi) maybe built-in oracles or decentralized dispute resolution or other "non-computationally-verifiable" features * Be stage 1 at the minimum (otherwise you really are just a separate L1 with a bridge, and you should just call yourself that) if you're doing things with ETH or other ethereum-issued assets * Support maximum interoperability with Ethereum, though this will differ for each one (eg. what if you're not EVM, or even not financial?) From Ethereum's side, over the past few months I've become more convinced of the value of the native rollup precompile, particuarly once we have enshrined ZK-EVM proofs that we need anyway to scale L1. This is a precompile that verifies a ZK-EVM proof, and it's "part of Ethereum", so (i) it auto-upgrades along with Ethereum, and (ii) if the precompile has a bug, Ethereum will hard-fork to fix the bug. The native rollup precompile would make full, security-council-free, EVM verification accessible. We should spend much more time working out how to design it in such a way that if your L2 is "EVM plus other stuff", then the native rollup precompile would verify the EVM, and you only have to bring your own prover for the "other stuff" (eg. Stylus). This might involve a canonical way of exposing a lookup table between contract call inputs and outputs, and letting you provide your own values to the lookup table (that you would prove separately). This would make it easy to have safe, strong, trustless interoperability with Ethereum. It also enables synchronous composability (see: ethresear.ch/t/combining-pr… and ethresear.ch/t/synchronous-… ). And from there, it's each L2's choice exactly what they want to build. Don't just "extend L1", figure out something new to add. This of course means that some will add things that are trust-dependent, or backdoored, or otherwise insecure; this is unavoidable in a permissionless ecosystem where developers have freedom. Our job should make to make it clear to users what guarantees they have, and to build up the strongest Ethereum that we can.

English
3
3
89
5.1K
yoav.eth retweetledi
Steven Goldfeder
Steven Goldfeder@sgoldfed·
My thoughts on Vitalik's post: 🧵
English
123
146
896
213.7K
yoav.eth retweetledi
thedao.fund
thedao.fund@thedaofund·
TheDAO is back. BULLISH A decade later, we’re opening a new chapter. TheDAO Security Fund: activating 75,000+ ETH to strengthen Ethereum security. thedao.fund
GIF
English
261
258
1.3K
483.3K
yoav.eth retweetledi
gaudenzio.eth
gaudenzio.eth@gaudenzio_eth·
While some shake hands at Davos, others bring uncomfortable truths @VitalikButerin. The World Economic Forum convenes to discuss "rebuilding trust" in institutions. Meanwhile, @yoavw, Vitalik, @ThewizardofPOS answered with The Trustless Manifesto: we shouldn't need to trust at all. trustlessness.eth.limo/general/2025/1… The inconvenient reality: Every centralized system begins with good intentions. Gateways become platforms. Platforms become landlords. Landlords decide who enters and what they do. @ethereum wasn't built to make the old system more efficient. It was built to make it obsolete. The manifesto's message is clear: -Self-sovereignty over delegation -Verification over blind trust -Code over policy -Math over middlemen Trustlessness costs complexity, latency, and mental effort. It buys resilience, longevity, neutrality, and freedom. The drift is already here: Hosted RPCs as defaults. Centralized sequencing. Upgrade keys that never disappear. Cross-chain relayers acting as gatekeepers. Decentralization doesn't die through capture, it erodes through convenience. So yes, I'm at Davos. Not to participate in the theater of "rebuilding trust," but to remind the architects of centralized systems why we're building the alternative. Someone has to be here as well @VitalikButerin Some conversations need to happen in uncomfortable rooms. The world doesn't need more efficient middlemen. It needs fewer reasons to trust them.
gaudenzio.eth tweet media
English
2
4
35
9.1K
yoav.eth retweetledi
bartek.eth
bartek.eth@bkiepuszewski·
In the next few threads, I will do a deep dive into EIL - Ehtereum Interoperabiliy Layer. The protocol allows for trust-minimized cross-chain execution with many interesting use cases and it's worth building intuition around it. This is Part 1 of the explainer 🧵👇
English
16
9
77
6.8K
yoav.eth retweetledi
Marissa Posner
Marissa Posner@ThewizardofPOS·
Ethereum isn’t here to win the average case. It’s here to survive the worst case. Ethereum is forever. That’s why we wrote the trustless manifesto in the first place - to remind people what Ethereum truly stands for @VitalikButerin @yoavw 🚀
vitalik.eth@VitalikButerin

“Ethereum was not created to make finance efficient or apps convenient. It was created to set people free” This was an important - and controversial - line from the Trustless Manifesto ( trustlessness.eth.limo ), and it is worth revisiting it and better understanding what it means. “efficient” and “convenient” have the connotation of improving the average case, in situations where it’s already pretty good. Efficiency is about telling the world's best engineers to put their souls into reducing latency from 473 ms to 368ms, or increasing yields from 4.5% APY to 5.3% APY. Convenience is about people making one click instead of three, and reducing signup times from 1 min to 20 sec. These things can be good to do. But we must do them under the understanding that we will never be as good at this game as the Silicon Valley corporate players. And so the primary underlying game that Ethereum plays must be a different game. What is the game? Resilience. Resilience is the game where it’s not about 4.5% APY vs 5.3% APY - rather, it’s about minimizing the chance that you get -100% APY. Resilience is the game where if you become politically unpopular and get deplatformed, or if a the developers of your application go bankrupt or disappear, or if Cloudflare goes down, or if an internet cyberwar breaks out, your 2000ms latency continues to be 2000ms. Resilience is the game where anyone, anywhere in the world will be able to access the network and be a first-class participant. Resilience is sovereignty. Not sovereignty in the sense of lobbying to become a UN member state and shaking hands at Davos in two weeks, but sovereignty in the sense that people talk about "digital sovereignty" or "food sovereignty" - aggressively reducing your vulnerabilities to external dependencies that can be taken away from you on a whim. This is the sense in which the world computer can be sovereign, and in doing so make its users also sovereign. This baseline is what enables interdependence as equals, and not as vassals of corporate overlords thousands of kilometers away. This is the game that Ethereum is suited to win, and it delivers a type of value that, in our increasingly unstable world, a lot of people are going to need. The fundamental DNA of web2 consumer tech is not suited to resilience. The fundamental DNA of _finance_ often spends considerable effort on resilience, but it is a very partial form of resilience, good at solving for some types of risks but not others. Blockspace is abundant. Decentralized, permissionless and resilient blockspace is not. Ethereum must first and foremost be decentralized, permissionless and resilient block space - and then make that abundant.

English
5
7
54
2.3K
yoav.eth retweetledi
vitalik.eth
vitalik.eth@VitalikButerin·
“Ethereum was not created to make finance efficient or apps convenient. It was created to set people free” This was an important - and controversial - line from the Trustless Manifesto ( trustlessness.eth.limo ), and it is worth revisiting it and better understanding what it means. “efficient” and “convenient” have the connotation of improving the average case, in situations where it’s already pretty good. Efficiency is about telling the world's best engineers to put their souls into reducing latency from 473 ms to 368ms, or increasing yields from 4.5% APY to 5.3% APY. Convenience is about people making one click instead of three, and reducing signup times from 1 min to 20 sec. These things can be good to do. But we must do them under the understanding that we will never be as good at this game as the Silicon Valley corporate players. And so the primary underlying game that Ethereum plays must be a different game. What is the game? Resilience. Resilience is the game where it’s not about 4.5% APY vs 5.3% APY - rather, it’s about minimizing the chance that you get -100% APY. Resilience is the game where if you become politically unpopular and get deplatformed, or if a the developers of your application go bankrupt or disappear, or if Cloudflare goes down, or if an internet cyberwar breaks out, your 2000ms latency continues to be 2000ms. Resilience is the game where anyone, anywhere in the world will be able to access the network and be a first-class participant. Resilience is sovereignty. Not sovereignty in the sense of lobbying to become a UN member state and shaking hands at Davos in two weeks, but sovereignty in the sense that people talk about "digital sovereignty" or "food sovereignty" - aggressively reducing your vulnerabilities to external dependencies that can be taken away from you on a whim. This is the sense in which the world computer can be sovereign, and in doing so make its users also sovereign. This baseline is what enables interdependence as equals, and not as vassals of corporate overlords thousands of kilometers away. This is the game that Ethereum is suited to win, and it delivers a type of value that, in our increasingly unstable world, a lot of people are going to need. The fundamental DNA of web2 consumer tech is not suited to resilience. The fundamental DNA of _finance_ often spends considerable effort on resilience, but it is a very partial form of resilience, good at solving for some types of risks but not others. Blockspace is abundant. Decentralized, permissionless and resilient blockspace is not. Ethereum must first and foremost be decentralized, permissionless and resilient block space - and then make that abundant.
English
1.2K
1.3K
7.2K
1.1M
yoav.eth
yoav.eth@yoavw·
Having to pay someone to run a bundler highlights a problem that has been annoying me for a long time. Bundlers are meant to live in a mempool, yet most of them don't offer a free way to send UserOps to the AA mempool. We recently gave a grant for launching a free (fair-use policy) RPC, to propagate UserOps to the mempool where any bundler can include them. You shouldn't need to pay a bundler any more than you need to pay a node operator for sending transactions. In an ideal world you wouldn't even need that RPC, and would be able to send transactions directly to the p2p mempool from your wallet/browser. Unfortunately there have been some technical challenges in the past, but I hope our p2p team will figure this out. Centralized RPCs hinder robustness, whether they're nodes or bundlers. As for separate account address for 4337, not if you use it with 7702. In fact 7702 is designed specifically to work well with 4337 so that it can use the AA mempool for transactions that require gas abstraction or custom validation. It's the successor of 3074 which served similar purposes but wasn't 4337 compatible. I think the most popular 7702 delegate implementations are 4337 compatible, e.g. metamask's. Re USDC<->DAI, I agree it's roughly the same situation. With similarly-priced assets, whether it's ARB<->ARB or USDC<->DAI, an XLP would treat them as the same and use the fee auction to account for the minor price fluctuations. Unreasonable risks - UX shouldn't have been a trade off. We can make it seamless AND trustless at the same time by removing intermediaries and introducing clear signing (where the wallet presents the entire operation in terms that the user easily understands, not by showing a set of function names and args). Re a 7702+4337 implementation that has session auths, I think there are some good options out there, e.g. @zerodev_app They already built it so you don't have to.
English
2
0
2
277
Noah Litvin
Noah Litvin@noahlitvin·
* Yea I think we're on the same page about the tokens, if the fee/auction is pricing L1 ARB -> L2 ARB and we understand them to be different tokens, the protocol might as well be designed for L1 USDC -> L2 DAI * Of course we don't want "the wallet transacting on the users behalf" - basically none of them do this? But I think those are sort of minor points. I'm just trying to convey how bad the devex is currently to help make sure this solves real problems. * People are taking what are to you unreasonable risks because the metamask ux is so bad. Go open an ETH long on hyperliquid right now to see what users prefer. * My team is currently trying to build a sessions implementation superior to that. If we use 4337, we get the weird separate smart account address and I need to pay someone to run a bundler. I'm actually waiting for a service provider right now (who doesn't even accept crypto payments) to deploy a bundler for an appchain. * 7702 sounds better but it isn't supported by rabby, hardware wallets, etc. And metamask uses their proprietary DeleGator contract, who knows what others will do, so an app will need awareness of every slightly-different future 7702 wallet implementation for sessions? I'd like to be wrong about this, but it seems like waiting on the bundler is our only path forward? The best real fix I can think of, as I put in my thread linked above, is to build a browser extension where its scope is simply a UI for a specific smart account impl for 7702 session auths. Then getting to feature parity with metamask for 'transaction verification mode' shouldn't take too long after that. It could be fully backwards compatible with all existing dapps. Hardware wallets still would need to add 7702 signing support afaik? I thought the auth was intentionally impossible with a 712 signature. I would love to design this and have claude build it, but unfortunately very busy at the moment... lol Here is an alt-l1's marketing material for "being able to log in" It's embarrassing for the entire industry tbh x.com/fogo/status/20…
English
1
0
0
54
L2BEAT 💗
L2BEAT 💗@l2beat·
At DevConnect Buenos Aires, the details of EIL @ethinteroplayer - Ethereum Interoperability Layer were unveiled. We’ve been deep-diving interop protocols for months and our initial assessment of EIL contracts (deployed on testnets already) is following 🧵👇
L2BEAT 💗 tweet media
English
57
81
334
98.6K
yoav.eth
yoav.eth@yoavw·
Thanks. All the speakers at @trustlessconf got these outfits 😎 Agreed re tokens on diff chains not being the same assets. EIL doesn't fix that, the user+XLP just use whatever representation is available and implicitly agree on a fee to account for the diff. More responsibility at the wallet - that's actually the core principle in EIL, not an implementation detail. We started from the requirement that no intermediaries will transact on the user's behalf, and that the wallet will be the user's agent. The rest is a result of that requirement. If you have to trust an intermediary with your funds and it's not trustless, wouldn't you want this intermediary to at least be regulated? I trust my bank more than I trust a solver, because the bank is regulated. EIL makes the interaction trustless so that the user is safe without a regulator. Blind-signing a session and then never signing transactions, sound like a risky proposition that should be discouraged. You could do the same with EIL if you want, by using session keys (there are some popular 4337 based implementations). If your account allows a session key to do anything, then all EIL interactions can happen without user involvement. Personally I wouldn't use this with an account that holds any nontrivial amount. An even simpler way you could use is by signing EIL's ephemeral key and modify the account to allow this key to execute arbitrary calls. Then you can cache this EK in the browser and include sig(EK) in every UserOp on every chain. Multichain session key without ever storing it in the account itself. Bundlers are the 4337 equivalent of block builders. They were never meant to be used in a centralized way although nothing stops them from operating that way. They're meant to work as a mempool (@yoav/unified-erc-4337-mempool" target="_blank" rel="nofollow noopener">notes.ethereum.org/@yoav/unified-…) and later EIP-7701 completely removes bundlers and shifts AA transactions to the block builder. It'll be as decentralized as the underlying chain. If the chain has decentralized block building, EIL will be as well. If the network uses a single sequencer, EIL can't be more decentralized than that.
English
1
0
1
74
Noah Litvin
Noah Litvin@noahlitvin·
Gotcha, love the outfit in the video. The original thread threw me a little since it seemed like the emphasis was "omnichain token UX"/bridging more than gas abstraction. A couple high-level points * Practically, tokens on different chains are not "the same asset" even if they have the same ticker and a canonical bridge integration. * I still don't think putting any more responsibility at the wallet level is a great idea. There's high-switching cost (psychological) for users and I assume the incumbents are going to continue to prioritize value capture. I want a wallet that's an authenticator and transaction verifier, not a browser. Trading perps inside of rabby is AOL energy in a bad way. FWIW, I'm currently building an app that would benefit from better interop. * People hate verifying and signing transactions. Hyperliquid's UX is praised because you blind sign a session that never expires and then never think about it again. * Ideally we could have configurable/cross-chain sessions, leveraging 7702/4337, that we don't blind sign. Wallets could build this today afaik? * If users have sessions enabled across chains, the UX can be as seamless as possible. If there's a multichain op that fails on the second leg, app-specific logic can recover, etc. Another general gripe is that app devs are expected to pay for a SaaS to run a bundler, which is then scoped their specific app. And all of the bundler infra is made for blockchains when it's generally used with centralized sequencers (which could just receive a eth_sendRawTransactionSync and charge for gas/inclusion however they want). Feels like most of thinking around 'gas abstraction' happened when we weren't in a <0.1 gwei regime. Normal users expect to have an app-specific account that you log into for a session and has a balance they can fund/withdraw from. They're fine paying transaction fees so long as they aren't unreasonably high because an unrelated protocol is doing an NFT mint. Any transaction verification beyond token transfer previews seems like too much to ask for (from wallet devs and users), so if we can just get a clear session auth UI in wallets, I think we'll be good? x.com/noahlitvin/sta… Just my two cents 😅
English
1
0
0
65
yoav.eth
yoav.eth@yoavw·
Thanks. 7702 is used for setting a 4337 account with multichain support. 5792 is the offchain interface, for the dapp to communicate a batch to the wallet. Bundler based orchestration is not part of EIL and should never be a dependency. Orchestration should be done by the wallet itself - self-execution. Bundlers just listen for UserOps in the mempool and include them (and will be replaced with block builders after 7701). Renaming: token swap (or rather same-token transfer since EIL doesn't support swapping) is a small part of the protocol, and definitely not its goal. EIL is for executing calls. Vouchers are meant primarily to pay for gas on chains where you have no eth. They just so happen to also carry tokens if needed. Looking at EIL as a way to transfer tokens misses the purpose. For token swaps, intents are great. The reason we refer to it as a layer has to do with our "http vision", see youtube.com/watch?v=JlBofR… Slippage, etc. - out of scope for the above reason. EIL is about multichain calls, not token swaps. Canonical bridges - they're only used for fraud proofs when an XLP misbehaves, which should happen... never. That's how the protocol remains trustless, by only depending on L1 and the canonical bridges of the rollups involved. batch dependencies - our SDK tries to help with that, but there's still work to be done. Separating the batches and treating each chain's execution as a separate transaction would break UX. EIL makes it feel like one transaction with one signature. See examples in the ethresearch post. If I want to mint an NFT on Optimism but I only have ETH on Arbitrum and Base, I don't want it to feel like two bridging transactions from Arbitrum and Base and then mint() on Arbiturm. I want it to just be mint() on Arbitrum, and the wallet should transparently bring my ETH from the other chains to enable the call. If a dependency fail, the wallet should try to fail gracefully by undoing transfers where possible (via voucher requests). You're right that the behavior is app specific so it'll involve callbacks in some cases. Better liquidity sources - again different focus. EIL gives you calls with the minimum possible latency. The voucher pays for the gas atomically during execution. If you use a different protocol to transfer eth and then send a transaction, it takes you at least one more block and probably two signatures. If the wallet's goal is to just send assets without a call, it should pick the method with the best price. If it wants seamless UX for multichain calls, EIL will give better performance. Cowswap - that's a very different use case. Cowswap has an orderbook and can match you the best deal for swapping tokens. EIL doesn't have this capability since it's out of scope for call execution. We follow the Unix philosophy: do one thing and do it well. Our one thing is calls, while abstracting gas and asset location. Had we focused on swaps, the protocol would've been different. But I'd love to see someone building a more efficient swap protocol on top of EIL.
YouTube video
YouTube
English
1
1
2
2.1K
Noah Litvin
Noah Litvin@noahlitvin·
ooo I thought this was calling out 7702 instead of 5792 because the idea was a bundler could handle the orchestration Okay - I think I have the picture now, here's some unsolicited feedback from someone who's built a lot of defi, hopefully helpful (glad you're working on this, not trying to be too critical here) * Consider renaming. This is more a cross-chain token swap protocol than 'interop' and it's not a 'layer' in the sense of L1, L2. * Drop same the asset distinction. There's more slippage moving ARB from L1 to L2 than L1 USDC to L2 DAI. Canonical bridge integrations are inconsistent and irrelevant. * Handing off multiple dependent batches of operations to the wallet at once is going to cause huge headaches. If the first batch succeeds/fails, it needs to be communicated back to the app, and these behaviors are going to be very app-specific. * The best we can hope for from metamask rabby etc is clear batch tx signing and session auths. Of course they won't use XLPs if there's another liquidity source that's more mature and will pay them for order flow. They've integrated hyperliquid and polymarket (neither of which even settle to ethereum) before decent 7702/4337/5792 support. * I really like the idea of SDKs/libraries to 'enhance' proposed batches at the app layer. This what we we built for erc7412 (erc7412.github.io). A library that sees a batch needs a certain token to succeed could automatically suggest a swap (crosschain or otherwise), but the app needs awareness/control over this, esp if the user is in a session. The user might prefer to swap out of a different stable than the "same" one on a different chain when they have both. If the fundamental idea is that this is an alternative protocol design to cowswap that further reduces trust assumptions, that's cool, but separate from the UX issue. We just need better batch tx/session support at the wallet level. Maybe that means marketing efforts to have ambire unseat metamask, but that's a very different shape of project.
English
1
0
0
61