Build Your First ZK App with Noir

Transcript

Thank you everyone for joining us today. We have another iteration of building a ZK app in 30 minutes. Uh we're going to cover a lot of ground today. Um so it's really great to have everyone uh here and with us. So I'm going to start presenting. Um just to introduce uh the Aztec team that is here real quick. Um my name is David. I'm on the product marketing side. Uh we have Z Pedro who's going to be taking us through the demo and then we also have Josh uh who leads our Devrell team who's here to answer any questions that you have in the chat.

So we've got a lot of uh brain power to answer your questions. So please uh take notes and feel free to to jump in or interrupt as well or drop comments in the chat and we'll get to them as we go along. Okay, cool. So thank you all again for joining. We're going to be building an app today. Um or at least watching uh Pedro build it and you can code along or you'll also get the recording afterwards so you can uh try it out yourself. Um we've also got many great resources on the noir docs for you to jump into. Um, but we're really hoping that this session today is going to give you a good introduction to what's possible and just to give you a feel for what it's like to um, actually build something.

And so, first we're going to cover I'm going to cover a quick intro to just ZK apps in general, the landscape, where things fit in. Uh, then we'll dive into the live demo and then we'll have a Q&A. So, we've reached a really exciting time uh in the web 3 landscape. It's been a long time coming, but the application layer is finally here. I'm happy to announce. Uh and this is all being brought to you by privacy. So, we're at the very beginning of this new wave of things that can be built. Um, but when you enable privacy and bring it into web 3, you unlock all of these incredible use cases. Uh, from online gaming, where

of course you don't want to see certain things on chain as you're interacting, uh, to things like private voting, uh, uncolateralized lending or the entire wave of applications that um, bringing identity on chain privately can uh, can unlock. So quickly to recap where uh what you might have heard uh about ZK um there's really uh two different ways that people have thought about it and worked with it so far uh in the space. One is you've probably heard that it scales Ethereum.

It makes it fast, cheap, and secure. Uh and all these L2s are are using it uh to do exactly that. The other thing you've probably heard is that it enables privacy. And so there's all these different networks that are starting to incorporate ZK in different ways uh to achieve different outcomes and different levels of privacy, but to try to enable people to build uh and incorporate privacy in their um in their applications. But what we're going to be focusing on today is specifically uh not the infrastructure level uh which was the previous slide but really what you can build as developers on top of uh this new infrastructure and how you can use ZK to build privacy preserving apps. And

so this is already a space that is uh taking off. So we have everything from uh identity coming on chain like with things like CK passport uh to things like stealth note that enable uh a glass door for uh for web 3 where you can prove you're part of an organization and interact privately based on those credentials uh everything from that to private DeFi uh email verification and things like gaming uh battles is an example of that where it's like an onchain private battle battleship game.

And so really the the possibilities are uh are endless with this and we're starting to see some really exciting new use cases. Just so we're all all on the same page here, we're going to cover ZK uh proofs. Uh just really quickly, this is probably already familiar to you, but just so we're all on the same page. Um what's happening here? Why are we using ZK proofs? Well, it enables one person, the prover and Alice in this case, to prove to a verifier, Bob in this case, that she knows something, some sort of information, um that uh that he can verify without her having to reveal that information. And she does that by

sending him a proof um that he can use to verify that. Specifically, we're going to be talking about a proving scheme, uh, a ZK scheme that is called ZK Snarks, which you're probably also familiar with. Usually, it's used just for the second property here, which is the succinctness. Um, but we're also going to be talking more specifically here about the other properties that it enables, privacy, and of of course the third one is uh that is non-interactive. So, there's not a extensive back and forth. Everything can just be passed in one message.

So, how does this actually work? Um, well, Alice is going to take some sort of information. She's going to feed it into a proving backend. This could be any type of backend. You might have heard of Plonc or Grath 16 or different pro proving backends. This is going to spit out a proof, send it over to Bob, uh, who's going to check if it's valid. He's going to do this using a verification key which is generated uh during out of the uh proving back end during the setup. Um and it's uh importantly it's a key that can live onchain and so we can it can be stored in a smart contract on L1 and that's what we see with uh verifier contracts

