The Based Rollup Stack with Spire Labs

Transcript

GM what's up guys welcome to another episode of the rollup today we have a great followup to our recent episode with Justin Drake on based sequencing in today's episode we chat with M team from Spire Labs who is building the based stack and we talk about what the based stack is and what based sequencing is all of the intricacies and nuances about using the ethereum validator set as the sequencers trade-offs and some of the value proposition of based Roll-Ups hope you guys enjoyed today's episode without further Ado first a word from our sponsors enjoy welcome to the ignition Mantle's newest campaign to liberate the

growth power of Bitcoin fbtc ignition has officially begun with a total token supply of over 2,000 fbtc with a tvl of over 150 million right now you can go on the fbtc website to see all of the featured campaigns saking opportunities and liquidity pools where you can utilize fbtc onchain today for some of the best yields available on l2s the ignition Sparkle campaign can be found at fbtc ongoing campaign welcome aboard on our journey into the singularity this is the endgame road map for fra and FRA the new L2 out of the fra ecosystem that is totally

based on fractal scaling fractal is a modular L2 blockchain built by fra with modular and fractal scaling in mind fractal scaling is based on the mandal BR set of fractal images and it explains how l2s become l3s and the entire app chain life cycle goes through its Evolution the frax ecosystem is made of some of the top builders in the space and has stemmed from its OG days of the frax stable coin it is now in the LST space the LRT space and this frax L2 joins the existing Suite of fra products

including fra Swap and frax lend you can see frax fairy the bridge to go from any chain arbitrum optimism or main net into the fra main net Bridge your tokens and bring your frax assets into the fractal ecosystem join today to get the best out of fraxel you are still early join today take part in our Expedition into the singularity what is going on guys welcome to another episode of the rollup feeling today particularly based and aligned um we're going to get into base rollups in particular Spire uh today

we're here with Matthew AKA M team he's going to be Audio Only today you guys might recognize his uh his profile picture picture which is uh we'll also have it on the thumbnail so you guys can uh build some of that that social recognition um says first time on the channel uh yeah Matthew uh welcome to the rollup man it's good to have you Robie appreciate it um absolutely yeah so I can give a quick background to myself so I'm uh I've been in crypto for see about five years now doing primarily MB searching so shadowy supercoder stuff selftaught rust and solidity um yeah so I'm a super technical guy but happy to get into some of these non technical

conversations as well awesome man yeah let's uh let Let's uh get pretty technical today on Spire uh this is the uh the base rollup stack uh as you've coined the term um and so yeah maybe we'll start somewhat high level but we'll we'll go deep into base rollups today talking about how Spire uh is thinking about based rollups uh from this stack perspective uh some of the trade-offs with based rollups um and how you guys are are designing the mechanism uh for what you're calling customizable composability and I I think this is this idea of composability we we had a a chat with Espress uh Jill from espresso um who who was coining the term like make

ethereum composable again uh the rollup started out as defi slate um and so we are very very familiar with this idea of defi money Legos um that was core of the thesis in in sort of the 2020 defi era and so you know I think there is some mixed feelings out there with respect to composability now interop the entire user experience feels very fragmented I think we we want more composability than exists in the current implementation of ethereum and its rollups um but maybe we don't get to full you know gaming assets are interoperable and composable with the world financial system maybe that is a little bit overblown in terms of composability

so in in in your perspective maybe you know we can start off let's let's start off by by talking about Spire what is it um we'll get into how it works and then we'll we'll kind of talk about why it brings about the level of composability that it does so lot there but first question is what is what is Spire yeah thanks for the question Robbie um as a high level overview we like to describe Spire um in our product was which is the the based stack as a framework for you know allowing app developers to deploy based app chains this is a base rollup that is application specific as opposed to like a general purpose rollup um built on ethereum as a layer two and then we're also interested in exploring

layer 3es in in the future right um and so the the we also have some auxiliary products which we can talk more about later that are um we get into like pre- confirmations and stuff like this that augment the ecosystem um but our big big play is the the rollup framework right the base stack which is where we take app chains um from how they exist today on things like Cosmos and take those to the next level uh with with Bas sequencing right so there's a whole bunch of things we could explore but I I do really want to focus on um composability as being an important reason base rollups are better than every other rollup but also yeah we can get into some other features that I think are are super super important to talk about here such as bootstrapping right it's a lot easier to bootstrap a

