Modular March EP 1: Unifying the Modular Ecosystem with Union Build

Transcript

welcome to modular March I'm handy this is Robbie and we are the rollup modular March is an educational experience about all things Moder [Music] enjoy [Music] welcome back to modular march today we

have gal from Union build talking about the Sovereign interoperability layer welcome to module March hey Andy super excited to be here yeah I'm going to talk about Union The Sovereign interoperability layer for the modular St today as well as some more uh philosophical mind share about modular versus monolithic and kind of the utopian abundant future that we're all trying to build fantastic looking forward to it of course Rob's here and um not our first presentation with Carell but I feel like this is going to be the most interesting one yet so excited to dive in let's do it all right a little bit about me uh I'm Carell ZX kaer Carol on Twitter so

give me a follow uh I'm a developer meaning crypto since 2016 doing anything from solidity substrate Cosmos SDK Bally all across the stack and founder of Union Labs currently heading that uh today going to be chatting a bit about my modular mindset and how I see and web 3 as a whole uh transitioning from uh a monolithic uh stack where a lot of control lies in the underlying L1 to far more abundant stack where I as a developer can actually finally build what I want to build builds um to start discussing that I first want to kind of dive back into origin why ethereum and almost why Crypt out um web3 is the goal of building the world computer basically

one layer where any Dy computation can happen where code is law so when you interact with an APPA protocol it's completely predictable what's going to happen completely trustless no intermediaries no company that could dive into the database and alter your funds for example uh verifiable so not only do I know that they're not capable of doing this but I can also check that they're not doing this and track this and without any intermediaries uh General the only layer that we have is the mining layer or the validator layer um and no other offchain component can have any control on the contract that's really the goal of web 3 of ethereum of salana and really from a de perspective what we're trying to build but this

results into of course is a really great use case for finance because in the end Finance is kind of the frontier of would almost say combat right now like we do economic Warfare restrictions this is where kind of most of the cowboy land is right now and so having all of these properties in finance is the clear use case for web 3 to me think with defi right now 100% what we see um where we're kind of um see this power come from is composability so uh the reason why ethereum is so great is I wrote a really simple contract someone else WR a really simple contracts and someone else can build a third product by combining these two we have this money Lego uh concept where basically

with just a few core products we can create almost infinite products like a real Cambrian explosion of products um all because they are composable uh composability only works when the protocol interactions are the same security level as just calling a single contract so if I call a contract that uh doesn't swap on un swap that has the same security guarantee as if I interact with some um Vault strategy that interacts with Unis swop like that interaction between the deck and the Vault contract has that same security guarantee and that's why you can do this composability um for me at least at the moment we're building one single Global computer that's what we see with salana that's what we see with ethereum um and this

kind of in some point leads to a bit of a dystopia future because uh the single computer first of all came out skill so we have um issues with me and only high value trans can get in so not everyone can be included anymore and there's an issue with censorship resistence because one single Global computer has one single Global sequencer in the end and so what we might see for example is validators unwilling to include transactions uh for tornado cash or perhaps for uh certain country IPS at some point even and so building towards a singular Global computer leads to a world where we're not really web three anymore we're not really doing open finance for everyone to me the solution to this is modular architecture this

allows us to scale infinitely um while at the same time remaining censorship persistence having products for everyone out there um in uh the mo St we have a few Concepts to kind of have the same guarantees of composability it's obviously shared security which allows us to create many different blockchains but still have the same massive security that ethereum has for example um what execution proofs even the next generation of this it basically makes it so you almost don't need shared security anymore because now you have mathematical indisputable correctness and then of course we have data availability and sequencing which kind of separates this into individual stacks and that allows us to basically offload certain risks because now um the parties that are responsible for uh execution

don't decides on the order of the transaction so we get more censorship resistance and modular is obviously On The Rise I don't need to tell you guys that but over the last couple of years we've seen this Cambrian explosion happening it's only continuing like so to me this is amazing to see this is div Vision why I originally went into crypto to really kind of see the full wideness of experimentation however there are still a few problems with modular the way it's right now is it fundamentally cannot succeed cannot beat ethereum or Solana yet because what we gain in security and sensorship resistance at the moment we lose in composability um asynchronous composability basically bridging transactions and other interrup at the moment just isn't as good as synchron