which you'll be using today where you're actually going to be deploying a verifier contract to continuously check if your proofs are correct. So uh that's a highlevel theoretical overview. How is this actually being implemented? Um when we talk about ZK for scaling um of course we have all of the transactions that are uh the witness in this case all the information that's coming in and L2 like scroll for example will take all these transactions and in this case they are the prover. for rolling all of these transactions up, creating a proof, sending it to the verifier contract on uh the L1 to

actually verify this information. This just takes advantage of the succinctness aspect. Um, and so it's really just trying to use layer 1 for settlement um and speed and use layer 2 uh to uh help scale transactions without having them them all be onchain on layer 1. If you want to do this for privacy, you have to move the prover to the user. The user has to become the prover and all the proofs are going to be offchain and those are going to be sent to the layer 2 uh to be executed. And from there, the layer 2 is going to become the prover again and send all of bundle all of those up and send them to layer 1.

Now you might be asking okay everything happens uh if if the proofs are being generated offchain you can still see how everything happens on the layer 2 like scroll like all the wallets are public all the transactions are public um and that's why you have something like Aztec network that we're building where you can have off-chain proofs but you can also have private wallets private transactions um and all of that is still bundled led up in the same way uh as a zk rollup and sent to layer 1 to be settled. So how do we actually build an application that allows us to create uh

proofs offchain and um on the client side and uh integrate them into our into integrate that into our applications. Uh it's been very challenging uh and has required a lot of ex um a lot of advanced skill to actually build these systems and applications so far. But that's why we built Noir. It's the universal language of ZK. And it makes this super easy for you as a developer. Specifically, it allows you to use logic instead of having to write all these like crazy uh proof uh these crazy like circuits under the hood. Does all of that for you. And so it's a Rustlike syntax. It'll be familiar for you as a developer. Uh it's open source. So there

are many different libraries that you can use. Uh and it's flexible and so there's very little vendor lock in because you can you can swap out any proving backend uh that you choose. So if you're the world team, you might have your own proving backend that you're developing for a really tailor specific use case, but you can still use Noir on the front end. Um or if you're building on Aztec, you can still use Nor on the front end and you're going to use uh a proving system that is tailored to really fast client side proofs uh which is what we're trying to um which is what we're building at Aztec. So uh final slide here before we actually jump into the demo. Uh this is

a really great time to start learning Noir. Uh we've had Noiron zero and Noircon 1, uh which were two conferences. one was at Devcon and then one was at East Denver. Uh there was a lot of buzz around both, a lot of great attendees um and a lot of great projects that are being built and come out of those and so the momentum is here. Uh and it's a really exciting time to start building with Noir. Um so, uh congratulations. You're in the right place at the right time. Uh, and you're with the right people with Z Pedro who's going to take you through actually building something now.

Hey, um, glad to be here. So, I'm trying to um, so you um, yeah, here I hope you can see my screen now. Yeah. Okay. Um just to just to tell you basically what what we're going to be doing here. Um as as I said we do have we are going to be this person Alice uh which is actually a um she's a fighter you know she likes to she's like a she like Brad pit you know likes to go to fight clubs like very um very

secretive and everything but and and she has to know a password in order to enter the fight club. Um, and there's one thing like the guy that is actually the bouncer like that's it at the door of the fight club, he doesn't know the password and he can't he can't know the password as well because he's not a member. He's just a bouncer. I mean, he just like hired to be there. Uh, and so what Alice wants to do is to prove uh that she knows this password but without actually revealing it. And so the way that it works is that Alice will generate the hash of the password and will send the hash to a

bot. Everyone will be able to know what the hash is because the hash is just gibberish. I mean it's impossible to do it the other way around. You couldn't know from the hash what the password is. Um and so bot can know this hash no problem. Um, and the way that zero knowledge works is so cool that Bob can actually verify that Alice knows the password, but without knowing, without actually seeing the password. That's why it's called zero knowledge because he knows nothing about what is the actual password. He only knows what the hash is. Um, and so that's what we're going to be building today. So, I'm I'm Jedro.

Um, and this is a little link you can follow. um for my link tree. And so with this link tree, which is uh just a link tree uh slash uh zk pedro and basically you're going to see um code space um and uh sheet. So let me just move to that screen. Um, is that something else? Uh, so we just going to present the whole window. I think this makes more sense. So I hope you can see my window now. Oh yeah, this uh sunny loop.

