Build Smart Contracts on Ethereum in Any Programming Language3 by @RosuGrigore fr @Pi_Squared_Pi2

[Music] hello I am Gregor rosu I'm the founder and COO of p squar and our mission at p squar is to bring all programming languages and the next million of developers to web 3 it is well accepted and broadly acknowledged and proved over and over again in surveys that fragmentation is one of the main critical pain points in web 3 fragmentation of ecosystems blockchains providing different languages different applications fighting with each other for the users to steal users from each other liquidity billions of dollars spread all over and the user experience is terrible everybody wants to fix it let me tell you how we want to approach how to solve of this problem of fragmentation through universality universality at three different levels first universality in programming languages and program execution we firmly believe that all programming languages should be available to web3 developers universality with respect to verifiability and proof mechanism verifiability should not be negotiable every execution should be provably verifiable and we should also allow different proof mechanisms we should not be stuck with just some of them also universality with respect to distributed consensus protocols uh that assure security we should be able to achieve consensus at the speed of light for applications that operate that uh way how precisely we do that so we offer a universality stack containing three components the universal language machine the universal settlement layer and the universal consensus protocol the universal language machine is a blockchain architecture that allows you to write smart contracts in any programming language existing programming languages or new programming languages even in programming languages that have not been invented yet you can even bring your own language b y o l plug and play your language into the blockchain and then write smart contracts in the language ULM Builds on top of the usell the universal settlement layer which allows you to generate proofs of execution for any programming languages executions with any programs in any programming languages therefore proofs also across different ecosystems based on different languages and also it is fast and low late lcy settlement and when we talk about proofs in this presentation we mean two types of proofs both mathematical proofs and zero knowledge proofs usually in the blockchain space we understand zero knowledge proofs by proofs but you'll see that mathematical proofs are even more important when it gets to actual correctness and the USL to achieve all these performance benefits Builds on top of the universal consensus protocol which is a consensus prot protol for claims that are true and it is not based on or relies on a total order of transactions it is a set consensus protocol you achieve consensus on a set of truths and this can be done amazingly at the speed of light literally all you need is a roundtrip message between the client and the verifier to get confirmation that this claim is true and to achieve agreement on that all right so what does this really mean well it means the following that through ULM we can now bring all the developers in the world to web 3 they can use their favorite programming languages they don't have they no longer have to learn obscure programming languages in order to be part of the web 3 space that includes millions of developers out there tens of millions of developers not to count all the AI agents who are also Pro programmers themselves USL what it really means is that we can settle correct executions on this common layer across web 3 web two all kind of applications any computation that has nothing to hide that wants to prove that it happened correctly can settle on the USL Web Two or web 3 everything everybody any computation can settle AI agents can settle their inferences and UCP means that we no longer have to wait seconds for finality it will happen at the speed of light I don't need to tell you how important that is and what opportunities this brings basically any developer and any language can now participate in the web 3 uh space we no longer have to go with only 20 30,000 programmers like today which can very quickly extend to 20 30 million developers not to mention all the AI prompt Engineers programs in the future will be written by AI agents not by humans and all those will participate as well in the web three all right so enough talk about universality in general let's now go deeper and try to understand why we need universality actually instead of why actually that's not right that's not the right question why universality the right question is why why not why don't we have it yet because you want universality I hope I convince you that we want all that universality to eliminate fragmentation or reduce fragmentation why we don't have it well programming languages come into the picture here this slide shows the state-ofthe-art in the programming language field it's a lot of pain what this slide shows basically every single programming language combined with any single tool is an arrow in this picture and that means a whole complex system by itself for example C and compilers we have GCC ICC Clank tens of years of effort hundreds of many years of effort or Java interpreters or evm interpreters like get rest so all of these these tools need to be developed and need to need to be maintained you cannot just add a language to an ecosystem you need to bring all the tools so developers can develop actual programs properly using the language so maintenance is a hell training developers is hard and tools are always behind to or three versions of the actual language so bringing a new language to a blockchain or any for that matter is a big deal and this is what we believe is a major barrier that measure obstacle that we have to avoid well how can we do that how can we avoid that and this is what we believe is the key to avoid all this fragmentation of programming languages and eliminate the barriers brought by programming languages this is not a new idea I propose the framework back in 2003 when I started my career as a professor at University of Illinois and I built it with my research lab my students uh then several companies adopted it several other universities uh universities adopted it to teach programming languages but this is the idea actually let me let me tell you what I don't think is the right way to go picking one particular language no matter how beautiful the language is and no matter whether that language is high level or low level you know llvm any language that you think this is the best language ever and by the way I mentioned llvm because it was invented in our department at University of Illinois so I can mention it so pick llvm no matter how beautiful the language is it will never be the ultimate programming language right so if you compile any other translate any other programming language to that one language you'll suffer from the same problems like before you'll have compilers that you have to keep updating you'll have each tool that needs to be updated and you'll have errors and so on and so forth so we believe that the solution is to actually do the exact opposite which is what I proposed back in 2003 so instead of translating everything to one language and call it the ultimate language instead of that what we do we Define everything mathematically every single programming language is a mathematical Theory called a formal semantics let me ask you a question here how many of you here knew and be honest that in order to talk about correctness somebody gives you a program and say this program is correct so in order to even talk about correctness you need a formal semantics of the programming language how many people here knew that nobody okay you see so that's what happens people talk about correctness all the time but in order to have correctness you need a formal semantic which is a mathematical definition of the programming language once you have that a universal language framework like the K framework will generate for you all the tools that you need from that mathematical definition including an interpreter okay so you don't have to implement an interpreter by hand you don't have to implement a compiler by hand you don't have to implement a program verifier by hand anymore all right all of them are generated from the actual mathematical definition of the language and they are correct by construction what that means is that everything they do including The Interpreter which executes a program everything they do is done using a mathematical proof under the hood okay so you can take that mathematical proof and check it and now you know with absolute certainty forget zero knowledge proofs there's not absolute certainty but this is absolute certainty that the execution happened correctly because the mathematical proof was constructed and that mathematical proof was checked all right so that's the magic of a universal language framework any programming language in the framework is a mathematical ground truth a set of axioms and now everything that you do in terms of execution verification everything you do with that programming language becomes a rigorous mathematical proof that can be checked so this is the key that allows us to get universality because there is nothing nothing specific to any particular programming language here and you may say that yeah yeah yeah that's great but it must be horrible to define a language uh mathematically and I can tell you that no far from it it is actually easier and you don't have to trust my word just look at this slide it is easier to define a formal semantics of a programming language then to implement an interpreter for that programming language in some ad hoc programming language what you see here is a complete language definition of a simple programming language but what is important is that it's complete on the left you have the syntax you can see the if then else statement for example here in the middle to the right you have the semantics all right the if then else notice that is strict in the first argument you have to write strict in the first argument that means that it evaluates the first argument and then in the right side where you have the semantics the actual axioms defining the language we have two different rules one when the first argument is zero one it is when it is not zero exactly what you would expect I claim that this is much much easier to read than an actual interpreter for the language but the beauty of this is that this is very rigorous mathematically very rigorous and yesterday on the same stage here we demonstrated how ULM works and how smart contracts written in this language actually execute all right so now what is pi Square Pi squ comes from proof of proof specifically from zero knowledge proof of mathematical proof okay remember that in K when you execute any program in any programming language you get a mathematical proof under the hood right wonderful the problem is that that mathematical proof can be big and it is Big so big that you may not even be able to store it so the secret is to actually discard it as it is generated you check it and you generate a zero knowledge proof of its existence and this is where the name Pi Square comes from zero knowledge proof of mathematical proof all right this slide shows the big picture which we call verifiable Computing 2.0 why because this is verifiable computing as we know it but Universal it works with all programming languages it is correct by construction no Z KVM to be formally verified all right this is how it works let's start with the output at the output we get a zero knowledge proof same like in any other um ZK uh circuit at the beginning you get as input a program and execution environment don't look at this yet which is exactly what you get in any Z KVM which is specialized to this particular programming language in which the program is written what is different here is that the programming language itself is an input all right and then K does its magic and generates a mathematical proof from the execution of the program right so now I don't have to trust any of these complicated stuff because I verify the mathematical proof once I verify the mathematical proof I know that the execution was correct with absolute certainty how can we do that well we can do it using ZK technology so now we completely separated concerns computation from cryptography computation is verified with the best that we know for after more than 50 years of research in programming language semantics and formal semantics in general now we are done with this part and now we can focus on just one aspect let's generate a proof for mathematical proofs this Builds on everything we' learned in probably oldest in the oldest field of computer science programming languages and it is not only Universal that it works with all programming languages but it is correct by construction there is nothing to formally verify here and formal verification is my field that I've done all my career now finally we don't need it all right and this is my last slide um let me tell you what the current status is we are a new company which started one year ago exactly one year ago at East Denver 24 and this is what really wanted to do back then first of all no matter how many times I said correctness is critical in the end everything boil down to Performance everybody asked me yeah but this is going to be slow great it will be correct everything by construction but going to be slow not anymore so we had to improve the performance of K by 10x to make it 10x faster in order to be convincing and now it is actually 15 times faster than it used to be after one year of effort now it's 1.58 faster than yet okay please if there is one thing to go home with this is the most important thing you execute a program generating a mathematical proof using aover and you get a proof of correctness for the execution of the program using the most rigorous known framework for correctness that we humans know and that happens faster than an ad hoc manually WR interpreter which is the most used client in blockchain okay so this is fascinating for me at least it's the first time that happened so formal sematics whoever tells you the formal sematics is great but it's slow tell them not anymore and send them to this by the way all these papers confirm and explain how it happen so this paper explains all the engineering that has been put into this how to make it really really fast the second thing we wanted to demonstrate was that proof of proof makes sense as a concept that we can indeed generate zero knowledge proofs of mathematical proofs and we plan to do it with just one Z KVM with risk zero but what happened was that once we started getting results we were approached by other friends a different other ZK with other Z kvms and uh before we knew it we ended up putting together a benchmark which now is the largest Benchmark for ZK VMS that we aware of has almost 10,000 programs more than 1,200 programs but multiply by 7even because now we run them with seven different ZK VMS and um yeah so it's all open source if you have a ZK VM please try it and add the eight or the ninth or more so the bottom line is that now because of what I showed you previously on the previous slide we can bring all programming languages to all Z kvms okay you no longer have a ZK VM for risk 5 or for evm no now you have a ZK VM for all programming languages without any compiler to your language and finally we wanted to show that we can indeed settle on the USL claims corresponding to blocks on ethereum and we've done a lot more actually we managed to integrate with Wormhole so USL now provides an alternative to the Guardians on Wormhole which we all know they are a big pain they run full nodes on all the networks so now you can settle everything they do on the USL actually and one other thing that happened last year is that ULM the blockchain architect cure that supports all programming languages PL and player language now is actually alive it's not a blockchain it's still in our lab but it's a proof of concept showing that yes you can plug and play your programming languages and then write smart contracts in them and then you have interoperable programming languages so interoperable programming languages interchain applications everything going through mathematics and mathematical actions and 12 mathematical proof rules that can prove anything about any theorem about any mathematical Theory so all right with that and by the way all this demo demonstrating USL and ULM have been recorded they are on YouTube on our web page please try them out was them first and then try them out and with this I'd like to invite you at our boot as well 402 right next to the coffee uh place and see your live demo of uslm thank you