composability we don't yet have those same guarantees that you get when a vault contract calls unisoft we don't have that when an L2 calls uh another L2 really the issue that we have right now is that we do go outside of this very pure mathematical blockchain space and we kind of add this third party intermediary to facilitate composability um and obviously that's not going to work out because the world of inro that we live in right now is kind of the same as if the ethereum foundation would need to Whit list every single contract can you imagine that like if they had to do that since 2015 we wouldn't see this Cambrian explosion we would have 60 contracts on the eum right now and nothing would be going on and no experimentation could happen and that's kind of the main

limitation Factor right now with uh composability with interrup is that we don't have yet um the kind of same guarantees the same security that allows us to allow this composability synchronous we have Cod is law we have Atomic execution and really kind of web 3 ethos a synchronous we have these intermediaries sometimes they are oracles sometimes they are multi contracts sometimes they're market makers with intents but they still don't provide the same guarantees um we don't have Atomic execution so we end up with these like broken States funs are in limbo and especially if you do like contract to contract calls on different layers you can't have something remain in limbo because contracts can't like make an API call dive into a database and such and so then you need all this

offchain architecture to fix up these limbo States and then all of the sudden it's no longer pure smart contract or pure protocol it's a whole Web Two surface that you need to run next to it to keep it working and most of the time to fix these broken States you kind of need to use like admin keys or some form another to deal with this so the real question that we Union ask ourselves and that we try to uh build for is how do we make asynchronous as good as synchronous like how do we introduce the same guarantees that we get in monolithic stxs into the mod stxs and that really is the solution to making sure that modular succeeds in the end and then we can build out this abundant ecosystem it's also some of the hardest out there um no longer do you

just get the erc20 interface or ERC interface between smart contracts you really now need to dive so deep into the security stack and that's part of the reason why we haven't seen these products out there yet they're just a lot harder to build and they require a ton of research to do so so in the space right now a few short cuts have been made by different interro providers that's fine because in the end like we need to get product to markets and we first need to deal with the world of like 30 chains wanting to start with each other but in the end with modular we're working towards a future where we want 10,000 chains and 10,000 rups to talk with each other even 100,000 and right now infro protocols deal with 80 to 100 so we're really just not there yet at all what we really need to do to support

this future of like 10,000 chain 700,000 rups is invert control just like the ethereum foundation can't widel list all of the contracts and intro protocol can't have a bdq and just talk with teams and decide we're going to do this one first this one next because then it's just never going to scill out then we remain in this kind of web two mindset of permission systems really um oh this should be interoperability uh yeah inability is not a privilege um it's a right right any Builder should be able to create an app chain create an L2 and connect to the wider ecosystem that's not something that's only reserved for projects with already billions in tvl that are extremely high like I love protocols like dydx bar

chain and such and they have no issues doing Partnerships with major intro providers the agression that we need to ask us is how can we make the next 10,000 or 100,000 startups build the same products or competing products or new products using those same Stacks startups that don't yet have 500 million in funding don't have a massive uh Community but instead are starting from scratch how do we provide them Unstoppable systems as well and how do we get them to hypers skill so for that introp needs to be inverted these startups need to be able to integrate themselves they need to be able to just boot up their new layer connect to the intro protocol and permissionless connect to do this obviously it needs to be extremely secure and trustless

because if you're going to allow others to connect to you now you introduce potential vulnerabilities right you can't just trust any chain you can just have them run a multi bridge and blindly trust that MC Bridge because the first thing I would do as a def is set one up and just like M sense with my MC rights so really we need to rethink the underlying security systems that we have for interrup as well and to us at least like security is not pick and choose we see some protocols out there that say choose your own security do like multi for certain messages do fraud proofs for other messages that just leads to a massively complex in player and one that leads to a lot of vulnerabilities like do you really want to make all of these startups think about which message needs to be of the highest security which one

doesn't or this leads into situations like tornado cach where the fundamental protocol was Secure but the doubt that cover it wasn't monitors as much and someone just manages to sneak in a proposal you have the same with these messages being send out maybe this new protocol decides a security standard for a message that's too low which an attacker uses to in the end hijack the entire protocol just like with websites right like we have htps everywhere now it's just not a chust like it's not only for banks it's not only for financial transactions everything should be just at the highest security level for this to work so otherwise you lose the compos abilities again imagine a world where some smart contract calls on ethereum are trustless and are pure but other smart contract calls are not at all and