Yeah, cool. So here uh you can see just link tree/dk pedro and this is where we are are going to be working. So you can actually follow along by uh clicking these two links. Uh the the first one is just a cheat sheet. So you can you can basically go here and if you've missed something in this in this um workshop, you can always go here and there's all the commands that we're going to be learning. I mean I think uh I may remember something in the middle. But yeah, in any case, this is the this is the the sheet and also uh the code space. So the code space I call it for because it's really like really really

um a simple simple thing. So I'm going to just present that one. Um just a second just to present something else. Yeah, just present that out. I think it's going to be easier. So, um, so in this you're going to have the you're gonna Sorry. Yeah. Uh, you're going to be able to choose um just a I'm going to choose a big machine so it's just faster to run. And this is free. Okay. Right.

You'll see here is paid by protocol, but it's actually paid by whoever you are uh logged in. So um but this is this is free. you have a number of um hours available and basically codespace is just a remote machine. It's like a cloud machine but this one in particular comes with uh some tooling installed. So if you go on the cheat sheet and for whatever reason you don't want to um to use the code space you can actually install this tooling manually. Uh this would be the what we call no app and BB app. So those are installers, those are like Rust apps, like uh Foundry app. So they're just like

ways to get your your tooling um for whatever version you need. Um so yeah, in this case of this code space, it already comes with that like already comes with that installed. So that's why it's taking a little bit because it's actually installing uh our tooling. Um in the meantime let's just uh talk a little bit about how how sometimes it is a bit confusing who is actually running uh what we're writing here and the answer is Alex will be right will be writing and we'll be proving but um Bob will also have the same the same program so he can verify

what Bob doesn't know is uh what we call the witness which would be sort of the solution to um to the to the program. Uh so that's that's one thing that we should keep in mind. So uh once this is done um we can get started and I'll I'll make that clearer. So here have what I call Nordberg just like a nice repo. Um but yeah you can see you can actually run Nargo and BB.

So nargo is inspired from cargo from R. Uh this what it does is just um it's kind of a package manager and makes has some tooling for executing the NAR circuits and NB is the Baratenberg um back end. So this is what you could actually swap by some other back end uh as long as it's it understands the the intermediate language um between the two called ACR. Um so to start we can actually just go now go in it and you have to define a name going to call it workshop and yeah and it creates a new program. So what

what are we looking at here at? We have nargo.l. So if you know r, this is same thing as cargo.l. So it has some properties. If you need dependencies, it will pull them from github. And um so just a file that you have to have so you can understand that it's a noir project. And then there's our main file uh main. Noir. So first thing we want to do here actually it should be highlighting the syntax. I don't know why it's not uh yeah maybe maybe still booting up. Any case um so we are Alice right? So we want

to have um a password and the hash of a password. So first thing we want to do here is know how the hash of the password is right because we don't know anything about that. So we need to import uh some kind of crypto library uh some kind of library that um allows us to hatch things. So let's just use uh the standard no standard library that has it because okay here's the syntax um because um that uh we use it a lot obviously. So just import this hash this is hash um very known very z friendly. So let's imagine that our password is the password is going to be um one two three

right because right because that's that's the that's the the set password ever. Uh and then what we want to know first first of all we want to know how does that password how does a hash look like? So how could we can send this hash to the to the to the verifier in this case to Bob. So let's start there. Let's just start with hashing password. Uh it also requires the number of um things we want to hash which is just three. So let's just uh print this. So this is the first thing we want to know. Usually you would do this in another language but honestly I think just fine and and better to do it this way. Uh also we can we can

introduce this um this command called nargo test nargo test and this will be show show output. So it shows how does the hash look like. So the hash looks like this. Okay here. So everyone knows this and obviously if you look at this you can't hopefully you can never understand that this is the half of one two three right. Um, so this is publicly known. This is what only thing that Bob will know is this is this hash, right? So if we are alias um we want to have a

password we let's call it a field. F field is I mean I'm going to be lying but it's you can treat it as kind of a big integer. Um and there is the password hash. Password hash. Uh so this is what is public. Again this will be this right. So password hash will be something that is public and the password will be something that only I only I know. So the very simple circuit that we build is just I'll take the password within my program. I am Alice. Keep that in mind. I am going to prove that if I do hash my password, it

