NOVA Scotia folding scheme test done #227

mopro-ffi/Cargo.toml

@@ -36,6 +36,8 @@ circom = [
     "byteorder",
 ]
 
+nova_scotia = []
+
 [dependencies]
 uniffi = { version = "=0.28.0", features = ["cli", "build"] }
 
@@ -71,6 +73,12 @@ ark-bls12-381 = { version = "0.4.0", optional = true }
 num-traits = { version = "0.2.0", optional = true }
 anyhow = "1.0.86"
 
+# Nova Scotia dependencies
+nova-scotia = "0.5.0"
+nova-snark = "0.23.0"
+serde_json = "1.0.85"
+pasta_curves = "0.5"
+
 [build-dependencies]
 rust-witness = "0.1.0"
 uniffi = { version = "=0.28.0", features = ["build"] }
@@ -85,4 +93,4 @@ serde = { version = "1.0", features = ["derive"] }
 serde_derive = "1.0"
 
 # Halo2 dependencies
-halo2-fibonacci = { git = "https://github.com/ElusAegis/halo2-fibonacci-sample.git" }
+halo2-fibonacci = { git = "https://github.com/ElusAegis/halo2-fibonacci-sample.git" }

mopro-ffi/src/lib.rs

@@ -4,6 +4,8 @@ pub mod app_config;
 mod circom;
 #[cfg(feature = "halo2")]
 mod halo2;