might just go through a hackable intermediary but it's not observable to you now as a developer you can just integrate any contract anymore with the same security guarantee you need to dive into every single one and assess what's going to happen and have a home security model to it um really to achieve kind of the same guarantees that we want you have to do consensus verification that really is the only possible solution that scals to what we want to build with inter here consensus verification inherits the same security guarantees of the underlying L1 CRA bridging so in the end you inherit ethereum security guarantees celesti and you don't introduce third party intermediaries and that's kind of the best that you can do right uh really inherit the billions of security uh underlying and really the

only way to do consensus verification properly is using zero knowledge proofs um this for the less technical people here really is a scalability thing if we go to this abundant f of 10,000 rollups all integrating with each other we can be allocating 50% of our blob space to int we can be filling everything up with bridging transfers because in the end we want user transactions we want swaps we want lping we want gaming Etc and we want to make this communication between apps as like little cost as possible and with zkps you get that scalability really ensure that you basically have a constant cost you allocate 0.1% of a block to interrup and you can connect to as many chains as you want and so this leads to this hypers scaling this high

security and really makes asynchronous composability as good as synchronous and then permission is uh infra is what leads to hyperscaling and there's tons of depths out there trust me that want to build their own app chains their own l2s and have full control of the stack but really right now there's just some fundamental business choices that don't allow them to do this yet making interoperability of right is really what allows them to do so um if in the end the intro protocol has to choose to support different chains and has to make value choices there and make a stance it will fa in the end uh it cannot skill with crypto it cannot skill with web3 um it then kind of becomes its own like permissioned Corner that in the end at least to me isn't aligned with why I

originally started developing on ethereum which was to be S to have full control of my funds to build whatever I want to do with it what I want we at Union have chosen to use IBC as this core protocol IBC is originally from the cosmos ecosystem to connect app Chains It's kind of really the uh TCP of uh web 3 uh fully designed to adhere to everything I've said so far we also made the decision not to do our own proprietary protocol because there are a lot of intro protocols out there right now um and in the end that means that instead of having 14 competing standards you have 15 competing standards uh so we made the choice to instead align with what we thought was the best standards U meanwhile IBC has grown a lot when we

first started building on it it was about 200 million in monthly volume right now it's about 4 billion in mully volume you think out of like all intro protocols it's it's number one at the moment in mully volume and so really the rise of Grassroots protocols uh that kind of originate from the developer Community to really like uh solve this core needs um I think this was going to be a leading uh narrative in kind of the next modular wave we saw with like the rise of the internet that a lot of massive companies that were kind of too big to fail try to do their own proprietary protocols IBM had their own version of Internet protocols um and Bell Labs working on it but in the end like none of those really succeeded and what kind of succeeded were the devs

with the gray beards in their attics working on Linux uh inventing kind of protocols that didn't have um any like kind of PC backing Etc that reach the top so that's our bet as well what are we doing right now um so Union itself connects basically IBC enable chains um we do IBC Integrations we connect with different settlement layers with different data availability layers we support Sovereign rollups and rollups building on The Sovereign ecosystems example movement um right now this doesn't sh let show aail but on Alpha we are working on aail Integrations as well and then finally basically integrating the kind of more pure evm rollups as well that don't just

Sly like rose in the Celestia ecosystem or the clour ecosystem as well really the objective is to have that one standard player across everything that just supports whatever developers need to do and this is kind of our objective for uh the next year and a half but really the big picture right and the like utopian future that we're working towards is proof of proof technology first we get to a world where chains are sending hundreds of C proofs to each other all with their individual channels different connections and a routing layer that's necessary but the future of zkps is actually collecting all of these proofs and then putting them into one single ckp which you then send out to all the chains this leads to that

massive scalability where you only need to allocate 0. 1% of block space to interrupt and you literally have a connection to every single chain out there not hundreds not a thousand but 10,000s this is also where I think the frontier of intense is going to happen because if you have this like fully trusted layer based on zq pce it's incredibly cheap to run you basically build a decentralized sequencer for interal where every single blockchain that you're connected to is kind of a that goes into this decentralized sequencer where you could do intense coincident of once do all of this inside the zkp settle the zkp everywhere and so you're not even paying gas for these intents you're not paying gas for this coincident of mons it's literally the same gas that you're paying for the