will end up matching the password hash uh that you know you are b. So this is what the program will do. So I will just very simply say assert hash password password equals password hash. Okay. And this is it. Okay, this is my program. So you can see the program doesn't reveal anything about the password or anything about the password path. Uh if your program becomes too complex, you can always go and write a test and say test and that's the test name. And let's just uh use the same example of a password. So it's also

going to be one two three and then the the password hash this will be this thing that we computed. Um and then you can actually check that um if I pass password and I pass the password hash that they will they will actually um match. So I can go and run our go test again and just see uh password what I'm doing what am I doing wrong here password hash uh oh yeah yeah it's a you need to put that there are three parameters so

um two parameters but one was given password yes uh I need to put here that it's uh three three um inputs. So my test has passed. So I have now proved actually test that my program works correctly and I can actually even write a test that is supposed to fail and say test uh show fail test should fail and I can make um a test file and I can do the exact same thing. copy it here, but then change the password or change the hash to something just here and both tests will hopefully pass because this one is supposed to

fail and it did fail. So that's good. Okay, so no comes with this testing framework by default that you are maybe used to work with like with death or uh basically any any testing framework. So if your logic becomes too complex, you don't have to go through the whole process of uh creating tests in another language. Just can do it here. No problem. So let's just delete all of this. Um and just actually prove something. So um again just to just to recap, we have we know the password. I am Alice. I only only I know that the password is one two three. Uh you are Bob. you know the

hash. So let's just initialize. So I need to prove right. So let's just initialize my u um constraint system with nargo check. This will generate a proofer tunnel file. Again remind you that this will never leave my machine. Right? I'm actually going to delete this uh later on just to prove to you that uh it works as intend. So with approve.coml I'm going to put here the password uh which will be one two three and the password hash that will be this thing. So by doing this I'm actually um I'm going to be able to

generate a proof that I know what the password is and the proof will not don't it will not reveal what the password is. So to do so I'm going to go with nargo execute. This will basically compile my circuit into um this thing which is what we call the ACR. If you're used to solidity you know what an AI is. So this is basically the same thing. Just tell how many inputs are are there and then there's the bite code is the actual thing that's going to be built. And actually there was the code afterwards as well. Um, but you don't need to know what this is. It's just like it's um

it's the compiled version of this circuit. You could serve this for example in a in a form on the web or something. And here is the the the witness. This is what uh I can't open it here but anyway you wouldn't understand anything as well but this is the solution of our circuit. So what Noir did was basically prove that there is a solution for this for this problem. There is a solution for uh some dark magic that will make um that will there is a solution for the password that being hashed corresponds to the password hash. So it's not

enough. I can just I can't just give this to the proofer because he wouldn't be convinced uh that I know the password. So I actually need this back end to generate the proof for me. So this is where PB or whatever back end comes in. So um can just go PB proof because I've named this workshop uh I can't use the default parameters which is intended. I I wanted to show you like all the flag that you can use. So, and go um target workshop.json. This uh sorry gz this is the W for witness. Then I'm sending the B for the bite code. Uh so target

workshop.json and also the output. So my proof goes somewhere. Okay. So this is the command I'm going to run. This will generate my proof in both um in here. Okay. So, I can't see this. Uh there's a command in the sheet you can actually use. Um I think it's yeah, it's a very last line in the sheet which is here. You can use to see the proof if you want to. So, because it's a weird format, but you can see here the proof looks looks great. But I mean you can look everywhere you want. You will never see here anything that will tell me will tell you what the password is. Okay, trust me. Because what you will see is

here the beginning of it will actually be the public input. Um so if you see here it's uh ends up DD8. So this is the public input here. This is just how the back end works. This is a little bit and this is actually changing. where uh I think in the next version we'll split and show you the proof and the public input separately. Um because like in a smart contract you probably don't want this to be in the proof. You want this to be in the smart contract. But this uh is basically allows you uh just just sells the proof what are supposed to be the public input. But again this proof is a zero knowledge proof. It doesn't know. It