based roll up than a um another r with a decentralized sequence say cool okay so um maybe just one more like quick definitional or framing of this why and this is a really basic question why is a a based app chain different from a regular app that is deployed on the L1 sure yeah so let's let's kind of think about this from the Cy life cycle of an application right so you have at first if you're an application developer you if you are building just an app on a layer one or a layer two you will deploy your application a set of smart contracts orchestrated together directly to that roll up so you might interact with RPC

um to deploy those contracts that's a a pretty straightforward process you usually run through some configuration initialization and then you're up and running um there's no other kind of external dependencies you can use like the um all all the features that are already set up for building apps on on that layer so these are things like uh rpcs these are things like sequencers which are are built into layer ones and layer 2os today um and and also just things that are important for data right as you have indexing and things like this whereas if you're going to launch a based AP the difference here is that you're deploying a fully-fledged rollup which does mean you you need to have nodes you need to have indexing you need to have a bridge and things like this that are important features of every rollup this a big part of like the

kind of the modular road map here um that we we think these kind of cost and infra roles will be um competitive cost will TR zero I think I know that's a big part of you guys' thesis um but I do really want to focus on that difference is like you do need to laun this in front or or guess I'm going to do it for you right um that's a important difference the what's not different is the sequencing so today um applications uh built on a base layer use the uh the sequencing of that Bas layer right I think that's pretty clear to understand um with rollups today you're moving to a layer two for example U and you're adding a new sequencer right maybe you're using your own centralized sequencer uh maybe you're using you know

another external sequencer from a third party maybe you're doing something in-house totally up to you but the important thing is that you're not using the same sequencing as the Bas layer whereas base app chains and base rups in general we we try to reuse the sequencing of the base layer as much as possible and there's a few reasons for that the big one is that uh we inherit properties that the sequencing of the Bas layer controls and we can get into some of these but I think the important ones are you know the network and state that lives on that layer right so if you're sequencing ethereum and you're also sequencing a based app chain then you can do shed sing between those and then we can also talk about things like liveness right that's super important for some uh Financial applications right so if you want the livess of ethereum

which is really really good U then Bas sequencing is is one of the best ways to do that as well now you also inherit some negative aspects right so if your base layer is not Sy resistant then your rups will not be um if you end up having you know live problems on the Bas layer your Bas R will also have those and of course block times is a big one that people talk about where you do inherit the the block times of the base layer that you build on um it's a it's a limitation that's kind of fundamental to base f-ups but there are workarounds and some tricks that allow us to to make that user experience even faster than what you might see on some other Roll-Ups super helpful cool okay so yeah you you laid out um you know kind of like what is the benefit of using the

big B sequencer you mentioned Network effects State liveness um all of these are are normally uh more robust and and significant on the on the layer one sequencer um and then also sensorship resistance as as as well as this idea of uh block times right which is a trade-off depending on on uh the the base layer um and so these are all kind of the considerations for whether or not um you know applications are going to to deploy their own rollup uh and with their own sequencer or use the the base uh layer as sequencers um and then the the fundamental difference here between an app that's deployed on the L1 or an

app chain uh that is a based app chain using the L1 sequencer is going to be all of the other infra um that is associated with being a chain which is rpcs indexers um Bridges um if you are just an L1 app you don't really need to do all of that you just inherit all of that tooling um but if you're going to be your own app chain you need to build all of that bespoke um unless you use maybe like a like a stack and we'll get into the base stack so okay now um you know I I right I remember using 2020 defi like I could just send my funds everything was ethereum polygon and and Avalanche started to pop up a little bit

later but for the most part mainnet applications were on mainnet and you could just send you didn't need a bridge you could just go pretty quickly you could withdraw from one application and deposit into the next um without any weight times or um and everything was pretty composable and and that was part of what fueled defi was the idea where I could take a LP token from Unis swap go deposit it into a yield compounder and get significantly more yield and it it had this flywheel effect that led to a lot of inflated yield as in Hind sight right it was great while it was happening we were getting significantly higher apys than we have now but it was as a it was a result of uh much easier

rehypothecation uh which at the time was a feature now now maybe uh we'll get into the the customizable composability conversation uh because I think maybe there was too much rehypothecation that led to kind of like the artificial yields and uh inflated yields and so the user experience was was a massive advantage but it kind of had its own pitfalls and so when you guys are thinking about composability um between based app chains um you know there's a lot of infrastructure that you sort of have to navigate and coordinate between um so in your view what is generally what is your view on composability what is the right amount or right mix of

