Pi Squared: Bringing Universality to Web3 | Yi Zhang | Ovidiu Damian | Grigore Rosu - Pi Squared |

[Music] hello hello I am Gregor roshu the CEO and founder of p squar and our mission at p squar is to bring the next million developers to web3 we have a big problem in web 3 a critical pain point is fragmentation hundreds of billions of dollars are split across different ecosystems different blockchains different applications that try to steal each other's users instead of smoothly working together and user experience is at best very complex it's a process to move funds from one ecosystem to another our proposal to this fragmentation problem is in one word universality universality with respect to programming languages and program execution we want all programming languages to be available to web three developers universality with respect to verifiability and different proof mechanisms we want all of them to be used and universality we respect to distributed consensus to assure security guarantees we want that to be as fast as possible sorry something happened here oops don't touch anything okay sorry something is going on here let's go back and all right you see universality one button only which doesn't work okay our stack contains three major components one the universal universal language machine think of it as a blockchain in which you can write smart contract in any programming languages even in programming languages that have not been invented yet you can bring your own language B Yol L the second component is the universal settlement layer which allows us to generate proofs of execution and settle them across on a common layer across various ecosystems and that will be instant finality instant settlement and what counts as a proof can be both mathematical proofs and zero knowledge proofs you'll see that mathematical proofs are just as important or even more important than the zero knowledge proofs and finally the universal consensus protocol which allows extremely scalable parallel consensus which is not based on a total order of transactions or blocks as in the blockchain we'll talk more about that as well what does this really mean it means that we can bring ULM means that we can bring all developers in all programming languages to web3 any developer is a web3 developer USL means that we can now prove correct execution across any applications in blockchain or not in web3 or web to that includes millions of applications around there everything everybody who wants to prove that something happened can settle that computation on the USL and UCP means that we can have consensus at optimal speed you cannot do any faster than that again same problem the market opportunity for this universality that Pi Square brings is immense the word of developers grows from 20 30,000 of developers as we have today in web 3 to 30 millions or even 100 million uh if you include all the AI prompt uh developers as well essentially every programming every programming language can now become a web 3 program a few words about universality so why we want universality but before diving into why we want universality let's first try to understand why we don't have it already what stays in the way programming language barriers programming languages are not easy to implement and to integrate in an ecos system because for each programming language you have a variety of tools that you want to offer to the developers and you have cross product between languages and tools and each of these arrows is an entire complex system by itself for example compilers for C took 40 years to develop them or interpreters for evm all these need to be implemented in order to be deployed on blockchains which is is a highly highly non-trivial task and not to mention maintenance which is a hell you have to maintain all these tools as languages evolve and all languages evolve all languages worth their salt evolve we have a new version every few months what is our secret Source the secret Source what brings us universality is the K framework the K framework was invented 20ish years ago when I was still a researcher um at Nasa and I moved to Academia and what K offers is this complete separation of concerns between programming languages and tools for programming languages you define a programming language or Implement a programming language if you want once and for all and once you have that which is a mathematical Theory now the K framework generates any tool that you need for your language but what is really important here is the fact that K is a Prov mathematical Prov so everything that these tools will do to the right is supported by a mathematical proof under the hood that K constructs as it performs the task for example for execution when you generate an interpreter for evm let's follow this path The Interpreter will not only execute evm programs but will also generate a mathematical proof why the execution of that evm program is correct and that allows us to separate concerns which is a golden principle programming languages from tools while at the same time assuring correctness by construction we call it correctness by Construction very quickly to give you a flavor of what it means to define a language in K this is a complete definition of a simple language which has only 39 lines here you have the syntax of the language here you have the semantics of the language in the syntax of the language you have uh usual context free grammars describing how statements look like like if then else which is strict in the first argument that means that we have to evaluate the first argument on the right we have semantics and what's important here is you have like one semantic rule which is an axom mathematically speaking for each language construct for if then else well depends on how many cases if the NS has two cases so it has two rules here what is important here is not the details but the fact that this is all you need to do in order to plug and play a new programming language you define the language like this and now plug it in K and K will give you an interpreter that also constructs proofs under the hood we are going to demonstrate this language actually slightly more complex version of this language shortly so Pi squar comes from proof of proof the name Pi squar comes from proof of proof specifically from zero knowledge proof of mathematical proof why because K already gives us mathematical proofs and now we generate ZK proofs from mathematical proofs bury me for a second all right so at a very high level this is how it works you start with a program and an execution environment same like in any ZK VM or VM for that matter and what we get at the end is a zero knowledge proof same like in a ZK VM what is different and critically important is the fact that programming language itself is an input and also what is super important is that after K does its magic we obtain a mathematical proof here that stands for the correctness of the execution of the program on that input in that execution environment now all all is left to do now is to verify the Integrity the correctness of this mathematical proof and we can use it we can do it using any existing ZK technology or new ZK Technologies what I insist to observe on this slide is that one circuit works with all programming languages you don't need one ZK VM for each VM for each programming language you only need one circuit for mathematics and now you got ZK VMS for all languages and all VMS that's why we call this verifiable Computing this picture verifiable Computing 2.0 because it is verifiable Computing as you know it but it is universal and correct by construction Universal because it works with all programming languages and correct by construction because there is nothing to formally verify ZK VMS need to be formally verified which is a very complex process here you don't have to verify anything specific to any particular programming language moreover the ZK circuit can be implemented using any ZK VM so you can bring universality to any ZK VM this way following following this path all right so that's the theory now what's the current status one year ago when we started the company pi squar actually exactly one year at the previous e Denver this was our wish list the K framework in spite of being correct by construction Jing mathematical proofs was slower not in spite it's kind of expected it was slower than handwritten interpreters in particular about 10x or 1,000% slower than uh than get that was a big challenge we had to improve the performance of K and I'm happy to say that now with all the optimizations that you can do at the mathematical level mathematical proof optimizations proof engineering we manage to execute evm programs actually faster than evm all right this is again very important because it's not only that you get a correct by construction execution that builds a mathematical proof under the hood but it is also faster than the ad hoc manual uh manually written interpreters so performance is not an issue whoever tells you that formal semantics is great but it's slow tell them no not anymore and send them to our white papers all of these optimizations and techniques I explain in detail in the in the white papers the second task that we really wanted to get accomplished very quickly was to prove the concept to prove the proof of proof makes sense that it makes sense to generate a mathematical proof and then a zero knowledge proof out of it and initially we wanted to use just one ZK VM which was uh risk zero but very shortly we started talking to different ZK VM developers and everybody was interested and before we knew it we had seven different implementations of our ZK circuit using all the measure Z kvms and also we have a benchmark now that contains more than 1,200 tests multiply that by seven and many people think that this is actually the most extensive benchmark ever develop for ZK VMS you can it's all public everything is open source you can also read the white paper to to see the details and how the whole thing uh Works finally we wanted to demonstrate that we can generate mathematically provably correct claims from ethereum transactions ethereum blocks so more or less to mirror ethereum on the USL by proving every single block mathematically nobody has done that before by the way we heard of zero knowledge proofs of blocks but now mathematical proofs of blocks they more rigorous than that well we've done more than we expected actually we'll see a demo today by my colleagues here that not only that we've done that but we also integrated USL with Wormhole and now we can use USL instead of Guardians to to prove all the transactions um and to have instant finality and also with the PO protocol that gives us maximum optimal um consensus and our po colleagues also here thank you finally one thing that we didn't plan initially and now it's done and we'll demonstrate it as well was to actually demonstrate an ethereum like blockchain that would support all program languages right that's what we want after all to Plug and Play our language and what would be easier to understand in an ethereum like blockchain where you can do certain transactions and plug a new programming language and then write smart contracts in that language it turned out that that was a lot simpler than we imagined to do sometimes when you do things the right things right they are simpler than you expect so we are going to demonstrate that um as well so it's basically a blockchain ULM that supports all programming languages and moreover it is implemented using for consensus on top of the Pod uh protocol and with this I will pass it to oid who will uh talk about this blockchain ULM and will demonstrate uh it as well live thank you Gregory GMG everyone my name is IDU and I'm glad to talk to you about ULM which is something I've been working at with pi squar for the last few months and we're very proud of what we achieved up up until now in the sense that you will see that in just a few minutes we will be able to have one blockchain where you not just bring your own language you bring your own languages for now we support solidity evm wasm rust and also a special language that you've probably never heard about up until now but you will and we'll soon have also move python go JS and so on now let's talk some Theory first I'll be brief I won't bore you I promise so when it comes to formal semantics it's basically a mathematical definition of all behaviors of all programs in that language meaning that if we have that mathematical definition of set programming languages we can know how that programming language behaves in any VM Isa computational model and so on moreover we can have using that definition automatically generated language interpreters that are correct by construction and and fast now how do we get this and put it on a blockchain we do this by having interpreters that should be able to modify the same blockchain state that's one precondition and we solve that by having all semantics implement the ULM interface and second of all we H we have Smart contracts that need to interact with each other I want to have my evm contract calling your wasam contract without any issue so that's why we have contract calls that take place through ABI encodings meaning that all smart contract interactions are programming language agnostic meaning that if I have an evm contract I don't care that your contract is wasm I can just call it like any other contract and we'll prove that soon now let's see how everything works for a for a minute so first of all we have we have a transaction that goes into the ULM and that transaction that is a contract call that contract call sees what semantics it has to use in order to execute said call maybe it's evm maybe it's rust maybe it's move and so on and using an ULM interface reads and rights to the blockchain database and that's how we do all those changes the ULM interface basically abstractism language specific when it comes to interaction with the blockchain database and that's the beauty of it now we've went through enough talk talk let's see something hands on so with that being said musab let's go through the bring your own language demo so this is our quick demo in which we show you how to bring your own language meaning that you can just come to the chain and in the same way you would have a smart contract deployed you can deploy your own language which will work and can then be referenced in smart contracts to use them and let's see how we're going to do that and you can see in the top Corner that we have a language registry which shows all the available languages that we have on chain for now we have evm and that's relevant obviously because it's the basic programming language for evm compatible uh blockchains and it's K beforehand and it's important because it's not the usual execution engine it's rather implemented in K and that's how we run programs by using K not by having the usual execution engine we also have the ID which I'm going to show why it's relevant later and the hash which helps prove that the language that we're running is authentic basically by having by having the ID and hash of a programming language we can check that the programming language that we're using in a smart contract is the language we expect it to be to be we can also using that hash check in the node as I said and we have this definition here as well to see what you see here is the definition of set programming language we won't lose too much time on this it's just interesting to see all the complexity behind it but on chain we don't care too much about the specifics of it now that we have the hash what we'll what we'll shortly uh what we'll shortly do is add one more language and as we add the language we see that we can choose any language that we want and we will quickly add solidity as you see we have the definition here and as this definition will be added on chain via a transaction you can see it's a transaction like any other sent via metamask and we also have a disclaimer showing what we have saved on chain URL language ID definition and so on now the language is there we can use it it was that simple and attention this is solidity we're not compiling it to evm we take the ID and input the ID here because we use it when deploying a contract to tell the node hey this contract will be in this programming language it's relevant that's the code you need to run and as we do that let's deploy a token that is directly solidity on chain now we're deploying a usdc copy you can see the solidity code there and attention we're just hex en coding it and sending to the blockchain you can even see that it's recognized as a contract deployment transaction without doing any change to metamask of course now as this transaction gets completed we have the address of said contract that we can simply copy and then use to interact with the contract now we input the address and as the address goes on we also obviously need the ABI because that's the usual interaction that we use for all contract interactions and we will use the usdc API we have some options there because we're a demo mode now we load set contract and we can see USD coin symbol usdc we quickly copy our address check our balance obviously our balance is zero because we just deploy the contract and we're going to Mint some tokens we're going to Mint pi squared tokens 986 and you can see it's a simple transaction like any other now we don't care anymore that uh the cont contract is directly in solidity all we care about is the fact that it's a contract and we can interact with it and we have the transaction receed which shows that it's working like any evm execution engine it's again language agnostic it doesn't care that it's written in solidity and now as I read my balance you can see that I have 986 tokens which is amazing we have interacted with a solidity contract director and we're going to show that on chain as well now you can see that it is detected as being a solidity contract and that's relevant how does the Explorer know this even though all all contract interactions are language agnostic well we'll show you exactly if we see the contract code you can see it's hex coding but the first four bytes are the ID of the programming language used that's the only change we make outside to the evm interface to say so we have the language ID which is basically how the node knows okay I will run this I will run this uh code using this programming language now that we have done it let's add one more language now in order to go a bit faster we will use the predefined menu and we will deploy rust you see it's just as before nothing special when compared to solidity but very special in general special enough in the sense that with a simple transaction we enable 3 million Ras developers to use our blockchain and we use the language ID we deploy a contract we're deploying a wrapped Bitcoin contract and as this contract goes on we're pretty much going to go to through a similar flow as we did with solidity and as we do it you can see rep Bitcoin as the name you can see wbtc as the symbol but now we will use the allowance endpoint to show that it works as well now as we use this endpoint now we will use just pi as our mock value we send the transaction you see it's recognized as a spending cap request metamask has no idea this is rust and metamask shouldn't even know it is rust this just makes it Greater okay the transaction is completed and we have this on chain we have the we have the spending cap increased and we can also see it on chain you can also see that once again it's detected as a rust contract the language is known because of the ID here the code is again hex encoded but is directly rust and you can see we have the free languages we and now what we will do is also run some KV KVM code to show that it works as well so you saw before solidity which was directly solidity we didn't compile it to evm now let's see some ugly evm bite code being executed now we put it we put it on chain this is rep ethereum and as opposed to other tokens we will need to deposit ethereum to actually get rep ethereum back so you can see the name there rep ethereum and what we'll do is we'll check our balance which is zero and we will deposit some ethereum we will deposit 0.1 ethereum and we confirm a transaction we see that all works well we we wait for the transaction to be completed and as the transaction is done we have the receipt again all well the the balance is here 0.1 and we can also see the balance here the contract has received 0.1 ethereum from us without any issue and it's also depleted from my own balance and we can also check it on the Explorer we can see that it's recognized as a KVM contract which is the usual evm we can see it has 0.

