Bitcoin and Beyond EP7: Zero Trust Protocols with dWallet Network

Transcript

[Music] [Music] [Music] what's going on guys welcome to bitcoin and Beyond today we're going to be talking about zero trust protocols with Omar Omar is part of dallet and dallet is building the zero trust protocols for

applications on bitcoin Omar welcome thank you so much Ruby great to talk with you today likewise let's Dive In okay so um first of all I think maybe we can start talking about the team um and also we'll get into the concept what it means but in general we enable zero trust protocols it's something that is very important it comes from cyber security and this is also our background so we are the founders we're are coming from cyber security background we have been to intelligence uh core before and cyber security companies um also from the

cryptograph cryptographic side so we have also people from the academy on the team we have today on the team over a dozen of cryptographers and cyber Security Experts and this is really the the focus and what we wanted to do is to bring this new concept of zero trust protocols um which is something that really Chang since Bitcoin started with crypto started with Bitcoin and and we had that security Assumption of zero trust and along the way because we needed to innovate and we needed to bring new capabilities we had to change to different type of security

models in order to enable stuff but at the same time we had to reduce the security assumptions that we had before so this is really the goal this is really what we try to solve and and I'll start with talking about what it is right what is zero trust why it's important why we need it so in web to cyber security it comes from web to cyber security and also we have that in in crypto in web tree but the concept says that we have two two different security models one is called castle and mode and it it means that we have a security parameter that this is

the mode this is what secures the the castle right but if we if we get into the castle then we get access to everything we can do whatever we want and this is by the way how companies in web 2 in in in itch Right started they started with this cutell and mode Concepts but during the time the space the ecosystem started to understand like from the security perspective that it's not good enough and we need the better solution we need a better way um to change the secure the the trust assumptions that we have and this is how this new concept of zero trust can the concept of zero trust says that trust nothing right don't have the

same model where you have the castle and just you have to pass the mode and if you're into the castle you can do whatever you want let's have a different approach that every every time that you want to do something we need to verify you right we need if we need to verify that you are really the user you are really the person that make this action and you you should be able to do and to make that action and we do that all the time right so the concept of a zero trust is trust nothing validate all the time all the time and then if we connect that to web Tre um when we started with repb three with crypto Bitcoin ethereum we had zero

trust by Design okay it means that everything that we have done before was uh using those assumptions and I know that people in web tree haven't been really talking about that about this concept of zero trust but this is actually the design that we have in in web Tre like the initial design the way that we started so what I mean by that let's give you an example right let's try to connect that to to web tree so we said that in repb tree what we have Bitcoin ethereum chains there are zero trust architecture this is the model so just to let you understand what

it means let's just imagine for a second that we have a different universe and in that Universe instead of ethereum we have a a celum right which is the clein mode version of ethereum so what's the difference right how it will look like how ethereum will operate in this scenario so the difference is that in celum what we have is that we have the castle the blockchain state right so the state of the blockchain is what we really um look at right and this is what people or users will try to to change to manipulate or whatever they do whatever

action that you do in a blockchain right at the end of the day really change the state and in that case what it means is that the validators will agree what is the state right they will say that for example Andy you have five H coins right um but you have no way to validate that right the only the only way that you have to validate is just to know that they sign on a block you have the signatures of the validators but maybe they lie you have no way to to understand that to know that and if I compare that to reality to ethereum and how ethereum works then it's very similar in in in other chains like Bitcoin or other Solana other type of chains also by the way with the

rollups and l2s it's it's a bit different the mechanism but the concept is the same we have users they signed transactions and those transactions are included inside blocks right and then the validators they sign on the Block right they don't just approve the state they don't don't just tell us that's the state trust me I'm telling you that's the right State and you have five coins trust me um the difference is that there are transactions and those transactions they are the way to to change the state so it means that everyone can calculate the state using those blocks so anyone can run a full node right I can run my

own full node with with ethereum I can start from Genesis I can calculate all the blocks every blocks then since ethereum started or Bitcoin started and I can by myself calculate uh the state of today the current state when I do that what actually I does is to verify every transaction and to verify that every transaction is valid and is corresponding to the public of the user right so for example if and if you transfer to m coins there is a transaction in one of the block and I can verify that right I don't have to trust the validator that you really have this amount of coins I can do it myself I can validate myself the only thing