composability um and then we'll get into like how that works in the base stack and how you coordinate amongst some of these different pieces of INF infrastructure yeah yeah I'll sort of off this by saying that um a very famous podcaster said fragmentation is sovereignty and I think that idea um you know well it's it's a little bit misleading I think at face value uh there is some truth to that right as as we get a um more kind of fragmentation among an ecosystem that also enables like more experimentation and more sovereignty right that's a good thing but the the fragmentation trade-off is still there and is a very real problem um and so we do have to understand like how does composability solve that problem and in what ways you know is that like a important part of

what Spire is building so I'll start off this by saying that like main is dead there are very very few applications that only exist on ethereum lay one like I can think of a few but not many um a lot of these Big D Protocols are multi-chain now and if they have not deployed in every chain then there are Forks of them on every chain right um and so you you do deal with complexity of like of like a multi-chain upgrade or doing governments across multiple chains like you can't just choose to opt out of the layer 2 uh road map of a theum right you do have to um somehow touch those layer Toes or else you're just missing out on the the primary um way that ethereum is is evolving and growing right and so I I think that's a big thing to to point out here is that

fragmentation is not just like a a rollup problem it's everyone's problem because ethereum is growing through rollups if you know if you like it or not um and if you stay on layer one as an application and you you just are not addressing the market that you could and so it's a problem for everyone and and that's why we we think that's a important thing to focus on um when we talk about composability there's a few kind of levels of composability we can get a little more technical here I think um that we like to Define so these are all kind of like useful for for different circumstances for different users um I'd say the we'll start at the top we have what Justin likes to call synchronous composability or Universal synchronous composability um and the idea here is that this is exactly what a

single layer looks like so salana has Universal synchronous composability which is just great for for Sal apps um eum layer one has Universal synch possibility so does Bas so does all the layer twos that you can name right um they're all very powerful but they're all isolated this is isolated ecosystems of synchronously composable chains um kind of the next step down is like we like to kind of call it asynchronous composability um we start to get into definitions of like composability versus interop um I like to keep it simple say that's there's like a somewhat linear scale of um things that fall along the drop kind of landscape right so the most basic of this is atomic inclusion and that just means you have multiple

transactions on multiple domains and then you can purchase like a cryptoeconomic guarantee that each of these tractions transactions will be included or none of them will be right and this is important for like instant bridging some cross and swapping like governance you know doing governance upgrades across different chains but it's not as useful as some other types of right and so we started to get into like what if we had not just Atomic inclusion but also Atomic execution and this is useful for cross chain Arbitrage is is the big one uh but you also do like cross chain contract calls at some level um with this as well so that's that is that is useful now the problem with doing cross-chain contract calls through only Atomic execution is that a smart

contract cannot just like read a um execution promise from a sequencer right or or a pre-confirmation as some will call it and and use that within their code right they need like to be able to check that somehow um or have some some you know larger guarantee that the chain will just execute and then revert right maybe you have a a problem with your chain finalizing this is a super Veil problem with ethereum right because we do have reworks on ethereum um same thing on rollups right it's totally possible to have a problem with like a decentralized signer or Shar signer or something I guess um so we have to figure out how do we like enforce that these chains are not only experiencing like Atomic transactions but the actual like settlement uh and finality of the chain itself is atomic right and that's

where we get into um synchronous compability right and and you know the best way to do that that we know of now is through validity proofs of some form or another uh and proof aggregation so there's like a single uh base layer or ethereum layer one transaction that proposes a a bunch of blocks essentially you know finalizes the sequences of those chains um and then submits ail de proof for each of these it Aggregates all those proofs which STS on cost but is also means you can't just do one without also doing the other and this is what some great teams like like agir and espresso are working on but we think that is a super powerful Vision as well Okay so we've we've uh solidified a lot of definitions here but let's let's talk

about the based stack right the the main offering at of spire this is something that you know we see we see rollups as a service providers really spurring like the the proliferation of new rollups applications launching their own chains like again the proliferation of the AP chain thesis and and sort of like you know not just one chain not just like the alternative layer one thesis but but layer twos layer 3es and and app chains Galore Cambrian explosion I'm calling this um and and we've seen the op stack we've seen arbitrum Nitro we've seen the polygon sdks the ZK elastic chain and and ethereum has the ability for based