security itself and now that's kind of the modular utopian future that like we're building towards that I want to see that basically can just completely subvert web to Trad F and which we can use to reach trillions and volume uh and basically like get everyone uh basically banked or at least crypto banked and that's my objective the jun's objective and uh uh that's at least why I'm excited about modular and what my modular mindset is horizontal scalability is the future uh I think everyone in this call fully agrees on that light lines and zkps uh are what can uh support this or enable this and really the future is modular all right guys that's it

yeah that awesome um ton of questions um going to start all the way back and then di into some of the uh uh um stuff in the beginning or sorry more towards the end I wanted to particularly touch on this one oops um on this could you maybe just unpack this uh decentralization Spectrum a little bit and walk us through uh maybe some some some uh brief technical overview of each of these components and and how they kind of Stack Up up against each other uh going from centralized all the way to uh decentralized yeah exactly we can kind of divide this into two halves on the one half we have single signature multi signature and MPC uh quadrant these are

all technologies that rely on having a set of offchain actors that we trust and really there are kind of security optimizations with a single signature system you trust a single signature relayer I'm not sure if we saw many intro protocols do this I'm sure that a few out there I think CA actually right now relies on this this obviously like extremely risky because you have a server somewhere doing bridging transactions with a single private key and if hackers get access to this it's dumb um from kind of a bigger picture perspective it's also a bad idea because you fundamentally trust the single party for your protocol so even if this party isn't hacked if they receive a letter from the SEC or the say uh knocks on their door or they just decide they don't want to comply anymore then your

whole system falls apart as a security optimization to a single signature system you can do multi6 there you basically pick a few parties so you see three five seven parties that need to collaborate and collaboratively sign the downside is you kind of usually see that these are parties that know each other right like two are depths from the protocol one is an investor one is an infrastructure provider that's a seat investor as well and one is perhaps some other person that they knew and now you have a decentralized system but really it's still five people running a server in the US that still have that same vulnerability to the SEC the NSA or just deciding to collaborate and work the protocol multiparty computation can kind of skill multi sick out to 100 nodes

that's what XLR uses if you combine that with like a validator set with token governance you do have like a much better system and a much more secure system U but in the end like validators know each other you still have like a group of on of chain parties that make decisions for the protocol and so bigger pictures still up at greates then we go to the actual decentralized qu consensus verification and state verification and with consensus verification we inherit the security of the underlying validators of the two chains themselves so we don't introduce like a new group or an offchain party that has to make these decisions so that's kind of the best you can do because you already rely on these validators because they are the ones running the different chains so you don't add any additional security assumptions what you do have with

consensus verification is if 2third of the validators are malicious which to be honest I think has never happing Jet and it's really hard to perform an attack like that uh but you do have a risk if that occurs State verification is like the full golden standard and basically what you then do is you combine uh the validates as a settlement layer but the state transition so the execution is a ZK rollup itself and that way they cannot commit frauds even if they want to do this um that's kind of the golden standard that's what polygon is working on with their aggregation layer the downset is right now you can do this for any chain you can only do this if you like support very specific SEC rollups which are quite Limited in their capabilities and so if you want to support like the caman explosion of

products then at the moment this won't work yet for example uh skip protocol Slinky wouldn't work at the moment with this so you're really like limited with what you can build that's why I think kind of sweet spot at the moment lies at consensus verification until we make a little bit more progress with ckp technology right now for example even those Sy sp1 is great if you want to like prove a full ethereum Block it's still 40 minutes to do so until we get that down to 12 seconds really State verification is a bit too far away to be usable for the ecosystem I give it about three to four years until we get there maybe earlier awesome great um yeah rob you go ahead yeah I mean what what's the limiting factor like what is the what

are the obstacles what are the blockers for State ver is it a hardware like we we just don't have the processing power or is it more of a mathematical problem that we're still trying to solve no it's it's really about about processing power so right now we can do it it just takes way too long so things like GPU acceleration uh ZK S6 and such can basically unlock this Hardware has a long cycle right like you can't iterate on a weekly basis you have to build these chips iterate again and again and again so we see right now performance from CK S6 is good enough we just need a few iteration Cycles to actually get there gotcha gotcha another really interesting point was which might be simpler than I'm trying to make it on these two slides