that we H trust in the in the current model that you have we have in blockchain specifically in proof of steak but it's it's also in proof of fork is the set of transactions that we have in every block all right so this is what they can play with but I can't generate a transaction there is no way for validators in ethereum to create a transaction that you ended you transfer coins to Ruby right you can do that but but what they can actually do they can censor you which still keep the same security assumptions of zero trust okay that does it make sense

Okay the reason why I'm talking about it why we are focusing on on that part is for you to understand what what are the security assumptions that we started with right the zero trust where we know that that we can very validate everything we can verify any action of any user every transaction um and we can do it cryptographically right so we know that we know the the identity of of the um of the wallet that made that transaction but whenever we come to um interoperability or multi-chain or in

general where we have many n networks and we live in a a sovereign H uh different zones of of sovy right in that case we have huge problem because it's really really hard to apply the same module the same security module the same um zero trust architecture in that case and and the reason why it's so hard is because now we have different uh states of different chains and we don't have a way to um make the connection between the two from the user perspective right

so you well we always have to trust some third party we need to trust like something of that state and this is how we go to this castle and mode and by the way this is something that vitalic talked about right and vitalic talked about it specifically about cross chain right versus multi chain which means that in Cross chain we have for example Bridges or we have other Solutions where we represent the asset in other chain but at the at the end of the day what vitalic is really talking about is zero trust compared to C and mode right because in that case in those solutions that let us create new protocols that

can be uh can interact in different chains in different Assets in that case it's it's almost impossible to do it in a way that is zero trust and that's because again because the connection to the user we we don't have an easy way to verify every action every transaction so for example if I'll just give you an example we have a wbtc right and if I use Unis swap with wbtc so this is a very simple example to understand we have to trust H bit goes right custody because wbtc you have bitgo they decides what's the state right and they can decide whatever they

want we have solutions that are more distributed or more decentralized H but still we have some castle that if we get into to we can change it to whatever we want right it can be centralized it can be decentralized but at the end of the day in any of those cases e either if it's easy to do right to pass the Moe or very hard if we get into the castle we have a full control we can do whatever we want yeah there's a something to add there like on the bridge stuff I I think that um chain abstraction there's this idea um that that kind of plays into this interoperability work it kind of

falls under the same umbrella where you know it's almost like the weakest link security issue where you have you know you as a user in a chain abstracted world or in a completely interoperable world yeah I mean there's a world where you end up using chains you know without realizing if you will or at least uh not understanding what trust assumptions you're taking as user exactly and I think this is part of the things that is that are missing today and this is one of the first thing that we want to make everybody in this space to educate the space to understand is this concept right so they know what

is so everybody knows what is zero trust everybody knows to try to evaluate a protocol if it's a zero trust protocol or it's a castle and mode protocol and again I'm not saying that if it's better onr it's at the end of the day it's really about your risk appetite right so if you really care about the ownership of your asset right if you are in this type as this type of user so yeah bridge is not for you right because if you use Bridge you take um a different security assumptions than you have with Native assets and many people don't even know that they think like they they believe that it's the same so here we we have a few um examples H but way we call it the

anot problem because people say like for example we I have this protocol and it has been working for years and nothing really happened that's great right but what it means it means that maybe the mode is hard to to bypass but it doesn't mean that it's impossible right that's one second of all it means that maybe the anot is not big enough yet right so maybe the assets that I can steal are not enough that they have the incentive to try to steal them maybe in two years when it will be 10x 100x then I will have the incentive I will do that right and this incentive can be from acers trying to steal all the assets and it can be also from the collusion of the participants of the

network right they can say like the token or the asset or what we what we get from being validator is worth X and to steal the asset will be a million x right so let's steal the assets right so it's really really hard to try to use that argument because it just means that we don't really we are not yet into this phase where it's worth it right we don't have the right incentive but it doesn't mean that it's impossible and this is I think the confusion that many users have right they don't really distinguish between the two right you have some things that you say it's been working for years I can trust the security because probably if we had some

vulnerability some somebody would find it but the incentive side is very different because it also depends on what you have what's theot what I can do with that what I can steal so we have example of of Tor chain right torsion is is a great example of by the way I think it's a really good protocol it's a really good solution but it's a a castle and mode protocol and the reason is because and by the way they have NPC and I know that people believe that if it's NPC then it's secure and and that's correct we also use NPC we use it in a very different way to be zero trust but it doesn't mean that you are automatically zero trust right just mean that probably the mode is is harder to

