update serialized_proof_test_case

halo2_gadgets/src/ecc.rs

@@ -598,8 +598,8 @@ pub(crate) mod tests {
         },
         FixedPoints,
     };
-    use crate::utilities::lookup_range_check::tests::test_proof_size;
     use crate::utilities::lookup_range_check::{LookupRangeCheck, LookupRangeCheckConfig};
+    use crate::utilities::test_circuit::{Proof, read_test_case, test_proof_size, write_test_case};
 
     #[derive(Debug, Eq, PartialEq, Clone)]
     pub(crate) struct TestFixedBases;
@@ -931,6 +931,41 @@ pub(crate) mod tests {
         }
         test_proof_size(k, circuit, params, vk)
     }
+
+    #[test]
+    fn serialized_proof_test_case() {
+        use std::fs;
+
+        let circuit = MyCircuit { test_errors: false };
+        // Setup phase: generate parameters, vk for the circuit.
+        let params:Params<Affine> = Params::new(11);
+        let vk = plonk::keygen_vk(&params, &circuit).unwrap();
+
+        if std::env::var_os("CIRCUIT_TEST_GENERATE_NEW_PROOF").is_some() {
+            let create_proof = || -> std::io::Result<()> {
+                let proof = Proof::create(
+                    &vk,
+                    &params,
+                    circuit,
+                ).unwrap();
+                assert!(proof.verify(&vk, &params).is_ok());
+
+                let file = std::fs::File::create("src/circuit_proof_test_case_ecc.bin")?;
+                write_test_case(file, &proof)
+            };
+            create_proof().expect("should be able to write new proof");
+        }
+
+        // Parse the hardcoded proof test case.
+        let proof= {
+            let test_case_bytes = fs::read("src/circuit_proof_test_case_ecc.bin").unwrap();
+            read_test_case(&test_case_bytes[..]).expect("proof must be valid")
+        };
+
+        // todo: check size
+        assert_eq!(proof.as_ref().len(), 3872);
+        assert!(proof.verify(&vk, &params).is_ok());
+    }
     #[cfg(feature = "test-dev-graph")]
     #[test]
     fn print_ecc_chip() {

halo2_gadgets/src/sinsemilla.rs

@@ -489,10 +489,10 @@ pub(crate) mod tests {
     use lazy_static::lazy_static;
     use pasta_curves::pallas;
 
-    use crate::utilities::lookup_range_check::tests::test_proof_size;
     use halo2_proofs::poly::commitment::Params;
     use pasta_curves::vesta::Affine;
     use std::convert::TryInto;
+    use crate::utilities::test_circuit::{Proof, read_test_case, test_proof_size, write_test_case};
 
     pub(crate) const PERSONALIZATION: &str = "MerkleCRH";
 
@@ -786,6 +786,40 @@ pub(crate) mod tests {
         test_proof_size(11, circuit, params, vk)
     }
 
+    #[test]
+    fn serialized_proof_test_case() {
+        use std::fs;
+
+        let circuit = MyCircuit {};
+        // Setup phase: generate parameters, vk for the circuit.
+        let params:Params<Affine> = Params::new(11);
+        let vk = plonk::keygen_vk(&params, &circuit).unwrap();
+
+        if std::env::var_os("CIRCUIT_TEST_GENERATE_NEW_PROOF").is_some() {
+            let create_proof = || -> std::io::Result<()> {
+                let proof = Proof::create(
+                    &vk,
+                    &params,
+                    circuit,
+                ).unwrap();
+                assert!(proof.verify(&vk, &params).is_ok());
+
+                let file = std::fs::File::create("src/circuit_proof_test_case_sinsemilla.bin")?;
+                write_test_case(file, &proof)
+            };
+            create_proof().expect("should be able to write new proof");
+        }
+
+        // Parse the hardcoded proof test case.
+        let proof= {
+            let test_case_bytes = fs::read("src/circuit_proof_test_case_sinsemilla.bin").unwrap();
+            read_test_case(&test_case_bytes[..]).expect("proof must be valid")
+        };
+
+        assert_eq!(proof.as_ref().len(), 4576);
+        assert!(proof.verify(&vk, &params).is_ok());
+    }
+
     #[cfg(feature = "test-dev-graph")]
     #[test]
     fn print_sinsemilla_chip() {

halo2_gadgets/src/sinsemilla/merkle.rs

@@ -204,6 +204,7 @@ pub mod tests {
     use pasta_curves::vesta::Affine;
     use rand::{rngs::OsRng, RngCore};
     use std::{convert::TryInto, iter};
+    use crate::utilities::test_circuit::{Proof, read_test_case, test_proof_size, write_test_case};
 
     const MERKLE_DEPTH: usize = 32;
 
@@ -421,7 +422,42 @@ pub mod tests {
         }
 
         // Test that the proof size is as expected.
-        crate::utilities::lookup_range_check::tests::test_proof_size(k, circuit, params, vk)
+        test_proof_size(k, circuit, params, vk)
+    }
+
+    #[test]
+    fn serialized_proof_test_case() {
+        use std::fs;
+
+        let circuit = generate_circuit();
+        // Setup phase: generate parameters, vk for the circuit.
+        let params:Params<Affine> = Params::new(11);
+        let vk = plonk::keygen_vk(&params, &circuit).unwrap();
+
+        if std::env::var_os("CIRCUIT_TEST_GENERATE_NEW_PROOF").is_some() {
+            let create_proof = || -> std::io::Result<()> {
+                let proof = Proof::create(
+                    &vk,
+                    &params,
+                    circuit,
+                ).unwrap();
+                assert!(proof.verify(&vk, &params).is_ok());
+
+
+                let file = std::fs::File::create("src/sinsemilla/circuit_proof_test_case_merkle.bin")?;
+                write_test_case(file, &proof)
+            };
+            create_proof().expect("should be able to write new proof");
+        }
+
+        // Parse the hardcoded proof test case.
+        let proof= {
+            let test_case_bytes = fs::read("src/sinsemilla/circuit_proof_test_case_merkle.bin").unwrap();
+            read_test_case(&test_case_bytes[..]).expect("proof must be valid")
+        };
+
+        assert_eq!(proof.as_ref().len(), 4160);
+        assert!(proof.verify(&vk, &params).is_ok());
     }
 
     #[cfg(feature = "test-dev-graph")]

halo2_gadgets/src/utilities.rs

@@ -12,6 +12,7 @@ use std::ops::Range;
 pub mod cond_swap;
 pub mod decompose_running_sum;
 pub mod lookup_range_check;
+pub mod test_circuit;
 
 /// A type that has a value at either keygen or proving time.
 pub trait FieldValue<F: Field> {

halo2_gadgets/src/utilities/lookup_range_check.rs

@@ -454,41 +454,14 @@ pub(crate) mod tests {
         plonk,
         plonk::{Circuit, ConstraintSystem, Error},
     };
-    use pasta_curves::{pallas, vesta};
+    use pasta_curves::{pallas};
 
-    use halo2_proofs::plonk::{SingleVerifier, VerifyingKey};
     use halo2_proofs::poly::commitment::Params;
-    use halo2_proofs::transcript::{Blake2bRead, Blake2bWrite, Challenge255};
     use pasta_curves::vesta::Affine;
-    use rand::rngs::OsRng;
-    use std::{convert::TryInto, marker::PhantomData};
-
-    pub(crate) fn test_proof_size<C>(
-        k: u32,
-        circuit: C,
-        params: Params<Affine>,
-        vk: VerifyingKey<Affine>,
-    ) where
-        C: Circuit<pallas::Base>,
-    {
-        // Test that the proof size is as expected.
-        let circuit_cost =
-            halo2_proofs::dev::CircuitCost::<pasta_curves::vesta::Point, _>::measure(k, &circuit);
-        let expected_proof_size = usize::from(circuit_cost.proof_size(1));
-
-        let pk = plonk::keygen_pk(&params, vk.clone(), &circuit).unwrap();
-        let mut transcript = Blake2bWrite::<_, vesta::Affine, _>::init(vec![]);
-        plonk::create_proof(&params, &pk, &[circuit], &[&[]], OsRng, &mut transcript).unwrap();
-        let proof = transcript.finalize();
-
-        let strategy = SingleVerifier::new(&params);
-        let mut transcript: Blake2bRead<&[u8], vesta::Affine, Challenge255<vesta::Affine>> =
-            Blake2bRead::init(&proof[..]);
-        let verify = plonk::verify_proof(&params, &vk, strategy, &[&[]], &mut transcript);
-        // Round-trip assertion: check the proof is valid and matches expected values.
-        assert!(verify.is_ok());
-        assert_eq!(proof.len(), expected_proof_size);
-    }
+    use std::{convert::TryInto, fs, marker::PhantomData};
+    use crate::utilities::test_circuit::{Proof, read_test_case, test_proof_size, write_test_case};
+
+
     #[test]
     fn lookup_range_check() {
         #[derive(Clone, Copy)]
@@ -598,6 +571,33 @@ pub(crate) mod tests {
                 );
             }
 
+            // serialized_proof_test_case
+            {
+                if std::env::var_os("CIRCUIT_TEST_GENERATE_NEW_PROOF").is_some() {
+                    let create_proof = || -> std::io::Result<()> {
+                        let proof = Proof::create(
+                            &vk,
+                            &params,
+                            circuit,
+                        ).unwrap();
+                        assert!(proof.verify(&vk, &params).is_ok());
+
+                        let file = std::fs::File::create("src/utilities/circuit_proof_test_case_lookup_range_check.bin")?;
+                        write_test_case(file, &proof)
+                    };
+                    create_proof().expect("should be able to write new proof");
+                }
+                // Parse the hardcoded proof test case.
+                let proof= {
+                    let test_case_bytes = fs::read("src/utilities/circuit_proof_test_case_lookup_range_check.bin").unwrap();
+                    read_test_case(&test_case_bytes[..]).expect("proof must be valid")
+                };
+
+                // todo: check size
+                assert_eq!(proof.as_ref().len(), 4160);
+                assert!(proof.verify(&vk, &params).is_ok());
+            }
+
             // Test that the proof size is as expected.
             test_proof_size(11, circuit, params, vk)
         }

halo2_gadgets/src/utilities/test_circuit.rs

@@ -0,0 +1,95 @@
+use std::io::{Read, Write};
+use pasta_curves::{pallas, vesta};
+use pasta_curves::vesta::Affine;
+use rand::rngs::OsRng;
+use halo2_proofs::plonk;
+use halo2_proofs::plonk::{Circuit, SingleVerifier, VerifyingKey};
+use halo2_proofs::poly::commitment::Params;
+use halo2_proofs::transcript::{Blake2bRead, Blake2bWrite};
+
+/// A proof structure
+#[derive(Clone, Debug)]
+pub struct Proof(Vec<u8>);
+impl AsRef<[u8]> for Proof {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl Proof {
+    /// Creates a proof for the given circuits and instances.
+    pub fn create<C>(
+        vk: &VerifyingKey<Affine>,
+        params: &Params<Affine>,
+        circuit: C,
+    )
+        -> Result<Self, plonk::Error>
+        where
+            C: Circuit<pallas::Base>,
+    {
+        let pk = plonk::keygen_pk(&params, vk.clone(), &circuit).unwrap();
+
+        let mut transcript = Blake2bWrite::<_, vesta::Affine, _>::init(vec![]);
+        plonk::create_proof(
+            &params,
+            &pk,
+            &[circuit],
+            &[&[]],
+            OsRng,
+            &mut transcript,
+        )?;
+        let proof = transcript.finalize();
+
+        Ok(Proof(proof))
+    }
+
+    /// Verifies this proof with the instances.
+    pub fn verify(
+        &self,
+        vk: &VerifyingKey<Affine>,
+        params: &Params<Affine>,
+    ) -> Result<(), plonk::Error> {
+
+        let strategy = SingleVerifier::new(&params);
+        let mut transcript = Blake2bRead::init(&self.0[..]);
+        plonk::verify_proof(&params, &vk, strategy, &[&[]], &mut transcript)
+    }
+    pub fn new(bytes: Vec<u8>) -> Self {
+        Proof(bytes)
+    }
+}
+
+pub(crate) fn test_proof_size<C>(
+    k: u32,
+    circuit: C,
+    params: Params<Affine>,
+    vk: VerifyingKey<Affine>,
+) where
+    C: Circuit<pallas::Base>,
+{
+    // Test that the proof size is as expected.
+    let circuit_cost =
+        halo2_proofs::dev::CircuitCost::<pasta_curves::vesta::Point, _>::measure(k, &circuit);
+    let expected_proof_size = usize::from(circuit_cost.proof_size(1));
+
+
+    let proof = Proof::create(&vk,&params,circuit).unwrap();
+
+    assert!(proof.verify(&vk, &params).is_ok());
+    assert_eq!(proof.as_ref().len(), expected_proof_size);
+}
+pub fn write_test_case<W: Write>(
+    mut w: W,
+    proof: &Proof,
+) -> std::io::Result<()> {
+    w.write_all(proof.as_ref())?;
+    Ok(())
+}
+
+pub fn read_test_case<R: Read>(mut r: R) -> std::io::Result<Proof> {
+    let mut proof_bytes = vec![];
+    r.read_to_end(&mut proof_bytes)?;
+    let proof = Proof::new(proof_bytes);
+
+    Ok(proof)
+}