From d4cf60b5e65742fe97b8fa7d28f05876a0344eae Mon Sep 17 00:00:00 2001 From: adria0 Date: Thu, 20 Jun 2024 10:25:30 +0200 Subject: [PATCH] One thread results --- halo2_debug/Cargo.toml | 6 +- halo2_debug/src/lib.rs | 20 ++ halo2_proofs/tests/compress_selectors.rs | 18 +- halo2_proofs/tests/frontend_backend_split.rs | 256 ++++++++++--------- halo2_proofs/tests/plonk_api.rs | 100 ++++---- halo2_proofs/tests/serialization.rs | 146 +++++------ halo2_proofs/tests/shuffle.rs | 22 +- halo2_proofs/tests/shuffle_api.rs | 53 ++-- halo2_proofs/tests/vector-ops-unblinded.rs | 20 +- 9 files changed, 330 insertions(+), 311 deletions(-) diff --git a/halo2_debug/Cargo.toml b/halo2_debug/Cargo.toml index 1bbff0f08..3af6c761d 100644 --- a/halo2_debug/Cargo.toml +++ b/halo2_debug/Cargo.toml @@ -28,4 +28,8 @@ halo2_middleware = { path = "../halo2_middleware" } tiny-keccak = { version = "2.0.2", features=["keccak"] } hex = "0.4.3" rand_core = "0.6.4" -rand_chacha = "0.3" \ No newline at end of file +rand_chacha = "0.3" +rayon = "1.8" + +[features] +vector-tests = [] \ No newline at end of file diff --git a/halo2_debug/src/lib.rs b/halo2_debug/src/lib.rs index e1c1508d0..c26df9866 100644 --- a/halo2_debug/src/lib.rs +++ b/halo2_debug/src/lib.rs @@ -14,4 +14,24 @@ pub fn keccak_hex>(data: D) -> String { hasher.finalize(&mut hash); hex::encode(hash) } + +/// Executes a test and checks the result against the expected value +pub fn test_result Vec + Send>(test: F, _expected: &str) -> Vec { + #[cfg(feature = "vector-tests")] + let result = rayon::ThreadPoolBuilder::new() + .num_threads(1) + .build() + .unwrap() + .install(|| { + let result = test(); + assert_eq!(_expected, keccak_hex(result.clone()),); + result + }); + + #[cfg(not(feature = "vector-tests"))] + let result = test(); + + result +} + pub mod display; diff --git a/halo2_proofs/tests/compress_selectors.rs b/halo2_proofs/tests/compress_selectors.rs index 7076b9809..99cacab9a 100644 --- a/halo2_proofs/tests/compress_selectors.rs +++ b/halo2_proofs/tests/compress_selectors.rs @@ -4,7 +4,7 @@ use std::marker::PhantomData; use ff::PrimeField; use halo2_debug::display::expr_disp_names; -use halo2_debug::test_rng; +use halo2_debug::{test_result, test_rng}; use halo2_frontend::circuit::compile_circuit; use halo2_frontend::plonk::Error; use halo2_proofs::circuit::{Cell, Layouter, SimpleFloorPlanner, Value}; @@ -486,19 +486,15 @@ fn test_compress_gates() { #[test] fn test_success() -> Result<(), halo2_proofs::plonk::Error> { // vk & pk keygen both WITH compress - let _proof = test_mycircuit(true, true)?; - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "54567f2f61aca2232780ff6becb4e3d755b10deefea3a421af2b0448336e0bfb", - halo2_debug::keccak_hex(_proof), + test_result( + || test_mycircuit(true, true).expect("should pass"), + "8326140d1873a91630d439a8812d1f104667144e03e0cd5c59eb358ae5d1a4eb", ); // vk & pk keygen both WITHOUT compress - let _proof = test_mycircuit(false, false)?; - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "74695fecf57b69fd698c55290beb34e21c631df58cb31947e3ecf0b961e56631", - halo2_debug::keccak_hex(_proof), + test_result( + || test_mycircuit(false, false).expect("should pass"), + "73dd4c3c9c51d55dc8cf68ca2b5d8acdb40ed44bc8a88d718325bc0023688f64", ); Ok(()) diff --git a/halo2_proofs/tests/frontend_backend_split.rs b/halo2_proofs/tests/frontend_backend_split.rs index 53ec3d53c..6238a13e3 100644 --- a/halo2_proofs/tests/frontend_backend_split.rs +++ b/halo2_proofs/tests/frontend_backend_split.rs @@ -485,136 +485,140 @@ const WIDTH_FACTOR: usize = 1; #[test] fn test_mycircuit_full_legacy() { - use halo2_proofs::plonk::{ - create_proof, keygen_pk as keygen_pk_legacy, keygen_vk as keygen_vk_legacy, - }; - - let k = K; - let circuit: MyCircuit = MyCircuit::new(k, 42); - - // Setup - let mut rng = test_rng(); - let params = ParamsKZG::::setup(k, &mut rng); - let start = Instant::now(); - let vk = keygen_vk_legacy(¶ms, &circuit).expect("keygen_vk should not fail"); - let pk = keygen_pk_legacy(¶ms, vk.clone(), &circuit).expect("keygen_pk should not fail"); - println!("Keygen: {:?}", start.elapsed()); - - // Proving - let instances = vec![circuit.instances()]; - - let start = Instant::now(); - let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]); - create_proof::, ProverSHPLONK<'_, Bn256>, _, _, _, _>( - ¶ms, - &pk, - &[circuit], - instances.as_slice(), - &mut rng, - &mut transcript, - ) - .expect("proof generation should not fail"); - let proof = transcript.finalize(); - println!("Prove: {:?}", start.elapsed()); - - // Verify - let start = Instant::now(); - let mut verifier_transcript = - Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice()); - let verifier_params = params.verifier_params(); - let strategy = SingleStrategy::new(&verifier_params); - - verify_proof::, VerifierSHPLONK, _, _, _>( - &verifier_params, - &vk, - strategy, - instances.as_slice(), - &mut verifier_transcript, - ) - .expect("verify succeeds"); - println!("Verify: {:?}", start.elapsed()); - - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "625d492217ab78c9a55eb6f9154bd57a63ca7a37f6e3f64cce670b6d1fc8271d", - halo2_debug::keccak_hex(proof), + halo2_debug::test_result( + || { + use halo2_proofs::plonk::{ + create_proof, keygen_pk as keygen_pk_legacy, keygen_vk as keygen_vk_legacy, + }; + + let k = K; + let circuit: MyCircuit = MyCircuit::new(k, 42); + + // Setup + let mut rng = test_rng(); + let params = ParamsKZG::::setup(k, &mut rng); + let start = Instant::now(); + let vk = keygen_vk_legacy(¶ms, &circuit).expect("keygen_vk should not fail"); + let pk = + keygen_pk_legacy(¶ms, vk.clone(), &circuit).expect("keygen_pk should not fail"); + println!("Keygen: {:?}", start.elapsed()); + + // Proving + let instances = vec![circuit.instances()]; + + let start = Instant::now(); + let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]); + create_proof::, ProverSHPLONK<'_, Bn256>, _, _, _, _>( + ¶ms, + &pk, + &[circuit], + instances.as_slice(), + &mut rng, + &mut transcript, + ) + .expect("proof generation should not fail"); + let proof = transcript.finalize(); + println!("Prove: {:?}", start.elapsed()); + + // Verify + let start = Instant::now(); + let mut verifier_transcript = + Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice()); + let verifier_params = params.verifier_params(); + let strategy = SingleStrategy::new(&verifier_params); + + verify_proof::, VerifierSHPLONK, _, _, _>( + &verifier_params, + &vk, + strategy, + instances.as_slice(), + &mut verifier_transcript, + ) + .expect("verify succeeds"); + println!("Verify: {:?}", start.elapsed()); + + proof + }, + "427e55eafeaafd9f4dfc7ec6f782ec7464251c749bb08e23efb663790c0419ed", ); } #[test] fn test_mycircuit_full_split() { - use halo2_middleware::zal::impls::{H2cEngine, PlonkEngineConfig}; - - let engine = PlonkEngineConfig::new() - .set_curve::() - .set_msm(H2cEngine::new()) - .build(); - let k = K; - let circuit: MyCircuit = MyCircuit::new(k, 42); - let (compiled_circuit, config, cs) = compile_circuit(k, &circuit, true).unwrap(); - - // Setup - let mut rng = test_rng(); - let params = ParamsKZG::::setup(k, &mut rng); - let start = Instant::now(); - let vk = keygen_vk(¶ms, &compiled_circuit).expect("keygen_vk should not fail"); - let pk = keygen_pk(¶ms, vk.clone(), &compiled_circuit).expect("keygen_pk should not fail"); - println!("Keygen: {:?}", start.elapsed()); - drop(compiled_circuit); - - let instances = circuit.instances(); - // Proving - println!("Proving..."); - let start = Instant::now(); - let mut witness_calc = WitnessCalculator::new(k, &circuit, &config, &cs, &instances); - let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]); - let mut prover = ProverSingle::< - KZGCommitmentScheme, - ProverSHPLONK<'_, Bn256>, - _, - _, - _, - _, - >::new_with_engine( - engine, - ¶ms, - &pk, -instances.clone(), - &mut rng, - &mut transcript, - ) - .unwrap(); - let mut challenges = HashMap::new(); - for phase in 0..cs.phases().count() { - println!("phase {phase}"); - let witness = witness_calc.calc(phase as u8, &challenges).unwrap(); - challenges = prover.commit_phase(phase as u8, witness).unwrap(); - } - prover.create_proof().unwrap(); - let proof = transcript.finalize(); - println!("Prove: {:?}", start.elapsed()); - - // Verify - let start = Instant::now(); - println!("Verifying..."); - let mut verifier_transcript = - Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice()); - let verifier_params = params.verifier_params(); - let strategy = SingleStrategy::new(&verifier_params); - - verify_proof_single::, VerifierSHPLONK, _, _, _>( - &verifier_params, - &vk, - strategy, - instances, - &mut verifier_transcript, - ) - .expect("verify succeeds"); - println!("Verify: {:?}", start.elapsed()); - - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "625d492217ab78c9a55eb6f9154bd57a63ca7a37f6e3f64cce670b6d1fc8271d", - halo2_debug::keccak_hex(proof), + halo2_debug::test_result( + || { + use halo2_middleware::zal::impls::{H2cEngine, PlonkEngineConfig}; + + let engine = PlonkEngineConfig::new() + .set_curve::() + .set_msm(H2cEngine::new()) + .build(); + let k = K; + let circuit: MyCircuit = MyCircuit::new(k, 42); + let (compiled_circuit, config, cs) = compile_circuit(k, &circuit, true).unwrap(); + + // Setup + let mut rng = test_rng(); + let params = ParamsKZG::::setup(k, &mut rng); + let start = Instant::now(); + let vk = keygen_vk(¶ms, &compiled_circuit).expect("keygen_vk should not fail"); + let pk = keygen_pk(¶ms, vk.clone(), &compiled_circuit) + .expect("keygen_pk should not fail"); + println!("Keygen: {:?}", start.elapsed()); + drop(compiled_circuit); + + let instances = circuit.instances(); + // Proving + println!("Proving..."); + let start = Instant::now(); + let mut witness_calc = WitnessCalculator::new(k, &circuit, &config, &cs, &instances); + let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]); + let mut prover = ProverSingle::< + KZGCommitmentScheme, + ProverSHPLONK<'_, Bn256>, + _, + _, + _, + _, + >::new_with_engine( + engine, + ¶ms, + &pk, + instances.clone(), + &mut rng, + &mut transcript, + ) + .unwrap(); + let mut challenges = HashMap::new(); + for phase in 0..cs.phases().count() { + println!("phase {phase}"); + let witness = witness_calc.calc(phase as u8, &challenges).unwrap(); + challenges = prover.commit_phase(phase as u8, witness).unwrap(); + } + prover.create_proof().unwrap(); + let proof = transcript.finalize(); + println!("Prove: {:?}", start.elapsed()); + + // Verify + let start = Instant::now(); + println!("Verifying..."); + let mut verifier_transcript = + Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice()); + let verifier_params = params.verifier_params(); + let strategy = SingleStrategy::new(&verifier_params); + + verify_proof_single::, VerifierSHPLONK, _, _, _>( + &verifier_params, + &vk, + strategy, + instances, + &mut verifier_transcript, + ) + .expect("verify succeeds"); + println!("Verify: {:?}", start.elapsed()); + + proof + }, + "427e55eafeaafd9f4dfc7ec6f782ec7464251c749bb08e23efb663790c0419ed", ); } diff --git a/halo2_proofs/tests/plonk_api.rs b/halo2_proofs/tests/plonk_api.rs index b3b9923d8..d454d0292 100644 --- a/halo2_proofs/tests/plonk_api.rs +++ b/halo2_proofs/tests/plonk_api.rs @@ -568,73 +568,77 @@ fn plonk_api() { } fn test_plonk_api_gwc() { - use halo2_proofs::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG}; - use halo2_proofs::poly::kzg::multiopen::{ProverGWC, VerifierGWC}; - use halo2_proofs::poly::kzg::strategy::AccumulatorStrategy; - use halo2curves::bn256::Bn256; + halo2_debug::test_result( + || { + use halo2_proofs::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG}; + use halo2_proofs::poly::kzg::multiopen::{ProverGWC, VerifierGWC}; + use halo2_proofs::poly::kzg::strategy::AccumulatorStrategy; + use halo2curves::bn256::Bn256; - type Scheme = KZGCommitmentScheme; + type Scheme = KZGCommitmentScheme; - bad_keys!(Scheme); + bad_keys!(Scheme); - let mut rng = test_rng(); + let mut rng = test_rng(); - let params = ParamsKZG::::setup(K, &mut rng); - let pk = keygen::>(¶ms); + let params = ParamsKZG::::setup(K, &mut rng); + let pk = keygen::>(¶ms); - let proof = create_proof::<_, ProverGWC<_>, _, _, Blake2bWrite<_, _, Challenge255<_>>>( - &mut rng, ¶ms, &pk, - ); + let proof = + create_proof::<_, ProverGWC<_>, _, _, Blake2bWrite<_, _, Challenge255<_>>>( + &mut rng, ¶ms, &pk, + ); - let verifier_params = params.verifier_params(); + let verifier_params = params.verifier_params(); - verify_proof::< - _, - VerifierGWC<_>, - _, - Blake2bRead<_, _, Challenge255<_>>, - AccumulatorStrategy<_>, - >(&verifier_params, pk.get_vk(), &proof[..]); + verify_proof::< + _, + VerifierGWC<_>, + _, + Blake2bRead<_, _, Challenge255<_>>, + AccumulatorStrategy<_>, + >(&verifier_params, pk.get_vk(), &proof[..]); - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "c1476c9e9075574456d16442a2e2da05c8e718adcfd8e8647a0c701b5cef67d0", - halo2_debug::keccak_hex(proof), + proof + }, + "b749dfa90ac3bc3d45f994cc8bf527928a274c2225e4e87668eece79938e6d12", ); } fn test_plonk_api_shplonk() { - use halo2_proofs::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG}; - use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK}; - use halo2_proofs::poly::kzg::strategy::AccumulatorStrategy; - use halo2curves::bn256::Bn256; + halo2_debug::test_result( + || { + use halo2_proofs::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG}; + use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK}; + use halo2_proofs::poly::kzg::strategy::AccumulatorStrategy; + use halo2curves::bn256::Bn256; - type Scheme = KZGCommitmentScheme; - bad_keys!(Scheme); + type Scheme = KZGCommitmentScheme; + bad_keys!(Scheme); - let mut rng = test_rng(); - let params = ParamsKZG::::setup(K, &mut rng); + let mut rng = test_rng(); + let params = ParamsKZG::::setup(K, &mut rng); - let pk = keygen::>(¶ms); + let pk = keygen::>(¶ms); - let proof = create_proof::<_, ProverSHPLONK<_>, _, _, Blake2bWrite<_, _, Challenge255<_>>>( - rng, ¶ms, &pk, - ); + let proof = + create_proof::<_, ProverSHPLONK<_>, _, _, Blake2bWrite<_, _, Challenge255<_>>>( + rng, ¶ms, &pk, + ); - let verifier_params = params.verifier_params(); + let verifier_params = params.verifier_params(); - verify_proof::< - _, - VerifierSHPLONK<_>, - _, - Blake2bRead<_, _, Challenge255<_>>, - AccumulatorStrategy<_>, - >(&verifier_params, pk.get_vk(), &proof[..]); + verify_proof::< + _, + VerifierSHPLONK<_>, + _, + Blake2bRead<_, _, Challenge255<_>>, + AccumulatorStrategy<_>, + >(&verifier_params, pk.get_vk(), &proof[..]); - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "352b7b196bd010c31f287cd25376eab0e74be444711891ff0b05068d8366c70d", - halo2_debug::keccak_hex(proof), + proof + }, + "284001f93f86a5d18ad9ebff6da81031e5ad9f799ea1dc2606271a6ff240fbd3", ); } diff --git a/halo2_proofs/tests/serialization.rs b/halo2_proofs/tests/serialization.rs index 8a02a93d1..54e350d7d 100644 --- a/halo2_proofs/tests/serialization.rs +++ b/halo2_proofs/tests/serialization.rs @@ -130,76 +130,78 @@ impl Circuit for StandardPlonk { #[test] fn test_serialization() { - let k = 4; - - let mut rng = test_rng(); - - let circuit = StandardPlonk(Fr::random(&mut rng)); - let params = ParamsKZG::::setup(k, &mut rng); - let compress_selectors = true; - let vk = keygen_vk_custom(¶ms, &circuit, compress_selectors).expect("vk should not fail"); - let pk = keygen_pk(¶ms, vk, &circuit).expect("pk should not fail"); - - let f = File::create("serialization-test.pk").unwrap(); - let mut writer = BufWriter::new(f); - pk.write(&mut writer, SerdeFormat::RawBytes).unwrap(); - writer.flush().unwrap(); - - let f = File::open("serialization-test.pk").unwrap(); - let mut reader = BufReader::new(f); - #[allow(clippy::unit_arg)] - let pk = pk_read::( - &mut reader, - SerdeFormat::RawBytes, - k, - &circuit, - compress_selectors, - ) - .unwrap(); - - std::fs::remove_file("serialization-test.pk").unwrap(); - - let instances: Vec>> = vec![vec![vec![circuit.0]]]; - let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]); - create_proof::< - KZGCommitmentScheme, - ProverGWC<'_, Bn256>, - Challenge255, - _, - Blake2bWrite, G1Affine, Challenge255<_>>, - _, - >( - ¶ms, - &pk, - &[circuit], - instances.as_slice(), - test_rng(), - &mut transcript, - ) - .expect("prover should not fail"); - let proof = transcript.finalize(); - - let verifier_params = params.verifier_params(); - let strategy = SingleStrategy::new(&verifier_params); - let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]); - assert!(verify_proof::< - KZGCommitmentScheme, - VerifierGWC, - Challenge255, - Blake2bRead<&[u8], G1Affine, Challenge255>, - SingleStrategy, - >( - &verifier_params, - pk.get_vk(), - strategy, - instances.as_slice(), - &mut transcript - ) - .is_ok()); - - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "a8bc8d8311d30617ba9d170f1610adc6cfc0a93074c6d2ac4e0b65d931be3848", - halo2_debug::keccak_hex(proof), - ) + halo2_debug::test_result( + || { + let k = 4; + + let mut rng = test_rng(); + + let circuit = StandardPlonk(Fr::random(&mut rng)); + let params = ParamsKZG::::setup(k, &mut rng); + let compress_selectors = true; + let vk = keygen_vk_custom(¶ms, &circuit, compress_selectors) + .expect("vk should not fail"); + let pk = keygen_pk(¶ms, vk, &circuit).expect("pk should not fail"); + + let f = File::create("serialization-test.pk").unwrap(); + let mut writer = BufWriter::new(f); + pk.write(&mut writer, SerdeFormat::RawBytes).unwrap(); + writer.flush().unwrap(); + + let f = File::open("serialization-test.pk").unwrap(); + let mut reader = BufReader::new(f); + #[allow(clippy::unit_arg)] + let pk = pk_read::( + &mut reader, + SerdeFormat::RawBytes, + k, + &circuit, + compress_selectors, + ) + .unwrap(); + + std::fs::remove_file("serialization-test.pk").unwrap(); + + let instances: Vec>> = vec![vec![vec![circuit.0]]]; + let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]); + create_proof::< + KZGCommitmentScheme, + ProverGWC<'_, Bn256>, + Challenge255, + _, + Blake2bWrite, G1Affine, Challenge255<_>>, + _, + >( + ¶ms, + &pk, + &[circuit], + instances.as_slice(), + test_rng(), + &mut transcript, + ) + .expect("prover should not fail"); + let proof = transcript.finalize(); + + let verifier_params = params.verifier_params(); + let strategy = SingleStrategy::new(&verifier_params); + let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]); + assert!(verify_proof::< + KZGCommitmentScheme, + VerifierGWC, + Challenge255, + Blake2bRead<&[u8], G1Affine, Challenge255>, + SingleStrategy, + >( + &verifier_params, + pk.get_vk(), + strategy, + instances.as_slice(), + &mut transcript + ) + .is_ok()); + + proof + }, + "0d3baeea90249588c3939dc2f64b071b24b7e4744c4ca8442fe4b2553aae9167", + ); } diff --git a/halo2_proofs/tests/shuffle.rs b/halo2_proofs/tests/shuffle.rs index a270292b5..f74958bee 100644 --- a/halo2_proofs/tests/shuffle.rs +++ b/halo2_proofs/tests/shuffle.rs @@ -328,16 +328,12 @@ fn test_shuffle() { let circuit = &MyCircuit::<_, W, H>::rand(&mut test_rng()); - { - test_mock_prover(K, circuit.clone(), Ok(())); - let _proof = test_prover::(K, circuit.clone(), true); + test_mock_prover(K, circuit.clone(), Ok(())); - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "4aa130bdb970e2c3176a0b385efc672468a6ac7ed65c68afb4c1c9928278afba", - halo2_debug::keccak_hex(_proof), - ); - } + halo2_debug::test_result( + || test_prover::(K, circuit.clone(), true), + "8526b66a372eaeccb687c21daf358d4fdb1c9d2b7e81470317c472634c5c1470", + ); #[cfg(not(feature = "sanity-checks"))] { @@ -360,11 +356,9 @@ fn test_shuffle() { }, )]), ); - let _proof = test_prover::(K, circuit, false); - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "0b4e97f2d561fae56fe893333eba2df5228c78e80f8bd7c509d4d40d127dff92", - halo2_debug::keccak_hex(_proof), + halo2_debug::test_result( + || test_prover::(K, circuit.clone(), false), + "27ad558ee60a6675911b87a0df5de49d7c9b5673d723bb05a9811aa33bf486d1", ); } } diff --git a/halo2_proofs/tests/shuffle_api.rs b/halo2_proofs/tests/shuffle_api.rs index 5d94d6c4d..7dc8d73bc 100644 --- a/halo2_proofs/tests/shuffle_api.rs +++ b/halo2_proofs/tests/shuffle_api.rs @@ -196,32 +196,31 @@ where #[test] fn test_shuffle_api() { - use halo2_proofs::dev::MockProver; - use halo2curves::pasta::Fp; - const K: u32 = 4; - let input_0 = [1, 2, 4, 1] - .map(|e: u64| Value::known(Fp::from(e))) - .to_vec(); - let input_1 = [10, 20, 40, 10].map(Fp::from).to_vec(); - let shuffle_0 = [4, 1, 1, 2] - .map(|e: u64| Value::known(Fp::from(e))) - .to_vec(); - let shuffle_1 = [40, 10, 10, 20] - .map(|e: u64| Value::known(Fp::from(e))) - .to_vec(); - let circuit = MyCircuit { - input_0, - input_1, - shuffle_0, - shuffle_1, - }; - let prover = MockProver::run(K, &circuit, vec![]).unwrap(); - prover.assert_satisfied(); - let _proof = test_prover::(K, circuit, true); - - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "31a11556ab6a031a5c1015f6269686736aa1273203a99460ad9dfcc8ec29d383", - halo2_debug::keccak_hex(_proof), + halo2_debug::test_result( + || { + use halo2_proofs::dev::MockProver; + use halo2curves::pasta::Fp; + const K: u32 = 4; + let input_0 = [1, 2, 4, 1] + .map(|e: u64| Value::known(Fp::from(e))) + .to_vec(); + let input_1 = [10, 20, 40, 10].map(Fp::from).to_vec(); + let shuffle_0 = [4, 1, 1, 2] + .map(|e: u64| Value::known(Fp::from(e))) + .to_vec(); + let shuffle_1 = [40, 10, 10, 20] + .map(|e: u64| Value::known(Fp::from(e))) + .to_vec(); + let circuit = MyCircuit { + input_0, + input_1, + shuffle_0, + shuffle_1, + }; + let prover = MockProver::run(K, &circuit, vec![]).unwrap(); + prover.assert_satisfied(); + test_prover::(K, circuit, true) + }, + "54f4fec1776178aadf8816754d7877f1de685e0ffb5b6af4db20f557d87550d6", ); } diff --git a/halo2_proofs/tests/vector-ops-unblinded.rs b/halo2_proofs/tests/vector-ops-unblinded.rs index bee4ec78e..6a3f54a4a 100644 --- a/halo2_proofs/tests/vector-ops-unblinded.rs +++ b/halo2_proofs/tests/vector-ops-unblinded.rs @@ -360,7 +360,7 @@ impl NumericInstructions for AddChip { } } -#[derive(Default)] +#[derive(Default, Clone)] struct MulCircuit { a: Vec>, b: Vec>, @@ -413,7 +413,7 @@ impl Circuit for MulCircuit { } // ANCHOR_END: circuit -#[derive(Default)] +#[derive(Default, Clone)] struct AddCircuit { a: Vec>, b: Vec>, @@ -547,19 +547,15 @@ fn test_vector_ops_unbinded() { }; // the commitments will be the first columns of the proof transcript so we can compare them easily - let proof_1 = test_prover::(k, mul_circuit, true, c_mul); - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "1ad48349d290fd0862955d0bb8c5a03cbaff24cdd6c6a2251f65a53b14c70da0", - halo2_debug::keccak_hex(&proof_1), + let proof_1 = halo2_debug::test_result( + || test_prover::(k, mul_circuit.clone(), true, c_mul.clone()), + "1f726eaddd926057e6c2aa8a364d1b4192da27f53c38c9f21d8924ef3eb0f0ab", ); // the commitments will be the first columns of the proof transcript so we can compare them easily - let proof_2 = test_prover::(k, add_circuit, true, c_add); - #[cfg(all(feature = "vector-tests", not(coverage)))] - assert_eq!( - "7d9f9525dcbdfc4d99ec42afcbf29824ed6df8455ab10df9bab78fc2351aad0a", - halo2_debug::keccak_hex(&proof_2), + let proof_2 = halo2_debug::test_result( + || test_prover::(k, add_circuit.clone(), true, c_add.clone()), + "a42eb2f3e4761e6588bfd8db7e7035ead1cc1331017b6b09a7b75ddfbefefc58", ); // the commitments will be the first columns of the proof transcript so we can compare them easily