Dive into the groundbreaking world of zkVerify, a modular blockchain designed to revolutionize Web3 scalability and privacy through zero-knowledge proofs (ZKPs). This expert-curated course takes you on a journey from the fundamentals of ZKPs and their role in blockchain to a deep dive into zkVerify's unique architecture and proof verification process. We'll explore the challenges faced by existing ZK Rollup solutions, and how zkVerify tackles these issues to provide a more efficient and secure platform. You'll learn about the motivation and goals behind zkVerify, and gain hands-on experience setting up wallets, connecting to the testnet, and submitting proofs. Whether you're a blockchain developer, a crypto enthusiast, or simply curious about the future of Web3, this course will equip you with the knowledge and skills to understand the transformative power of zkVerify.

# What Are We Learning Today

Hey there 👋, gm. We are very excited to bring the first-ever learning tutorial for developers on the zkVerify blockchain on the Metaschool platform. Exciting, right?

First, let's see some great numbers. At the time of writing, zkVerify has already hit a strong following on [X of 12K followers](https://x.com/ZKVProtocol) and [5k+ discord members](https://discord.com/invite/zkverify). Awesome, isn’t it?

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%201_%20What%20Are%20We%20Learning%20Today/image2.webp?raw=true)

Great! But why zkVerify 🤔? Horizen Labs, a well-known name in the web3 world, introduced zkVerify to the public. Founded in 2019, Horizen Labs is dedicated to building secure blockchains and web3 products to solve real-world problems. Their mission is to scale decentralized networks by reducing the costs associated with zero-knowledge proofs (ZKPs).

Zero-knowledge proofs (ZKPs) allow you to prove something is true without revealing the details. These proofs are essential for ensuring privacy, security, and scalability in web3 applications like private transactions, decentralized finance (DeFi), and more. However, traditional ZKPs can make blockchain transactions expensive due to the high computational cost of verifying these proofs, hindering their widespread adoption.

Enter **zkVerify**, Horizen Labs' innovative solution designed to drastically reduce the cost of ZKP verification – not by a mere 10-20%, but by a staggering **90%+**. zkVerify isn't just another blockchain; it's a blockchain purpose-built for ZKPs verification. This breakthrough technology opens the door to a new era of scalable Web3 applications that were previously unimaginable.

Let's take a quick peek at what's in store and what you'll take away from this course.

## Course overview

We will:

1. Understand zero-knowledge proofs in detail
2. Understand the blockchain scalability challenge and how ZK Rollups solve it
3. Go through the current challenges faced by ZK Rollups
4. Understand zkVerify in detail and how it solves the challenges faced by ZK Rollups
5. Understand the goals and motivations of zkVerify
6. Understand the architecture and inner workings of zkVerify in detail
7. Set up your wallet and play around with the zkVerify testnet network
8. Lastly, understand how you can submit your proofs for verifications on the zkVerify blockchain

## Who exactly should take this course?

This zkVerify course is for blockchain enthusiasts excited to learn how zkVerify handles ZK-proof verification and ZK developers who want to contribute to the zkVerify ecosystem.

## What will you be getting out of this course?

You will be getting the following outcomes when you complete this course:

1. Understanding the core concepts of ZK proofs, ZK Rollups, and zkVerify
2. Set up your wallet on the zkVerify testnet network and get the $ACME tokens
3. Submit your proofs for verification to zkVerify.
4. Claim your custom NFT on course completion

## Proof of completion

If you complete this course, you will get a special NFT, a utility token, which will unlock many more opportunities on the Metaschool platform. Here is what the NFT looks like.

![zkverify-horizen.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%201_%20What%20Are%20We%20Learning%20Today/zkverify-horizen%20(1).webp?raw=true)

Now before we move forward, let’s set some house rules first.

1. Kindly do your quick assignments properly.
2. Join [our discord server](https://discord.com/invite/UkesWMvA) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://twitter.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/), it would be a great support. 🫣
4. You can subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool/) channel for exciting videos too. ✨
5. Stay happy and positive!

While you're learning, don't forget to join the vibrant zkVerify community!