pass right it's stronger the security um that we have but it doesn't mean that it's impossible to pass to pass that so we Tor chain for example we have those vaults of nodes right they have I think around un validator something like that and they speak SPL them between different vaults and each Vault can access certain assets right and what it means is that this volt every vault is a castle right so it might be hard to get to that volt right maybe I need to act 20 nodes and to steal there not even probably it's not

20 because usually you have a threshold so let's say that I need two3 right so I need let's say 1 14 um validators and then I can steal the The Vault or those validators they can collude and together they said that they want to steal the vote because the vote worth more than their assets and more than everything that they do right so this is a great example of protocol that it's is great protocol it's super useful but the security assumption is very very different than using native assets right yeah so that's one example second example is for example Camino it's it's in Solana and here actually what we

wanted to demonstrate is that you have sometimes native protocols like um swapping or Landing like Unis swap those that they can be on Solana or they can be on ethereum and at first look you might say zero trust right because it's on ethereum and ethereum is zero trust so I can trust the protocol which is correct but it's correct only while the assets that you trade in those Protocols are also zero trust and which means only if there are native assets but once you use um rupt assets then the old protocol stop being zero trust it may be

partially zero trust right but as a user for you it's not zero trust anymore so it means that for example with Cino you have W if which is the rra version of if on on Solana they are used in gual and then H that's uh the castle right those 18 waral Guardians they are theote if you get into and you control them then you control the castle you control all the assets on warmal and you can seal everything also they can collude right so again the security assumption is that you have to trust those 18 waral Guardians right right this is what you do whenever you use WF on Solana and even if you use it on a

native protocol that may seems like it's a zero trust protocol right a different example which is unis Swap and I think this is great example because it's like one of the most amazing protocols that we have um also on ethereum ethereum is very secure very decentralized and in terms of the security assumptions again it ethereum is zero trust we may think that Unis swap is always zero trust but that's not completely correct it's correct that whenever use that with Native assets is H zero trust but whenever we use that with wbtc then we have to trust bitgo and that's the mode if we get into a

bitgo we can steal the assets right if if an employee at bitgo have access to the keys of wbtc they can steal that BTC so what we do whenever we use that solution is that we actually trust in bitgo and it sounds very counterintuitive because you think about Unis swap as a very decentralized protocol but whenever you have asset like wbtc then immediately you're not really having the same security assumptions and then we have more of the Bitcoin L2 right H which we have right now today many H new Bitcoin l2s that com in with different solutions so for

example with stocks they have MPC that is in force which is an NPC protocol for schnore signatures and they try to create something that is uh clever and and to secure to create um many small ways to to increase the incentive to make it more secure which is great which is amazing but again it's not zero trust and why it's not zero trust because we have to trust the nodes they can collude it might be harder to do that with Stacks than do it that with Tor chain maybe because they have more nodes it's more decentralized but we can do that right so again it's not about how hard it is to get into the castle

it's either if we get into the castle we get access to everything right so this is how we compare zero trust protocol to Castle and mode protocol would you say that ethereum is Castle and moat because it has a a decentralized it it has a decentralized set of validators but if you're able to compromise the set of validators then you get into the castle so actually ethereum is zero trust is not CLE and mode and cleum the example the imaginary parallel universe blockchain right this is Castle and mode right but it's not really exist it was just an example how it can be and the reason why

and this is again it's important again maybe we need to get back to it is because the validators of ethereum they're they they're not deciding the the the state they're not saying this is the state trust us the way that you calculate the states is based on transactions from the users that you can validate all the time so you can verify every transaction and this is exactly the requirement of zero trust right we can verify all the time every everyone can verify so there is no way from the protocol perspective right if you follow the protocol that somebody will be able to lie to you or and cheat and say I transfer to your assets without really having a transaction that I transfer the

asset and I signed on it right no one else on one of the blocks on E here right if you don't have that then it doesn't exist right so you can just create it from ther and that's exactly the the difference right what's the the Assumption who you should trust so in on ethereum ethereum is zero trust because the user have to sign on transaction and everybody can ver validate and verify every transaction right and with all those Solutions all those examples right we don't have that security guarantee okay and there was one question that I had [Music] um on on this real real world zero trust blockch

