How Espresso Aims To Solve The L2 Fragmentation Problem

Transcript

we are here with another episode as part of our I layer Series today we welcome Ellie from espresso to talk about espresso's sequencing Marketplace and fast finality welcome to igen lay unlocked an interactive educational Journey Through the Igan lay ecosystem created by technical Founders and builders for the entire crypto Community a special thank you to our partners allir polymer authentic skate and grun for helping to make this happen our goal is to raise the collective knowledge of the igen lair ABS ecosystem and unpack the technical designs of the top teams in space welcome to I layer unlocked welcome to the rollup we are

here with another episode as part of our I layer Series today we welcome Ellie from espresso to talk about espresso's sequencing Marketplace and fast finality welcome Ellie yeah thanks for having me um all right I'll dive right into it so I'm Ellie I am a researcher and engineer at espresso and yeah today I'm going to describe our sequencing Marketplace and fast finality layer why we even need those in the first place um and then how they use igen layer to make them even better so first off why do we need this sequencing Marketplace and fast finality layer that's the obvious question well the reason is composability this is a

really hot word all the time on crypto Twitter but you know it's this is what we want and what do we mean by composability we mean that applications on different chains can coordinate as if they were on one chain so if we look at today uh we don't really have this so let's take a couple of examples um so each r a lot of the rollups that exist they each have their own deck deployed to each rollup each of these dexes has its own liquidity and it's not very seamless to transfer this liquidity between all of these different chains and it's not very efficient to have this liquidity in all of these different places um and then secondly I think that

another example is app chains so I think app chains will be really awesome in the future and I can see them growing but app chains because they're focused on one specific application they may never get a whole lot of liquidity or um or a whole lot of you know they it's very difficult for an app chain to like maintain the composability it has on L1 on their own L2 but there's a lot of benefits to creating an app chain like they get customized sequencing they can capture a lot more fees uh so how do we solve this well if we can make all of these rollups composable together uh then we can solve this and app chains can become a lot more powerful and then of course course you

know we have a lot of words that that get thrown around uh cross chain interoperability atomicity synchronous composability they're all they're all related uh they all mean sort of different things but really the goal of each one of these is composability so now uh the obvious question is okay well how do we get to composability uh the answer is that it's actually a lot trickier trickier than it seems um and this is why is why we see a lot of projects working on it including espresso um it's very tricky to do it in a way that uh is seamless but also is incentive compatible to all of the participants um but I'll explain how espresso is going about this so uh back to the question how do we get

composability well we're building a sequencing Marketplace and a fast finality layer that's how espresso believes we can get composability and then where igen layer comes in is Igan layer serves as this foundational infrastructure in which uh both of these things can built on and we can get a lot of really cool benefits from that which I'll go into later all right so I'll go into the marketplace and then later I'll go into the finality layer so the marketplace is fundamentally it's just about coordination that's all it is so if you recall our definition of composability We're just trying to coordinate as if we're on one chain and this means that we need a way for different chains to coordinate their sequencing if you want

to have composability between two different um chains they need to be or it's best that they're sequenced together and if we make an analogy to the L1 in ethereum um this is true apps that are deployed on ethereum are sequenced together they're sequenced in the same ethereum block by the same party and so really to get composability among all of these different chains we need to have something very similar to that uh but there's the issue that we have sovereignty so this is a really popular reason for app chains is that applications don't want to give up their fees to L1 proposers or L1 Builders um app chains also want to be able to

customize a lot of things like they want to customize their sequencing rules uh they want to customize their VMS all of these different things which makes an app chain great so we want to enable this coordination without forcing rollups to give up their sovereignty and so this is where the marketplace comes in so I'm going to go through how the marketplace works at a high level so we have these rollups a b c and d on the left side and they are going to sell their sequencing rights to the espresso Marketplace the espresso Marketplace runs an auction that's essentially just what it is and so each rollup will decide to sell their sequencing rights and then on the right here we have

