The 3rd generation is intent-centric

Transcript

foreign [Music] thank you very much everyone for coming today I'm Adrian and today I'm going to very briefly in the next 20 minutes or so introduce you to anoma which really is the first generalized intense Centric architecture and just to start you off with us the next wave of blockchains is going to build around intense Centric architectures there's almost no way

around this because what we're starting to realize sort of given the applications that have emerged since the theory must built is that transactions are really bad fundamental building blocks for 90 of all applications like transactions make a lot of sense if you have if they contain the entire State transition right like if you go to a store and you buy some milk using Bitcoin transaction transactions make a lot of sense because this is a fully fledged State transition that is immediately executable on chain most of the applications we have nowadays whether this is some mov front running or some roll up or some multisig they all evolve around partial State transitions or what we call intense and the idea here is that intents are partial as in they can't be settled directly on chain they have to have some

other counterparty with whom you and can't act in order to make them settled in order to make them fully balanced and so the most trivial example here is a multi-sick actually it's like a one out of two multi-sick the one out of two multisig is already an intent because when I have my component of that multisig this is not something I can actually execute on chain I need some other person's signature as well to make this into a fully fledged thing that is executable on the chain but before we get too deep into this and all the implications we have around decentralizing sequences and decentralizing Roll-Ups and privacy I'd like to go through brief evolution of protocols here um so really we started off with generation one or what I'd called

scriptable settlement and this is really everything around Bitcoin and Bitcoin like systems and they are fantastic platforms to build things like cryptocurrencies things like colored coins name coin and long tail of Bitcoin like Forks but they are fundamentally limited you can't really build applications on top of them the best thing you could do was sort of you Fork the C plus code base and then you slap your name on it Implement some new up codes in your script and now you have a new blockchain but we didn't really have application development as such on these systems and really as a result of this experience we got to generation two or what I'd call fully programmable settlement so

touring complete execution environments where application developers could write some code and deploy to them and all of a sudden colored coins became the sd20s name coin became ens but we also got a whole new host of applications like dials new kinds of assets um and everything that sort of has happened since ethereum came out in 2015. um I'd also like to briefly go through programmable settlement plus plus um and I I think I may ruffle some feathers here but to me really we are still in generation two uh we haven't evolved from this when we look at things like near Solana Paul carat Avalanche you name it it doesn't really matter they're all fundamentally

transaction-centric designs they're not intense Centric designs they are designed around sequentially executed VMS where the user that signs the thing needs to have access to the entire State transition and settled in order to execute it on chain however of course we've made tremendous advances in things like civil resistance advances in scaling advances in privacy advances and consensus but fundamentally the model did not change of what developers had access to and what kind of applications could be built using these systems so this is what most of the talk today is about intent Centric architectures and 10 Centric design and really here I'd like to introduce onoma which is the

first specification for fully generalized intense Centric architecture um and really how did this come about well we start from first principle it's like what is the fundamental building block that users have and when you look at an example like openc the fundamental building blocks that users have it's not a transaction it's an intent that you use our science and submits to some web 2 server in San Francisco that then collects a bunch of these intents does some compute to this and then settles their own chain and this model generally extends whether this is openc or some other nft Marketplace whether it's darknet whether it's any roll-up of your choice pretty much currently works this way user signs a thing that is not directly executed on chain sends it to some web 2 server web 2 server does some compute to it and then executes on some

other settlement system and just to highlight how prevalent this is gnosis safe works the same way like what actually happens when you interact with the nurses save your eyes is that you do your individual part of the multi-secreage then gets uploaded to a central server probably running a Berlin somewhere and the last person before submitting the entire multi-sig transaction on chain pulls all the individual constituent signatures from chain wraps them into one single transaction submits them so really this design pattern of intense Centric design is everywhere the big problem is that until sort of 2021 no one had named this like we everyone all these applications are building custom Solutions around this some were trying harder than others

to make this actually decentralized but no one had tried to build some fresh principles with like what happens if we think about our systems not as transaction centering systems but rather as intense Centric systems so with this coming to what is our Noma um anoma is the first ever intentional architecture introducing a new paradigm for building infrastructure layers this is really the idea is that it is designed from the ground up for applications that involve infinite number of users issuing infinite numbers of intents each of arbitrary complexity and here it's important to understand that intents are just code that's it it's state in code you can write whatever you want in an intent this gives you the very cool ability to have very complex multi-six for example