- **Follow:** Stay in the loop on [X (formerly Twitter)](https://x.com/ZKVProtocol).
- **Chat & Connect:** Join the community on [Discord](https://discord.com/invite/zkverify) and [Telegram](https://t.me/zkverify).
- **Star:** Show your support on [GitHub](https://github.com/HorizenLabs/zkVerify) and give the zkVerify repository a star.
- **Learn**: Dive into the detailed [zkVerify documentation](https://docs.zkverify.io/).

By actively participating in the community, you'll gain valuable insights, network with like-minded individuals, and stay at the forefront of the decentralized finance revolution.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/1.%20Kicking%20Off%20with%20Web3%20and%20ZK%20Fundamental/1.%20What%20Are%20We%20Learning%20Today.md

What Are We Learning Today

Kicking Off with Web3 and ZK Fundamentals

# Understanding Zero-knowledge Proofs

Hello, Welcome back! Let's dive into zero-knowledge proofs!

## What are zero knowledge proofs (ZKPs)?

A zero-knowledge proof (ZKP) is a way to prove something is true without actually revealing the details of what you're proving. It's like knowing the magic trick but not revealing how it's done! Let me illustrate this with an example featuring Waldo.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%202_%20Understanding%20Zero-knowledge%20Proofs/zkverify-l2.webp?raw=true)

Let’s make this into a challenge. Try finding Waldo. As illustrated above, Waldo is a character with a distinctive appearance: he wears a red and white striped shirt, round glasses, and a red and white bobble hat. See if you can find him in under 2 minutes, if not the most I can do is to prove that Waldo is in fact present in the image 😅.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%202_%20Understanding%20Zero-knowledge%20Proofs/zkverify-l2.webp?raw=true)

Let’s say I want to convince you that I know the location of Waldo in this image without revealing his exact position. Trust me if you’re going to try finding him in [here](https://drive.google.com/file/d/1zzI_4QHIiQV1e5J-QWQjG5YqqmOdh48Q/view?usp=sharing), it’ll take a while 😅.

One thing I can do is place a black overlay on top of this image with a small circular cutout and show you Waldo. This will ensure that I can prove Waldo’s existence without revealing this exact location.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%202_%20Understanding%20Zero-knowledge%20Proofs/l2-image3.webp?raw=true)

This is the basic premise of Zero-knowledge proofs. The ability to prove a claim without having to reveal the underlying details of that claim.

Basically, it's a system with three parts: a prover, a verifier, and a challenge.

- **Prover**: The party proving knowledge of a secret without revealing the secret itself.
- **Verifier**: The party verifying the proof without revealing the secret.
- **Challenge**: A process where the verifier challenges the prover to prove their claim without disclosing the secret.

In this Waldo analogy, I'm the prover because I know exactly where Waldo is in the picture. You’re the verifier, trying to be sure that I really know Waldo’s spot without me telling you directly. The challenge here is the task of finding Waldo. By putting a black overlay with a small cutout to show only Waldo, I can prove to you that I know where he is without showing the whole image. This is just like zero-knowledge proofs, where one person shows they know something without revealing the actual information.

## Zero knowledge and web3

Zero-knowledge proof is one of the most powerful tools in the world of cryptography and blockchain. There are several reasons for this claim :

- **Enhanced privacy and security**
    
    It boosts privacy and security in transactions. With zero-knowledge proofs, you can prove a transaction is legit without giving away any personal details.
    
- **Scalability of blockchain networks** 

    ZKPs and zkRollups significantly enhance blockchain scalability by enabling off-chain computation and validation. ZkRollups bundle transactions and submit a single proof to the blockchain, dramatically increasing transaction throughput.
- **New applications and use cases**
    
    Zero-knowledge opens the door to additional web3 use cases. Think proving you own a digital asset without anyone knowing who you are, or logging in without needing a password.
    
- **Cryptography**
    
    In cryptography, zero-knowledge proofs are integral to protocols like anonymous digital signatures and secure multiparty computation. They enable secure communication and data sharing without exposing sensitive information.
    

Some of the use cases of zero knowledge are:

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%202_%20Understanding%20Zero-knowledge%20Proofs/image1.webp?raw=true)

- **Password verification**
    
    When you enter your password on a website, zero-knowledge proofs can verify it without the website actually seeing the password. This keeps your password private and secure.
    
- **Financial transactions**
    
    Zero-knowledge proofs ensure that financial transactions are valid without revealing sensitive details such as account balances or transaction amounts.
    
- **Identity verification**
    
    Zero-knowledge proofs can confirm a person's identity without disclosing any personally identifiable information. This is particularly useful in sensitive contexts like medical or legal situations.
    

Beyond these examples, zero-knowledge proofs are finding application in a growing number of innovative blockchain projects. Emerging blockchain solutions like **zkVerify** are capitalizing on zero-knowledge proofs to unlock a new era of scalability and privacy-preserving applications.

## zkSNARKs and zkSTARKs

These are two of the most well-known types of zero-knowledge proofs, each with its own quirks and features.

- **zkSNARKs** 
    (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) are known for their compact proofs and fast verification. They're great for quick checks in cases like blockchain transactions. But they also need an additional initial trusted setup.
- **zkSTARKs** 
    (Zero-Knowledge Scalable Transparent Argument of Knowledge) are newer and focus on handling bigger and more complex proofs efficiently. They skip the trusted setup part, which makes them more transparent and theoretically safer in some ways. However, they tend to have larger proofs and can take longer to verify compared to zkSNARKs.

### Main differences

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%202_%20Understanding%20Zero-knowledge%20Proofs/image2.webp?raw=true)

No need to worry if you’re unfamiliar with these definitions, Let’s simplify.

- **Trusted setup**
    - zkSNARKs: Requires a special phase at the start to create some initial settings securely, known as a "trusted setup.”
    - zkSTARKs: Do not require a trusted setup, promoting transparency and potentially improving security.
- **Proof sizes and speed**
    - zkSNARKs: Have smaller proof sizes and faster verification times, suitable for applications requiring quick responses.
    - zkSTARKs: Have larger proofs and take longer to verify, making them more suitable for scenarios prioritizing robustness over speed.
- **Succinct setup (Efficient initial configuration process)**
    - zkSNARKs: Setup time can vary but may take linear time or more depending on the implementation.
    - zkSTARKs: Usually get started quickly, in a way that grows slowly even as the system gets bigger ( Logarithmic setup time).
- **Scalability**
    - zkSNARKs: Efficient for certain scalability needs with verification time for proof-checking time growing slowly even as the system scales (Logarithmic verification time).
    - zkSTARKs: Provides quasi-linear proving time and logarithmic verification time i.e. proof-making time grows slowly and proof-checking time grows very slowly. It is suitable for handling larger and more complex proofs efficiently.
- **Applications**
    - zkSNARKs: Widely adopted in blockchain for their speed and efficiency in transaction verification.
    - zkSTARKs: Gaining traction in applications requiring high security and transparency, such as financial audits and privacy-preserving protocols.

## That’s a wrap

That's a wrap! We covered what zero-knowledge proofs are, how they work, their importance in Web3, and the main differences between zkSNARKs and zkSTARKs. These concepts might seem complex at first, but they are key to enhancing privacy and security in our digital world. Keep exploring, and we’ll continue in the next lesson.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/1.%20Kicking%20Off%20with%20Web3%20and%20ZK%20Fundamental/2.%20Understanding%20Zero-knowledge%20Proofs.md

Understanding Zero-knowledge Proofs

# ZK Rollups and ZKPs Fit Into Blockchain Scalability

Welcome back! You did great on learning all about the zero-knowledge proofs.

In this lesson, we’re going to discuss the big challenge blockchain faces and how that problem can be solved with zero knowledge rollups that use ZK proofs.

## The “challenge” blockchains face

The one most daunting challenge the ever-growing and ever-expanding blockchain technology faces is “scalability”.

Imagine you're hosting a huge pizza party for all your friends. 🍕 Everyone's hungry and excited, but there's only one oven, and it can only bake one pizza at a time. This is a big problem because the more friends you invite, the longer everyone has to wait for their pizza.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%203_%20ZK%20Rollups%20and%20ZKPs%20Fit%20Into%20Blockchain%20Scalability/image3.webp?raw=true)

This situation is similar to the scalability issue in blockchain.

As the blockchain grows and more complex applications are built on top of it, the system can face limitations in its ability to process transactions quickly and efficiently, leading to slower transaction times and higher fees. This is akin to your pizza oven having a limited capacity – it can only bake a certain amount of pizzas at once. So, scalability is about making the blockchain capable of handling more transactions quickly and efficiently, just like figuring out how to bake more pizzas faster at your party.

## ZK Rollups to the rescue

Now, imagine you get a magic pizza oven that can bake multiple pizzas without losing quality. ZK Rollups work similarly for blockchains. They bundle many transactions together into a single batch, process them all at once, and then update the main blockchain with the results. This makes the blockchain much faster and more efficient without sacrificing security or decentralization.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%203_%20ZK%20Rollups%20and%20ZKPs%20Fit%20Into%20Blockchain%20Scalability/image5.webp?raw=true)

In short, ZK Rollups help the blockchain handle more transactions quickly, just like a magic oven helps you serve more pizzas faster!

## So, what exactly are ZK Rollups?

Before we move forward, let’s take a step back and revisit ZK Proofs from our previous lesson. This brief recap will help all the pieces fall into place for a better understanding of ZK Rollups.

### Zero-Knowledge Proofs (ZKPs)

Remember the "Where's Waldo?" analogy from our last lesson? Finding Waldo in the crowd without revealing his exact location is like using a Zero-Knowledge Proof (ZKP). We used a black overlay with a circular cutout to highlight the area where Waldo is, without pointing directly to him.This demonstrates the knowledge of his presence without giving the location away.

### ZK Rollups mechanism

Imagine you're checking a "Where's Waldo?" book, but instead of finding Waldo yourself, you have a helper who does it for you. Here's how this works:

- **Finding Waldo on each page:** Your helper looks through each page of the book
- **Bundling pages together:** Your helper puts sticky notes on all pages where they found Waldo and bundle them together.
- **Creating a summary proof:** Your helper writes a note saying "I found Waldo on 20 pages" without telling you which pages.
- **Verification:** You believe your helper's note without checking each page yourself.

ZK Rollups operate similarly:

1. ZK Rollups collect multiple transactions (like finding Waldo on multiple pages) off the main blockchain.
2. They then create a special cryptographic proof (zk-SNARK) that confirms all the transactions are valid.
3. This proof is sent to the main blockchain, which verifies the summary without needing to check each transaction in detail.

### The role of ZKPs in ZK Rollups

So, ZKPs are the magic behind this system. They allow us to confirm that all bundled transactions are correct while reducing the data stored on the blockchain, making it faster and more efficient.

In short, ZK Rollups use the power of ZKPs to bundle and verify transactions off-chain, ensuring privacy and speed, just like your magic box confirms treasures without revealing their secrets!

## Challenges in ZK Rollups

While ZK Rollups solve the scalability challenge they introduce new challenges. Let’s discuss those challenges and see what bottlenecks they present.

### High computational costs

ZK Rollups require complex cryptographic computations to generate proofs. These computations are resource-intensive and can be expensive, especially for more complex smart contracts. This cost can be a barrier to widespread adoption, particularly for smaller-scale applications.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%203_%20ZK%20Rollups%20and%20ZKPs%20Fit%20Into%20Blockchain%20Scalability/image4.webp?raw=true)

### Limited support for new cryptographic types

The cryptographic proofs used in ZK Rollups, typically zk-SNARKs or zk-STARKs, are highly specialized. Implementing support for new types of cryptographic proofs or upgrading existing ones can be challenging. This limitation can slow down innovation and make it difficult to adapt to new security requirements or more efficient proof systems as they emerge.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%203_%20ZK%20Rollups%20and%20ZKPs%20Fit%20Into%20Blockchain%20Scalability/image2.webp?raw=true)

## Proof verification costs

This is something we already discussed but let me give you some numbers, according to Horizen Labs, ZK Rollups spent around $50 million on proof verification in 2023. This cost is expected to skyrocket to over $1 billion by 2028 due to the growing popularity of ZK Rollups.

L2BEAT reports that the ZK-Rollup sector boomed in 2023 with 20 active projects and 18 more launching in 2024. This is a whopping 90% growth, showing the sector's massive potential. With this rapid expansion, we expect the number of active ZK-Rollups to double each year from 2024 to 2028. By 2028, we could see around 500 ZK-Rollups, with proof verification costs soaring past $1 billion.

This shows how much verification costs we need to ZK Rollups at large scale which becomes problematic and expensive for the users to use.

## The power of zkVerify

Solving one issue using ZK Rollups introduces another challenge. To address this challenge, Horizen Labs introduced the zkVerify blockchain network to collapse proof verification costs.

zkVerify’s specialized proof verification layer has the potential to slash-proof verification costs by over 90%! If it had been available in 2023, ZK-Rollup users could have saved a whopping $43 million. Talk about a game-changer! As the co-founder of Horizen Labs mentioned:

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%203_%20ZK%20Rollups%20and%20ZKPs%20Fit%20Into%20Blockchain%20Scalability/image1.webp?raw=true)

## That’s a wrap

In summary, ZKrollups faces challenges like data availability issues, proof verification costs, and potential centralization risks. However, with new innovative solutions like zkVerify blockchain, these hurdles can be overcome to create a robust and efficient blockchain system.

In the next lesson, we will cover zkVerify in detail and understand what exactly it is and what are its goals.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/1.%20Kicking%20Off%20with%20Web3%20and%20ZK%20Fundamental/3.%20ZK%20Rollups%20and%20ZKPs%20Fit%20Into%20Blockchain%20Scalability.md

ZK Rollups and ZKPs Fit Into Blockchain Scalability

# Introducing zkVerify

Hey there! You're now masters of zero-knowledge proofs and ZK Rollups, and you totally get how they work. Awesome, right? But why did we even learn about them and spend so much of our time understanding their basic mechanics?

It’s because Zero-knowledge proofs (ZKPs) are the cornerstone of zkVerify's technology and they play a pivotal role in its ability to improve and enhance ZK Rollups. zkVerify leverages the power of ZKPs to provide secure and efficient verification for a wide range of blockchain projects and decentralized applications (dApps). But what exactly is zkVerify? Let’s explore it in detail.

## What is zkVerify?

Picture this: you’re throwing the biggest, coolest outdoor music festival ever! To make sure everything goes off without a hitch, you decide to split the event into different parts, each with its own team in charge.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%204_%20Introducing%20zkVerify/image7.webp?raw=true)

1. **Execution (Stage Performance Team)**: These folks handle all the performances. They get the artists ready, ensure the sound is perfect, and make sure the show rocks on without any hiccups.
2. **Consensus (Crowd Control Team)**: This team keeps the crowd happy and safe. They make sure everyone follows the rules and has a blast without any trouble.
3. **Data Availability (Media Team)**: This crew captures and shares every awesome moment of the festival. They take photos, record videos, and update social media so everyone can see what’s happening in real time.

