: Introduction Zero-knowledge proofs enable private, secure transactions. With zkSNARKs and zkSTARKs, a prover can prove possession of some information to a verifier without revealing the actual data. This has huge potential for anonymity and confidentiality. But zkSTARKs and zkSNARKs are complex. Risc0 makes them more accessible. Let’s see it’s very basic implementation: This tutorial will cover: Installation of Risc0 Writing your first zero-knowledge proof program using rust Prerequisites: Copy pasting shortcuts Installations required: Rust language Cargo crate Some basic coding knowledge in rust Code Editor (VSCODE if possible) By the end, you'll have practical experience with zero-knowledge proofs in Risc0. No advanced math or cryptography background required. We'll focus on the coding essentials to start building real-world solutions. This hands-on introduction aims to make powerful privacy tech understandable for any developer. : Installation (For MacOS) To install you can run the below command in the terminal: rust and cargo, curl [https://sh.rustup.rs](https://sh.rustup.rs/) -sSf | sh To install Risc0, you run the below command after installation of rust and restart the terminal: cargo install cargo-risczero For the above commands to build successfully, you will need to have installed the required dependencies. brew install openssl brew install pkgconf Next, we'll need to install the toolchain with: risc0 cargo risczero install That’s all we need. So, let’s head to the code editor. Writing Some Magical Lines: Now that we are done with the installation you can read and follow along these abra kadabra 🪄 steps: Open the code editor and head to the location where you want to create your project in the editor’s terminal. Create a new instance of the project using the below command in the terminal: . cargo risczero new multiply You should be seeing a folder created called multiply. cd into it. cd multiply The folder structure is very simple. We have a host folder and a methods folder. The host folder contains the host program which we call the guest program. It also has the ability to verify if you want. The methods folder contains the guest program which contains the portion of the zkvm application that gets proven. It receives the input params from the host, then based on the logic, it generates results, commits them to the journal, and sends them to the host as a receipt. The rest of the files will be explained on the go as required. Let's start with the guest program. Let’s change the name of the files . main.rs —> multiply.rs Create a folder named in folder and move to it. Your folder structure should look something like this: bin src mutiply.rs Open and change the update to the . Cargo.toml name = "method_name” —> name = "multiply” Add the below code in . Cargo.toml [[bin]]
name = "multiply"
path = "src/bin/multiply.rs" So your final will look like this: Cargo.toml Now, open . Here we will edit the main function. This is the function that will be executed in zkvm. multiply.rs In the below code, we are taking the input from the host program. Then we are making sure that the input is not trivial factors that is 1. Then we calculate the product and finally commit it back to the host of the program. // We will get the values for these variables from host program
    let a:u64 = env::read();
    let b:u64 = env::read();

    // To avoid trivial factors like multiplication by 1
    if a == 1 || b == 1 {
        panic!("Trivial factors !!")  // The panic! macro in Rust is used to intentionally crash a program when an unrecoverable error occurs
    }

    // Caculate the product of the two numbers
    let product = a.checked_mul(b).expect("Integer Overflow");

    // Commit back the output to the host to save it as receipt
    env::commit(&product); After the above changes, your should look like this. multiply.rs There is one more final change in the of folder. Cargo.toml methods Open and update the value of . name = "multiply-methods” Your final will look like below. Cargo.toml Our work here is done. Now, let’s go to the host program. Your host folder must be looking like this now. We want to split the into two files that are and . main.rs prover.rs verify.rs Create a new folder under and name it as . src bin Remove . Create files and name them as & . main.rs verify.rs prove.rs Your folder structure should look something like this now. Open , and let’s start coding: prove.rs Add the below code. These are the imports that we will require. use multiply_methods::MULTIPLY_ELF; // It is a binary file of multiply_method
use risc0_zkvm::{
    default_prover,
    serde::{from_slice, to_vec},
    ExecutorEnv,
  }; Let’s make changes to the main function. fn main() {

		// Declaring our secret input params
    let a: u64 = 17;
    let b: u64 = 23;

    // First, we construct an executor environment
    let env = ExecutorEnv::builder()
        .add_input(&to_vec(&a).unwrap())  // Passing the input params to environment so it can be used by gues proggram
        .add_input(&to_vec(&b).unwrap())
        .build()
        .unwrap();

    // Obtain the default prover.
    let prover = default_prover();

    // Produce a receipt by proving the specified ELF binary.
    let receipt = prover.prove_elf(env, MULTIPLY_ELF).unwrap();

    // Extract journal of receipt (i.e. output c, where c = a * b)
    let c: u64 = from_slice(&receipt.journal).unwrap();

    // Print an assertion
    println!("Hello, world! I know the factors of {}, and I can prove it!", c);

		// Let's serialize the receipt so we can save it to an file for verifier program to verify.
    let serialized = bincode::serialize(&receipt).unwrap();

		// Writing the serialized contect to receipt.bin file
    let _saved_file = match std::fs::write("./receipt.bin", serialized){
         Ok(()) => println!("Receipt saved and serialized as receipt.bin"),
         Err(_) => println!("Something went wrong !!"),
    };

} Your final should look like this. prove.rs Let’s open and add code to our . verify.rs Here, we will import the guest program image ID and some basic imports. use multiply_methods::MULTIPLY_ID;
use risc0_zkvm::Receipt; Let’s make changes to the main function. fn main(){
    // Let's impor the receipt that was generated by prove
    let receipt_path ="./receipt.bin".to_string();
    let receipt_file = std::fs::read(receipt_path).unwrap();
   
    // As we has serialized the receipt we need to desrialize it
    let receipt = bincode::deserialize::<Receipt>(&receipt_file).unwrap();
    
	// Let's verify if the receipt that was generated was not created tampered with
    let _verification = match receipt.verify(MULTIPLY_ID){
        Ok(()) => println!("Proof is Valid"),
        Err(_) => println!("Something went wrong !!"),
    };
} Your final should look something like this. verify.rs I promise these are the final changes. Now, we are almost done. Open the in folder, and make the below changes under dependencies. Cargo.toml host multiply-methods = { path = "../methods" } Your Cargo.toml will look like this. It’s finally time to see if our code works. Fire up your console in the root directory of the project, and run the below command in console cargo run --release --bin prove This command will generate the proof and receipt for the verifier. When running first time it will take a lot of time. So don’t worry grab a coffee until it completes. Once this is done, if you want, you can verify the receipt that you have generated. For that, run this command cargo run --release --bin verify When running first time it will take a lot of time. So don’t worry grab a coffee until it completes. Congratulations !!! on writing your first ZK app using Risc0. If you need any help, please drop me a comment, and I will get back to you.

Too Long; Didn't Read

Make resilience your competitive advantage

Creating Your First ZK Project Using Risc0: A Guide for Beginners

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

$PEPE, a Purple Lamborghini, and More: The Story Continues

102 Most Important Webism Quotes by Unknown Authors

100 Days of AI Day 3: Leveraging AI for Prompt Engineering and Inference

100 Days of AI, Day 8: Experimenting With Microsoft's Semantic Kernel Using GPT-4

10 Tips to Take Your ChatGPT Prompts to the Next Level

$PEPE, a Purple Lamborghini, and More: The Story Continues

102 Most Important Webism Quotes by Unknown Authors

100 Days of AI Day 3: Leveraging AI for Prompt Engineering and Inference

100 Days of AI, Day 8: Experimenting With Microsoft's Semantic Kernel Using GPT-4

10 Tips to Take Your ChatGPT Prompts to the Next Level

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps