## Build on Scroll

Okay, so you've already gotten your feet wet with the essentials of zero-knowledge proofs, understanding the flavors like Zk-SNARKs and ZK-STARKS. Now, let's get practical! It's time to meet Noir, a fantastic tool that actually lets you build those privacy-powered applications we've been talking about.

**Noir: The Privacy Programmer's Friend**

Think of Noir as a language specifically designed for zero-knowledge circuits. Traditionally, making these circuits has been a bit like... well, like doing brain surgery for cryptographers. Noir changes that. It gives us a more streamlined way to say, "Hey, I want to prove I know something without revealing all the details."

**Why Noir? Because Privacy Shouldn't be a Headache**

The whole point of Noir is to make ZKPs accessible. It's about letting more developers build awesome things like private trading, or games where your secret strategy is truly secret. Imagine proving you're old enough to enter a virtual club without flashing your birthdate!

**Noir in Action: Use Cases**

So, where can you use Noir? Think about DeFi – trading without everyone seeing your wallet balance. Or imagine proving your credit score is good enough for a loan, without handing over your entire financial history. And hey, gamers, how about a poker game where no one can cheat by peeking at your cards? That's the power of Noir!

**Who Should Get Up Close and Personal with Noir?**

If you're a blockchain developer excited about privacy, or just super curious about ZKPs, Noir is your entry point. It's about making this groundbreaking tech usable for more of us.

**The Bridge: Aztec Contracts**

Alright, a quick technical bit: Noir code doesn't live directly on the blockchain because the blockchain itself isn't great at keeping things private. Instead, it gets compiled into an Aztec Contract. Think of an Aztec Contract as a secure envelope. Inside, you put your Noir circuit, which describes what you're trying to prove. The envelope also holds all the tools needed to verify that proof. This way, you can submit the entire package (the Aztec Contract) to the blockchain, and anyone can check the proof without ever seeing the original contents of the envelope (your Noir code).

**Talking to Noir: Solidity Verifiers**

How do you use these Aztec Contracts in your everyday application? That's where Solidity Verifiers come in. They act like little translators between the world of Noir circuits and your regular Solidity code. Let's say you have a Noir circuit proving a user has enough tokens to play your awesome game. A Solidity Verifier lets your game code take that proof from the user and check if it's valid. Think of it as asking the verifier, "Hey, can you trust this proof? Does it really show this user has enough tokens?" If the verifier says yes, then you know it's safe to let the user into your game.

Now let’s see an example of a verifier **(this part is technical and requires Solidity knowledge. We will break it down the code but you can skip this part if you want):**

```
/**
* @notice Verify an Ultra Plonk proof
* @param-proof - The serialized proof
* @param _publicInputs - An array of the public inputs
* @return True if proof is valid, reverts otherwise
*/
function verify(bytes calldata -proof, bytes32[] calldata -publicInputs) external view returns (bool) {
LoadVerificationKey (N_LOC, OMEGA_INVERSE_LOC) ;
}
```

**Now let’s break it down:**

**@notice Verify an Ultra Plonk proof ...: **This is a NatSpec comment providing human-readable documentation for the function. NatSpec is a standardized way to document Solidity contracts.

**function verify(bytes calldata proof, bytes32[] calldata publicInputs) external view returns (bool) { ... }**

**verify**: The function's name.**bytes calldata _proof**: The serialized Ultra Plonk proof the verifier will check.**bytes32[] calldata _publicInputs**: The public inputs needed for the verification process.**external view**:**external**: Means the function can be called by users or contracts outside of this one.**view**: This function does not modify state, only reads it (hence the "view").**returns (bool)**: The function will return true for a valid proof, false otherwise.**loadVerificationKey (N_LOC, OMEGA_INVERSE_LOC) ;**- The loadVerificationKey function unpacks the serialized proof and uses the verification key to cryptographically validate the proof using the provided public inputs.

**Building the Whole Privacy Puzzle**

Noir is just one piece, though. Think of it like this: you design your proof circuit in Noir, that gets packed into an Aztec Contract, your Solidity verifies those proofs, and you've got a slick frontend so users can actually interact with all this coolness.

Need some inspiration for what kind of proofs you can build with Noir libraries? Check out the awesome-noir repository on GitHub. This is a great resource to explore libraries for common ZKP functionalities.

**Want to Dig Deeper?**

If you're feeling the Noir love, dive deeper! The Aztec Network documentation is a treasure trove of information. You can start with an overview of how Noir fits into the Aztec ecosystem, and then explore specific topics like writing your first Noir circuit or using the Aztec CLI. The Noir primer is another fantastic resource, offering a step-by-step introduction to the language. And to see Noir in action, head over to GitHub and explore the wild things people are building with it. The awesome-noir repository is a great starting point, showcasing libraries for common ZKP functionalities and code examples from real-world projects.