Just like your music festival, web3 developers love breaking down blockchain functions into separate modules to make them work better and more efficiently. Each module has a specific job, helping the whole system run smoother.

Inspired by modular systems, Horizen Labs introduced **zkVerify**—the ultimate proof verification layer for blockchains!

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%204_%20Introducing%20zkVerify/image1.webp?raw=true)

Imagine zkVerify as your go-to network that helps blockchains handle heavy and expensive proof verifications. It's the first modular solution that can reduce the cost of proof verification on Ethereum and other blockchains by an impressive 90%+!

What does this mean? zkVerify takes zero-knowledge proofs to the next level by making proof verifications cheaper and faster for all kinds of projects and apps. Its main goal is to boost the efficiency of ZKP verification.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%204_%20Introducing%20zkVerify/image2.webp?raw=true)

zkVerify is a high-performance, public, decentralized, reliable, and secure blockchain. It offers modular solutions and more affordable proof verification, with verifiers written in the Rust programming language. Just like breaking down a big task into smaller, manageable parts, zkVerify makes blockchain processes smoother and more efficient! Feel free to explore their [official website](https://zkverify.io/?utm_source=metaschool&utm_medium=pd&utm_campaign=campaign) as well.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%204_%20Introducing%20zkVerify/image3.webp?raw=true)

Let’s understand the goals of zkVerify by taking a real-world example and how zkVerify deals with it.

## Let’s discuss the “Motivations behind zkVerify”

Let's imagine you're organizing an epic amusement park day for a huge group of friends. You want everyone to have a blast, but there are some big challenges to overcome. Here's how the motivations behind zkVerify fit into this fun example:

## Prohibitive costs

### The Problem
Amusement parks can be super expensive! You have to pay for tickets, food, rides, and games. Imagine if the costs change based on the number of people in line for each ride, just like the fluctuating gas fees on the Ethereum network during peak times. One minute a roller coaster ride is $5; the next it's $50! This unpredictability makes it hard for everyone to enjoy the day without worrying about their budget, similar to how high gas fees can deter users from transacting on Ethereum.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%204_%20Introducing%20zkVerify/image5.webp?raw=true)

### zkVerify's Solution
zkVerify is like having a pass that drastically cuts down these unpredictable costs. Normally, verifying a zero-knowledge proof on Ethereum can be expensive due to high gas fees, especially during network congestion. These fees range from $20 to $60 per single proof verification! Using zkVerify is like having a special ticket that keeps costs low and stable, no matter how crowded the park gets. This way, everyone can enjoy more rides without breaking the bank.

## Hampering innovation

### The Problem
Imagine the amusement park has tons of awesome new rides planned, but they can't open them because they need specialized components that are difficult and costly to acquire. This is similar to the Ethereum blockchain, where certain advanced cryptographic techniques can't be used easily because they are too expensive or not supported.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%204_%20Introducing%20zkVerify/image6.webp?raw=true)

### zkVerify's Solution
zkVerify is like a super-efficient supplier that provides all the parts the amusement park needs at a lower cost and with more variety. Ethereum Improvement Proposals (EIPs) help introduce new features, like new rides, but the process is slow and requires a lot of agreement from different stakeholders. zkVerify makes it easier to adopt new cryptographic standards and techniques without waiting for a lengthy approval process. This way, the amusement park (or blockchain) can keep innovating and adding exciting new features for everyone to enjoy.

## The “Goals of zkVerify”

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%204_%20Introducing%20zkVerify/image4.webp?raw=true)

1. **Reducing Costs**: Just like keeping amusement park tickets affordable, zkVerify helps keep blockchain-proof verification costs low and stable. This also enhances the efficiency by offloading the computational burden of the blockchain while reducing the cost.
2. **Promoting Innovation**: Just like adding new, thrilling rides to the park, zkVerify supports the use of new cryptographic methods, making the blockchain more versatile, modular, and innovative.
3. **Ensuring Smooth Experience**: By handling heavy verification processes, zkVerify ensures the blockchain runs smoothly, much like ensuring all the park's rides are up and running without long wait times.

## That’s a wrap

zkVerify is a great innovation that introduces a modular proof verification layer of ZK proofs. zkVerify reduces proof verification costs by +90% and offers a more efficient blockchain system.

As we now know the goals of zkVerify in detail, we need to understand the exact problems it solves. Let’s discuss all of this in the next lesson. Stay tuned!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/2.%20Introducing%20and%20Architecting%20zkVerify/4.%20Introducing%20zkVerify.md

Introducing zkVerify

Introducing and Architecting zkVerify

# zkVerify's Proof Verification Architecture

Welcome back! In our previous lessons, we laid the foundation for understanding zkVerify, the groundbreaking modular blockchain that leverages zero-knowledge proofs. Now, it's time to take a closer look at the heart of zkVerify – its proof verification architecture. In this lesson, we'll uncover the step-by-step process of how proofs are submitted and verified. By the end, you'll have a clear understanding of how zkVerify ensures the integrity and security of data while maintaining its commitment to decentralization. So, let's dive into the inner workings of this innovative technology!

zkVerify is made up of 5 core components. Let’s go through each of them one by one.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%205_%20zkVerify's%20Proof%20Verification%20Architecture/image4.webp?raw=true)

## Proof submitters: The driving force behind zkVerify

Proof submitters are the lifeblood of the zkVerify ecosystem. They are the individuals, developers, or organizations who utilize zkVerify to verify their zero-knowledge proofs (ZKPs). But why would someone choose zkVerify for this purpose?

zkVerify supports a wide range of proving systems and proof types, opening the door to innovative applications that might not be feasible on other blockchains. This flexibility empowers developers to explore cutting-edge cryptographic techniques and build novel solutions without being limited by the constraints of a single blockchain ecosystem.

## Proof submission interface: Your gateway to proof verification

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%205_%20zkVerify's%20Proof%20Verification%20Architecture/image2.webp?raw=true)

Imagine you've developed a zkRollup or a zkApp that utilizes zero-knowledge proofs Now, you need to verify the validity of your proofs on the zkVerify network. This is where the Proof Submission Interface comes in.

### Technically speaking

The Proof Submission Interface consists of transactions and RPC (Remote Procedure Call) methods that enable you to submit your proof to the zkVerify network. It provides a standardized format for proof submission, ensuring compatibility and ease of use.

### How it works

