fix conflicts

Cargo.lock

@@ -990,7 +990,7 @@ dependencies = [
  "atty",
  "humantime",
  "log",
- "regex 1.5.6",
+ "regex 1.6.0",
  "termcolor",
 ]
 
@@ -1027,7 +1027,7 @@ dependencies = [
  "ethereum-types",
  "hex 0.4.3",
  "once_cell",
- "regex 1.5.6",
+ "regex 1.6.0",
  "serde",
  "serde_json",
  "sha3 0.10.1",
@@ -1702,9 +1702,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.12.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac8b1a9b2518dc799a2271eff1688707eb315f0d4697aa6b0871369ca4c4da55"
+checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
 
 [[package]]
 name = "opaque-debug"
@@ -2124,13 +2124,13 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.5.6"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d83f127d94bdbcda4c8cc2e50f6f84f4b611f69c902699ca385a39c3a75f9ff1"
+checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
 dependencies = [
  "aho-corasick 0.7.18",
  "memchr",
- "regex-syntax 0.6.26",
+ "regex-syntax 0.6.27",
 ]
 
 [[package]]
@@ -2150,9 +2150,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.26"
+version = "0.6.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49b3de9ec5dc0a3417da371aab17d729997c15010e7fd24ff707773a33bddb64"
+checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
 
 [[package]]
 name = "remove_dir_all"
@@ -2166,7 +2166,8 @@ dependencies = [
 [[package]]
 name = "revm"
 version = "1.6.0"
-source = "git+https://github.com/bluealloy/revm#6c2a08bf75640cefad1b82b29e541b3c93cbebf1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b60030444003ac25474f5281e7e91f15e8475c173b729aac1c10aced56b3adac"
 dependencies = [
  "arrayref",
  "auto_impl",
@@ -2182,7 +2183,8 @@ dependencies = [
 [[package]]
 name = "revm_precompiles"
 version = "1.0.0"
-source = "git+https://github.com/bluealloy/revm#6c2a08bf75640cefad1b82b29e541b3c93cbebf1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd6aae8f44783ef6ff39fc22c9c999dfa0e17b79d663b752730c02a025935185"
 dependencies = [
  "bytes",
  "num 0.4.0",
@@ -2280,18 +2282,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "secp256k1"
-version = "0.23.3"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77cb4e47e3ccff9a1e168471c11e026c067f50ea7c11bf5e877cae505fb743a0"
+checksum = "26947345339603ae8395f68e2f3d85a6b0a8ddfe6315818e80b8504415099db0"
 dependencies = [
  "secp256k1-sys",
 ]
 
 [[package]]
 name = "secp256k1-sys"
-version = "0.6.0"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7058dc8eaf3f2810d7828680320acda0b25a288f6d288e19278e249bbf74226b"
+checksum = "152e20a0fd0519390fc43ab404663af8a0b794273d2a91d60ad4a39f13ffe110"
 dependencies = [
  "cc",
 ]
@@ -2693,15 +2695,15 @@ checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
 
 [[package]]
 name = "ucd-trie"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
+checksum = "89570599c4fe5585de2b388aab47e99f7fa4e9238a1399f707a02e356058141c"
 
 [[package]]
 name = "ucd-util"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85f514e095d348c279b1e5cd76795082cf15bd59b93207832abe0b1d8fed236"
+checksum = "65bfcbf611b122f2c10eb1bb6172fbc4c2e25df9970330e4d75ce2b5201c9bfc"
 
 [[package]]
 name = "uint"

zokrates_ast/src/common/utils.rs

@@ -0,0 +1,53 @@
+use crate::flat_absy::*;
+use zokrates_field::Field;
+
+// util to convert a vector of `(coefficient, expression)` to a flat_expression
+// we build a binary tree of additions by splitting the vector recursively
+pub fn flat_expression_from_expression_summands<T: Field, U: Clone + Into<FlatExpression<T>>>(
+    v: &[(T, U)],
+) -> FlatExpression<T> {
+    match v.len() {
+        0 => FlatExpression::Number(T::zero()),
+        1 => {
+            let (val, var) = v[0].clone();
+            FlatExpression::Mult(box FlatExpression::Number(val), box var.into())
+        }
+        n => {
+            let (u, v) = v.split_at(n / 2);
+            FlatExpression::Add(
+                box flat_expression_from_expression_summands(u),
+                box flat_expression_from_expression_summands(v),
+            )
+        }
+    }
+}
+
+pub fn flat_expression_from_bits<T: Field>(v: Vec<FlatExpression<T>>) -> FlatExpression<T> {
+    flat_expression_from_expression_summands(
+        &v.into_iter()
+            .rev()
+            .enumerate()
+            .map(|(index, var)| (T::from(2).pow(index), var))
+            .collect::<Vec<_>>(),
+    )
+}
+
+pub fn flat_expression_from_variable_summands<T: Field>(v: &[(T, usize)]) -> FlatExpression<T> {
+    match v.len() {
+        0 => FlatExpression::Number(T::zero()),
+        1 => {
+            let (val, var) = v[0].clone();
+            FlatExpression::Mult(
+                box FlatExpression::Number(val),
+                box FlatExpression::Identifier(FlatVariable::new(var)),
+            )
+        }
+        n => {
+            let (u, v) = v.split_at(n / 2);
+            FlatExpression::Add(
+                box flat_expression_from_variable_summands(u),
+                box flat_expression_from_variable_summands(v),
+            )
+        }
+    }
+}

zokrates_core/src/proof_system/libsnark/gm17.rs

@@ -0,0 +1,227 @@
+use crate::ir::{ProgIterator, Statement, Witness};
+use crate::proof_system::gm17::{ProofPoints, VerificationKey, GM17};
+use crate::proof_system::libsnark::ffi::{c_free, Buffer, ProofResult, SetupResult};
+use crate::proof_system::libsnark::{
+    prepare_generate_proof, prepare_public_inputs, prepare_setup, serialization::*, Libsnark,
+};
+use crate::proof_system::Scheme;
+use crate::proof_system::{Backend, G1Affine, G2Affine, NonUniversalBackend, Proof, SetupKeypair};
+use std::io::{BufReader, BufWriter, Write};
+use zokrates_field::{Bn128Field, Field};
+
+extern "C" {
+    fn gm17_bn128_setup(
+        a: *const u8,
+        b: *const u8,
+        c: *const u8,
+        a_len: i32,
+        b_len: i32,
+        c_len: i32,
+        constraints: i32,
+        variables: i32,
+        inputs: i32,
+    ) -> SetupResult;
+
+    fn gm17_bn128_generate_proof(
+        pk_buf: *mut Buffer,
+        public_query_inputs: *const u8,
+        public_query_inputs_length: i32,
+        private_inputs: *const u8,
+        private_inputs_length: i32,
+    ) -> ProofResult;
+
+    fn gm17_bn128_verify(
+        vk_buf: *mut Buffer,
+        proof_buf: *mut Buffer,
+        public_inputs: *const u8,
+        public_inputs_length: i32,
+    ) -> bool;
+}
+
+impl Backend<Bn128Field, GM17> for Libsnark {
+    fn generate_proof<I: IntoIterator<Item = Statement<Bn128Field>>>(
+        program: ProgIterator<Bn128Field, I>,
+        witness: Witness<Bn128Field>,
+        proving_key: Vec<u8>,
+    ) -> Proof<Bn128Field, GM17> {
+        let program = program.collect();
+
+        let (public_inputs_arr, public_inputs_length, private_inputs_arr, private_inputs_length) =
+            prepare_generate_proof(program.clone(), witness.clone());
+
+        let mut pk_buffer = Buffer::from_vec(&proving_key);
+
+        let proof = unsafe {
+            let result = gm17_bn128_generate_proof(
+                &mut pk_buffer as *mut _,
+                public_inputs_arr[0].as_ptr(),
+                public_inputs_length as i32,
+                private_inputs_arr[0].as_ptr(),
+                private_inputs_length as i32,
+            );
+
+            let proof = std::slice::from_raw_parts(result.proof.data, result.proof.length as usize)
+                .to_vec();
+
+            // free c allocated buffer
+            c_free(result.proof.data);
+
+            proof
+        };
+
+        let mut reader = BufReader::new(proof.as_slice());
+        let a = read_g1(&mut reader).unwrap();
+        let b = read_g2(&mut reader).unwrap();
+        let c = read_g1(&mut reader).unwrap();
+
+        let points = ProofPoints::<G1Affine, G2Affine> { a, b, c };
+        let public_inputs: Vec<String> = program
+            .public_inputs_values(&witness)
+            .iter()
+            .map(|f| format!("0x{:064x}", f.to_biguint()))
+            .collect();
+
+        Proof::new(points, public_inputs)
+    }
+
+    fn verify(
+        vk: <GM17 as Scheme<Bn128Field>>::VerificationKey,
+        proof: Proof<Bn128Field, GM17>,
+    ) -> bool {
+        let vk_buffer = vec![];
+        let mut vk_writer = BufWriter::new(vk_buffer);
+
+        write_g2(&mut vk_writer, &vk.h);
+        write_g1(&mut vk_writer, &vk.g_alpha);
+        write_g2(&mut vk_writer, &vk.h_beta);
+        write_g1(&mut vk_writer, &vk.g_gamma);
+        write_g2(&mut vk_writer, &vk.h_gamma);
+
+        vk.query.iter().for_each(|q| write_g1(&mut vk_writer, q));
+
+        vk_writer.flush().unwrap();
+
+        let proof_buffer = vec![];
+        let mut proof_writer = BufWriter::new(proof_buffer);
+
+        write_g1(&mut proof_writer, &proof.proof.a);
+        write_g2(&mut proof_writer, &proof.proof.b);
+        write_g1(&mut proof_writer, &proof.proof.c);
+        proof_writer.flush().unwrap();
+
+        let public_inputs: Vec<_> = proof
+            .inputs
+            .iter()
+            .map(|v| Bn128Field::try_from_str(v.as_str().trim_start_matches("0x"), 16).unwrap())
+            .collect();
+
+        let (public_inputs_arr, public_inputs_length) = prepare_public_inputs(public_inputs);
+
+        let mut vk_buffer = Buffer::from_vec(vk_writer.get_ref());
+        let mut proof_buffer = Buffer::from_vec(proof_writer.get_ref());
+
+        unsafe {
+            gm17_bn128_verify(
+                &mut vk_buffer as *mut _,
+                &mut proof_buffer as *mut _,
+                public_inputs_arr[0].as_ptr(),
+                public_inputs_length as i32,
+            )
+        }
+    }
+}
+
+impl NonUniversalBackend<Bn128Field, GM17> for Libsnark {
+    fn setup<I: IntoIterator<Item = Statement<Bn128Field>>>(
+        program: ProgIterator<Bn128Field, I>,
+    ) -> SetupKeypair<Bn128Field, GM17> {
+        let program = program.collect();
+
+        let (a_arr, b_arr, c_arr, a_vec, b_vec, c_vec, num_constraints, num_variables, num_inputs) =
+            prepare_setup(program);
+
+        let (vk, pk) = unsafe {
+            let result: SetupResult = gm17_bn128_setup(
+                a_arr.as_ptr(),
+                b_arr.as_ptr(),
+                c_arr.as_ptr(),
+                a_vec.len() as i32,
+                b_vec.len() as i32,
+                c_vec.len() as i32,
+                num_constraints as i32,
+                num_variables as i32,
+                num_inputs as i32,
+            );
+
+            let vk: Vec<u8> =
+                std::slice::from_raw_parts(result.vk.data, result.vk.length as usize).to_vec();
+            let pk: Vec<u8> =
+                std::slice::from_raw_parts(result.pk.data, result.pk.length as usize).to_vec();
+
+            // free c allocated buffers
+            c_free(result.vk.data);
+            c_free(result.pk.data);
+
+            (vk, pk)
+        };
+
+        let vk_slice = vk.as_slice();
+        let mut reader = BufReader::new(vk_slice);
+
+        let h = read_g2(&mut reader).unwrap();
+        let g_alpha = read_g1(&mut reader).unwrap();
+        let h_beta = read_g2(&mut reader).unwrap();
+        let g_gamma = read_g1(&mut reader).unwrap();
+        let h_gamma = read_g2(&mut reader).unwrap();
+
+        let mut query = vec![];
+        while let Ok(q) = read_g1(&mut reader) {
+            query.push(q);
+        }
+
+        let vk = VerificationKey::<G1Affine, G2Affine> {
+            h,
+            g_alpha,
+            h_beta,
+            g_gamma,
+            h_gamma,
+            query,
+        };
+
+        SetupKeypair::new(vk, pk)
+    }
+}
+
+#[cfg(feature = "libsnark")]
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::flat_absy::{FlatParameter, FlatVariable};
+    use crate::ir::{Interpreter, Prog, Statement};
+    use zokrates_field::Bn128Field;
+
+    #[test]
+    fn verify() {
+        let program: Prog<Bn128Field> = Prog {
+            arguments: vec![FlatParameter::private(FlatVariable::new(0))],
+            return_count: 1,
+            statements: vec![Statement::constraint(
+                FlatVariable::new(0),
+                FlatVariable::public(0),
+            )],
+        };
+
+        let keypair = <Libsnark as NonUniversalBackend<Bn128Field, GM17>>::setup(program.clone());
+        let interpreter = Interpreter::default();
+
+        let witness = interpreter
+            .execute(program.clone(), &vec![Bn128Field::from(42)])
+            .unwrap();
+
+        let proof =
+            <Libsnark as Backend<Bn128Field, GM17>>::generate_proof(program, witness, keypair.pk);
+
+        let ans = <Libsnark as Backend<Bn128Field, GM17>>::verify(keypair.vk, proof);
+        assert!(ans);
+    }
+}

zokrates_core/src/proof_system/libsnark/pghr13.rs

@@ -0,0 +1,257 @@
+use crate::proof_system::libsnark::ffi::{c_free, Buffer, ProofResult, SetupResult};
+use crate::proof_system::libsnark::{
+    prepare_generate_proof, prepare_public_inputs, prepare_setup, Libsnark,
+};
+use crate::proof_system::{Backend, G1Affine, G2Affine, NonUniversalBackend, Proof, SetupKeypair};
+
+use crate::ir::{ProgIterator, Statement, Witness};
+use crate::proof_system::libsnark::serialization::{read_g1, read_g2, write_g1, write_g2};
+use crate::proof_system::pghr13::{ProofPoints, VerificationKey, PGHR13};
+use crate::proof_system::Scheme;
+use std::io::{BufReader, BufWriter, Write};
+use zokrates_field::Bn128Field;
+use zokrates_field::Field;
+
+extern "C" {
+    fn pghr13_bn128_setup(
+        a: *const u8,
+        b: *const u8,
+        c: *const u8,
+        a_len: i32,
+        b_len: i32,
+        c_len: i32,
+        constraints: i32,
+        variables: i32,
+        inputs: i32,
+    ) -> SetupResult;
+
+    fn pghr13_bn128_generate_proof(
+        pk_buf: *mut Buffer,
+        public_query_inputs: *const u8,
+        public_query_inputs_length: i32,
+        private_inputs: *const u8,
+        private_inputs_length: i32,
+    ) -> ProofResult;
+
+    fn pghr13_bn128_verify(
+        vk_buf: *mut Buffer,
+        proof_buf: *mut Buffer,
+        public_inputs: *const u8,
+        public_inputs_length: i32,
+    ) -> bool;
+}
+
+impl Backend<Bn128Field, PGHR13> for Libsnark {
+    fn generate_proof<I: IntoIterator<Item = Statement<Bn128Field>>>(
+        program: ProgIterator<Bn128Field, I>,
+        witness: Witness<Bn128Field>,
+        proving_key: Vec<u8>,
+    ) -> Proof<Bn128Field, PGHR13> {
+        let program = program.collect();
+
+        let (public_inputs_arr, public_inputs_length, private_inputs_arr, private_inputs_length) =
+            prepare_generate_proof(program.clone(), witness.clone());
+
+        let mut pk_buffer = Buffer::from_vec(&proving_key);
+
+        let proof = unsafe {
+            let result = pghr13_bn128_generate_proof(
+                &mut pk_buffer as *mut _,
+                public_inputs_arr[0].as_ptr(),
+                public_inputs_length as i32,
+                private_inputs_arr[0].as_ptr(),
+                private_inputs_length as i32,
+            );
+
+            let proof = std::slice::from_raw_parts(result.proof.data, result.proof.length as usize)
+                .to_vec();
+
+            // free c allocated buffer
+            c_free(result.proof.data);
+
+            proof
+        };
+
+        let mut reader = BufReader::new(proof.as_slice());
+        let a = read_g1(&mut reader).unwrap();
+        let a_p = read_g1(&mut reader).unwrap();
+        let b = read_g2(&mut reader).unwrap();
+        let b_p = read_g1(&mut reader).unwrap();
+        let c = read_g1(&mut reader).unwrap();
+        let c_p = read_g1(&mut reader).unwrap();
+        let h = read_g1(&mut reader).unwrap();
+        let k = read_g1(&mut reader).unwrap();
+
+        let points = ProofPoints::<G1Affine, G2Affine> {
+            a,
+            a_p,
+            b,
+            b_p,
+            c,
+            c_p,
+            h,
+            k,
+        };
+
+        let public_inputs: Vec<String> = program
+            .public_inputs_values(&witness)
+            .iter()
+            .map(|f| format!("0x{:064x}", f.to_biguint()))
+            .collect();
+
+        Proof::new(points, public_inputs)
+    }
+
+    fn verify(
+        vk: <PGHR13 as Scheme<Bn128Field>>::VerificationKey,
+        proof: Proof<Bn128Field, PGHR13>,
+    ) -> bool {
+        let vk_buffer = vec![];
+        let mut vk_writer = BufWriter::new(vk_buffer);
+
+        write_g2(&mut vk_writer, &vk.a);
+        write_g1(&mut vk_writer, &vk.b);
+        write_g2(&mut vk_writer, &vk.c);
+        write_g2(&mut vk_writer, &vk.gamma);
+        write_g1(&mut vk_writer, &vk.gamma_beta_1);
+        write_g2(&mut vk_writer, &vk.gamma_beta_2);
+        write_g2(&mut vk_writer, &vk.z);
+
+        vk.ic
+            .iter()
+            .for_each(|ic_query| write_g1(&mut vk_writer, ic_query));
+        vk_writer.flush().unwrap();
+
+        let proof_buffer = vec![];
+        let mut proof_writer = BufWriter::new(proof_buffer);
+
+        write_g1(&mut proof_writer, &proof.proof.a);
+        write_g1(&mut proof_writer, &proof.proof.a_p);
+        write_g2(&mut proof_writer, &proof.proof.b);
+        write_g1(&mut proof_writer, &proof.proof.b_p);
+        write_g1(&mut proof_writer, &proof.proof.c);
+        write_g1(&mut proof_writer, &proof.proof.c_p);
+        write_g1(&mut proof_writer, &proof.proof.h);
+        write_g1(&mut proof_writer, &proof.proof.k);
+        proof_writer.flush().unwrap();
+
+        let public_inputs: Vec<_> = proof
+            .inputs
+            .iter()
+            .map(|v| Bn128Field::try_from_str(v.as_str().trim_start_matches("0x"), 16).unwrap())
+            .collect();
+
+        let (public_inputs_arr, public_inputs_length) = prepare_public_inputs(public_inputs);
+
+        let mut vk_buffer = Buffer::from_vec(vk_writer.get_ref());
+        let mut proof_buffer = Buffer::from_vec(proof_writer.get_ref());
+
+        unsafe {
+            pghr13_bn128_verify(
+                &mut vk_buffer as *mut _,
+                &mut proof_buffer as *mut _,
+                public_inputs_arr[0].as_ptr(),
+                public_inputs_length as i32,
+            )
+        }
+    }
+}
+
+impl NonUniversalBackend<Bn128Field, PGHR13> for Libsnark {
+    fn setup<I: IntoIterator<Item = Statement<Bn128Field>>>(
+        program: ProgIterator<Bn128Field, I>,
+    ) -> SetupKeypair<Bn128Field, PGHR13> {
+        let program = program.collect();
+
+        let (a_arr, b_arr, c_arr, a_vec, b_vec, c_vec, num_constraints, num_variables, num_inputs) =
+            prepare_setup(program);
+
+        let (vk, pk) = unsafe {
+            let result: SetupResult = pghr13_bn128_setup(
+                a_arr.as_ptr(),
+                b_arr.as_ptr(),
+                c_arr.as_ptr(),
+                a_vec.len() as i32,
+                b_vec.len() as i32,
+                c_vec.len() as i32,
+                num_constraints as i32,
+                num_variables as i32,
+                num_inputs as i32,
+            );
+
+            let vk: Vec<u8> =
+                std::slice::from_raw_parts(result.vk.data, result.vk.length as usize).to_vec();
+            let pk: Vec<u8> =
+                std::slice::from_raw_parts(result.pk.data, result.pk.length as usize).to_vec();
+
+            // free c allocated buffers
+            c_free(result.vk.data);
+            c_free(result.pk.data);
+
+            (vk, pk)
+        };
+
+        let vk_slice = vk.as_slice();
+        let mut reader = BufReader::new(vk_slice);
+
+        let a = read_g2(&mut reader).unwrap();
+        let b = read_g1(&mut reader).unwrap();
+        let c = read_g2(&mut reader).unwrap();
+        let gamma = read_g2(&mut reader).unwrap();
+        let gamma_beta_1 = read_g1(&mut reader).unwrap();
+        let gamma_beta_2 = read_g2(&mut reader).unwrap();
+        let z = read_g2(&mut reader).unwrap();
+
+        let mut ic = vec![];
+        while let Ok(q) = read_g1(&mut reader) {
+            ic.push(q);
+        }
+
+        let vk = VerificationKey::<G1Affine, G2Affine> {
+            a,
+            b,
+            c,
+            gamma,
+            gamma_beta_1,
+            gamma_beta_2,
+            z,
+            ic,
+        };
+
+        SetupKeypair::new(vk, pk)
+    }
+}
+
+#[cfg(feature = "libsnark")]
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::flat_absy::{FlatParameter, FlatVariable};
+    use crate::ir::{Interpreter, Prog, Statement};
+    use zokrates_field::Bn128Field;
+
+    #[test]
+    fn verify() {
+        let program: Prog<Bn128Field> = Prog {
+            arguments: vec![FlatParameter::private(FlatVariable::new(0))],
+            return_count: 1,
+            statements: vec![Statement::constraint(
+                FlatVariable::new(0),
+                FlatVariable::public(0),
+            )],
+        };
+
+        let keypair = <Libsnark as NonUniversalBackend<Bn128Field, PGHR13>>::setup(program.clone());
+        let interpreter = Interpreter::default();
+
+        let witness = interpreter
+            .execute(program.clone(), &vec![Bn128Field::from(42)])
+            .unwrap();
+
+        let proof =
+            <Libsnark as Backend<Bn128Field, PGHR13>>::generate_proof(program, witness, keypair.pk);
+
+        let ans = <Libsnark as Backend<Bn128Field, PGHR13>>::verify(keypair.vk, proof);
+        assert!(ans);
+    }
+}

zokrates_solidity_test/Cargo.toml

@@ -14,5 +14,5 @@ bytes = { version = "1.1", default-features = false }
 serde_json = { version = "1.0" }
 rand = { version = "0.8" }
 
-revm = { git = "https://github.com/bluealloy/revm", version = "1.2" }
+revm = { version = "1.6.0" }
 solc = { git = "https://github.com/g-r-a-n-t/solc-rust", rev = "52d4146" }