add monolith sampling tests

proof-input/tests/sampling.rs

@@ -1,41 +1,24 @@
-use plonky2::hash::poseidon::PoseidonHash;
+use plonky2::plonk::circuit_data::CircuitConfig;
-use plonky2::plonk::config::PoseidonGoldilocksConfig;
+use plonky2::plonk::config::{AlgebraicHasher, GenericConfig, Hasher, PoseidonGoldilocksConfig};
+use plonky2::plonk::proof::ProofWithPublicInputs;
 use plonky2_field::goldilocks_field::GoldilocksField;
+use codex_plonky2_circuits::circuit_trait::Plonky2Circuit;
+use codex_plonky2_circuits::circuits::sample_cells::SampleCircuit;
+use proof_input::input_generator::InputGenerator;
+use proof_input::params::Params;
 
 // types used in all tests
 type F = GoldilocksField;
 const D: usize = 2;
-type H = PoseidonHash;
 type C = PoseidonGoldilocksConfig;
 
-
+fn test_sampling_proof<H: Hasher<F>>(){
-#[cfg(test)]
+    let input_gen = InputGenerator::<F,D, H>::default();
-mod sampling_tests {
-    use super::*;
-    use proof_input::input_generator::InputGenerator;
-
-    // Test sample cells (non-circuit)
-    #[test]
-    fn test_gen_verify_proof(){
-        let input_gen = InputGenerator::<F,D,H>::default();
     let w = input_gen.gen_testing_circuit_input();
     assert!(input_gen.verify_circuit_input(w));
-    }
 }
 
-#[cfg(test)]
+fn test_sampling_proof_in_circuit<C: GenericConfig<D, F = F>, H: AlgebraicHasher<F>>(config: CircuitConfig) -> anyhow::Result<()> {
-mod sampling_circuit_tests {
-    use super::*;
-    use std::time::Instant;
-    use plonky2::plonk::proof::ProofWithPublicInputs;
-    use codex_plonky2_circuits::circuit_trait::Plonky2Circuit;
-    use codex_plonky2_circuits::circuits::sample_cells::SampleCircuit;
-    use proof_input::input_generator::InputGenerator;
-    use proof_input::params::Params;
-
-    // Test sample cells in-circuit for a selected slot
-    #[test]
-    fn test_proof_in_circuit() -> anyhow::Result<()> {
     // get input
     let mut params = Params::default();
     params.set_n_samples(10);
@@ -46,17 +29,14 @@ mod sampling_circuit_tests {
 
     // build the circuit
     let circ = SampleCircuit::<F,D,H>::new(circuit_params.clone());
-        let (targets, data) = circ.build_with_standard_config()?;
+    let (targets, data) = circ.build(config)?;
-        println!("circuit size = {:?}", data.common.degree_bits());
 
     // separate the prover and verifier
     let verifier_data = data.verifier_data();
     let prover_data = data.prover_data();
 
     // Prove the circuit using the circuit input
-        let start_time = Instant::now();
     let proof_with_pis: ProofWithPublicInputs<F, C, D> = circ.prove(&targets, &circ_input, &prover_data)?;
-        println!("prove_time = {:?}", start_time.elapsed());
 
     // Verify the proof
     assert!(
@@ -65,6 +45,47 @@ mod sampling_circuit_tests {
     );
 
     Ok(())
+}
+
+#[cfg(test)]
+mod poseidon2_sampling_tests {
+    use super::*;
+    use plonky2_poseidon2::poseidon2_hash::poseidon2::Poseidon2Hash;
+
+    type H = Poseidon2Hash;
+
+    // Test sample cells (non-circuit)
+    #[test]
+    fn test_poseidon2_sampling_proof(){
+        test_sampling_proof::<H>();
     }
 
+    // Test sample cells in-circuit for a selected slot
+    #[test]
+    fn test_poseidon2_sampling_proof_in_circuit() -> anyhow::Result<()> {
+        let config = CircuitConfig::standard_recursion_config();
+        test_sampling_proof_in_circuit::<C,H>(config)
+    }
+}
+
+#[cfg(test)]
+mod monolith_sampling_tests {
+    use plonky2_monolith::gates::generate_config_for_monolith_gate;
+    use super::*;
+    use plonky2_monolith::monolith_hash::MonolithHash;
+
+    type H = MonolithHash;
+
+    // Test sample cells (non-circuit)
+    #[test]
+    fn test_monolith_sampling_proof(){
+        test_sampling_proof::<H>();
+    }
+
+    // Test sample cells in-circuit for a selected slot
+    #[test]
+    fn test_monolith_sampling_proof_in_circuit() -> anyhow::Result<()> {
+        let config = generate_config_for_monolith_gate::<F, D>();
+        test_sampling_proof_in_circuit::<C,H>(config)
+    }
 }