[CLS] Ethereum Magicians Infinite Endgames: Block construction

I don't have any slides prepared for this event, but I have some from a past talk that I can use to kind of kick off the discussion. And I think that's more the framing is just to have a conversation with the people here in this room. But yeah, I can tell you a bit about the state of things now in Ethereum with MedBoost and PBS and things like that. And yeah, then maybe that will seed off the conversation and we can go from there. So, yeah.

I guess, uh, one question is just, like, has everyone here heard of MedBoost? Does this mean anything? Yeah? Okay. There's, like, maybe a few nods.

So, anyway, uh, maybe I'll just start from the beginning then. So, we have Ethereum. We all, we all know and love Ethereum. And Ethereum's cool because it lets you send transactions, which can do all sorts of types of things with all these decentralized applications. It turns out that you can basically, you know, craft the blocks of Ethereum in a certain way.

And in this certain way, it turns out that, like, a builder of the block can get more, you get more revenue or profit compared to other ways. We generally call this thing MEV. And point being is this poses a concern for the protocol because, yeah, essentially if you're better at MEV extraction than someone else, then you now kind of have this flywheel where you can reinvest in your operations and you just get bigger and bigger. What this could even look like right now is offering better returns to validators. And then you have this flywheel where like all the stake ends up with you and Ethereum is no longer decentralized.

So this is very bad. And, you know, I think the way we generally think about this in terms of at least protocol research is with PBS. PBS here is Proposer-builder separation. And it's thinking about ways to separate off this building role of these very valuable execution payloads in the protocol from these validators. So what you could imagine is there's this very even light layer of validators that are, again, sort of attesting to the validity of the network, but then you entirely fire off these concerns of this MEV stuff.

And the point here is that even if you do end up with a very centralized builder or block builder world, I mean even nowadays we talk about transaction supply chain, so it's very much professionalizing and operationalizing. Even if that does become more centralized than we would like, you still have this very robust validator set that attests to the truth of the chain. So, is there a question? Oh, sorry. I'll keep going.

So what else is there to say? So PBS, right, I guess from PBS then there's a question of I just killed it. What happened? Oh, my computer went to sleep, sorry. So from PBS, there's a question of, how do you actually implement this?

There's a lot of ways to think about it. You can either do it, I guess, like one high decision point is like, is your PBS on-chain or off-chain? We'll talk about on-chain flavors in a bit. But given that, like an on-chain setting would be a protocol change. It's probably going to take a while to even come to an agreement around what the best way to do this.

And even right now, maybe I'll talk about this in a little bit, but even right now, there's still, like, big open questions around the best way to do PBS in the protocol. So what can we do? Well, in the meantime, we can essentially do PBS off-chain, and the implementation we have that has the most adoption at this point in time is MedBoost. And I think that'll tee me up for these slides. So the way you can think about this working is that it's almost this, like, rendezvous service between, again, builders and proposers.

So these proposers, you know, as you go to, like, validate the chain as a validator, you then also have the opportunity every so often to propose a block. This is building the consensus block, and then also this execution payload. And now this is where the PBS comes in, as you can think about carving off the task of building this execution payload, the execution part of the block where all this juicy MEV is, and handing it off to someone else. And MevBoost, again, is a software stack and a protocol that implements this. And one way to think about it is, yeah, you have this green sort of rectangle over here is the execution payload.

The gold is meant to represent the MEV around it because it's this nice money everyone likes to fight over. And then you have this blue block on the right, and this is the consensus block that the proposer wants to, you know, send to the network. And the question now is, like, how do you have, like, this, you know, secure exchange between these two parties who might not trust each other, and in fact we don't want them to trust each other. Because otherwise, again, you kind of fall back to the status quo I was talking about, or not the status quo, but, you know, a failure mode, I was talking about a minute ago where you have a very small validator set that all works with these one or two builders and things like this. So in any case, we now have to think about how to get this block, the extrusion payload into the block and make this all work well.

And at a high level, the way to think about MedBoost today is that it's like this commit reveal protocol, meaning you like commit to something and then once you've committed to it, it's, you know, the person committing now is the proposer, but once they've committed to it, then the builder is free to like release their block with no worries. And, you know, diagrammatically, you can imagine that the builder then has their like nice, nice screen execution payload. It has, like, some juicy MEV with a gold border. And then the, like, shaded thing on top of it is meant to represent that it's blinded. And the reason why you want this is because if the builder sends the payload unclear, then the proposer basically could, like, copy the builder's work, take all the sort of, you know, rewards from that work for themselves, and the builder would be unhappy.

What this means then is that the mechanism itself is not sound, and then no one would use it, and it would be bad. Because proposers would just fall back to, like, these backroom deals and God knows what. So the way to get around this is basically you need some way for the proposer to commit to the block. This is the commit step, and so they get a blinded payload, which goes into the block. The way this works is that, you know, sort of like zooming away into the details, the proposer signs over this block in a compatible way with what's actually the thing that ends up on chain.

And, yeah, basically they do this, and then they can show the builder kind of as proof that, like, they've committed to this particular payload, say including one that pays the builder for their work. And then once the builder sees that, they can release it to the wild. And this bottom right square is what would go on chain. And yeah, so the thing to consider here is this sort of mev stealing issue that I was just trying to describe. You can imagine that there's a block with some MVV.

The builder takes some amount of funds to that address and wants to pay the proposer this. If there isn't this commit to reveal step baked into the protocol, then the proposer basically could just take the block, say thank you very much for all this hard work. They could rewrite the payment transaction, for example, that sends all the revenue to the proposer, and then builders don't want to use it. There's no builders, no proposers use it, and again, we don't have some sort of PBS to protect the value set from pressures of centralization. So that's bad.

Okay, so that's kind of a very high-level review of PBS today, off-chain and how it works. And yeah, so this has been live basically since the merge, so for a few years now, and at this point, it's an even more complicated picture in this, because now there's solvers and bundlers with 4.3.3.7.

And yeah, every day, new parties come online that are part of this transaction supply chain. But all being said, just to give you a sense of what this looks like right now, you'd have the validator here that's labeled. They use MapBoost to talk to these different relays, which I'll talk about more in a second. The relays then interact with builders and you have this. So, I called out this relay actor.

This one's very important and pretty much the source of all of our problems with this system today. The relay basically acts as like a trusted broker between a proposers and builders.