you you mention in this feature with one proof to rule them all you know you've got all these different chains interacting with one you know ZK proof that is basically able to be shared with all those chains at the same time simultaneously with a a very small percentage of a given block I guess just like how would that look so there's in a block there's different sections that are made of like the state of the transactions of like you know which validator validated the block and then there's like I guess just talk to us a bit about how these blocks are like structured like what the subsets are and like how when I yeah when I talk about blob space usually what we refer to is

the gas in the block so if you need 10% blob space that's 10% of the available gas which you can't use for user transactions then um that leads to like State growth and search as well um with zkps we have constant cost so you can do like a ton of computation and proving time increases with uh uh the more comput you do but the verification stays the same so you always pay the same amount of gas 230k gas for example now if you start connecting chains with ckps then in kind of the initial version that you do you let's say you have one chain that's connect to three other chains each of those connections is costing you 230k gas per um like proof that you do which means that let's say 230k gas is 0.1% that means three connections cost

you 0.3% of the block space and so if you go to like this 10,000 chain future it stops working now the power of zkps is that actually we can aggregate them so we can take two zkps and create a third ckp out of it the third ckp then again has a 230k gas cost so really the future that you work towards is first get to a state where we have a bunch of ckps being settled on chain right like this 10 being settled and then add a ckp aggregation layer where you now bundle them into a single one and that then gets you down to that 0.1% again and now that's kind of the golden standard because that's infinite scalability that you derve at and that's kind of proof of proof technology what I think is like

should be the future of interop it also means at the moment of When You Reach this then you don't need to say all right like I'm this L2 I'm going to connect to this bigger L2 because this bigger L2 has connections to even more chains and then I need to route through them you certainly get that everything is connected to everything because every one has the same zkp so they all have state connections to everyone else and so really instead of going through bigger chains as intermediaries you now can just do almost direct calls to everyone there and that's kind of that step towards not really Atomic composability but really fast composability and really secure composability without there being these limbo states where let's say you want to like route which you need to route through osmosis what happens if the second bridging transaction doesn't

occur and now there's fun stuck on osmosis it's like a bad state to arrive in really you want that direct connection because then either funds go back to the original user wallet or it succeeds completely on the other side and and that's the best we can do so basically just to make sure that I've got the right kind of picture here all of these chains in in this diagram and any chain that Union connects to in the block of these chains there's an agregation of proofs that allows them to include any you know cross chain messages or transactions that happened or you know any data from other chains into their block and then also every other chain that's connected to the

union system or even just a broader ZK proof aggregation system also has like validation that that is like correct and is also a part of of the state of their chain as well like yeah exactly yeah yeah exactly like it's basically the closest you can get to the kind of Monolithic feel again where every single smart contract lives on the same chain and they can carry each other you get that but then for 10,000 chains all living together um so that that's the Final End state for introp like that's where we're we're heading to um you can do better than that at least like maybe we need to uh smoke uh a joint to think about what the next iteration could be

but I can't imagine it like this this is the end state of in so like interrupt is trustless permissionless interrupt proven by ZK technology is baked into the blocks of these chains that are just all connected by that it's impossible to have a misalignment of State because of the ZK proofs EX exactly and then because you need to generate the ZK proof at some point that's the point of like real value ACR because got all of these like queries messages coming in from chains you have a big zkp approver running you can actually just run like snark contracts there or other circuits that do def5 for example so let's say that um someone uh from uh osmosis sends a swap request or a transfer request to

dydx and somewhere from dydx to injective and Ive to osmosis at this like sequencer step you could actually prove that you don't need to do these swaps and instead do coincident of once and so just end everyone with exactly the same end state or if you know what the interactions on the other Protocols are going to be you know it's a swap transfer that's happening you might match that with someone else so the security stays the same for the end user like they get what they asked for um but you can do your own optimizations there to either spend much gas or basically have different Market participants Traders and search integrate with this and the the ZK proofs are very easy to verify but they're very difficult to