doesn't allow you to know what it is proving. I'm going to clean this up a little bit. Um, and sorry, my notes are gone. Just so I don't lose myself. So, yeah, now we have a proof. Uh, and now I'm just going to shape shift into B. I'm no B. I'm no I'm now Bob. Hello. Nice to see you all. Um, glad to be here. Um, so, uh, there's something that here. I'm just going to delete everything that Alice did. I'm just going to delete everything. Just going to leave just the proof and the and the program. So, yeah, I am Bob. I see this proof here. I don't know if

it's true. I know this circuit. I know what the public input is, but I really don't know like what the password is. Uh, but Alice just sent me this proof thing. Um and she she thinks that I can verify this proof using the same compilation of this turquoid and she can convince me that she knows the password. She knows what is this password, right? That's uh crazy, right? This is amazing. So let's try it. I don't know. I don't know if it's gonna work, right? I'm I'm just a bouncer. I I don't I don't know uh crypto. I don't know math. Um, so yeah, I'm just going to compile this

again just uh just like um Alice did I think and I'm just going to compile it. I have the same circuit as she has. Um, so one thing I want to be sure is that I am actually compiling the same circuit that that she's compiling because I want to be sure that she's proving what I want her to prove. Um, so what I need to do is uh generate a verification key and this ver verification key will have to match the one I'm expecting. So I'm going to do that with uh brainberg. So I'm going to go write verification key and and say target um this is workshop.json for the bite bite code and

then the output. Sorry. Okay. So now I have the verification key. I can be sure that uh she so when I run the the verification uh I I can't I it won't be uh she wouldn't be able to prove anything else other than disk. I'm absolutely sure this is the circuit that she proved. Um, so I'm good. Like, uh, I can go uh DP for a client and like it just works like crazy, right? So now I know that given this I know this is it was in the in

the but just knowing this I can I just that simply verify that Alice knew what the password was right do you see anything here that will reveal what the password is right so this is really powerful And is it is even more powerful if you think that you can actually now generate a smart contract out of that because this is all good if you're a member of the fight club and you want to enter a fight club and there's someone that verifies your proof. But

what if you want uh that there is no one to to like no physic no counterparty um how right how how is how is it um you can generate a smart contract you can put that smart contract in EVM chain or any kind of blockchain and then the smart contract will verify the proof for you and that's because the technology here is zero knowledge N succinct non interactive arguments of knowledge. Someone spoke. Okay, let me see. So good.

Um, so yeah, it's non-interactive. So I don't need Bob to do anything. Uh, right. I can just export this verification key into a smart contract and then it just just let the smart contract do its do the verification. So that's what we can do with BB. If you see BB the help command, it will tell you that you can write the solidity verifier. So I'm going to do that. Write solidity verifier. And this generated a solidity verifier here. Uh out just make it out.

That's all. And here's it. Like this is all the math you don't want to look at. Uh it's kind of scary. Uh but yeah, this is all the math that goes into the honk proof. Um ultra honk proof. So this is what we can actually deploy in in a smart contract and I believe we still have some time, right? Um so we can go maybe through so we can we can actually try this on remix. So, uh you probably know remix. Let me just um open it and share my screen again.

Um and here's it. Cool. So, you probably know this. This is really cool project. Um Oh, come on. It opens in another window. All right, same window here. Um, you probably know this if you are special if you are um solid developer. This is a known place to you. Um, this is um this is like a an IDE for um validity for development in solidity. So let's just start with a blank project. Uh create a blank project.

Um blank blank going to completely start a new um just going to paste here my my file say contract dots soul this is the contract that I just created and so yeah it will tell you don't paste code snippet don't trust yeah no yeah you can no problem in this case just in this case so here is my contract just I'm going Save that. And now I'm going to compile my circuit here. Uh, this actually should Oh, yeah.

I should use a different maybe 29 maybe version to compile this. Yeah. Okay. So now I have my contract is compile. Uh, now I'm good to deploy it. So just going to go to I mean whatever environment I want. It's going to f the contract. I think it's going to be on query card and I'm going to deploy it, right? So, it will say that this too big and I say, "Yeah, no problem. You could uh I could just um optimize it."