rollups but there's no stack there's no and and sort of sort of setting the stage here for the based stack you know why has no one else come in and done this already and and what is special about the base stack from Spire that you know provides kind of The Best of Both Worlds of ethereum um and and also you know maybe we could we could kind of compare this to the other rollup Stacks that are out there from arbitrum optimism and the other L2 rollup Stacks yeah great question so uh there's a lot of things to unpack here um I'm sure we won't get into all them today so I will tell all of our listeners that we will be releasing our light paper which is not very light it's like 20 Pages um and then a whole bunch of like articles

as well in the next few months so if you're if you're curious about any of the stuff that I talk about soon then then please do take a look at that um you can follow the the Spire Twitter which we'll put in the description hopefully um yeah so let's try to get into the uh what is the base sack right and then what is like the advantages of of having a a custom sack for basically saying and for base rollups um and so at a practical level um and I'll give you like the the real definition and not the one that we um like vs and stuff uh Spire is building a a module um that contains sequencing rules and that's it so this is essentially means that we Define a few things about sequencing and then leave everything else up to uh

another roll up stack right and so when we launch our our um kind of full product uh not really main that cuz we're not actually running anything but uh we launch app chains on Main net right that will we will launch with a fork of the op stack so we take the op stack how it is they have frog proofs um they have Bridges they have a ton of like infrastructure that's built for the op stack and that's amazing um and then we just attach like a little module on top that makes the obac so much more powerful right and so instead of calling this a sequencer module like you might you know see some other like sh what our team's doing we decided to just completely call it Bas stack because it is so different um that it's it's almost not comparison and so it's kind of

different flavors I would say um so let's talk a little bit more about sequence or rules so I talked before about composability and like synchronous composability um all of that is what's being fed to people right now by by researchers and by um some of these other teams I want to make it very clear that like ZK and realtime proving and what we need to get to Atomic execution um and and pration and things like this is is a ways out right I've heard estimates from people of a year I've heard 10 years right there's no one really knows when this is is going to be live and when it's going to be like production ready and battle tested um but we do know that like we can get a good way of the way there with some some tricks like some uh almost some

shortcuts around some of these problems that we we are experiencing and so that's our that's our product right that's their big differentiator from some of these other Bas rollup names um we can talk more about kind of what the seing is uh I'd say like primarily the the idea is that Bas sequencing is reusing sequencer ction of a Bas layer so if we say ethereum ethereum sequence or election is proof of stake right we randomly elect using some um kind of coordination between nodes to decide on a see for Randomness a validator to be granted proposal rights for a single block and we did that like 32 validators at a time but there's some technical details there but the big idea is that there's a few like defined set of rules

for how this one proposer comes to be and that's based on proof of stake now there's other sequer election rules out there like base um has a permanent sequencer so does OB and a bunch of other rups today and there's some other options as well I think the uh the important thing to look at here is like this is the the way that we elect a sequencer um but the actual sequencing and the sequence of transactions that ends up being confirmed um is a whole different thing to talk about so Spire actually focuses on both which is very different some from some of the approaches that some other basic whatting teams take I think that's where we see that like 10x improvement over existing rollups as well so start with sequence election we I Define a base rollup as a as a rollup that uses base

sequencing which I know Define as um sequencing that inherits or uses uh as a foundation the sequence election of another Bas layer right um and so for for us that means using ethereum right so ethereum has their sequence or election um we just reuse that right we use we add some like little Jingles on top to to make it more friendly and more cost effective but that's kind of the starting point right uh and this this to means we inherit a bunch of things but are the qualities of ethereum that I mentioned before um but it's also you know some of the things that we add on top enable like M retention right so bopes are not ethereum align I hate to break it to all of you you people out there but um we are at alind right not eum alind and so I think the uh the

thing that we we should start to get into as well is like what is the other part of sequencing so we talked about sequencer election event and this is the the big focus of sh sequencing but there's so much more to it than that right um this is one of spire's like primary focuses which we do dive into a lot in the light paper which is that the sequence of transactions that is actually produced by a sequencer is arguably more important than like who is the sequencer right like nobody cares um who's sequencing their transactions they care if their transactions in um and you know if it's cheap and then what he can interact with what is like the interop and composability that we enable here uh and so that's you know I think i' love to talk about we call this customizable composability it's is a specific feature