several different sequencers and these are parties well they're in charge of sequencing transactions but but oftentimes we can think of them as Builders they're very similar and oftentimes they in fact are the same party um so these uh sequencers or Builders will bid in the auction to get sequencing rights for all of these different rollups and the key part here is that the sequencers can bid for multiple rollups at the same time and so for example this in this case you know one sequencer they bid for rollups A and B because they think that uh you know they can get a lot of benefit from SE from sequencing those together maybe there's a lot of interop or cross chain messaging between those two um and then

the other sequencer they bid for CN D so this is just one example but in uh in this case the auction or the espresso Marketplace it will find the most optimal solution to um to designate the sequencing the sequencing right so the auction will run a combinatorial auction it'll consider all of the different possible comb ations that people have bid on and it'll choose the one that maximizes the revenue across all of the rollups and so this is really great um and then how this works is yeah step one rollup sell their sequencing rights to the auction sequencers bid in the auction to earn the sequencing rights and then auction computes this maximum Revenue across

rollups this is you know what the marketplace is fundamentally um so do we have composability like we want well yes I'd argue yes because the sequencers since they can earn sequencing rights from multiple rollups at once they can sequence those rollups together and they can um and they can ensure that we have this really seamless composability between the rollups that they sequence together so yes this is great uh do we have sovereignty well maybe not yet so a clear issue with the what I initially described is that um you know the sequencers are kind of collecting all of the sequencing fees right they're deciding that order they're going to generate me potentially they are going

to earn transaction fees um like this isn't good for the rollups at all uh and rollups don't want to you know lose their sequencing fees so we're going to add an extra layer and this extra layer says that the proceeds from the auction that the espresso Marketplace runs actually get redistributed um back to the rollups based on how the proportion of how much they contributed uh into in the marketplace so for for example uh let's say one rollup they or let's say the total you know value of all of the bids in the marketplace was $40 and each rollup contributed equally well then each rollup would be refunded $10 so in this way rollups really do not

have to lose their revenue and you can actually design it such that rollups are always better off by participating in the marketplace rather than not and so well okay do we have sovereignty yet well still no and I'm going to introduce another thing which is a a reserve price or a floor price so we can end up in the scenario where a rollup is selling their sequencing rights but maybe the the people bidding on it aren't willing to pay what the what the rollup thinks is a fair price and the rollup says hey I can make that much money just sequencing for myself so I'll just sequence for myself so this is where these floor prices has

come in and these floor prices can be designated by each rollup and they can be changed over time and in order to earn sequencing rights the builders must bid at or above this floor price and if there's no bid that clears this floor price then the rollup gets to sequence for themselves and then they again get to keep all of the sequencing fees like they normally would so this is really neat because uh rollups can be always better off in this Marketplace and they can also access this coordination to en abl shared sequencing uh okay right so let's talk about how igen layer fits into all this though igen layer is uh has a bigger

part in the finality layer which I'll get to but the really neat thing about igen layer reaking is that it really simplifies based sequencing so espresso uh can absolutely enable base sequencing and base sequencing is when you enable the ethereum L1 proposer to also build blocks for rollups at the same time that it's proposing a block on ethereum and the way that igen layer helps this is that you know every node that is staked in espresso portol is actively participating in ethereum's protocol um they are actively Stak in ethereum's protocol so you can assume things um you know you can generally assume that they

will be up to date on the latest state of ethereum Etc and then also because you you know that the espresso uh software can coordinate with the L1 you know ethereum client you can then actually sync up the two so maybe an example would be um okay I'm the L1 proposer and I want to build rollup blocks in espresso well that's only valuable if I'm building the blocks during my ethereum proposal slot time and the tricky part is you need to sync those up to make sure that that's what happens because otherwise it could be very common that the case is the L1 proposer get sequencing rits on espresso but it's like after their proposal time and then they can't do anything