But uh in any case, like here's my here's my thing. Here's my um my verifier here. Uh it only exposes one call, which is verify. So, what I'm going to be doing now is uh exporting that proof with that ugly command I sent you. Um, just copy it. I know you're not seeing. Just going to show you. Just copy it to the to the Remix uh uh window so you know. So um what I'm looking at is this proof. I was just going to proof uh

proof whatever. So this is the the huge proof that uh was created by by honk with the proof command inputs. You remember that it ended up with DD8. I'm going to split it here just to help me. as soon I put some zero access at the beginning. Cool. So, now I have the proof and I have the public input. So, and I have my contract. I can deploy it. Oh, I have deployed already. So, I'm good to go. I can actually now put to my contract. I have proved to my contract that I know a password um such that when hashed it'll uh be the

same as this thing that basically tells you nothing about password. Um so going to copy my proof here and copy it. I'm not copying copy my proof into the proof here. And the public inputs here they are. I'm gonna just say and then here I think I need to quote them for public inputs and this will hopefully uh like verify but oh wait file some check file uh what did I do wrong well I don't know uh I don't know

what I did wrong but any in any case like yeah it's not it's not a damaged work so Um yeah, but this this is hopefully would work and and be able to prove to the to the contract that I know the password uh just by showing it the the public input. Uh now you can basically use this in a in another contract to uh to do any kind of uh gates that you want. And more than all you can go into your circuit back into your circuit and do more complex thing like proving that you are a member of a of a of a group using a pre uh membership proof. Um you could do things like uh private voting for example. And all of that is just clever um usage of

um encryption zero zero knowledge and uh contracts. So again you can just import this uh home verifier in whatever contract you want and just make it make a call to it to verify a proof um before you do something like in a modifier or something like that. So, you're going to see some of those examples in the noir uh lang website and that's where that's where um there are some tutorials and uh all of that. You can always go back into my link tree and you're gonna see the discord. Um there was a there was a discord server. Um um I don't know if

see or Josh if you can add that like an invite there and also norang.org um or okay I see it nor.org uh for the for the documentation and that's it. Yeah, it's pretty amazing. Uh as you can see, very simple to do uh very simple small uh examples but also very simple complex examples. Uh so yeah, I'm up for questions if you if you have any.

Thanks so much, Pedro. And definitely we're we're happy to take any questions here. Um I think specifically also about um what you can build with this. Uh maybe while we're waiting for questions too um Pedro, you could go into maybe there's some other examples you want to highlight of types of things you can build like uh anything from like ZK Passport to games or or things that you think are particularly interesting to kind of get people's mind turnurning. Uh but also happy to to take questions here. Uh you can raise your hand or drop them in the chat.

Yeah, definitely like you can you can uh think of it it gets it gets pretty impressive very quickly. I mean it's already impressive but uh but like uh when you think that you can not only prove the pre-image of a hash that also means that you could for example prove that a signature came from a valid public key without knowing what the public key or the signature is. Um and that will that is very nice use case for uh solidity um solidity uh signatures uh sorry Ethereum signatures and also for passport signatures. You see your passport most passports in the world have are electronic. So basically um

they are signed with the key for the country. Your country signs your passport before uh sending it to you. And so uh basically yeah it comes with with that. So basically when you when you uh go into the automatic electronic gates in airports or something it just reads that uh and sign the message and that's basically what proves that you are in the ownership of a uh passport that was actually issued by the country it says it it is. It also contains all the information in the password like your name, your age, um your country of origin, stuff like that.

So someone was like how could I couldn't I just verify this signature within a zero knowledge circuit? And turns out that yes, you could basically just prove that you can that your your passport was um was verified was signed by that by a known public key that everyone knows it's in the website in the ICA website and you can prove that it was signed by that by that uh country and then you can assert anything about what is inside the pass the passport like your age without revealing any of that. So you could uh do things like proving that you are over a certain age, proving that you are from

a certain country, proving that you are from the EU, proving that you are not from uh the US or I mean whatever you want to do basically. Uh as long as that information is is there. Uh and so that's that's really really powerful. Um that's exactly what DK Passport does. No more no less. It's it's pretty impressive. Um, so yeah, questions. Um, cool. There there's a question on how to get started. I dropped a a link to a full stack Nord uhJS app in the chat. It's a great place to go and see how all the pieces fit together and just get a basic project off the ground. Um, if you're interested also on the Aztec side,