1. **Proof generation:** You generate your zero-knowledge proof for your zkRollup or zkApp. This proof encapsulates the validity of your data or computation.
2. **Proof Submission:** You use the Proof Submission Interface to securely transmit your proof to the zkVerify network. This involves creating a transaction that includes your proof data.
3. **Mainchain verification:** The zkVerify Mainchain, a Proof-of-Stake blockchain, receives your proof. The Mainchain utilizes its specialized verifier modules (fflonk, zksync-era, risc0, and Groth16) to assess the validity of your proof.
4. **Verification results:**
    - **Valid proof:** If the proof is valid, it is included in a Mainchain block. This marks the proof as officially verified and accepted by the zkVerify network.
    - **Invalid proof:** If the proof is invalid, the transaction reverts with an error. However, the failing transaction will still be included in the block to prevent denial-of-service (DoS) attacks. This means that even if your proof is rejected, you will still incur fees for the transaction.

## Mainchain: The zkVerify powerhouse

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%205_%20zkVerify's%20Proof%20Verification%20Architecture/image3.webp?raw=true)

The Mainchain, a Layer 1 Nominated Proof-of-Stake (NPoS) blockchain built on the Substrate framework, serves as the core infrastructure for zkVerify. A decentralized network of validators upholds the integrity of the blockchain through a proof-of-stake consensus mechanism. This means that instead of miners, validators stake their tokens to participate in the validation process, ensuring the network's security and accuracy.

Within the zkVerify ecosystem, the Mainchain plays several crucial roles:

1. **The verifier:** The Mainchain houses powerful verification modules, including the Fflonk native verifier for general-purpose ZKPs, the Groth16 verifier for Ethereum-compatible proofs, the RISC Zero verifier for a broader range of zk-applications, and the zkSync Era verifier, specifically tailored for the zkSync Era Layer 2 scaling solution. This multi-verifier approach empowers zkVerify to handle diverse types of ZKPs, catering to a wide array of use cases within the Web3 ecosystem. More verifiers will be added over time to further expand zkVerify's capabilities and support a wider range of zero-knowledge proof systems.
2. **The recorder:** This step focuses on the internal record-keeping of the zkVerify Mainchain. Once a proof is verified by the verifier, it's etched into the blockchain itself to ensure that the proof's validity is permanently recorded.

In summary, the Mainchain is the backbone of zkVerify, providing a secure and efficient platform for proof verification, storage, and value exchange. Its robust architecture and advanced verification capabilities make it a key component in unlocking the potential of ZKPs for real-world applications.

## Attestation: Your proof's seal of approval

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%205_%20zkVerify's%20Proof%20Verification%20Architecture/image5.webp?raw=true)

In zkVerify, attestation is the process of creating a publicly verifiable record of your proof's validity on other blockchains (in addition to zkVerify mainchain). For example, imagine that after your university meticulously verifies your academic transcript, you need to have it attested by a higher educational authority to confirm its authenticity for further studies.

Why is this necessary? Submitting each individual proof to a blockchain like Ethereum would be extremely expensive due to the high gas fees associated with each transaction. It would be like sending every single page of your transcript separately, incurring exorbitant postage costs.

### The Solution: Merkle Trees and Roots

zkVerify cleverly solves this problem using Merkle Trees, a type of data structure that acts as a digital fingerprint for a set of data. Instead of submitting every single proof, zkVerify organizes them into a Merkle Tree.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%205_%20zkVerify's%20Proof%20Verification%20Architecture/image1.webp?raw=true)

This tree has branches that combine the hashes (unique identifiers) of multiple proofs. At the very top of the tree is the Merkle Root – a single hash that represents all the proofs in the tree.

### Efficient attestation

Instead of submitting each proof, zkVerify publishes only the Merkle Root onto a smart contract on chains like Gobi, Jenkins, and Sepolia. This is like sending a single letter (the Merkle Root) that contains a summary of your entire academic record.

To prove that a proof is a part of the attestation, the user can supply a Merkle proof leading from its path from the Merkle’s root to the zkVerify Smart Contract deployed on the chains where these attestations are stored

In summary, attestation is a crucial step in the zkVerify process. It ensures the integrity and validity of proofs by creating a publicly verifiable record on the blockchain. By utilizing Merkle Trees and Roots, zkVerify achieves this attestation efficiently and cost-effectively, enabling the scalability and accessibility of zero-knowledge proof verification even outside of the zkVerify ecosystem.

## zkVerify smart contract: The keeper of attestations and proof validation

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%205_%20zkVerify's%20Proof%20Verification%20Architecture/image6.webp?raw=true)

After your proof has been verified by the Mainchain it is attested on the destination blockchain (= stored in the zkVerify smart contract on that chain). Think of it as the official record keeper, responsible for maintaining the integrity and accessibility of your verified proofs.

This smart contract, residing on the blockchain, acts as a secure and transparent repository for attestations. Each attestation represents a batch of verified proofs, bundled together and summarized using a Merkle Root. The smart contract meticulously stores these Merkle Roots, creating a public record of all verified proofs and also provides you with the means to check if your specific proof was included in a particular attestation. This is like checking a library's catalog to see if a specific book is part of its collection, together with the indication to the specific shelf.

The zkVerify Smart Contract plays a pivotal role in building trust and transparency within the zkVerify ecosystem. By providing a publicly accessible and verifiable record of attestations, it ensures that anyone can check the validity of proofs without needing to trust any single entity. This is a crucial step towards enabling the widespread adoption of zero-knowledge proofs in various applications, as it guarantees the integrity and security of the underlying data.

## That's a wrap

Congratulations on completing this lesson!! Here, we explored zkVerify's proof verification architecture from start to finish. We covered the mainchain, proof submission interface, attestation mechanism, zkVerify smart contract and explored how each component plays a vital role in the proof verification process. In the next lesson, we will set up our wallet and get some test tokens to be able to submit proofs and we cannot wait to see you there!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/2.%20Introducing%20and%20Architecting%20zkVerify/5.%20zkVerify's%20Proof%20Verification%20Architecture.md

zkVerify's Proof Verification Architecture

# Setting Up a Wallet and Connecting to Testnet

Congratulations on coming this far in the course!

In this lesson, we will be going through the process of setting up a wallet and getting some zkVerify ACME testnet tokens. We hope you are super excited about that! So without any delay, let’s get right into it.

## Setting up a wallet