meaningful with that uh so Ian layer because you can work under these assumptions that you know that nodes are actively participating and proposing in the L1 protocol this makes base sequencing a lot easier which is really cool um oh yeah had a couple of images so Bas sequencing uh yeah ethereum proposers and I would argue that this kind of gives us composability Plus+ so our initial definition of composability was that all of these different chains could interoperate together and they could act as one chain but we didn't really mention the L1 and so this composability Plus+ means that we get composability between rollups but also between the L1 and rollups which is

a very very powerful property to have all right now I'm going to go on to to the fast shared finality portion of espresso so we have our same picture of the auction the rollup sell their sequencing rights and sequencers bid on them but we're going to add a few more steps so this is the marketplace and then to the right we're adding the finality layer so what happens with the finality layer is that the blocks that the sequencers produce get sent to the espresso Network and the espresso Network finalizes them and this finality ultimately it's not ethereum finality the rollups do still have to

settle for ethereum but the idea is that the finality you get from the espresso network is extremely strong that you can have a very good guarantee that it will actually be final on ethereum um and the way that this finality works it's uh you know it's a consensus protocol that we've designed it's called Hot Shot it's um in my opinion it's really interesting it's based on hot stuff it's a bft protocol so it has the same um it's very similar to how ethereum do you uh does finalization where you have um you know one something a block proposal and then everybody has to vote on it and then it gets like Justified and then everybody votes on it again and then it gets committed this is a very similar scheme uh but the really important important

parts are that uh this scheme can go so much faster than ethereum's finality so you can generally expect to get finality between um you know hopefully with less than 4 seconds on on average which is really good so this is great and this finality layer uh is really strong but let's see like why do we need this finality layer anyway it's fast which is great but like do you actually really need that um so this finality layer gives us a few good things one thing is that it makes it easy to enforce composability properties among rollups so a user likely wants an atomic um cross-chain transaction an atomic means

that they want both sides of their transaction to succeed on each chain or they want them both to fail they really don't want one to succeed and one to fail so we want to enforce this atomicity and to do this rollups need to be somewhat aware of other rollups um generally rollups are not aware of other rollups they have no idea how another rollup might execute its VM they really don't know and so we can have uh you know other services that come in and can do this uh can be knowledgeable of like both Roll-Ups at once and where espresso comes in is that you don't have to wait for the rollups to settle to ethereum before you can figure out what the

shared state is um this is this is important as well because rollups do not all settle to ethereum at the same rate some rollups settle every few minutes which is great but then you may have a ZK rollup that's only settling one every 30 minutes to reduce their gas costs uh so this is really not ideal if you're trying to figure out if your transactions executed or did not execute so since espresso or since both of the rollups that your transactions are on are finalized through espresso at the same time as each other you can then immediately see okay my cross chain message worked or it didn't work and this is really good um so yeah this reduces a lot of the latency in these cross chain uh this cross chain

experience and then the other thing is you get faster composable finality than the L1 uh this is actually very similar to what I just said um the you know normally you would have to wait on ethereum to see if your transactions made it or not and in the worst case you know the rollups might have to wait until they're settled on ethereum to even check like what the other rollup is even doing and now maybe there's L1 function calls involved and this gets really expensive maybe they need to verify a ZK proof of another rollup and this gets like expensive so the fact that you can do this before settling it on ethereum is really advantageous um all right but then let's

finally go to the igen layer part so how does igen layer help all of this so first igen layer gives you very strong Economic Security this is probably the reason most people are using igen layer for reaking you know if we want this ality layer that's really strong and that can give these really strong pre-confirmation to rollups we need to have a lot of Economic Security behind that the easiest way to do that is to use ethereum's Economic Security the really wonderful thing about ethereum that makes it very unique compared to other change is that chains is that it has so many nodes participating the nodes are relatively decentralized and it has so much Economic Security behind it so we can through reaking we can

basically use that Economic Security and we can have a very secure network we've actually designed our Network to be able to handle all of the ethereum validators if at one point it needs that um and so this is really really great this gives users a very strong guarantee that a pre-confirmation from espresso will be finalized on ethereum the other thing it gives us is transparency so when different projects use igen layer for reaking it's very transparent um where stake is allocated and which nodes like which operators are running nodes in multiple protocols and in my opinion this is very helpful for