of the base stack uh where we modify the sequencing rules so what is like considered a valid sequence of transactions um and Define it as only a sequence of transactions that meets some criteria it is actually set by the application so there's a easy onboarding process you can go through to say you know I want my customizable composability to apply to nfts on ethereum ler one so maybe only the cryptopunks contract or maybe you say only Unis swap pools and only these 10 us swes that you know you save costs from interacting with the rest of ethereum and what ends up happening is that you uh Define like a a special function that is run on your rollup contract um and that produces some result and that result is like must be

the the contents of the first transaction in your rollup block and so therefore every other transaction in that roll up block can view like what happened in that first transaction after it writes to a contract and I know that's a lot of and you know there's more teal stuff in the light paper but the big idea here is that we allow application developers to Define exactly what they want to know about ethereum and then every transaction in their up will have real time read access to this um and so just to like a simple example Oracle is on ethereum so you you want your chain link data feed you want your your unisoft price feed then you can uh get that on a Bas drill up with like barely any configuration we think that's already like a super powerful

um kind of idea that we haven't seen any other GES exploring as of now um that's something that that Spire is really hoping to Pioneer and so the the this module that contains the sequencing rules are those those rules that when when you say the top of the block and then the rest of the the rest of the block can see that access it view it read it and and use the information uh for the sequencing of the rest of the block um are these the instructions or what do you have to grab data from the rest of ethereum or could you just kind of talk a little bit more about exactly what happens at the top of the block I think the the rest of it is pretty

straightforward that it reads what happens at the at the top of the block um but yeah could you just kind of really because I I correct me if I'm wrong but this is kind of the Special Sauce of spire it's what happens at the top of the block for the rollups that are deployed with the base stack so could you could you kind of dig into that a bit deeper yeah for sure um I just want to say that there's like uh there's a ton of features of the you know the Bas stack that we like to talk about um this is one of them and I think it's one of the the coolest just frankly um and so I'd love to spend some time on this but you know we can also talk through some of the other features as well um yeah so let's get into the the

technical bits so we allow application developers to define a sync function which lives in the rollup contract um and every time a rollup block is proposed then that sync function is run by ethereum so it's like by code executed on ethereum layer one which is expensive but it's only run once for every user of the of the application during that block so the actual marginal cost for users um is not super high and can be even more advertised across a network of of Base T chains right and so I just want to put that out and then the so then we have like the result of this execution so this is just s like bites um some um object that represents what happened during this execution and so maybe you've read from an oracle and

your response is just a number that says eth usdc is 3,000 right and you know that um and then you you move this into kind of the the way that rollups actually work today and we can talk about like optimistic rollups versus Z rollups uh but the idea is that they have some derivation rules which allows them to Define what is considered a valid rollup block based on the state of the layer one so you're deriving your state from layer one state um and so one of the things that you can see about layer one is this event that C that kind of described um the result of executing the sync function um and then the the actual rule itself is simple it's just does the result of a sync function equal the input to the first transaction like

the the very first transaction in a rollup block and so um let's kind of back up here and put some terms we call this first transaction the sync transaction um or the sync TX and then the this like interacts with a contract on the layer two or anything on the layer two really um and can save state so maybe this uh this sync transaction um has the result of that e usdc price we metioned earlier so the kind of the call data for this transaction is just 3,000 and we enforce that in like the um the rollup derivation rules then this is like kind of directly applied to a contract um would call the sync contract on the layer two who stores this in

memory and makes this accessible for uh for the rest of the transactions in that block to happen so you could do kind of longterm storage here you could do a short-term um storage as well but big idea is that you have some real time access to ethereum that you know is like enforced by the the actual derivation rules of your application itself got it awesome so that that's how this this app chain albe it still has its own infrastructure but because it uses the sync function that reads the data uh or the state it reads the state from the L1 uh it it sort of encapsulates it into this sync transaction and then the rollup uh is able to read that through the sync

function uh understand its call data and then check to make sure that it matches um if it does match then it uses this uh call data for the rest of the transactions in the rollup block and that's how it orders uh the transactions um and and maybe reorders based on what is contained in the sync function on the rest of the layer one I would say I wouldn't say orders I would just say excuse so maybe the result of your your Oracle call is like like I said $3,000 um you could store this in a contract in the sync contract and this would be readable just like any other contract so maybe you deploy your application and instead of like reading from a um kind of like an oracle buffer or whatever you use today you you read