There are currently two recommended wallet options -  Talisman and SubWallet. We will be going ahead and setting up a wallet with Talisman. Talisman provides a secure and user-friendly platform for managing assets, interacting with dApps, and exploring both the Polkadot and Ethereum ecosystems. It also comes with support for a variety of networks, NFT management, and hardware wallets, Talisman presents itself as a holistic wallet solution.

Follow the instructions below to set up your Talisman wallet:

- Click on [https://www.talisman.xyz/](https://www.talisman.xyz/) and click on the “Download Wallet” button.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image4.webp?raw=true)
    
- Next, click on the “Add to Chrome button” to add the wallet extension to your Chrome. Please make sure you are using Chrome for this tutorial.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image10.webp?raw=true_)
    
- Now after adding the wallet, it will prompt you to the new window. Click on the “Get Started” button to continue.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image5.webp?raw=true)
    
- You will be asked to choose a strong password now. Please set a strong password and click on the “Continue” button. If prompted to agree to privacy policies please click on the “I Agree” button.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image6.webp?raw=true)
    
- Once you’re done, click on the “New Polkadot Account” button to create a new account.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image2.webp?raw=true)
    
- You will be asked to give a name to your account. So, give any name to your account. We gave it zkVerify and click on the “Create” button.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image8.webp?raw=true)
    
- You will be prompted to save your seed phrase. Make sure you save your seed phrase properly as it's very crucial. Verify your seed phrase next and complete the verification.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image1.webp?raw=true_)
    

Once that is done, congratulations!!! You have successfully set up your wallet!!

## Explore the zkVerify testnet blockchain

Now, let’s add Test Network and get some testnet $ACME tokens as well.

1. Click on the three dots in the lower right corner of the Talisman wallet. Then click on the “Settings” button as pointed out in the following image.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image15.webp?raw=true)
    
2. Select “Network & Tokens” from the left sidebar.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image7.webp?raw=true)
    
3. Choose the “Manage networks” option.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image3.webp?raw=true)
    
4. Find and click on “Polkadot” from the two of the options mentioned in the screenshot.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image9.webp?raw=true)
    
5. Click on the “Add Network” button as shown in the screenshot.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image11.webp?raw=true)
    
6. Fill in the information with the following and click on the “Add Network” button:
    - RPC URLs: wss://testnet-rpc.zkverify.io
    - Network Name: zkVerify Testnet

    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image13.webp?raw=true)

Now, once you have added a network when you search for networks, you should see your Network in the option.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image14.webp?raw=true)

## Copy wallet address

Now, you need to find and copy the wallet address to get some testnet tokens. So, follow the following steps:

1. Go back to your Talisman wallet.
2. You must be able to see the account name you added to your account. Click on it.
3. Then click on the copy button.
4. Next, you will be prompted to select the network. Type “zkVerify” in the search bar. There you’ll find the “zkVerify Network”. Click on the copy button to finally copy the wallet address.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image12.webp?raw=true)
    

## Get $ACME zkVerify testnet tokens

To get testnet $ACME token:

- Go to [zkVerify Test Token Faucet](https://www.zkay.io/faucet).
- Connect your wallet and click on "Claim Token", you should be able to receive $ACME.


> Check out our FAQ page for answers to common questions about the zkVerify Network course: https://metaschool.so/articles/faqs-zkverify-network-course/

## That’s a wrap

Great job on completing this lesson. Next, we are going to do something really really fun. We will create proofs and verify them! And we are sure that you don’t want to miss it. So see you in the next section!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/3.%20Hands-On%20with%20zkVerify%20Wallets%2C%20Testnets/6.%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet.md

Setting Up a Wallet and Connecting to Testnet

Hands-On with zkVerify: Wallets, Testnets, and Nodes

# Proof Submission Tutorial

Welcome back! In this lesson, we’re going to dive in and submit proofs for verification to zkVerify, walking through each step from start to finish.

Let’s get started!

## Before we start

If you are using Mac or Linux, feel free to skip this section and directly jump onto the ‘**Clone Repository**’ section. But in case you are using Windows, you need to install Windows subsystem for Linux (or WSL). You can do so by using the simple command:

```
wsl --install
```

Make sure that if you are using Windows, use WSL to work with this project. Now let’s get started!

## Clone GIT repository

First of all, open the terminal/CLI in your system and clone the repository using the following command.

```
git clone https://github.com/0xmetaschool/zkverify-proofverification.git

cd zkverify-proofverification
```
## Do some installations

Now, we need to do some installations. So, run the following commands one by one.

- Install the snarkjs latest version:

    ```
    npm install -g snarkjs@latest
    ```

    If you have already installed it you might see something like this.

    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%207_%20Proof%20Submission%20Tutorial/image3.webp?raw=true)

- **Note:** If you face permission issues with the installation add sudo before the command(only for Mac User)

- Install Rust. If prompted to ask about different installation setups please press “Enter” to just install the default ones.

    ```
    curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
    ```

    Here’s what it looks like for us on macOS:

    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%207_%20Proof%20Submission%20Tutorial/image5.webp?raw=true)


- Now, we need to clone the circom git repository to do the installations. So, run the following command:

    ```
    git clone https://github.com/iden3/circom.git
    ```

    You will find the circom folder in your zkverify-proofverification folder.

    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%207_%20Proof%20Submission%20Tutorial/image6.webp?raw=true)

- Move to circom folder and run the following cargo install command.
    ```
    cd circom

    cargo install --path circom

    cd ..
    ```

    Here’s what it looks like for us on macOS.

    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%207_%20Proof%20Submission%20Tutorial/image2.webp?raw=true)

## Run the .sh file

Now, we need to run the `circuit_setup.sh` file. So, run the following commands.

```
sudo chmod +x circuit_setup.sh

./circuit_setup.sh
```

When asked to write any text, just type any text for example Entropy.

After running the command, you’ll see that many new files namely `proof.json`, `public.json`, and `verification_key.json` are generated as shown below:

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%207_%20Proof%20Submission%20Tutorial/image4.webp?raw=true)

## Convert to zkVerify format

We need to convert JSON files to zkVerify format to submit them for proof verifications. Follow the following steps to do so.

- Run the following commands one by one to set up the `snarkjs2zkv`.

    ```
    git clone https://github.com/HorizenLabs/snarkjs2zkv.git

    cd snarkjs2zkv

    npm install
    ```

- Run the following command and replace the `<path_to_proof.json>` path with the complete path of the `proof.json` file.

    ```
    node snarkjs2zkv convert-proof <path_to_proof.json> -o proof_zkv.json
    ```

