On Interoperability & Trustless Bridges Rotem Hemo

get that all right hopefully everyone can hear me let me get this thing a bit better okay let's begin um i said my name is rotem i'm from algorand and i want to talk a bit about state proofs and interoperability in general a few thoughts and a few cool things that we've created so um let's begin so really blockchainers are great right i mean this is really what we all heal for p2p decentralized secure low cost always available i mean what can you ask for more but the problem is that there are walled gardens like all the great benefits i mentioned are essentially constrained within the protocol itself which is great but not so and the other thing is like you can't well at least not easily and or trustlessly um interact with other chains so for example we can't just like swap eth and i'll go with the native ones like easily or if you have usdt for example both on algorand and ethereum it's not that easy to just swap them the other problem is that like you can't really choose your ecosystem so for example if you have your favorite erc20 you can just like go away and play with it on another chains well again at least not that easily and same thing for other um nice tokens that you have everywhere and the last thing is um composability or it should say probably the lack of um which practically we yet to be able to build like the apps that use more than one blockchain underneath them which is something that i would be really happy to see very very much soon so i just got a problem but clearly there are some solutions out there and people found way around it and essentially we all know that like every inter chain essentially bridging of um transaction done mainly by third parties and this is a problem because um third parties usually introduce risk latency and cost which are exactly the things that we try to avoid when we started playing with blockchains and like building this great thing and you know it's like this guy in the middle which we don't like so we're looking for a solution and how would the solution look like very simple two main things first we wanted to be trustless second we wanted to be efficient really as simple as that essentially switch from this nice guy in the middle send him away and move to that now how would this be like a bit of a game changer right i mean once we have this like great tool we really be able to build like this central process and fully decentralized bridges um no man in the middle we'll be able to have like multi-block chain damps which is something that i i've been in the industry for a while like really looking for would be able to have like cross-chain smart contracts think of like having a smart contract on ethereum that depends on a state of a smart contract on auger and or any other chain and vice versa and like have question oracles like if you have an oracle one chain why wouldn't you be able to use it on another network like seems pretty obvious to me but the thing is different companies try to solve this problem in different ways and all the way from like fully centralized solutions to some ones that like like semi trustless you know several validators in the middle and all the way to trust us one but what we really need we need like a light client that is complete process and when it comes to proof of stake is a bit difficult in proof of work this thing is fairly simple like we need to prove that the consensus happened so we really need this just to validate the headers and the hash and to see that everything matches and we have all the information needed but when it comes to proof of stake you need well the stake to prove that and to get a stake this is a bit less trivial because we really need to compute all the transactions from the genesis to understand like what is the current balance of each one of the accounts to understand that people were actually that accounts were actually selected properly for the consensus and to propose the and to propose the blocks so that's a bit more tricky but we need to do that anyway and um how are we going to do that how are we going to create a light client that can do it very lightly and efficiently so let me introduce you to algar and state proofs conceptually think about it as the blockchain just a test to it to itself um to its own state in a lightweight portable and hypocritically secure way practically speaking technically it's a compressed set of signatures from the consensus participants themselves attesting to the state of the blockchain in our case is really going to be the block and how can we use that so dabs on foreign sorry so that's on foreign chains um can actually validate that a transaction a smart contract state or any balance happen on another uh on the algorithm blockchain now in the next few slides um they're going to be a bit more technical than what i talked up to now so if it's not your thing feel free to go to sleep i'm not offended i will wake you up at the end and we're going to build a bridge using um diagrams approved so we look at three steps first understand how we generate the state proofs second we build the like clients and third we'll see how the bridge actually going to work also if you like science um the state proofs are a result of a pretty slowly long research from all grand mit and stanford um the paper is out there was published in ieee obviously peer reviewed everyone is more than welcome to see it links and the slides will be available at the end i promise all right so how states roofs are actually being generated so as i said we want to attest to a specific block in time so the story actually begins 256 blocks earlier and on this block we're going to select the list of participants that are going to attest to this block in the future how we're going to select them that you can read in the paper it's kind of like some nice tricks so we select them we commit to this like list in this block fast forward 256 rounds later the block is being generated and now all the testers starting to work they all see the block making sure everything is fine signing it and shooting the signature to the real layers to the network and at some point in the middle essentially block 128 in this example um what's going to happen the relayers should have sufficient amount of signatures and they're going to collect them compress them and create the state proofs and the moment they pass the specific threshold of the security they will release it and now we have a nice state proof in hand now when we have these like state proofs and clearly this happened like in cycles we generate all of them um they're all getting posted to a specific address to make it easy for everyone to collect them and now we want to build like land so really what we're going to do is like we're going to have an off-chain um server it can be aws or your laptop or whatever and it's okay it doesn't need to be trusted we don't care what happens with them you cannot tamper with the state proofs as i said the ketographic is secure so it's okay it pulls them from the algara network from this like address and then essentially post them to the target chain let's let's say it's ethereum and there we have a set of smart contracts that we really serve as the like line so we keep like updating the state of the algorithm blockchain using these um state proofs and now when we have this like client client one that essentially knows the state of the algorithm chain what we can really do is ask questions of has this transaction happened is was this the balance of this account at this specific round was that the state of the smart contract this specific round et cetera now when we have these um like clients let's build a bridge because now we're really all set so let's let's show an example of like one way but practically speaking it's really symmetric like you just need to do the same thing from the other direction so let's say that we want to bridge your favorite token from algorand um to ethereum so we're going to have a smart contract on longer end that will lock these tokens so let's say we want to we send the tok we send 100 tokens to this smart contract and now what we can do on the other side the smart control on it on ethereum can really go and ask the like line that we just built hey as this transaction actually happened once it get the answer hopefully for yes they can release the 100 tokens simultaneously on the other chain so really they just like verify the state to verify that something happened on the other chain and remember there was no one in the middle no no validators nothing else there just straight up the network that attested to itself and we're done and we have a bridge which is was as simple as that so to build that we we use some fancy and nice um new cryptographic primitives both um are optimized for post quantum security which is a hint um actually provides you with historical integrity for possible security and zika snarks and i'll talk about why zika snarks in a second and we have two new we have two new ones one subsystem there is a small asterisk um for those kind of like very no well like the hashtag thing it has actually just two of the three properties it's not a random oracle but that's actually perfectly fine for our purposes and the second one is the falcon signature scheme which is post quantum secure um both these things are available oh everything is open source you're more than welcome to see them i dropped here a few more links for everyone was interested to kind of like see more and read as i said the slide will be available now i want to talk about something very important so attesting to a state of a blockchain or specifically a proof-of-stake blockchain is a difficult problem and it's a problem that every proof of stake blockchain out there has now we as essentially layer one blockchains we have the shared responsibility to make sure that we reduce every single one of these um sorry every one of the the trust issues there that the blockchain has with each other pretty much and um the other thing is that like we really believe that no one but no one should attest to the state of a blockchain except the blockchain itself like the the layer one needs to be the only primitive like the only layer that actually attests to the blockchain and we believe that like a state-proof based bridging ecosystem can really reduce this like trust um problems and make and make it better for everyone not for not for only for algorithm ecosystem um and the one thing i didn't say is that the state proofs are actually a generic solution they'll completely blockchain agnostic and every proof-of-stake protocol out there can and also should implement them to make sure we all have trustless ability to bridge tokens and any assets from one network to another all right so what's next um we actually released this week the first part of state proofs to the network we released the keys now nodes can generate them and that's great um very soon we'll be able to start generating the ciphers themselves that's going to happen kind of like about like in a month and a half after that what we're going to have is that we are going to release the zika snark proofs so as i said staples are compact and light but we want to make them even cheaper and faster to verify because gas fees are not always cheap so we are go so essentially we are snarkifying them and we we were generating um just like zika snack proofs that you can verify easily instead of the instead of the staples themselves once we're done with that what are we going to have we're going to release like two light clients one ethereum one an algorithm that will allow everyone to use this technology and verify whatever state they need whether it's an algorithm or ethereum and as i promised i deliver also this qr code for the slides themselves you can have it see everything i talked about all the papers links everything is there thank you very much