from the sync contract and you just know that that's some reflection of ethereum State got it okay yeah that makes sense one other question I wanted to ask you was you mentioned that this this function runs on L1 which is costly because it runs on L1 but it can be amortized across all of the users on all of the based rollups from the based stack um and I was curious if th If this means that they that one uh based app chain like that that is launched with the base stack is somewhat dependent on another based app chain that's launched on the base stack because they both use this sync function at the top of the block and they sort of share that is that I have a feeling that's not the case but could you maybe explain why

yeah so I mean we feel really strongly that Aban should maintain sovereignty so uh we don't we don't go down this like Shar sequen route where we um demand that you must opt in and and you know give us some sequence of Revenue we think that's silly um we we understand that there's like different like levels of opting in and the espresso guys are great at explaining this where they say like you don't have to give us all of your sequencing rights just a little bit we we say like we will take all of your sequencing rights and give them to ethereum we're not going to give it 10% for ourselves um but the other thing that you can give us is like your your blobs so maybe you're uh running ta and you'd like to share a blob with another app chain we'd love to coordinate that

for you it's called like blob sharing or blob aggregation um and we have some more research on that coming soon uh so I think that's something important is like as we build more based app chains there's a network effect that we get just from that coordination um that it just isn't explored right now on something like the super chain um so you mentioned like the sing function and let's talk about that a little more so based app chains and then based robes in general are expensive I could put some numbers here but essentially you're paying thousands of dollars every day to to keep this app chain running um but the the nice thing here is that this scales sublinearly as you you know increase the number of app chains so maybe you start off with with one app chain that Bears all of the cost but

then when you add 10 more app chains each of them bears that cost somewhat equally right and so you end up um having a a much cleaner kind of experience here so you know everyone's paying less it's good for everyone this is the kind of incentives and coordination games that we we like playing um and that means like everyone is happier here now when we talk about like I mentioned sovereignty at the beginning of this um this paragraph but the the idea with with sovereignty here is that every app chain is still running on their own contract so they still have like a rollup contract that is separate from every other app chain but the kind of sync function and some of that can can almost be shared between um between epin so if you propose a block as a as a sequencer for multiple Apes at the same

time so we talk about shared sequencing right um then you can also kind of run these sync functions together at the same time right um and if the sync functions are exactly the same then you don't need to reexecute them so if theoretically just by coincidence um two chains were trying to get the same Oracle uh at once you would not need to re execute that twice it could just be kind of um almost enforced once right you execute once and and enforce across all of these domains um kind of individually I guess and so that's that's where the the cost saving comes through with the sync function is that you have the same sync function to run and that you don't need to run it twice now we expect sync functions will will look very different for every option so then we'll be a um a cost saving for

every AP um but the there are components and modules of this that you know wouldn't have to be re-executed multiple times so I think that's a really important thing to to look at as well I think there's like a whole bunch of paths that we could go down here about like you know how expensive are Base rups today um what is like the cost structure of spire base rups compared to some existing Stacks I'll give you a hint we're a lot cheaper um and and we can you know talk about some of these as well but I think we should leave that to to another conversation and and maybe talk a little bit more about what this means for E theum so happy to you know go in that direction I guess sure yeah would love to talk more about the network effects from blob sharing as

well but I have a feeling again like that's something that let's let's leave that again for another conversation let's talk more about like what what impact this has on on ethereum and the base role of ecosystem yeah no um okay so I just want to start by saying that there has been a lot of um kind of Bas scroll up information from you know the EF and and J and Drake and some of these people where we talk about base rollups um leak me to ethereum and that's not true like it's totally possible to implement you know even like a deterministic sequencing rule for a Bas Dr so you don't link any mbv to anyone um or you can add sequencer election gadgets to save me as a revenue right for the op chain um with the base stack that's like

a feline configuration change um so you know that's one thing that we we strongly support but the big idea is that you don't have to link your MV to layer one so base rups do not like return uh me to the layer one and I know Kyle Sone will be sorry to hear this but this doesn't make like the eth full case better in that regard now what it does do um is it increases like usage of of layer one so if you look at ether scan now Tao a live Bas Roll Up is like the the third and fifth largest consumers of of gas right of block space on ethereum which is pretty crazy to think about but um something we think about here is like is the uh the ethereum ecosystem being made better by base sequencing and by uh the