design so in this CA this is ethereum's case right this is a zero trust blockchain and the last sentence you say no one not even the validator consensus is trusted everything must be verified and so is that because ver is that because users are running full nodes and it's permissionless to run a full node um I I guess could you kind of elaborate on how we're able to verify the valid validator consensus and we don't just trust the validators to provide the next uh Block in the in the chain yes so that's exactly correct so the way that we validate is by running full node right if if you run full node

yourself no one can lie to you right you take what the full Noe does is to take every block right you can you have ways to make it faster and then you have to trust somebody and then you don't have to start from Genesis but if you really want to trust no one you can start from Genesis and you can execute every block and you can verify every transaction of every user since Genesis right so you know the state and no one can lie there is no way to lie right it's impossible but um in the example that we gave right you have to trust the H the validators because they tell you what's the state right you don't have in the

imaginary examples we don't have all the transactions in the block we just the state right what's the current state and then you have to trust them saying the current state actually if you want um a good technology that we have today um that uses this concept is light clients right are you familiar with the light clients yes so light light clients it's actually cust REM mode because what we say is that look to run a a full node it's it's costly it's expensive and it's not something that everyone can do so let's find a better way to have some security assumptions over the state right because today you get um the data from a full node from somebody

else and they can lie to you right it's it's super simple attack Vector right you connect to a full node a full node lie to you and by that the full nodes cause you to to run transaction or to do stuff that the full node wanted right if it's not your full node so the idea of of a light client is that we have the valuator signing um on the current state right so it's not zero trust but it's better than trus in one full node right so something in the middle but this is an example for Castle and mode that we have today in many blockchain it's not in in any blockchain it's the one that supports light clients but we have that on ethereum for example Solana and many

other chains so what we have in blocks we have both right we have the transactions and also we have the usually it's the Merle root it's not like the full data of the state but it's like it's just the the root of the tree of the full State this is a way to to know the full State and they sign on that as part of the block so you know what they agreed that is the the right um the right state but still you can also verify that yourself right you don't have to trust them and this is the complete difference between the two and if we go back to all of those examples here you don't have that right there is no way for you to really verify validate

to be involved and whenever you do stuff between different chains so you need somewhere that you have the state and you need to trust on this place right so it might be in wbtc so you trust bitgo right to say what's the state even if you have native bridges that some sometimes people confuse it's still Castle in mode because then one validator sets in one blockchain they decide what's the state in the other chain right so at the end of the day you need a way to make sure that the users wanted to make actions in both both chains together in an atomic way which in most cases and in the most

technologies that we have today um seems at least as impossible and this is also why we created dallet Network and we started this New Concept of bringing back zero trust to interoperability to multi chain something that we don't have today in we Tre so what is zero trust protocols zero trust protocols is as the examples that we have here but instead of using um technologies that are not zero trust and then the protocol the full protocol will be castle and mode is to use solutions that there are zero trust and by that you make sure that the full protocol is

a zero trust protocol so how we do that we created a new building block the first zero trust building block we call it a d wallet this is also why it's called a dallet network um and it's a building block for Builders right it's not something for the end user um it's not a solution for end users to use to to it's it's not like a wallet right people sometime con confuse between the wallet to a wallet those are different concepts and the way that it works is that we created a new cryptography a new technology we're using MPC but it's a

new MPC protocol that we created from scratch it's called 2pc NPC and this is why we have this extensive team of cryptographers and cyber Security Experts it took us almost two years to create that but it's the first threshold ddsa uh signature protocol where um it's first of all very decentralized and and scalable but from the other end and this is the important part and this is what makes it zero trust the user is always required so there is no way for the network to make a decision right to sign a transaction to any of those chains without the user and even if all the value validators on

dallet network if 100% of them collude or act or whatever really I'll take the the most crazy scenario that probably is impossible in reality still there is no way to steal the user assets and why is that it's because cryptographically you need the user to participate in the signature generation okay so this is this is the concept and Omar uh just briefly you mention zero trust uh obviously through the presentation um as as kind of like the main uh the main um kind of ethos if you will of crypto of web 3 and of what what you guys are building um you know