generate is that yeah that's that's a COR of ZK uh technology normally like generating a verification and say that it's the same cost but because onchain we pay a lot for things and offchain we barely pay anything for it with ckps what we try to do is make the offchain co offchain cost a lot higher and the onchain cost a lot lower and because offchain we can have a single server that generates this and on chain we need to like run it over all validators to be verified um and so that's a core of ckp scaling technology is this kind of trying to create this imbalance um for optimization got it and the reason that we can create this constant cost of ZK proofs is that because once we're able to generate proofs at a very very quickly and very

low cost it's very easy to verify all the ones that are packed into that one block so the validators are doing the same thing that they've been doing and they can easily verify that proof of proofs but it's about packing all of those proofs generating all of them into a single proof that it's very resource intensive yeah and uh it's it's kind of amazing to see the difference because it's quite trivial to create a circuit that could generate appr proove for 10,000 erc20 transfers but the cost that you're paying for this is about the same cost as 10 erc20 transfers so really like with zkp tech you get a massive like uh scalability increase and so in the end like users pay less gas right so more money goes to the protocol or the

whole product becomes a lot cheaper um part of modular right as well like no one wants to be paying 300 million in gas fees through their users to their underlying L1 they want these funds to go back into the protocol or more trading to occur more liquidity to have 100% And that's the that's the cost element and then there's also the speed element that you talk about with asynchronous and synchronous composability and so does synchronous composability get unlocked once we're able to do state verification because once we are able to verify the state or I don't know if it's consensus verification or state verification but once we're able to verify the transaction in the same proof that we're

generating that's when we're able to do these things one after another and they don't have to run in parallel maybe you could kind of like demystify or unpack it what does asynchronous synch and parallelization mean in this ability so it kind of depends how far you push it for modular Sovereign rollups you can never get full asyn synchronous composability because of their Sovereign if they share like a sequencing layer you can do this um asynchronous composability what it really means is if my smart contract calls a DEX contract for swap it gets the result back immediately asynchronous composability means it gets it back the next block and that's just fundamental

because like it has to go to that other chain to be executed there now with bad asynchronous composability we uh can get into intermediate limbo states where the swap didn't occur but my FS aren't back either and so there's some total failure with good asynchronous composability either it succeeds and everything that I wanted is executed or I get all of my fence back but there's no in between states here and that's kind of like the golden standard I think we can reach with asynchronous composability because then uh at least for like the end user itself it's kind of the same as like a Solana transfer failing like you just execute it again and you try it and not even that occurs that often to be honest um yeah so that's kind of the the

difference and where we try to push it yeah there's there's a few presentations so far where there are um attempts at Atomic composability and very similar structure where they're trying to get a transaction to either if you're submitting two transactions on two separate rollups either they both go through or they both fail and if you're able to achieve that communication across rollups you've achieved Atomic composability yeah the one downside is it's kind of similar to adding extra accounts when you do a transaction salana you have to pay more for it because you need to apply more locks right because it needs to succeed on both sides you're kind of

stopping trading on the other side until this get executed so in like total through but asynchronous will beat synchronous composability because you don't need to apply these locks um so if your product works with asynchronous composability which I think in general like users are used to asynchron even when you interact with ethereum or Sal you submit a transaction and you have to wait like 10 seconds for something to occur um to see the end result so in general most products can actually use asynchronous composability but really synchronous is only necessary if you want to do flash loans because a flash loan you need to pay back in the same transaction otherwise the protocol loses so for that you need to apply locks I think for almost all other interactions that you do you can actually use asynchronous and and right now the

hardware just doesn't allow us to generate proofs quickly enough or cost effective enough to achieve synchronous composability that and with synchronous composability you lose your sovereignty because you need to now let another layer handle your sequencing so you have a shared dependency on sequencing um which allows for potential sensorship attacks again right like if you use a decentralized sequencer Network where all validators are based in the US then once again if you do a a privacy rollup what's going to happen to you yeah so you anticipate even in you know three to five years down the line when Hardware is at the AT metal and were able to submit these proofs very cheap and very quickly you still think you anticipate that some

rollups will choose not to share like the proof of proof aggregation to maintain sovereign well they'll still do the proof of proof but they will do proof of proof for asynchronous composability because the world that we're heading to even with decentralized sequencers right now that they're most likely going to be 10 decentralized sequencer networks and so you might be able to do synchronous composability within them but then what do you do in between them right so asynchronous always remains like the super sets the kind of everything solution and synchronous is almost an optimization within small ecosystems you can actually uh do uh synchronous composability in polad for example like their protocol supports this because