additional economic activity that is enabled through through scaling in this in this manner um is this just better for eth as an ecosystem anyway and we think yeah and so um that's something that we like to kind of promote as as the base narrative is let's not think about like me as being like a check to the validator let's think about like the additional economic activity that's unlocked here making um even like the layer one state more valuable so maybe you end up extracting more MV um but it's because uh ethereum is actually being you know improved right not because you're extracting value from applications and being unfriendly in that regard and so this is kind of our our thesis um there are some things ethereum can do to make itself better for Bas rollups I think that's probably

better left for another discussion um think shoulder block times are one example but the big idea here is that base rollups are really good for ethereum better than other rollups um because they improve like the access to ethereum state right like they uh they get more people touching ethereum every day um and that is that is super powerful for like the network effect of ethereum itself and something that we believe is you know it's not going to end up in like a direct check to the validators unless we get into pre-ops but that's another story um and is going to end up actually resulting in just a a strong strong strengthening of the um ethereum L1 itself as well as like the the whole ecosystem of Bas rups BX Edge is now live on say Network

say users can now trade 50 plus spot and per markets with the unified order book liquidity of vertex Edge across arbitrum blast mantle and say the next 6 weeks 850,000 say tokens will be up for grabs as trading rewards every single week exclusively on say join verx on say Network now on vertex Edge that's vertex protocol.com let's just briefly touch on on pre-confirmation and and kind of how you're viewing that um you know you say you say that that pre-confirmation end up with a check to validators I I'd love to hear more about what that what that

means um and then you also mentioned a little bit earlier about Spire having some of these uh auxiliary product offerings if you will uh one of them being uh uh take on pre-confirmation so so yeah we'd love to dig into to the Gen the pre-confirmation take in general and then and then how Spire approaches this yeah I know for sure so I have a ton of thoughts on this I've been um deep the pre-confirmation research for a while I just want to make it very clear that there are different types of pre- confirmations um there are layer one pre- confirmations and also based prec confirmations layer one is prec confirmations for transactions on layer one and base is for transactions on based fors orer layer twos right there's a really really important difference

here so there's a bunch of teams building layer one PR confirmations there's a bunch of teams building Bas there's some doing both um but the idea here is that we we care about based free confirmations um the reason that you know could end up with like a increased sticking rewards for validators um is because if they opt in to providing pre-confirmation through through any of these prec confirmation protocols that exist then uh you know it's very possible that they will end up uh producing a you know more value than than they would today right so they're providing an additional service that users are willing to pay for as a quick example um we did the math and and we estimated that if every user on arbitra if they paid one cent more per

transaction to be included instantly um then the sticking rewards of an ethereum validator would about double right if about I think said 30% of validat were opted in so don't send me on those numbers uh but the the important thing here is that we're um we have this like understanding that pre confirmations if users are willing to pay for them can be a big Revenue driver for for stickers uh yeah so let's let's talk about like what do um what does it mean for Spire so we're we're really bullish on some of these preon protocols out there um I won't name drop anybody at the moment but we're talking to a ton of teams and we're we're really excited about what they're building um we're not building our own pre-confirmation protocol so you know some of these teams can do it

better than um than we can and so we said you know why don't you guys use it and we'll just let the market decide what kind of pre- confirmations users want um and then we'll just make the base stack like compatible with all of these at the same time um and so it's kind of permissionless Market competition is what we kind of promote an incent device here to to give users like the the best of the pre-confirmation protocols that exist um so that's something we look at in terms of our auxiliary products we think break off per missions are um not like super important to base rups I think they're less important than maybe Justin Drake does but the uh they are important enough that coordination from like one Central team on some of this um will be nice to kind of get some of these pron

information protocols to work together and also to just make pron informations friendly to users so you don't have to install a new wallet to use PR confirmations to you that's that's one thing that we solve and so yeah I I think kind of a more technical dive into each of these would be better um in the future but that's a quick primer so we introduced something called the pre-confirmation registry which is a kind of validator or Staker facing product that allows pre-confirmation protocols to use collateral um kind of slashing rules together so they don't need to build their own registry um and and kind of allows for a unification some of these things so this is a uh open source public good we don't make any money off of the industry um and then the pre-confirmation

RPC U formerly known as pre-confirmation Gateway a little naming mixup um with some things that Justin were running I did I did uh coin the name first I'll just tell justtin that but um he went out in the research now so yeah you can go on eth research and find some of the um some of the things that that I talked about here but the the big idea is that uh we want to abstract prec confirmations from users so as a user I want to see a Green Sheet check mark in 100 milliseconds I don't want to install a new wallet I don't want to you know just something um I don't want to like have another gas slider in my wallet experience that's a that's a terrible ux we're trying to make ux better here not worse and so and so we said instead of