and then there's also like zero knowledge like zero knowledge proofs um you know and maybe we can kind of get into like some of the more technicals as to how it works but I was curious just kind of like how you guys are using ZK to make this possible if at all yeah so first of all it's connected to the NPC and maybe I will explain first of all what it means NPC I know that many people familiar with MPC maybe from stocks or Tor chain or from Solutions like far blocks um but MPC in general what it means is means multi-party computations it means that different parties can generate they can R they can run competition together without sharing

their uh secret information and you can use that to sign transactions right so instead of having just a private key you can have secret shares between the parties that that participates in in that NPC and then whenever they want to sign a transaction they do it together without sharing their secret shair so you create a signature no one have to share their own secret share and this is in general how it works for signatures like in in fire blocks in Tor chain Stacks chain obstruction today that near this right and the two problem that you have you have a few problems with the existing protocols that all of them are using is first of all

scalability it's really hard to scale those um protocols especially when it comes to ecdsa signatures which and ndsa it's easier but with d cdsa it's the hardest and you can go over around 20 30 parties and this is why for example with torch and we have a Max of of 20 parties it's really really hard to make it decentralized which know it's it's a bit better but still in terms of scalability everything is is is very hard um and in 2pc MPC the new protocol that we created we can scale it to thousands of participants and still to have amazing performance right so we are

the first one to do that uh to create this protocol and the second part is also to include the user so let's say say that you say you need two3 of the validators to to to generate a transaction but whenever you do that you don't include the user it means again they the validators they become theote and if you get access to the cell you can generate transactions freely to any user to any asset you can seal everything you can do whatever you you want in 2 PC MPC for the first time it's not enough you need two3 of the validators and it can be thousands of validators but still you need the user right so for every user you need their and when I say user it it can be

abstracted right it's not something that the user has to do right it can be abstracted as part of the protocol but the concept is that without having the consent from the user you can't um generate a transaction so you making sure that this protocol is zero trust all the time so you can think about it go ahead Robie sorry no no Sor sorry please and so we can think about it as what we did was to use the existing mechanism that we have in in blockchain for making it zero trust which is the user signatures right and on top of that we created a new layer where you can create logic between the different networks but

at the same time keep the user in the loop right so the user knows that there is no way to to make transactions without them and still the assets so this is the concept and so in the current like format of how we interact with blockchains you know I open up my wallet and I sign a transaction um and that's my public key that's signing the I I press confirm and it signs that my private key wants to do this thing my wallet I instruct my wallet I confirm the transaction and so when I'm signing that transtion action what you're saying is that in traditional NPC I need a counterpart to

ass that transaction and then I have two and I have the validators to sign I have my signature and then it executes the transaction in TPC MPC well I guess that's I that's a part I don't understand because when we interact with blockchains now we're the user is submitting the the transaction to the chain and we're doing that by pressing confirm and that signs the transactions and so in the model of 2pc NPC what is different about the user flow of signing transactions yeah so it's it's a good question so when what you explain about NPC when you use it as

a user you correct this is whenever you use something like fire blocks right or you have also retail apps for MPC but this is when you use like centralized MPC and then you do it you sign together with far blocks or you sign together with Zeno or any other of those Solutions right but this is more of making a better security from the user perspective what I'm talking about is from the protocol perspective so let's say for example that you want to create a protocol a swap protocol between BTC and E right how you do that so for example you use Bridge right and that bridge might be implemented with NPC right for example this is like for example with chain obstruction so with

chain obstruction on here you have I think five between five to 10 I'm not sure what's the exact number of nodes that participate in the NPC and they generate transactions to all the chains all the different chains and this is how they create the chain obstruction so you as user you have to give the assets you have to transfer the assets to the the address of the nodes of the chain obstruction right so it means that you're not the owner anymore right you can't sign it doesn't matter what you do you have to trust that somebody will follow your action right so then if you want to swap you you do it you swap it but this is on the abstracted layer but on the underlying layer they can steal

the asset right you have zero control over it and that's that's the point that's the concept right so from the user perspective if I create a zero trust swap protocol it means that the user will have to sign every time that you have to actually transfer the asset right so there is no way that in between somebody can steal the asset from you right so that's a difference so you are part of those of of those protocols that interact in different chains um for the logic or for the value of the protocol right so that's the difference does it make