1 ethereum basically it works without having to worry about anything that is programming language dependent users don't even have to know it's written in something specific now we add wasm quick as well the transaction is going to complete be completed any second now and boom we're now at our fourth language in just a few minutes we also deploy Doge in wasm and as the transaction gets deployed we will have the address and we'll one once again look to Mint some tokens in order to uh show that it works okay you see Dogecoin Doge alls good we copy the address we see our balance we go and mint yada yada here goes the transaction and now we have the balance there good so we had rust directly and we also had rust that was compiled to wasm and yeah it's as it's it's as easy as that to say that now we have shown some impressive languages some very well-known languages but you don't have to use something that's already created you can just create your own programming language which is simple in this case we created a programming language just to test things around and see that it worked why we did that well because we can and we want to show that you can create your own programming language as well it might be good it might be bad but the point is it's going to be supported on chain without any issues now as we have deployed simple we are going to also deploy a contract in simple and because it's our own programming language we're going to deploy our own mock Pi Square token now we go real quick to deploy it and as we confirm it we will get the address and once again go through the whole process and if you are thinking oh he's at the third token already how many more is he going to Min if you feel like it might be a bit boring great it should be having multiple programming languages shouldn't be exciting or complicated it should just be there like a normal normality now I meant 9.86 tokens Pi square and as a transaction gets completed we check the balance and it's there obviously we also check it on chain we can see we have the pi Square token that is detected as being in a simple programming language the language ID is there easy to see now what we have just done is have five different programming languages is on the same blockchain in under 15 minutes for sure this is amazing and it's not just that we have more MAV you can I think you can stop this and we can go back we can go to the next demo which is going to be oops The decentralized Exchange demo we're going to show how you can use you can basically have a DEX that has multiple programming languages interacting between them basically you you can have a token that is created in one language and swap it for a token in another language now let me explain the setup real quick so we have our Dex contract the router the pi Square token the rep Bitcoin uh token die usdc and Doge you can see real quick our router that is the Dex itself is an evm contract next you you um you can see the ID there as well as it's evm and next token is pi squ you can see it's in simple next token is rep Bitcoin in Rust next is D it's evm again next is usdc in solidity next is Dogecoin in wasm and what we're going to do is do a quick swap we will slop from usdc to uh Doge what's relevant to know here is that here we don't show the programming languages because the interface does not care about the languages you can see it's recognized as a spending C request first you have to approve the spending of tokens for the contract and here it goes once the spending cap is processed we will have also the transfer request we approve that as well and as that gets done you are able to see that our balances have changed and we can also check that on chain now this is my favorite part if we look at the transaction on chain you can see that we have interacted with a KVM contract transferred 986 solidity tokens and received back 895 something Doge tokens that are in wasm free programming languages interacting between each others in one single transaction or contract call that is as amazing as it gets and as simple as it gets it's not I wouldn't even call it language agnostic like the Dex not just that it doesn't care about the language the Dex doesn't even know they exist it's language atheistic if you want to call it like that and you can see that it works as we say it does in the in the sense that here's the code of the Dex and here's the transfer no programming language is specified you can see that is just where we send what we send and so on and this is because we use as we said ABI encoding to basically for to basically make sure that all the inputs and outputs that are sent between programming languages are let's say normalized so again KVM solidity wasm one transaction working together without any issue so this has been our multilanguage swap demo you can I think you can stop the recording musab thank you and that being said I want to give the mic to e to continue with our next school products um hello everyone uh my name is e and I'm glad to be here so first i' like to thank oidio for his very informative presentation on these universal language machines so next I will talk about uh our second component in our Universal ality stack which is the universal setlement layer and we call it us USL so if I want to give one sentence to describe what US is then it will be bring any offchain data to onchain uh in a verifiable way so there are two key words in this sentence the data and verifiable and this corresponds to two important Concepts in the USL which are claims and proofs claims are anything provable and proofs are something that used to verify the correctness of the claims so let me try to give you some examples of different claims uh and um proofs so the first we can use claims to capture the computations in any program languag and BMS uh for example we can use Uh u blockchain trans uh block transition claim that is interpreted as this two pole the pre-state the code you can think of as a list of transactions and postate so these two poll can capture the blockchain transition in any rups and we also can have this blockchain query uh claim that simply we call this view function on a certain state to get some results and these claims can be verified through uh different mechanism they can either be uh verified through mathematical proofs or they can be Veri through CK proes in any approved CK VMS and even they can also be verified through re-execution then we can also have the consensus proof which basically states that a claim is included in a canonical blockchain so the accy proof is usually a list of signatures from all validators that approve this block and we can also use the claims to capture those Ved knowledge or information uh like oracles or identity and we can prove them through a digital signatures or certicate certificates from ckls so now uh we have uh um uh some basic concepts of claims and proofs the USL is just a decentralized uh uh network of incentivized verifiers and those verifiers receives claims and proofs from users or applications and verifi them so uh there's one important property of USL that I want to highlight first we require those claims to be self-contained meaning that they can be verified uh independently and then all the verified claims actually form a set uh instead of U list and all sequence this is very important uh because the order of the verification um doesn't is not relevant anymore and actually they can be verified in parallel this important property uh can achieve can enable us to achieve fast finality if we choose the underlying uh consensus protocol properly that uh I will talk about it more in in the in in the in the implementation uh slide so once the claims are validated and then uh the claims are accumulated in this uh validated claim Set uh which is the state of the USL and the USL also provide this so-called membership or inclusion proof for user to to check whether a claim belongs uh to the USL state so and these membership proof are succinct and uh can be checked very efficiently and all applications of blockchains who wants to connect to the USL only needs to implement these simple uh verifi membership functions okay now so far I covered this universality of uh USL which it incorporates various uh types of claims and proofs and also uh once the claims is verified on USL it can be used everywhere next I want to talk about this uh our implementation of the USL uh uh settlment layer and uh we are collaborating with the port Team U actually we implementing the USL on top of the port so first what is p the port is a layer one Primitives that receive transactions as input and produce logs as output but unlike the traditional blockchain or consensus protocol so the port provide a persistent total order on the transactions in fact um the order of transactions as subject to change over time and by accepting uh these features it actually allows for making very performant uh systems and uh um the port team has produced some theoretical results showing that Port is uh optimal uh in latency and throughput under some constraints so uh as we said we implemented our Universal settlement layer on top of P we uh uh Implement uh the verification logic as a pre-compiled and deployed as some specific address on top of in the port Network and submitting claims and proofs to the USL is equivalent to uh send this uh verified transaction to the port Network so once uh this verified transaction is executed successfully and it will be appended to the port log and we have this USL client to query the port uh a port Network for for uh for this log and membership uh membership proof this membership proof is just aggregation of signatures of the uh validators from prod who uh approves these transactions and then we can uh use this claims and membership anywhere in those deps sorry so uh next part I would like to introduce uh a real use cases of our USL where we use USL as a verification layer for the warm HHO Entity framework so the warhole Entity framework is a a native token transfer framework that allows users to transfer tokens uh between chains um by burning uh or locking tokens on the source chain and meaning tokens on the destination chain so under the hood there's a a message verification layer which verifies the message between uh chains and it also allows developers to introduce their own um message uh message verification layer and they can uh configure which uh message verification protocol to use at run time so this is basically uh the basic workflow and how we use this us as customize uh message verification layer so first user submit Bridge transactions to interact with entity manager and this entity manager contract will burn the tokens on the source chain and construct an entity message that specifies the amount of of token to be minted on the destination chain so the and the message will be stored on the source chain and we have this claim generator offchain component to monitor the transactions on the uh Source chain especially those Bridge transactions and generate claims and proofs which we will uh see in a second and uh uh submit those claims and proof to the USL once these proofs uh claims are verified on the USL the relayer component willery the USL for the valid validated claim and the membership proof and submit to the destination chain on the destination chain it will first check uh the membership uh membership proof by running this ver verified membership uh uh function and then they would par uh the the validity claim to extract useful information and performs the token meeting now let's uh go go to see the real demo so I have prepared two demos and let's play the first one okay so this is the bridge demo uh where it allows user to transfer tokens from spolar to arit theol network so in this transfer tab it is a very basic uh Bridge uh interface and on the uh upper right there's a FY button to allow user to uh me some test tokens in the history tab uh it basically shows the uh uh Bridge transaction histories and each entry uh contains information like the source and destination transaction hashes um the P transaction that verifies the claim and proof and claim itself now let's move back to the transfer Tab and uh transfer some tokens we already approved a limited amount of tokens and now let's input some token to transfer so okay let's input 11 and then click the transfer button so the the standard is quite uh the workflow is quite standard and will prove the bridge transactions on the source chain so now let's uh go to the um uh history page and wait for the bridge transaction to be completed as you can see now the transaction on Source uh chain is completed and the port uh uh transaction is completed and we just need to wait a little while for the destination chain to be uh um transaction to be completed okay now the bridge is completed and we can click each link to verify what is happening so we first uh click the link on the source chain and we can see that uh the amount of token is actually burned on the source chain and then we click the transaction on destination chain and we can see the same am of token are actually minted on the desion as we said so the actually what happens under the hood is that our claim generator generates Claim about the entity message and then uh submit to the USL for verification now uh let's see what the claim and proofs actually look like so um we can uh yeah we can click the uh claim button and it will shows you the the Hax format and we can claim uh click the code claim and it will transform this Hax format into human rable format so in this assumption field it shows the uh block header of the current block being cured and then this action field uh uh shows the actual view function that we are called on this blockchain state and the result is the entity manager that is being stored on the source chain and we can further decode it to see the actual uh tokens the amount of tokens to be minted on the destination chain now we can go to the proof tab to see the actual proofs uh that is being generated they are actually the Merc inclusion proofs for those storage keys that are be used uh to to execute the view functions okay great um so and then once the claims are verified on the port right and then the relayer will submit uh this verified claim and prove to the destination chain and we can check the transaction of the port on this port Explorer finally let's go back to the transfer page and verify that all the balances on the uh two chains are updated correctly so this is the end of the first demo okay so let's play the second demo where I will show you a scenario where the CL generator stops working and the user can still uh complete the bridge transfer in a a trustless way so let's first uh stop the claim generator and then uh performs uh uh uh normal uh Bridge transfer so we enter 21 tokens here and uh do the transfer we click approve the transactions in the metamask and we go to the history tab to see what actually happens so now the transaction uh Source transaction is completed and we can see um the amount of tokens is burned on the source chain however since the claim generator is not working so no one will generate claims and proofs and the whole Bridge uh workflow get get stuck um instead of waiting for the developers to fix the issues the actually users can start uh the the claim generator locally because the bridge is actually by the claims and proofs it doesn't care who actually generates claims and proofs as long as the claims can be verified by USL so now let's do that let's start the claim generator in manual mode once in the manual mode U uh user need to provide the transaction hash uh of the source chain uh and uh submit it to the to the claim generator let's copy it from Explorer and give it to our local claim generator now we uh submit it to the local generator and boom you can see that it is job to uh generate proofs uh and claims and submit to the port and everything uh goes well now we can check um the destination chain transactions and verifies that the actual amount of tokens are minted on the destination chain I think uh this concludes the my My Demo so and I will hand over the presentation to Gori to uh for for the uh UCP component all right thank you I hope you guys are excited are as excited as we are about what happened here let me put things a bit back into perspective Okay so we've seen multiple programming languages on the same blockchain and we've seen programs written in multiple in these multiple programming languages where they interoperate on the same blockchain programs written in wasum Rust solidity and simple but simple is a new language alog together all of them on the same blockchain okay it felt and looked like any blockchain using metamask to do transactions and everything but what happened under the hood is critical because everything was turned into a mathematical proof that was checked okay so everything is mathematically correct you don't have to worry about an incorrect implementation of an interpreter or compiler right because everything was executed with the actual mathematical definition of the programming language that has never happened before okay we've seen zero knowledge proofs where you have a way to dat a zero knowledge certificate for an actual interpreter here there is no interpreter actually there is just a mathematical proof that justifies an execution The Interpreter only helps generate the mathematical proof then we've also seen how we can Implement Bridges so basically programs across different blockchain chains and different languages also using the same infrastructure where claims are settled once and for all at the speed of light using a protocol called Universal consensus protocol inspired and done in collaboration with the Pod colleagues from the Pod new pod company we're also writing a paper together so we cannot tell you a lot about the protocol right now um but what is important to know is that every single transaction generated a claim which is a rigorously proved mathematical fact which is verified by a decentralized network of verifiers who agree that that is indeed correct and that happens only with a round trip of messages so it's the maximum the optimal possible consensus that you can get and with is that we have a few minutes for questions um before uh or maybe let's put this again into perspective before you ask questions what really happens here is that now we can use all programming languages to write web three applications the programming language is not a barrier anymore you no longer have to learn weird programming language only to become a web three developer you can use your favorite programming language all you need is to plug and play it into the web three framework and you've got it that opens the web3 space to millions and if we include Ai influencers and AI prompts hundreds of millions of users um and that's how it should be with that we thank you and we are open for questions we have five five six more minutes for questions in case anybody has any question thank you first of all and questions please we can pass the microphone for questions we say some time for questions on purpose there is no bad question please feel free to ask anything what's the timeline to get to production or main it for the tech oh good question question so six months let's let's make it simple 6 months for testnet one year for mainnet and mayet for us means the USL Network that can settle claims in any languages and interconnected with several layer ones and layer twos as well uh hi my name is Nico I'm super excited about what you guys are building and uh something that I wanted to ask you maybe you already sort of explain it but I didn't get it so sorry at Advance for the programming language that you can like Implement uh how different can they be in terms of is only syntax that for example you're building something in solidity and then you're going to be able to build it in Ras it's like solidity with syntax on Ras or how deep can you go with that no the languages don't know anything about each other there is obviously an API a storage API they have to agree on so they read and write using an API so have when you define the semantics you have to accept that API and Define the semantics using that API yeah and that was my question about the API the API is sort of like a generic form of like what Sol does so in some level like you're still going to be like will have to take care of like some bags that are like in solidity but in rasp because of the way that that API is uh basically like the question is how deep can you go with the language and how different they can be between them before so you have the syntax you have to stop at some moment where you say this is my storage model and every language has to agree on the storage model how you access the storage model for example move move has a slightly different storage model model more General than uh than EVMS but they can live together we can go that's very technical it gets very technical in some sense that is what we call semantics engineering so when you when you define a language it's an Engineering Process and you have to understand the the semantics you have to understand the build things on which you build your semantics like numbers you have to pick numbers you know find infinite numbers finite size numbers and so on and similarly you have to build to to accept your domains on top of which you define computations um above and and this is a moving Target even for us now the storage model we keep improving the storage model as we add new languages thank you so much any other questions or you guys want to add more on that on the storage model no all right thank you for the questions and thank you for being here and I hope you'll soon try USL and ULM you can try them right now go to our website and you'll find them there thank way