risk management um in the case for example say that you have espresso is running and you have another project that's running and a lot of The Operators overlap and they're run by the same operators this other project has this major slashing event and a lot of money is lost well that is going to affect espresso like even if it's not the exact same stake that is being used in espresso those operators probably now have to cover their clients losses so they're going to withdraw from espresso Etc and if you have transparency into this process and it's very public the the network can be sure to maintain accuracy of its uh Economic Security so the worst thing that would

happen is that you say oh espresso has $10 billion worth of Economic Security but then some flashing event happens over here and actually espresso doesn't have1 billion but it's operating as if it did you really don't want that so with igen layer you can get transparency into what's happening with other protocols and this reduces the risk um of espresso and then the final thing is shared infrastructure so espresso will have slashing for um attributable fault very similar to ethereum um you know we will slash if someone tries to double sign or equivocate something Etc and the good thing about igen layer is that a lot of projects can use the same slashing infrastructure each project

might write their own specific slashing rules but the shared infrastructure is very important because slashing is something that is very personic you really need to make sure that you get it right you really don't want to slash people due to a bug in the software or anything like that so having a shared infrastructure that everybody can use can audit Etc is is really powerful and making sure that these slashes are safe um and yeah so then so that's pretty much the overview of the espresso Marketplace and the espresso finality layer um they work together in tandem um that's the end of my presentation and so I guess in

summary just to conclude uh the marketplace is mainly about coordination it allows rollups to coordinate their sequencers together so that users can have uh transaction sequenced across many rollups at the same time and this gives us a lot of great things it helps app chains it helps liquidity all of these great things and then also espresso has this finality layer um which can serve as a very strong pre-confirmation before rollup settle on ethereum yeah with that that's all I have awesome yeah you you were on a roll so I I sort of save my questions to the end um but I think overall that was that was phenomenal um you kind of addressed quite a few things uh that that you know we'll we'll dig into a little bit deeper

but starting with some of the igen layer uh things you know you hit on slashing I think one criticism of Ian layer in general has been this idea that everyone has to design their own slashing conditions and slashing contract but in in fact that's not the case you can read a lot of these modules um maybe there is some sort of attributable fault smart contract where you have double signing and equivocation in there and then that's somewhat generalizable to a set of the AV and we can reuse some of those contracts to to get some more shared infrastructure um so you hit on slashing rules um and and those are pretty much the two key reasons that operators could be slashed but the other side of that is

uh is the apy for for stakers to stake uh into espresso's ABS so because operators are taking on some risk uh in providing the capital they could be slashed you know they there's kind of the uh the itive reward uh or apy that you know you're paying for the economic security so kind of you know talk us through how how operators are uh being incentivized and how stakers are being incentivized essenti from and then that demand will go and and pay the apy for stakers uh yeah so the espresso Network um is a data availability layer and a sequencing layer so the the way that

validators in the espresso Network can earn fees is basically uh to sequence data in espresso you need to pay a small sequencing fee this is very similar to a lot of other data availability protocols and you're paying this fee to ensure that your data remains available for a very long period of time and um and then so yeah you're paying that and then also we have the auction which is generating Revenue as well so the main yeah the main way that validators would earn apy by reaking in espresso is through these sequencing fees that uh are paid to the network to hold their data and sequence it and keep it around forever awesome okay that that makes a

lot of sense um so okay great so um so yeah so stakers are incentivized uh to stake into these validators that are uh kind of like running the the nodes for espresso uh uh these operators and stakers are earning these apy because the the sequencers are paying a fee uh in order to sequence the transactions right and so they're paying uh a fee to the espresso protocol and then they're also buying the rights from the rollups to sequence their transactions um and so I'm going to skip back here to uh some of the sequencing slides and talk a little bit about