sense yeah I guess my my only hang up is that like you know people have been trying to do atomic swaps for a really long time and so I if you know we go back all the way to like shape shift and Eric Vorhees in the beginning you know he was trying to do these Atomic swaps and I think what the issue was was that we were you know someone would have to sign that I would send my so let's say Bitcoin and eth that's probably the best Atomic swap an like a example so let's say I have Bitcoin you have eth I want to I want to sign my Bitcoin goes to you on your side you sign your eth goes to me but unless those happen at the exact same time we have to derive some consensus right and

so like if I sign my Bitcoin and then it takes three or four or five seconds you have my Bitcoin but I don't have your eth right so then Bridges started to pop up and they would do an escrow service and then so I would sign my Bitcoin and this is what you described I would sign my Bitcoin to the escrow you would sign your e to the escrow and then they would release at the same time and so yeah please yeah so what you're saying is is a great example and this is something that you can exactly solve with d wallets in zero trust way right so the difference here is that the way that you do that and by the way we have a protocol that is building on us and this is exactly what they're building Atomic

swap between different assets and their focus is on BTC so you can swap BTC and if in a zero trust way and the idea is that let's say that we want to swap right you have your BTC I have my if and we want to swap so each one of us has a du wallet right we sign future transaction to each other not a full transaction it's partial transaction so it's just the side of the user from the NPC and we both send it to dallet Network right now dallet network will wait the logic that will be for network is the D network will wait until it receives two partially signed transaction to each one of us and dallet

network can also cryptographically verify that those are the correct transactions cor right that you didn't lie and you you sign on on a a different transaction so we know that you partially signed correctly and it's verifiable and only then once we have the both transactions the wallet network will complete both transactions together right so it's it's a different way of thinking right it's those things were impossible in the past right because you don't have way to do that in D wallet Network and tcmpc is the first time that those stuff will be possible the way by the way that you control the D wallet and you write logic is using integration so integrate with

other network other smart contract Network and it can be l1s and l2s by the way we have that in the picture in the diagram and this is how we we follow the logic right so we can write logic today we support ethereum we support s we announce integration with the monad then a veil and and we're going to announce many more very exciting l1s and l2s Integrations but that's the concept so you can build the projects for example the the team that is working on the atomic swap they're doing that on S right so you can from s write the logic you can write the smart contract and you can decide what's the logic so we say

that the logic is that we wait for getting both transactions for both users we validate that everything is correct and only then we give the okay to comp to complete the full to Future transactions right those capabilities weren't possible before right you don't have today any NPC protocols that enable something like that you don't have any network that Ena something like that right but this is exactly that com that removes this escrow that you need right because if you have escrow then it's not zero trust then you have castle and mode you have to trust some somebody and the escrow is exactly that castle right if you get into the escrow you can seal everything and and that's exactly the

difference so let's talk about a few examples right I think the very obvious solution is decentralized custody so it's a solution to manage custody it can be for institutions for companies we have by the way team that is building that onu um the idea is that you can think about it like any other custo dis solution but will that it will be decentralized will be built using D wallets H the second one is staking for Native BTC or it can be any asset right so you can think about it a universal igler that is not specific to one chain and you can hold assets on any chain and the idea is that me as the user I again

I I hold 50% of the power right the consent so this protocol whenever protocol that Builders will build won't be able to steal the assets right the staked tokens and this is super important uh for staking we have the native BTC Atomic swap right we talked about that this is I think Super exciting example especially when we connected that to BTC and we we'll talk a bit more about uh Bitcoin l2s and how it all connected right we'll connect all of that because our solution is super it's crucial for Bitcoin especially for the security ass options that we have in

Bitcoin H but we have many many examples of usage things that you can use you can use that for Lending right so I can use all my BTC as collateral on my D wallet right I don't have to transfer I don't have to escro that right I don't have to deposit that in any protocol I can just hold it in my D wallet it will be locked with a future transaction for Liquidation in case that you don't repay the law right very simple very intuitive and zero trust multi-chain nft that you can borrow you can lend you can rent right it can it can be across different chains so you can create a d wallet that holds nfts in different chains ordinals marketplace right think about today how