there's an Aztec uh starter as well. Um we are we're approaching testn net here so it's a great time to also start learning about Aztec and and how you can incorporate and start building there as well. Um I'll drop the link to that in the chat um as well. So if you either want to get started on the noir side or the Aztec side, there's great uh entry uh tutorials for getting started there. Well, so there's the question like how how often can you ask for for it? You can ask what however you want. So I can I can actually show you the the ZK passport. Uh oh no, I mean it has my private information there, right? Only on my on my machine. So So here's

my here's my uh DK passport um app and for whatever reason doesn't show my doesn't show my my photo. So that's fine. Uh but I can basically use this app and to approve to what whoever wants to check anything about me. They could just generate a proof approving request. Um so they can say uh yeah proof that you are uh born uh after uh before a certain time and I can just generate that z proof in my in my phone. So I can do it as often as you want. Um that's that's absolutely no problem. Um I can

generate as many proofs as you want. Um so Azik password moves to safe. That's you could do something like that which is very very very interesting and that comes so I think one at least one of the wallet designs for for Aztec is ex is actually to to have a passport uh to be able to uh recover your account using your passport which is really really cool. So you don't have to keep your seed bra anymore. you just if you lose your keys, you lose your wallet, you could just use your passport to uh recover that and to say um yeah, I own this password uh this passport here it uh and I can recover my account. So you

could you could do definitely you could do this with safe uh if you want to uh that's something that could be very interesting to do with with safe and solidity to use uh to use a passport. Yeah. Um a question that comes often is like what is the relationship between Noir and Actic? And this is exactly I just touched one of them uh where where you can um uh use Noir to prove um ownership of a specific uh passport without revealing what it is and then using that to recover your account. Um so that's that's exactly what uh what Aztec allows. Uh Aztec allows also for uh private states. So basically you can

um you can basically for example send a note to someone else uh with some information that is private to that someone else uh or it is private to you. So and basically there's this exchange of of um zero knowledge proofs that doesn't even need to be onchain. Uh but everything in in Aztec is a zero knowledge circuit. If it's if it's uh private then it is run on your uh device and um the proof is not shown um and uh yeah I mean it is shown that like not not the pre-image um and if it's public then it's like Ethereum you just send the public input uh to a node and the node will compute the state will

just uh generate a state just like just like Ethereum does and it's this composability because you can have uh private function uh private functions calling uh uh public functions and the other way around with a little caveat um and this is uh this this is possible. So there's this private and public composibility that's what makes us truly unique and like no one there was no other project that even remotely does something like this and so noir the relationship between noir and attic is just noir powers Aztec there is no attic if there is noir or actually there is no if there is nober but noir definitely

makes using much easier than just coding the circuits in in C++ So, so yeah, that's the relationship between the two projects. So if you are if you're building with no you're probably going to end up in a place where where you would say oh this would be so cool to if I could just store this value uh encrypted somewhere and that's where you're going to find out about and they're going to say cool I can actually do that and I like I can have that encrypted value and everyone can prove that it's true without uh being in any centralized place. So it's really really interesting. So no questions.

Cool. Last call for questions. Uh you can also feel free to unmute yourself uh if you're able to do that or drop your question in the in the chat. There's a question. Any connection with Zupass? Uh no I mean zup pass is also zero knowledge proof I think also also uses z proof but it's just not doesn't use noir it uses a different back end uh which is based in the growth 16 proving system um so just uh I would say just different uh so yeah you could definitely build zool path on in benburg and you'll probably find it more more easy to work with but yeah real path I I think it's not it's

not not written with with no. Cool. All right, we will wrap it up there. Thank you so much to uh to Josh for answering all the questions. Thank you all uh for being here. Thank you to Pedro for leading the demo. Uh it's been really wonderful. Please check out our Discord. Uh jump in, try out a tutorial on the docs and follow us on Twitter at Noirang. uh or at Aztec Network if you want to stay up to date on all the other things coming up. Um and feel free to always reach out to our team in Discord and ask questions. We have a very active uh Devril team that is is always there diligently answering all of your

questions. So uh I really encourage you to go there, check it out, drop your questions in uh and let's build some stuff together.