because you can write things I'm willing to authorize my one out of three part in this multi-sec if the weather is nice in Paris and if the weather is not nice in Paris I want to sell all my eth right so you can write whatever you want this also extends into roll ups I want to be in some optimistic roll up I don't color care which color it is I just want to be in the next one given that it has XYZ security guarantees um and really this is a much better model for what users actually do because users express what they want not how to get it and currently users really Express how to get it because when you think of what an action in ethereum transaction looks like and ethereum transaction is some um contract call with some op code and

some entry point right and the user signs of effectively a stacked trace or an execution trace of allowed compute over their state they don't Define a specific State change wallets may make it look like a user when they sign something they like sine over a transaction or a trade against Unison but that's some in reality what happens what a user signs of us they sign over a number of evm up codes that then can result in some State change and intense on the other hand just sign of a specific State changes they say I am willing to trade a4b at this price and I don't care how the execution of this happens so in that sense intents are binding programmatic commitments to preferences

and the fact that intense gets signed intends are specific State changes matters a whole lot for both composibility as well as a decent price counterparty Discovery because all of Mev or not all but most of Mev comes from the fact that we sign our execution traces and now interleaving matters right like if user A's execution Trace gets executes executed before user B's execution Trace we may end up in some other state so the ordering starts mattering whereas in intense since you've signed over a fully fledged State changes I can apply them in either way and they still result in the same state in the end maybe the second part is not settled anymore but I'm never in this position

where like my execution depends on whatever what other execution happened in front of me um yes and this leads to very nice declarative Paradigm for dapps where a user really just submits whether they what they want to do so they submit like I I'm willing to trade this one nft for one eth and then the system can figure out what how do I settle this like how does this actually get settled in practice it's not the user has to figure out oh I want to go to this specific Marketplace to interact with it the user just says I'm willing to commit to this state change and some of us have a look maybe there's one amm maybe there's 15 amms maybe there's some off-chain computer that needs to happen the user does not have to care what the execution Trace looks

like the user only has to care that they correctly specify the state changes they are willing to take and in the end if it's possible to settle then it's settled if it's not possible to settle then it's not settled right like intents don't guarantee that you can trade things that no one else wants to interact with and the best part of this is that this makes privacies privacy preserving applications a way easier to build because currently users have to make choices on do I go to this privacy preserving decks or do I go to this transparent deck so a user has to make an upfront choice on which application they want to interact with with intents users only have to write their intents

and then certain parts of the intents can be private or transparent and this is up to the user so we're removing this capability that applications make a choice on privacy versus transparency and make it a user Choice users all interact with the same decks but individual users can make choices that they individually want to be private when interacting with the system and here really private means this could either be using zkps or eventually once it gets faster encryption for even better privacy guarantees but besides that really nothing else changes because one of the coolest things is that the intents are still composable so between transparent and private intents that's still composable so if I want to trade ether Bitcoin transparently and someone

else wants to trade Bitcoin for eth privately a solver can pick up both of these things and settle them on chain in the same application and I'll come more into this later but what is really important here is that this is it's an architecture it's not a specific blockchain this is like this is intense for ethereum this is how you decentralize current applications on ethereum or how you bring intents to ethereum really um this is sort of an overview of the entire architecture and just from left to right very briefly you have intents users can issue them again they make choices at the user level not the application Level whether they want to be transparent field or private where transparent field and private are really corresponds to transparent dkps or

they then submit this to the intent gossip Network which is a globally non-contentense critical sparse Network that just gossips and sensor rounds solvers can hook into this and go I care about all the unisop intents I care about all the openc intents or I care about all the I don't know safe intents um solos then figure out which intents are compatible with each other I IE which intends for fully fledged or fully balanced State transitions as in if I trade one Bitcoin for one eth someone else has to take them inverse if no one else is willing to take the inverse this is never settleable and this is what solvers do solve us and submit this on chain to an encrypted mempool using fervio so they're not front runnable value has execute this and then start on the far right we get into the execution

environment which makes all of this possible which is tiger and tiger really is a very it's a Halo 2 ZK circuit which also enables anoma to be to be deployed as the ZK roll up to ethereum this is sort of a Noma is completely oblivious to the security model in which it is deployed you can the users can choose to reply Noma onto ethereum and say ZK roll up thereby bringing intense to ethereum they can choose to deploy this to some corporate chain run by Volkswagen like the architecture doesn't care the nice thing is intents are still spam the entire deployment model of all our Noma instances because my intent can say I am willing to be either settled on security model X or Y so for example I could say I am willing to trade on ethereum but