art it is to transfer ordinals so instead of that you can just create a d wallet and to transfer the D wallet why the D wallet itself is also transferable so we create new capabilities that instead of transferring the ordinal itself and waiting forever right and having so many issues with doing that and cost and all of that you can just play with the um the account that owns the the ordinal um also we have right now doing a running s overflow which is a global aaton together with s we're costing the the aaton with them and here if people want to read more examples so we have a document with more examples more use

cases what you can do what you can build uh with d wallets this is more focused on S but you can really do it in l2s you can do it in any other L l1s right so before I'll talk about Bitcoin L2 I just want to start from rollups and now rollups are connected to to zero trust and and in general modular blockchain so rollups um there are zero trust and why there are zero trust it depends on the type of the rollup right if we're talking about ZK rollup or um optimistic wup but in both

cases we have a way to verify that the user ER really signed every transaction it can be an optimistic way that we trust somebody but then we can dispute and everybody can say it's not correct and with zik we have as part of the proof the the proof includes crypto cryptographically it includes that information that the transactions were approved and and verified right so in both cases we have a very strong way to do that and also because because it's zero trust the bridge the connection between the L1 to L2 is also zero trust right so although in optimistic we have to wait like a

week it's still it's zero trust we know that if we waited for a week it's not possible to steal the assets right there is no one that can steal the asset now let's you have a question any yeah I mean I was GNA try I was gonna kind of get to this and that I think that um it's it's important to to Define what what a rollup is as well and explain how like these uh you know these the like the ZK uh proofs work like the lally proofs or um and kind of how fraud proofs work on optimistic Ro because yeah as you're getting to to the next

slide as we kind of come to the the close I think there's quite a bit of difference between L2 side chains and rollups in the Bitcoin space uh and this power this PowerPoint being about zero trust I think it's um you know it's important to highlight what is and what's not I I agree so the the thing about optimistic rollups is that we have the execution layer and we can um provide a fraud proof to the rollup to the Executioner sorry for example if you if we do it on ethereum so we can submit that to ethereum and in that case if somebody try to lie and to publish the wrong State we can fix that right and we keep it for a week usually that's the case

like in arbit room and optimistic weak because that's the time that we can make sure that we did everything that's possible to to validate and after week if no one submitted a fraud proof right if there is no dispute we can assume um with a very high certainty that um that's the correct State and no one try to compromise the state right with ZK the way that we do it with ZK is that we create a proof for every block right so we have the sequencer that execute the blocks right and the sequencer generates the state like what's the state after running the block but with ZK we also have a suent block a suent proof that

includes executing all the transactions and verifying the the uh the transactions the user the signature all of that right so as part of that 16 proof we can cryptographically if we validate this proof you can think about it like this proof includes verifying every transaction on every chain cryptographically so it's like aggregation in it's not really aggregation but just as as an idea you can think about it that way um and usually the way that it works with z rollups is that you have the last block and they use they connect between the proofs right so you change the block

from the last so you change the state from the last block with the last state right and you connect between the proofs and because you connect between the proofs you can think about the last proof as a proof that includes only all the history right this is why Z proofs are so powerful right and also why zik roll are very powerful the problem with Z rollups is the is the time right the performance so it still takes a while it's not that easy yeah I know that with the top ones it takes like a few hours so it's not immediate but once you have the proof you know what is the final State and no one can lie but it's heavy it takes time

ER an optimistic CRA up you don't have that problem the problem is that it's optimistic so you have to wait um and this is the way that you make sure that uh the security assumptions are met so this is we're talking about rollups l2s in general not about Bitcoin the here is when we connect that to bitcoin l2s or side chains right some people say that Bitcoin l2s are actually side chains at least most of them not all of them there are few that really trying to be um l2s but the problem in Bitcoin that it's super hard to do that because we don't have Smart contracts we can't execute

whatever we want everything is tricked and limited so to validate proofs on bitcoin if it's fraud proof or zik proof it's almost impossible there are a few teams are trying to find ways to do that and let's see let's see if they succeed but most Bitcoin l2s when they say that they bu Bitcoin l2s what actually they mean is that they are kind of a side chain or they roll up on ethereum or other chain with some kind of a bridge to bitcoin so you have a programmable BTC because because you have a bridge right this bridge can be with the MPC it can be a very with a very strong technology but again when