incentive compatibility because I think that is a a a key thing here when it comes to um I think maybe it's the next slide so okay so we have um kind of just to illuminate like all of the uh economic actors and incentives at stake here we have rollups uh they have order flow they have transactions and uh they could sequence the transactions themselves but they wouldn't they wouldn't have composability between them and so maybe there's we're missing out on atomicity and some some order flow that would be uh extra excited about composability is kind of getting snubbed yeah and then we have

sequencers that uh in the espresso Marketplace could could provide uh cross-chain synchronicity uh through sequencing transactions and then we have espresso the protocol which kind of takes uh like you know it has to validate consensus and so it takes this uh protocol fee and that's ultimately how validators earn uh apy for coordinating uh this this protocol and so these These sequencers are going to bid uh at least the reserve price to these rollups uh it doesn't mean the reserve price the rollups will just kind of they'll just kind of sequence on their own but let's say it does meet the the reserve price and they're they're uh sequencing for you know at least two or

more of these of these rollups um then we have to choose the the combination that maximizes Revenue across the rollups and I think this has been like the most contentious part because how do you how do you choose the the combination you know that provides the most the maximal revenue to rollups what if you know one combination provides uh 20 uh you know Revenue points to roll up a but there's another one that provides 20 to roll up B right how do you how do you and and let's say rollup C you know gets five in the first case and 10 in the second place so either way you know they're not as much but how do you how

do you choose if you know is there a tiebreaker mechanism or ultimately like do you have to do you have to choose preference of one roll up or the other how are some of these decisions made yeah so this is a really good question so the uh Marketplace comp computes the maximum Revenue across all of the rollups so it doesn't ensure that every single rollup is maybe getting the maximum bid that someone bid for it um it is possible that let's say someone bid for rollup D and they were willing to pay $10 but someone bids for rollup a b and c and they're willing to pay $50 that may not result necessarily in rollup D getting more than $10 um or or it very it could actually in a lot of cases it will but it it's not uh

guaranteed so this is how that works and when we're uh when the auction is deciding these uh different combinations a rollup so it takes a lot of things into consideration um so I I actually didn't touch on this but this is a very interesting extension we can add to our Marketplace is instead of just selling sequencing rights you can think of the rollups as uh providing intents you know I'm hesitant to throw another buzzword in here but rollups can kind of state their intents they could say okay I need to match this reserve price and they can also State the intent of like I really want to also be synchronized um and uh sequenced with arbitrum let's say because that's really important for my

rollup so they can they can specify these intents and with that the auction will kind of come up with a uh the best case scenario that gives the entire protocol the most revenue and the way that the revenue is split between protocols um is based on reserve prices so each um each rollup has a reserve price and this price is like what they think they're sequencing is worth by itself and so uh when you're redistributing the revenue to all of the rollups you take up all of these Reserve prices and you add them up and then you calculate the percentage of each one and then you take the revenue that's earned from the auction and you divide up that percentage based on um you know how much

each rollup was worth um and so that's how we you kind of decide how much each rollup is contributing into the auction um because you could have the case let's say that you have you have a rollup that's really popular popular and sequencers will bid a really really high price to sequence for them and then you have another rollup that's maybe not so popular and Builders are not going to you know bid as high just to sequence for them alone but they'll bid a really high value if they can sequence for them and this really major rollup um and in this case it makes sense that most of the revenue should go towards the really popular rollup that's really driving the high price of that bid um so this is how we uh this is how we allocate the revenue to each rollup kind of based on

how much they uh how much value they're adding into the network awesome okay yeah that that clarifies things quite a bit so it's not about the revenue each rup gets it's the the total aggregate Revenue uh that a c and d could could create together um sequencer is going to bid on that total value um and then they're gonna they're gonna we're going to choose the the bid uh that has the total aggregate the maximal total aggregate value yes um okay and then you you put out intents I I think that's great because there is like a declarative nature to this you can say you know you can Define your outcomes and then you have a competition