+#[cfg(feature = "nova_scotia")]
+mod nova_scotia;
 
 #[cfg(feature = "circom")]
 pub use circom::{
@@ -14,6 +16,9 @@ pub use circom::{
 #[cfg(feature = "halo2")]
 pub use halo2::{Halo2ProveFn, Halo2VerifyFn};
 
+#[cfg(feature = "nova_scotia")]
+//pub use nova_scotia::{};
+
 #[cfg(not(feature = "circom"))]
 #[macro_export]
 macro_rules! circom_app {
@@ -67,6 +72,30 @@ macro_rules! halo2_app {
     };
 }
 
+#[cfg(not(feature = "nova_scotia"))]
+#[macro_export]
+macro_rules! nova_scotia_app {
+    () => {
+        fn generate_nova_scotia_proof(
+            r1cs_path: String,
+            cpp_bin_or_wasm_path: String,
+            private_inputs: Vec<HashMap<String, Value>>,
+            start_public_input: Vec<F<G1>>,
+        ) -> Result<GenerateProofResult, MoproError> {
+            panic!("Nova Scotia is not enabled in this build. Please pass `nova-scotia` feature to `mopro-ffi` to enable Nova Scotia.")
+        }
+
+        fn verify_nova_scotia_proof(
+            recursive_snark: RecursiveSNARK<G1, G2, C1<G1>, C2<G2>>,
+            pp: &PublicParams<G1, G2, C1<G1>, C2<G2>>,
+            iteration_count: usize,
+            start_public_input: &[E1::Scalar],
+        ) -> Result<bool, MoproError> {
+            panic!("Nova Scotia is not enabled in this build. Please pass `nova-scotia` feature to `mopro-ffi` to enable Nova Scotia.")
+        }
+    };
+}
+
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -75,6 +104,8 @@ pub enum MoproError {
     CircomError(String),
     #[error("Halo2Error: {0}")]
     Halo2Error(String),
+    #[error("NovaScotiaError: {0}")]
+    NovaScotiaError(String),
 }
 
 #[derive(Debug, Clone)]
@@ -148,6 +179,8 @@ macro_rules! app {
 
         mopro_ffi::halo2_app!();
 
+        mopro_ffi::nova_scotia_app!();
+
         uniffi::include_scaffolding!("mopro");
     };
 }

mopro-ffi/src/nova_scotia/mod.rs

@@ -0,0 +1,195 @@
+#[macro_export]
+macro_rules! nova_scotia_app {
+    () => {
+
+        fn generate_recursive_snark_proof(
+            witness_generator_file: PathBuf,
+            r1cs: circom::circuit::R1CS<F<G1>>,
+            private_inputs: Vec<HashMap<String, serde_json::Value>>,
+            start_public_input: [F<G1>; 2],
+            pp: &PublicParams<G1, G2, C1<G1>, C2<G2>>,
+        ) -> Result<RecursiveSNARK<G1, G2, C1<G1>, C2<G2>>, mopro_ffi::MoproError> {
+
+            let res = create_recursive_circuit(
+                FileLocation::PathBuf(witness_generator_file),
+                r1cs,
+                private_inputs,
+                start_public_input.to_vec(),
+                &pp,
+            );
+
+            res.map_err(|e| mopro_ffi::MoproError::NovaScotiaError(format!("nova_scotia error: {}", e)))
+        }
+
+
+        fn verify_recursive_snark_proof(
+            recursive_snark: &RecursiveSNARK<G1, G2, C1<G1>, C2<G2>>,
+            pp: &PublicParams<G1, G2, C1<G1>, C2<G2>>,
+            iteration_count: usize,
+            start_public_input: [F<G1>; 2],
+            z0_secondary: [F<G2>; 1],
+        ) -> Result<(Vec<F<G1>>, Vec<F<G2>>), mopro_ffi::MoproError> {
+
+            let res = recursive_snark.verify(
+                &pp,
+                iteration_count,
+                &start_public_input.clone(),
+                &z0_secondary,
+            );
+
+            res.map_err(|e| {
+                mopro_ffi::MoproError::NovaScotiaError(format!("error verifying proof: {}", e))
+            })
+        }
+
+
+        fn compress_snark_proof(
+            recursive_snark: RecursiveSNARK<G1, G2, C1<G1>, C2<G2>>,
+            pp: &PublicParams<G1, G2, C1<G1>, C2<G2>>,
+            pk: &ProverKey<G1, G2, C1<G1>, C2<G2>, S<G1>, S<G2>>,
+        ) -> Result<CompressedSNARK<G1, G2, C1<G1>, C2<G2>, S<G1>, S<G2>>, mopro_ffi::MoproError> {
+
+            let res = CompressedSNARK::<_, _, _, _, S<G1>, S<G2>>::prove(&pp, &pk, &recursive_snark);
+
+            res.map_err(|e| {
+                mopro_ffi::MoproError::NovaScotiaError(format!("error compress proof: {}", e))
+            })
+        }
+
+
+        fn verify_compressed_snark_proof(
+            compressed_snark: CompressedSNARK<G1, G2, C1<G1>, C2<G2>,S<G1>, S<G2>>,
+            vk: &VerifierKey<G1, G2, C1<G1>, C2<G2>, S<G1>, S<G2>>,
+            iteration_count: usize,
+            start_public_input: [F<G1>; 2],
+            z0_secondary: [F<G2>; 1],
+        ) -> Result<(Vec<F<G1>>, Vec<F<G2>>), mopro_ffi::MoproError> {
+
+            let res = compressed_snark.verify(
+                &vk,
+                iteration_count,
+                start_public_input.clone().to_vec(),
+                z0_secondary.to_vec(),
+            );
+
+            res.map_err(|e| {
+                mopro_ffi::MoproError::NovaScotiaError(format!("error verifying proof: {}", e))
+            })
+        }
+
+
+    };
+}
+
+#[cfg(test)]
+mod test {
+    use std::{collections::HashMap, panic};
+
+    use nova_scotia::*;
+
+    use nova_snark::{
+        provider,
+        CompressedSNARK, PublicParams, RecursiveSNARK, ProverKey, VerifierKey,
+    };
+
+    use crate as mopro_ffi;
+    use serde_json::json;
+    use std::path::PathBuf;
+
+    nova_scotia_app!();
+
+    const R1CS_PATH: &str = "../test-vectors/nova_scotia/toy.r1cs";
+    const WASM_PATH: &str = "../test-vectors/nova_scotia/toy_js/toy.wasm";
+
+    // Define curve cycle, can be any curve cycle supported by Nova
+    type G1 = provider::bn256_grumpkin::bn256::Point;
+    type G2 = provider::bn256_grumpkin::grumpkin::Point;
+
+    #[test]
+    fn test_generate_and_verify_nova_scotia_proof() {
+        let root = std::env::current_dir().unwrap();
+
+        // Load r1cs file
+        let circuit_file = root.join(R1CS_PATH.to_string());
+        let r1cs = circom::reader::load_r1cs::<G1, G2>(&FileLocation::PathBuf(circuit_file));
+
+        // Load c++ binary or wasm file
+        let witness_generator_file = root.join(WASM_PATH.to_string());
+
+        // Generate private inputs
+        /*
+        each folding steps (step_in[0], step_in[1]):
+        step_out[0] <== step_in[0] + adder;
+        step_out[1] <== step_in[0] + step_in[1];
+
+        adder is the private input (auxiliary input) that we have.
+
+        step_in[0], step_in[1], adder
+            10,        10,        0
+            10,        20,        1
+            11,        30,        2
+            13,        41,        3
+            16,        54,        4
+            20,        70,        5 <-- state of things when we output results
+
+        */
+        let iteration_count = 5;
+        let mut private_inputs = Vec::new();
+        for i in 0..iteration_count {
+            let mut private_input = HashMap::new();
+            private_input.insert("adder".to_string(), json!(i));
+            private_inputs.push(private_input);
+        }
+
+        // Set starting public input
+        let start_public_input = [F::<G1>::from(10), F::<G1>::from(10)];
+
+        // Create public parameters(CRS)
+        let pp = create_public_params::<G1, G2>(r1cs.clone());
+
+        let z0_secondary = [F::<G2>::from(0)];
+
+        if let Ok(proof_result) = generate_recursive_snark_proof(
+            witness_generator_file,
+            r1cs,
+            private_inputs,
+            start_public_input,
+            &pp,
+        ) {
+
+            let result = verify_recursive_snark_proof(
+                &proof_result,
+                &pp,
+                iteration_count,
+                start_public_input,
+                z0_secondary,
+            );
+
+            assert!(result.is_ok());
+            let (pk, vk) = CompressedSNARK::<_, _, _, _, S<G1>, S<G2>>::setup(&pp).unwrap();
+
+            if let Ok(compressed_proof_result) = compress_snark_proof(
+                proof_result,
+                &pp,
+                &pk,
+            ) {
+
+                let result = verify_compressed_snark_proof(
+                    compressed_proof_result,
+                    &vk,
+                    iteration_count,
+                    start_public_input,
+                    z0_secondary,
+                );
+
+                assert!(result.is_ok());
+
+            } else {
+                panic!("Failed to generate the compressed proof!")
+            }
+
+        } else {
+            panic!("Failed to generate the recursive proof!")
+        }
+    }
+}

test-vectors/nova_scotia/toy.circom

@@ -0,0 +1,22 @@
+pragma circom 2.0.3;
+
+// include "https://github.com/0xPARC/circom-secp256k1/blob/master/circuits/bigint.circom";
+
+template Example () {
+    signal input step_in[2];
+
+    signal output step_out[2];
+
+    signal input adder;
+
+    step_out[0] <== step_in[0] + adder;
+    step_out[1] <== step_in[0] + step_in[1];
+}
+
+component main { public [step_in] } = Example();
+
+/* INPUT = {
+    "step_in": [1, 1],
+    "step_out": [1, 2],
+    "adder": 0
+} */

test-vectors/nova_scotia/toy_js/generate_witness.js

@@ -0,0 +1,20 @@
+const wc  = require("./witness_calculator.js");
+const { readFileSync, writeFile } = require("fs");
+
+if (process.argv.length != 5) {
+    console.log("Usage: node generate_witness.js <file.wasm> <input.json> <output.wtns>");
+} else {
+    const input = JSON.parse(readFileSync(process.argv[3], "utf8"));
+
+    const buffer = readFileSync(process.argv[2]);
+    wc(buffer).then(async witnessCalculator => {
+	//    const w= await witnessCalculator.calculateWitness(input,0);
+	//    for (let i=0; i< w.length; i++){
+	//	console.log(w[i]);
+	//    }
+	const buff= await witnessCalculator.calculateWTNSBin(input,0);
+	writeFile(process.argv[4], buff, function(err) {
+	    if (err) throw err;
+	});
+    });
+}