whenever we connect that those Solutions are castle and mode right because we don't have that guarantee of L2 we don't have that guarantee of the connection between L1 to L2 like we have on ethereum or um Avail or other networks that give us this um same security assumption here because it's really really hard to do that on bitcoin so many of those Solutions what they actually do is to create a rollup or a side chain that have some way to connect with Bitcoin it might be a very very good technology very good solution but again that's aote and we have the castle and if we get

into the castle we control everything and the way that we think about it we believe that we we get it we get it that it's hard right it's hard to create a real Bitcoin L2 like we have on ethereum and people want ways to have a programmable BTC and to play with BTC and to use BTC which that do all makes sense and we also believeing in this concept and in this vision and this is why we think that the wallets are the solution to create those Bitcoin rollups side chains right in a zero trust approach whenever we get from both words

right we get a benefit of being zero trust and we get this capability of programmability of the zero of the Native asset right without worrying about compromising our asset so this is really the way that we look on that you have the native BTC no bridging no wrapping you well directly um you can use that for rollups we have a few Partnerships I think a is the most interesting one right because also you can create a Bitcoin rollup on aail and that Bitcoin rollup although it won't be like L2 execution L on bitcoin but it still will be zero trust and we believe that it's important

in general but if you connect that to to to bitcoin it's even become much much stronger because the concepts the fundamentals of R three of security assumptions are much much stronger in Bitcoin I think people that started into got into the space through Bitcoin they keep the same mentality right for example we have the phrase not your keys not your coins right it's it's very um Bitcoin oriented and it's it's correct right if you use a bridge then it's not your keys and it's not your coins right they're totally correct also in Bitcoin you have a lot

of Institutions and if you want to have institutions you have a way to hold the native asset and to program the native asset and not to use the derivative or any other representation of the asset which can cause issues from regulatory or compliance issues and also you have in certain areas right it's not everywhere but also you have tax consequences right because in some places whenever use a r asset it's like you get a new token so you like swap different tokens from the perspective of some uh tax authorities and then you have to pay tax even for that action so if you can eliminate that you solve so many issues right you always keep the

native asset and and that's it very simple and yeah I think we're we're done do have a questions yeah yeah that that was great so this is the last slide here okay so um I do have a couple questions I mean first off thank you so much for coming on this was phenomenal and it was very it was very different from the Bitcoin and Beyond present that we've had so far in the series um we've heard a lot from uh some of the Bitcoin projects out there that

are building l2s um most of them are side chains at the moment some of them are more open about being a side chain in the moment and the road map to Progressive decentralization um most of them have bit VM as like a pretty important piece of their road map and the more honest ones and even the dishonest ones basically recognize their side chains now but in order for them to become rollups uh and I'm just going to revert back to this slide because these are zero trust execution layers and so gonna make the differentiation rollups are zero trust side chains and l2s are not zero trust you have to they're castle

and moat and so most of the Bitcoin l2s right now are castle and moat but with bit VM they would become rollups because bit VM is supposedly a trustless bridge with exceptions and complications so I'm I'm curious um does in your in your perspective does bit VM preserve the zero trust properties that you feel are are important to uh make something uh zero trust and keep native assets does bitm get there so I I more familiar with the the second version the bit vm2 which is more with the the ZK

stuff so with the BVM uh two yeah like in theory my difficulty with the solution is if it's practical right that that's that's really the issue and maybe it's it's practical maybe we need to have some upgrades for Bitcoin to make it really practical right but I feel like it's not mature yet it's not I think like the project and the team everything seems really good like the right approach and this is this is what I will I will really look at as rollup right a real rollup ER but at the end of the day it's really really hard to do that with

the Bitcoin just because of the design because of the capabilities because what you have with the um with Bitcoin and this is also why it's it's part of the road map of those many projects and it makes sense so the first thing that I would S suggest is to use the wallets right and make it zero trust so yeah it's okay that it's it's a side chain but why not to have a zero trust side chain instead of having um a castle and mode side chain ER and from the second perspective you know I would love to see um bit VM become very successful at the end of the day the goal of the world is to connect between everything so we are working with l1s and l2s and we would

love to see real uh rollups on bitcoin um but I I feel like it's more of a future solution and we'll see later on but the direction is is is the right direction awesome okay uh that's my only question thank you so much for coming on uh was an absolute pleasure and uh yeah very much looking forward to the integration of dallet into some of these networks sounds great thank you Robbie thank you Andy