- Run the following command and replace the `<path_to_verification_key.json>` path with the complete `verification_key.json` path.

    ```
    node snarkjs2zkv convert-vk <path_to_verification_key.json> -o verification_key_zkv.json
    ```

- Run the following command to convert the `public.json` file. Replace the `<path_to_public.json>` path with the complete path of the public.json file.

    ```
    node snarkjs2zkv convert-public <path_to_public.json> -o public_zkv.json -c bn128
    ```

After completing these steps, you will see three new files generated in `snarkjs2zkv` called `proof_zkv.json`, `public_zkv.json`, and `verification_key_zkv.json` as below:

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%207_%20Proof%20Submission%20Tutorial/image1.webp?raw=true)

> Check out our FAQ page for answers to common questions about the zkVerify Network course: https://metaschool.so/articles/faqs-zkverify-network-course/

## That’s a wrap

Phew! That was a lot but you did great! Next, we need to send the proofs we have to zkVerify for verification. See you in the next lesson!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/3.%20Hands-On%20with%20zkVerify%20Wallets%2C%20Testnets/7.%20Proof%20Submission%20Tutorial.md

Proof Submission Tutorial

# Sending the Proof to zkVerify For Verification

In the last lesson, we generated proof. Now it's time for the most fun part. Yes, we are now going to send the proofs we generated in the last lesson to zkVerify for verification.! Let’s get straight to it!

## Send the proof to zkVerify