I'm I want to take delivery of my assets on Solana for example so all these kinds of things are possible nowadays um yeah going a little bit to the stack so we have tiger which is the execution environment uh if you're into cryptography check it out it's very cool that demos that are running right now uh then you have Typhon which I really haven't spoken about the consensus part yet of anoma but the nice thing is we can make way more advances post sort of what is possible with fast finality modern B uh um with modern bft systems and so you can think of Typhon as an evolution of something like tenement which allows you to get a multi-chain atomic settlement work in that I can say if blockchain A and blockchain B have a large enough

overlap in their vowel data set we can do a on-demand chart between these two systems then your vampire which is if you're familiar with programming language it's it's llvm for polynomials so you don't have to worry about writing for a specific circuit back end but rather you write in vampire and then the compiler figures out whether you want a plonker back end or Halo 2 back end currently plunk up and Halo 2 are supported experimental support for Starks is also in the work as well as an fpg backend and then you have duvix which is really the high level language that targets vampire I would expect in the future most developers will never write vampire like vampire is more of a compiler Target I would hope that we get good

enough high level languages where in like in the case of juvex as a developer you don't have to think about what a field element is anymore like it abstracts the cryptography away from the sort of application development side of things um yeah so what can you build with anoma um and this is really this should really say what can you decentralize with anoma because you can either build this on global normal but you can also use anoma to decentralize these systems on ethereum nowadays you can use this to decentralize you actually your optimistic rollups or even your ZK roll ups you can use a Noma to decentralize your nft marketplaces um and lots of other things this is like sort of like once you start diving deep into how 90 of our infrastructure is run

it generally always ends up at somewhere at AWS and really this is intense I the solution to start fixing this going forward even for legacy applications um there's a host of things though that you can't build on existing systems so some of you may have realized that with intense they're just partial State transitions from A to B you just get roll ups for free because if I have an intent from A to B and someone else doesn't intent from B to C any solve on the network can just create a intent from a to c thereby creating a partial roll up this is also actually really important in order to have solve us not waste tons of computes in the sense that you can get paid for doing partial compute that is still valuable you can

also do things like multi-party multivariate bartering default apps such as sealed bit second price auctions or privacy preserving dollars I will skip over this for the brevity of time but maybe sort of the really important thing to understand is this kind of architecture makes building applications about an order of magnitude easier and makes applications about an order of magnitude more composable because currently as an application developer you have to sort of worry about pretty much this entire page whereas with an intensive architecture like anoma you only have to worry about building the application P so that box there and having an intent format that solvers can operate with you don't have to worry about how do I build a backend

on AWS that Aggregates all these intents then submits them as batches to some set of solvers and force some bounding constraints and solvers and so on really the important thing to remember is when ethereum came out in 2015 really we didn't know what was going to happen like we had a rough idea of some cool applications that may come about what we couldn't really spell out all the applications that we'd have nowadays and I think it's the same with a normal like architectures really what intense enabled we're just scratching the surface of that um yes so a normal is an architecture and as a result you can have many different deployment models you can deploy a Nomas in L1 as a sovereign chain Global or local whatever you want

but you can also use anoma to deploy this as an L1 and a half which is really you're trying to decentralize in application on an existing system for example you can use a Noma as an L1 and a half to decentralize the counterparty Discovery and solving component of cow swap while still being settled on ethereum or you can even if you want access to the entire privacy preserving aspect of a number you can also use a normal as a L2 on ethereum and this is really sort of the main message a normal loves a theorem like a Noma does something that ethereum doesn't do like no one we don't have any plans to like integrate intents yet and intents are just this very clean abstraction that allows applications to be built in a fully decentralized manner

without relying on sort of AWS not going down or open c not censoring trades uh yeah so this is bringing intents to ethereum um and the last sort of minute I'd just like to introduce the anoma of C program so Noma is specs first there are specs for everything some specs are better than others but the journey specs for the entire system and they live at specs.noma.net we are opening this up for comments effectively um this is starting so if you go there you can find more information but effectively if you're a researcher if you're interested in a space if you want to see what intents can do actually as

on an application Level please check this out uh the program is starting soon and we really much welcome other people to contribute here um yeah thank you very much um I hope this was insightful and yeah thanks [Applause] thank you [Music] [Music]