bulol itself is actually a sequencer and the different PA chains themselves are rollups and so they use this massive sequencers for this which you can do it when you go across different ecosystems like either you buy in fully into the tech and you're completely within it or um it doesn't work for you and that's why I kind of think asynchronous will be the big driver because it supports different products with synchronous you kind of get into like polygon's irrigation layer like if you choose this specific text Tech and you build everything with this Tex stack it will work for you but then we have so many people wanting to build on different Stacks right and try to experiment around yeah yeah really interesting stuff so with Within These groups of sequencers that tend to form around one another we'll achieve synchronous composability within those groups but

then we'll have to have asynchronous to communicate between these different sequencer groups exactly yeah and for sovereignty too that makes sense with the synchronous there's almost like a weak link issue or the most censorship or the least censorship resistant issue yeah it's Alla you get an extra feature but you lose on something else what I appreciate about the way that you think and the way that you guys are building this is you're doing this almost like with the true like unfuckwithable like like we're g to build stuff that can't be taken down that can't be taken apart that is just like almost like you know almost like nation state can't touch this stuff

right that's kind of like the like the end goal here to be honest if you're not building your products not to be taken down by the US government what are you even doing right oh bro I love it all right so kind of going back now to like the Practical well the zek stuff is quite practical but like the more of like okay what can our community watching this understand as to how this like looks so yeah I mean we've talked a ton about this but maybe just like explain a bit about this diagram like what's happening here and you know is it any different than what we've just talked about or maybe explain a little bit here as to what's kind of going on yeah so the initial state that we're working towards is not yet the

full proof of proofs so for certain chains we might settle multiple zkps that's very much like a value decision on our side because on some chains gas is cheap enough to just do a few for multiple connections um initially y Union was very much Cosmos focused but in the meantime we realized it actually kind of it's like Network that can be taken down by nation states is wanted by almost everyone out there so we've bred out first into the celester ecosystem now we're in to at theil um we actually like some uh Alpha uh we have our school integration almost ready so I think our principal engineer was tweeting about that stuff and so really like roaching out to the intro player that cross everything that's happening um we're at e Denver now we have a bounty out as

well so uh the first kind of uh developers that aren't even from companies that we partner with are starting to build on our stuff we're doing a ton of work right now on docs and uh UI rollouts so expect that in the next couple of weeks and that kind of allows people to start playing around with this stuff um some things I'm extremely bullish about even though they're kind of on the smaller side is for example uh the first stargaze integration which uh allows us to uh have stargaze settle on ethereum and kind of make that an nft co-processor for ethereum it's nice because least like I own some B kits so I'm happy to support that ecosystem and on The Wider scale um with a l of the new tech that's being built uh on the St side like

movement and suchar basically this means that we get like enshrined inability so for third party deaths building on top of this you can just interact with other products out there like you can just access liquidity uh without paying high fees without needing support from a specific uh intro protocol out there in the end like it's still uh inro so it's still bridging transfers message passing interchain accounts and uh uh storage proofs so data requests but at least I think um that it's the only solution I use as a developer out there right now compared to all other V Solutions it has the the least friction and the best capabilities and right now you you've got at least two proofs that are going

on here got the da proof from Celestia and and now Avail and and then you've also got the settlement proof to ethereum yeah so for example like this this diagram isn't like completely correct it's nice overview but what we're doing for movement for example is we're generating one zkp but it tracks movement consensus and celestius consensus and so we fold both of them so it's kind of two light clients in one single proof it already shows the power because normally you'd need to track both individually and pay for both individually but now you get them at once um for scroll we are running light clients on scroll itself so those are folded into a proofs uh scroll settles about every 30 seconds to 1 minute on ethereum the scroll light client is

actually an ethereum light client and we access Scrolls data through a storage proof and so when you want to connect to scroll you automatically get a connection to ethereum as well with that or the other way around if you connect to ethereum you are connected to scroll and there you already kind of see this like scalability starting to uh roll and we'll see the same with polygon and their aggregation layer like you kind of pay to connect to once and you get all of them for free there was a term that you mentioned on a live stream that we did around interoperability a few weeks ago you didn't touch on it here but I was hoping to hear a little bit more about it which was single slot finality and I think from the sound of it is very important