1. Firstly, head over to this link - [https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Ftestnet-rpc.zkverify.io#/extrinsics](https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Ftestnet-rpc.zkverify.io#/extrinsics)
2. Once you are there, you will be asked to connect to the wallet. After you are connected, you will see a screen like below. Then, select your account from the option provided.
    
    ![image (7)](https://github.com/user-attachments/assets/bae440d7-4674-4bf9-b2e2-b887093e68a5)
    
3. Next, you need to choose `settlementGroth16Pallet` and `submitProof` which are like so:
    
    ![image (8)](https://github.com/user-attachments/assets/80ba6134-d9f1-42d0-b53a-bd0edf92f2f6)
    
4. Now, in the `vkOrHash` section, choose `Vk` instead of Hash.
    
    ![image (9)](https://github.com/user-attachments/assets/abaac6f6-a5ca-4454-9822-676e24b475d9)
    
5. Next, we will need to return to the JSON files we generated during the previous lesson. First, let’s go to the `verification_key_zkv.json` file and paste the fields from that file. Make sure that you do not include the quotes.
    ![image (10)](https://github.com/user-attachments/assets/d15880a8-6806-455d-a425-1890241c52f2)
    
6. For `gammaAbcG1`, we need to add an item as we have two fields by pressing on ‘Add item’ and then adding both of them like below.
    ![image (11)](https://github.com/user-attachments/assets/d79f5ebf-e6a3-4a92-bd53-a2c0233698dd)
   
7. The next step is to go to the file `proof_zkv.json` and paste copy `a`, `b`, and `c` inputs from the file and paste them in the respective fields like so:
    ![image (13)](https://github.com/user-attachments/assets/c78de514-783f-4a84-9905-0adea1bd122c)
    
8. The last and final step is to go to `public_zkv.json` file and copy and paste in the last field. Now our final stage of submission before submitting the transaction looks like below:
    ![image (14)](https://github.com/user-attachments/assets/b169fadf-d870-48bb-a3ed-322ed9623681)


## Submit the transactions

The final stage is to now submit the transaction.

1. Click on the ‘Submit transaction’ button and you will see a page where you can sign and submit the transaction.    
    ![image (15)](https://github.com/user-attachments/assets/3cfc94b3-094b-4db1-af12-4b4198f56230)
    
2. You now need to ‘Approve’ the transaction with your Talisman wallet. After you approve the transaction, wait for a few seconds as your transaction is getting completed. Once your transaction is completed, you will get a notification from Talisman wallet.
    ![image (16)](https://github.com/user-attachments/assets/31c3bbe6-cbd4-4fa9-b829-3c7cdaafe48f)

3. Convert your address to the new format:
    a. Go to [https://polkadot.js.org/apps/#/utilities](https://polkadot.js.org/apps/#/utilities)
    b. Paste your Talisman wallet address into the conversion tool.
    c. Copy the new converted address format.
![image17](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%208_%20Sending%20the%20proof%20to%20zkVerify%20for%20verification/Image13.webp?raw=true)
1. Now that your transaction is complete and you have your converted address, paste the new address into the explorer - [https://testnet-explorer.zkverify.io/v0](https://testnet-explorer.zkverify.io/v0)
   ![image (17)](https://github.com/user-attachments/assets/1532cb50-bd1a-4fdb-9e54-563812585bab)
    
2. You can now see a screen similar to this.   
   ![image (18)](https://github.com/user-attachments/assets/67e7042e-a5d2-495a-b5be-065a958a43bd)
    
3. Now if you click on your Extrinsic ID, you can see your transaction here:
   ![image (19)](https://github.com/user-attachments/assets/ed30c5a5-1d91-4312-9ac5-800213e7555b)

> Check out our FAQ page for answers to common questions about the zkVerify Network course: https://metaschool.so/articles/faqs-zkverify-network-course/    

## That’s a wrap

Congratulations on successfully submitting your proof!! We hope you found this lesson interesting and exciting. You should be proud of yourself for getting here. Take a break, or go through earlier lessons if you feel like you missed out on something before. See you in the next lesson!!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/3.%20Hands-On%20with%20zkVerify%20Wallets%2C%20Testnets/8.%20Sending%20the%20proof%20to%20zkVerify%20for%20verification.md

Sending the proof to zkVerify for verification

# Let’s Wrap It Up

Alright, let's wrap it up and celebrate your incredible journey! 🎉 It's time to take a moment and reflect on everything you've learned in this course. We covered a lot of the technical components of proof verification and zkVerify - here’s a quick overview of our lessons.

## What we covered

We covered the following in our first zkVerify course:

1. We got an understanding of ZK proofs along with a basic overview of zkSNARKs & zkSTARKs.
2. We got to know the scalability challenge faced by the blockchains and how ZK Rollups solved this problem.
3. We also learnt about the high proof verification costs faced by ZK Rollups.
4. We got an understanding of zkVerify and how it reduces proof verification costs by 90%.
5. We got an understanding of the goals and motivations behind the zkVerify.
6. We went through a deeper dive into how zkVerify proof verification works and its technical architecture.
7. And lastly, we set up the wallet and got some testnet tokens to use on the zkVerify testnet.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%209_%20Let%E2%80%99s%20Wrap%20It%20Up/image1.webp?raw=true)
    

## ⚒️ A small yet important request

Here is a great news for you! This is a 100% open-source project like all the other projects on our platform. You can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects). If you find any issues in the course, please feel free to resolve them. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://discord.com/invite/vbVMUwXWgc) and GitHub, too.

While you’re contributing:

1. Don’t forget to star ⭐️ our [repository](https://github.com/0xmetaschool/Learning-Projects). We will be very thankful! ❤️
2. We are a completely free platform and we aim to stay the same, so please consider following us on [X](https://twitter.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) as well. 🫶
3. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool/) channel for exciting videos. ✨

Don't forget to join the vibrant zkVerify community!

- **Follow:** Stay in the loop on [X (formerly Twitter)](https://x.com/ZKVProtocol).
- **Chat & Connect:** Join the community on [Discord](https://discord.com/invite/zkverify) and [Telegram](https://t.me/zkverify).
- **Star:** Show your support on [GitHub](https://github.com/HorizenLabs/zkVerify) and give the zkVerify repository a star.
- **Learn**: Dive into the detailed [zkVerify documentation](https://docs.zkverify.io/).

## 🎊 Congratulations

You have completed the tutorial and are now equipped with the in-depth knowledge to start building in the exciting world of zkVerify blockchain. We wish you luck!

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20zkVerify%20Blockchain/4.%20Wrap%20Up/9.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Let’s Wrap It Up

Wrap Up

Master zkVerify, the modular blockchain for zk proof verification, unlocking the secrets of zero-knowledge proofs, scaling solutions, and proof submission tutorials.

Introduction to the zkVerify Network

That's cool

ETH go to $50000

Christopher

Smeef

# Setting Up a Wallet and Connecting to Testnet

Congratulations on coming this far in the course!

In this lesson, we will be going through the process of setting up a wallet and getting some zkVerify ACME testnet tokens. We hope you are super excited about that! So without any delay, let’s get right into it.

## Setting up a wallet

There are currently two recommended wallet options -  Talisman and SubWallet. We will be going ahead and setting up a wallet with Talisman. Talisman provides a secure and user-friendly platform for managing assets, interacting with dApps, and exploring both the Polkadot and Ethereum ecosystems. It also comes with support for a variety of networks, NFT management, and hardware wallets, Talisman presents itself as a holistic wallet solution.

Follow the instructions below to set up your Talisman wallet:

- Click on [https://www.talisman.xyz/](https://www.talisman.xyz/) and click on the “Download Wallet” button.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image4.png?raw=true)
    
- Next, click on the “Add to Chrome button” to add the wallet extension to your Chrome. Please make sure you are using Chrome for this tutorial.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image10.png?raw=true_)
    
- Now after adding the wallet, it will prompt you to the new window. Click on the “Get Started” button to continue.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image5.png?raw=true)
    
- You will be asked to choose a strong password now. Please set a strong password and click on the “Continue” button. If prompted to agree to privacy policies please click on the “I Agree” button.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image6.png?raw=true)
    
- Once you’re done, click on the “New Polkadot Account” button to create a new account.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image2.png?raw=true)
    
- You will be asked to give a name to your account. So, give any name to your account. We gave it zkVerify and click on the “Create” button.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image8.png?raw=true)
    
- You will be prompted to save your seed phrase. Make sure you save your seed phrase properly as it's very crucial. Verify your seed phrase next and complete the verification.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image1.png?raw=true_)
    

Once that is done, congratulations!!! You have successfully set up your wallet!!

## Explore the zkVerify testnet blockchain

Now, let’s add Test Network and get some testnet $ACME tokens as well.

1. Click on the three dots in the lower right corner of the Talisman wallet. Then click on the “Settings” button as pointed out in the following image.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image15.png?raw=true)
    
2. Select “Network & Tokens” from the left sidebar.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image7.png?raw=true)
    
3. Choose the “Manage networks” option.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image3.png?raw=true)
    
4. Find and click on “Polkadot” from the two of the options mentioned in the screenshot.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image9.png?raw=true)
    
5. Click on the “Add Network” button as shown in the screenshot.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image11.png?raw=true)
    
6. Fill in the information with the following and click on the “Add Network” button:
    - RPC URLs: wss://testnet-rpc.zkverify.io
    - Network Name: zkVerify Testnet

    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image13.png?raw=true)

Now, once you have added a network when you search for networks, you should see your Network in the option.

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image14.png?raw=true)

## Copy wallet address

Now, you need to find and copy the wallet address to get some testnet tokens. So, follow the following steps:

1. Go back to your Talisman wallet.
2. You must be able to see the account name you added to your account. Click on it.
3. Then click on the copy button.
4. Next, you will be prompted to select the network. Type “zkVerify” in the search bar. There you’ll find the “zkVerify Network”. Click on the copy button to finally copy the wallet address.
    
    ![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-zkverify-horizen/Lesson%206_%20Setting%20Up%20a%20Wallet%20and%20Connecting%20to%20Testnet/image12.png?raw=true)
    

## Get $ACME zkVerify testnet tokens

To get testnet $ACME token:

- Go to [zkVerify Test Token Faucet](https://www.zkay.io/faucet).
- Connect your wallet and click on "Claim Token", you should be able to receive $ACME.


> Check out our FAQ page for answers to common questions about the zkVerify Network course: https://metaschool.so/articles/faqs-zkverify-network-course/

## That’s a wrap

Great job on completing this lesson. Next, we are going to do something really really fun. We will create proofs and verify them! And we are sure that you don’t want to miss it. So see you in the next section!


Setup your wallet to mint your proof of completion NFT

Connect Metamask

Become a part of our vibrant and supportive community!

Join our Discord

Spread the word about what you are building

Follow us on Twitter

Keep us informed of your progress so we can assist you

Submit your first assignment

Reach half course

Complete the course to earn NFT along with XP

Complete Course

Submit your feedback at course completion and help us improve your learning experience

Kicking Off with Web3 and ZK Fundamentals

Introducing and Architecting zkVerify

Hands-On with zkVerify: Wallets, Testnets, and Nodes

Wrap Up

🎉 Congratulations!!
You've Received a Special NFT

How can we help?

🎉 Congratulations!! You've Received a Special NFT

How can we help?

🎉 Congratulations!!
You've Received a Special NFT