to to try to fulfill those outcomes the best the best way possible you know like you said we have the reserve price and you know rollups can opt in or opt out I imagine at each block right like each roll up block they can opt in and out yeah block you know I imagine like a lot of times these rollups are going to set really high Reserve prices because a lot of times they can make quite a few quite a bit of Revenue on their own you know recently we we did a podcast and kind of dove into some of the numbers with Justin Drake and in fact base is making like 800 they're making like $200 million do a uh uh a month I think and uh 80% of that is from me and so and sex Dex

Arbitrage and lever and so that is going to lead to quite a high reserve price yeah so often times you know they might set a super high reserve price biders May or you know they may not meet that or uh you know let's say bases rollup B in this case and rollup B doesn't get uh you know let's say rollup B could stand to make you know a million bucks on its own and the total aggregate is maybe five million but rollup B is only going to get 10% not 20% yeah and so they would opt out right for that block um but they can opt in and out on each block and so uh the I I imagine that a lot of times

rollups are going to set quite a high reserve price they may not they may not participate in the auction every single block but even you know for the for the off chance that they do get some sort of composability benefit it makes sense to at least at least kind of have a visibility into what it could be uh I if they work to participate and take that you know on a on a per block basis and so I think that declarative nature makes a lot of sense and yeah I guess I was gonna throw out another another bug word actually oh yeah yeah please please please um yeah so just a quick response is that uh when the auction is calculating the uh this Max this combination that maximizes Revenue it C

it will calculate to make sure that each rollup at least gets its reserve price back so even if a rollup is only contributing 10% to the total value so long as that 10% is greater than the reserve price they will still be sequenced um but yes like you were saying rollups can opt in and out of this Marketplace very regularly and um on a block per block basis and I imagine that some rups will do that I think it depends on uh for example app chains not all app chains may need composability all of the time and it may make sense for them to opt into this say once every 10 blocks depending on what that application is U maybe it's like a gaming chain that doesn't really you

know need a lot of composability with other chains so that makes a lot of sense and then you may have Dex app chains who would probably opt into this all of the time because they get access to this shared liquidity from other rollups so uh yes what you describe is something I could I think will will happen I I mean this is is a long a long time that you know shared sequencer sequencer marketplaces like composability has been discussed yeah and to me you know this in theory this has always been possible like you know I only want to participate if it's going to make me more money otherwise I'll do it on my own that yeah it's a pretty

simple uh principle and so now we have the mechanism to complete that like what are the what are the the downside or the criticisms that you you guys are hearing because to me like if I'm a rollup operator it's a no-brainer I can either make the same amount of money or I can make more like why wouldn't I do this what what are some of the the criticisms that you guys are hearing yeah so um this is um a problem that we've been working on internally at espresso a lot and kind of the obvious question when I describe this is like well what if you have a cross-chain transaction between rollups B and C those are not sequenced together and now maybe you know you have to go back to

using the old bridging approaches Etc like that's actually not good because you're not guaranteed that you that a single users's combination of rollups will be sequenced in the market place together um so yeah this is a we've been actually focusing a lot on this problem internally at espresso and uh I think in a few weeks we should actually have something that we'll publish um we'll publish publicly but the synopsis of it is that the role of coordinating between rollups can actually be separate from the sequencing of rollups and this is it's very very nuanced but rollups can potentially sequence for themselves or they can sell their sequencing rights to

whatever sequencer but then you can have this uh kind of coordinator come in and they the coordinator just makes sure that each rollup is aware of each other um but it doesn't sequence transactions it's not taking transaction fees Etc and because the coordinator can come in and do this they can do this between rollups that maybe don't always get sequenced together and uh so the the benefits of this are that users can get cross chain interoperability no matter which Roll-Ups they're going from uh but you the marketplace still provides an advantage because if you have a shared sequencer the shared sequencer can guarantee you things like execution the sh shared sequencer can guarantee uh what price you're going to execute at