you know spinning up like a um a new wallet or or you know setting up a front end to do this what if we just had users send their raw transactions today to a special RPC that gets pre confirmations for them on their behalf and that's all it is right um and so this pre confirmation RPC takes transactions um does some like some math to figure out how much MB they leak does pre confirmation tip pricing and some some other complicated stuff um that we provide as a service to users and then we route those kind of packaged up pre-confirmation requests to pre-confirmation protocols so anyone that's integrated with us go ahead all the code will be open source so you know easily forkable anyone can run this we will run one um at the start just to uh to make it easy to kind of bootstrap

some of these Bas robs but that's a that's going to the big idea with a pre-confirmation RPC is like how can we take the actual user experience um from from one to two instead of one back down to zero given that you're open sourcing this RPC and and these RPC providers are making money hand over fist one of the few Proto few crypto projects that are making money in the ecosystem along with along with these rollups um do you do you have any concern are you thinking that maybe you know the the likes of infura or Alchemy could kind of take this this idea and send their me their order flow through to uh validators that are providing these pre-confirmation or

or is there an integration opportunity or how are you thinking about um users switching over or integrating with existing [Music] rpcs cartey is your home for app specific rollup at the Forefront of developing new tools and platforms that enhance the capabilities of blockchain Technology carty enables applications that are flexible and built to scale build on a full Linux environment and use traditional software libraries but in blockchain development go to cy. that's cy. to learn more about building your

own app chain today for sure yeah so so value and mode are like a a much longer discussion we have a very different take on this than some other rollup Stacks even some just every team in crypto I think um so we should definitely talk through that but uh just kind of overview of this specific question um the the RPC itself is a um is an open source product but there are some like contemporary algorithms that we develop that are about me and like pricing PR information tips um that that make it harder to fork and out compet us at day one uh we fully expect that you know the Dark Forest always wins and we will we will be out competed eventually um but that's where we kind of fall back to the power defaults so if you if you do spin up a based app chain and you see um

different options out there but the default is the Spire pre-confirmation RPC so whenever users switch to a base app chain they automatically have the the Spire precon RPC um that does give us a good starting point um there's also some some research that we've done internally that shows there's a pretty big Advantage for the more transactions that you see um the better you are at pricing every one of them so we'll not only be able to be default but also um if you do the the data I think you'll be able to see that we end up pricing some of these pre-ops better than other options with that being said like it's not our specialty our specialty is building a deployment option for applications that is better than anything we've seen so far in crypto um and and so that means that we're more

than happy to to Outsource and coordinate some of this um some of this work we do have an internal team working on it but uh we're also you know more than happy to look into Integrations with some of these other teams as well awesome yeah I wouldn't phrase it like competition at this stage at all right right right yeah no that that makes sense cool man well I mean I I think there's you know you left plenty to be desired but I I think we went really deep here and um this has been a great primer and introduction to based rollups but but also despire and and has really set the stage for what's to come in the ethereum ecosystem um and so yeah appreciate you coming on and uh giving me some renowned Hope on uh on the the future of ethereum I think it's still

bright despite what the Twitter trolls are saying so appreciate you coming on man yeah sure no problem um I'll just kind of finish this part of the discussion by saying that bass rollups are a amazing option for application developers and if you're uh if you're building an app or you're thinking about building an app or you already have an app um then please reach out to us we we'd love to do some more of your research and understand your specific desires and and how we can help you um I think there's there's actually like a people don't realize this yet but Bas develops are like the a killer um we introduce uh a unified ethereum right and we have a whole bunch of marketing material but um I I'll save that for later where we talk about you know bring the applications home to ethereum right

and then we kind of understand that this a a a strength right and a ordination in in a time of need um looks like the Constitution for America right beating out the Articles of Confederation so this is like the bankless narrative um I'm sure but the uh we think about this as as being super important to the future of ethereum but also just the the future of of crypto right I think there's a lot to still be exploiter and a lot that we need to prove um and a lot that we are going to prove but you'll have to wait and see about that absolutely looking forward uh to hear more about that and having uh having some more conversations um awesome Matthew that that was uh that was a banger thank you so

much sure yeah no problem