for synchronous composability so I'm curious like how does single slot finality fit into this this proof aggregation and life like the life cycle of one of these proofs yeah so SLE Sal finality means that the moment a block is produced it's immediately finalized it's never going to be reared again uh Cosmos chains do this um but some other Chains Don't ethereum doesn't do this for example which means that ethereum actually very often has one or two block re Orcs you need to wait for that like you can't um execute the bridging transfer because if a rearch occurs then the deposit sides might just disappear from the chain entirely um so on ethereum's road map is single slot

finality as well which means that the moment you kind of get your transaction submits in the Block it's never going to disappear again so it's great for end users great for bridging protocols it's basically the same as a rollup that settles very very often um you can kind of compare not single slot finality to a rollup that has like a one day fraud proof window or something for full security you technically need to wait until you like reach finality or until like the dispute window is closed if you want to be really proper with how you do stuff in my opinion like Every Chain should have single slot finaly like it's it's a no-brainer most chains that don't have it right now really don't have it because they just didn't implemented initially and it's on their road map it's a bit harder to do on the ethereum

side um because they obviously have an existing system they're not building from scratch um but it's actually looking really good initially their assumptions with uh kind of how the new consensus works with BLS signatures and such they thought it would be more work on the notes but from like the actual metrics from mainnet right now um it's not at all so the road map for single SL finality is looking very good because the current system actually scales very nicely um to us like on the ethereum side we need to wait a couple of blocks you can't have this V oral clear as bridging providers like if you have this offchain architecture you can choose to take a risk if you want to it's always risky because the protocol can just lose money um if if a validator produces two blocks and uh submits one block to the

network one block to the Oracle then it can use that to do what's effectively a double spans attack yeah we've seen I mean on some deposits and withdrawals you've seen you know waiting for a 100 confirmations or or 50 confirmations and that's to make sure that the the blockchain doesn't reorg because if you only waited for one confirmation it might reorg might lose funds if that blockchain doesn't have single slot finality but I think what you're getting at here is that if you do have single slot finality you can proceed with the rest of your transaction after a single confirmation yeah exactly the moment it's produced it's confirmed um there a nobra like every chain should adopt it

yeah that's pretty awesome that that ties in here well as well right like this this this system that's on the screen is it becomes even more powerful when single slot finality is more adopted exactly like the future is a single Sals finality it's ZK pce um and this isn't just for INT like all of these things just make sense for user transactions in the end like it doesn't make sense that if I like input data with my bank it does work and if I do it on some chains I need to check back in 10 minutes to verify if it's actually arrived or not so for web three to actually be adopted meet SSO how do you handle latency in a proof of proofs landscape like if one rollup submits a

transaction every 10 seconds and another rollup submits a not a transaction but a block one rollup submits a block every 10 seconds another rollup submits a block every 30 seconds how do you reconcile the 20c difference between the block times yeah that's not really a problem you can make a choice you can basically decide to produce a proov in a certain interval and everyone that gets in uh gets in during that time and is lucky you can also generate a proof the moment new data gets in you don't necessarily need to settle it but you could if you wanted to um and then you just build on continuously on that proof until it makes sense to settle so with these systems what you ideally do is you you generate the proofs and you kind of keep a tell of how many fees has have accured and at some point you can then

say all right like there's enough right now to Warrant the cost so the more change you have connected to this the more often you're going to be setting this across with the proof of proof technology and if you build continuously on these proofs you also don't necessarily need to provide it to everyone at the same time even if all of them have data coming in um if like only transfers are heading into um Zing for example you only need to settle the next ZK proof on ZK sync and then you just generate another proof where perhaps now transfers are coming out from ZK sync you build on top of that and then you settle that back to the other parties so you can actually do like really clever optimizations here to even cut the cost down more yeah well Carell I um I appreciate you coming on and generally just blowing

our minds from modular March really excited to see some of this stuff come to light and yeah man stoked for stoked for the future of ZK I think that uh ZK has a lot to offer and we're just at The Cutting Edge now same guys thanks for having me super excited to be on again in a couple of months and show you guys all the progress awesome looking forward to