give you pre-confirmation at Etc the coordinator cannot do this uh the coordinator May coordinate between two rollups and find out that all of the cross-chain transactions fail for example that could happen but if they were being sequenced by the same actual sequencer you wouldn't have all of those failed transactions um but yeah so this is like this is an issue that we've been thinking about um and how we plan to solve it awesome I okay and so basically you have like uh you know you have some some cross change transactions between uh let's say A and B right um and then and then you know let's say they so they were both to opt out of the

auction and you would have to revert back to the previous like whether it's mint and lock or intent spased you would have to kind of revert back to the original way you couldn't do the sequencer composability maybe because it's only C indeed that are participating in the auction and so A and B still have to figure out a way to know what's going on with one another and so there's a coordinator and there's and so sequencers are kind of on the right part of this uh oh and I see why you chose B and C actually in the in the in the first example because it it kind of works with this diagram so what you're saying is that and we have all we have all the

sequencers on the right but there's actually like this middle uh layer of the coordinator that can read the state on both rollups at the same time and sort of work as like a central uh Hub of data availability to check what is in the M poool of each rollup at any given time um yeah so well sort of so the Coordinator would sit basically after to the right of the sequencers and so the Coordinator would take in blocks that are already sequenced and the Coordinator would just say Okay rollups these are the messages that are getting passed between you guys now go and execute those like you want uh so yeah the the coordinator's role

and like responsibility is very minimal it's just to say here's messages from another rollup got it okay that makes sense um because it's actually coming from the fast finality layer like the pre-confirmation is how they get uh okay um one one question I have is like you know let's say and and you mentioned like an chain right may or may not need composability but then you know another chain maybe really wants composability with arbitrum and you know what if th this this is maybe I'm I'm just gonna ask but like basic what if like there's a subset of

transactions for a particular rollup block that really need composability because you know it it would really benefit them but not all of the transactions in that block need composability it's just the subset yeah would would you be able to kind of separate these bundles to apart and and then synchronize some of them but then opt out of the auction with the other the other Set uh yeah that's a good question and this is something that I've thought about and I at this point I don't think that that's a way to do it and the reason is because app chains might or any sort of rollup might want to enforce certain SE certain sequencing rules so even if you have a cross-chain message they might want that cross-chain message to go at the top of the block or

they might want want it to go at the bottom of the block um and so you if you separate the two of them you it it maybe works but then you kind of need to recombine them in a way and when you recombine them you might end up with a different execution so um if I'm a user and I get a pre-confirmation for my cross chain chain Swap and it says it executes well then when these non-cross chain messages are added back in back in maybe it actually fails um but to address the the issue is that yeah so some times blocks may not have a lot of demand for uh cross chain composability if um depending on the rollups reserve price they may be still get shared SE or sequenced together if you have no no

messages between chains you can still have the same person sequence them and maybe you can even still get a few benefits from that um you know this shared sequencer can give pre-confirmation Etc uh but in the case that you don't have enough demand then you can use this coordinator role that is very minimal doesn't do any sequencing um and will just you know coordinate the messages between the blocks got it okay and so from the conversations you're having kind of the main opposition to rollups opting into this uh is is uh when it doesn't make sense and you opt out and you have kind of like a rever a a a set of transactions that revert because uh you

know they they don't really fit within within this framework um but we're kind of adding the coordinator role to address that um it I'm Al I mean I'm just I think I think all of us have a really common goal of like achieving synchronicity this is something that I I continue to hear over and over again it's like this is what we want even from the DI ogs like this has been a very main value proposition of of Commerce on chain like Far and Beyond you know if it's always been sort of this like the composability of of cryptocurrencies with one another and contracts but then you know we got so fragmented um and now it's like this

is the main core value principle of of onchain versus something like a binance you know they can't they can always they can Pro binance can probably be faster and cheaper because they don't do things in a decentralized environment but they don't have the composability that you can get on chain and so to solve this um I I think it is kind of like this greater good thing that a lot of us have as a common goal um a lot of users want to see it a lot of rollups want to see it and sequencers can make more money too and so you know getting to the point where it is a no-brainer and rollups are you know basically just ready to opt in um I think this is a point where a lot of us are it still feels kind of

idealistic but yeah um this is where this is where I think a lot of us want to get to yeah 100% And to comment on that so espresso is it's not the entirety of the solution so there's other projects that also are going to help this uh for example wallets when you have a cross chain message the user can't actually be generating both of these messages together the wallet needs to know how to generate messages that send messages to another chain Etc so like we need Wallets on board you need um other projects such as like AG layer that are doing this proof uh level uh so as first was only one piece of the puzzle um yeah I also will say uh main net for espresso is coming soon so hopefully this can be a reality very

soon awesome and will you have uh launch Partners um rollups ready to go live on day one um sorry I'm not sure if you can hear my dog barking in the background I can but it's all good uh yeah so um our initial launch will be just the infrastructure and rollups could any rup can decide to use it if they want and then really shortly after the launch we will have partner rollups that will launch um you know be launch partners and are officially using our chain awesome because I I really see the network effects here um they're kind of they're kind of in plain sight like once you get rollups A and B you know

rollup if rollup C wants to be composable with a or b then they're gonna have to join and so it it seems like um you know it's going to be slowly and then and then all of all at once uh as rollups sort of launch and and uh uh and and are incentivized to participate in this ecosystem for composability and for their users um you know I guess kind of as we wrap up here there's because this idea again has been around for quite a while and so um it's cool to very you know to see it come to fruition hopefully here very soon um but you guys aren't the only ones in this Arena that that are trying you know to build the solution

and so you know right now we have we have a lot of uh sequencers that are building uh kind of interoperability amongst rollups in their own cluster um and then we have and then we have rollups that are you know looking and sequencers that are looking to coordinate amongst different clusters will we see you know like kind of like a a layer on top if you will like we have the rollups then we're going to sequence the rollups in a sequencer Marketplace but then is there goingon to be have are we gonna need a Marketplace to sequence the sequencer marketplaces yeah uh yeah this is yeah a good question um I think in reality no because I I think that a lot of the

projects that are working on things related to Shared sequencing um they're actually not direct competitors they're actually different components of the ecosystem that can you know plug in together um you know so for example espresso offers da for example but rollups can always choose to use their own da layer as well and that's perfectly fine um you know rollups May rollups May opt in to using kind of one of these clusters but uh that doesn't actually that doesn't mean that they can't also use espresso as well every once in a while to gain interoperability with things outside of that cluster so I don't really view them as like competing and because of that I don't think we'll end up with like yet another third layer

um I think actually will just have all of these modular components finally come together oh that is the dream yeah I and I I think so too like off again it doesn't when it when it reaches this point it it's a no-brainer and there is no incentive not to participate and so even if you're you know you're participating but you end up opting out for 99% of blocks you're still particip like as long as you're in the ecosystem and you're aware of when it does make sense to participate I I I see that you know especially early on when there maybe isn't as you know the shelling point of rollups where it makes sense to compose all the time um you know that that's where I think uh a lot of rollups

where it's like there's no harm there's there's no incentive not to participate like no exactly it really isn't and then and then you can see how it goes um you'll make as much or more and then you know that that I think will will help to uh kind of get off the cold start and then and then once it gets going it really seems like it'll get going and I'm personally super excited for all of these applications that um are not possible right now but are possible when we have the levels of scale and composability that we get from Fast finality and uh composability amongst these rollups uh yeah I 100% agree and I think I'm most looking forward to app chain

specifically I think that like composability is the key thing that app chains really need and it's a kind of the key difficulty right now why it's very difficult to make an app chain uh but when we have composability app chains can be very common and I think that that's awesome because apps like instead of having your app deployed on yet another rollup which is essentially a chain your app is your chain and you have full customization over it uh so that's what I'm partic particularly looking forward to yeah awesome um it's always a pleasure yeah I mean this is great um always learn a lot and it's really cool to see how espresso has evolved since our last series that we did in modular March so thanks for coming on again yeah know it was great thanks for having me