From 691a2568ef890cbf2ea71f67caa0cd782dd6990c Mon Sep 17 00:00:00 2001 From: cezarapetrui19 Date: Mon, 7 Jul 2025 16:39:30 +0300 Subject: [PATCH 1/3] tests custom gates --- plonky2/src/gates/addition_base.rs | 132 ++++++++++++++++++ plonky2/src/gates/equality_base.rs | 157 ++++++++++++++++++++- plonky2/src/gates/multiplication_base.rs | 138 ++++++++++++++++++- plonky2/src/gates/select_base.rs | 168 +++++++++++++++++++++++ 4 files changed, 593 insertions(+), 2 deletions(-) diff --git a/plonky2/src/gates/addition_base.rs b/plonky2/src/gates/addition_base.rs index ca7e9567..f0fa13b8 100644 --- a/plonky2/src/gates/addition_base.rs +++ b/plonky2/src/gates/addition_base.rs @@ -242,10 +242,17 @@ impl, const D: usize> SimpleGenerator #[cfg(test)] mod tests { use anyhow::Result; + use plonky2_field::types::Sample; use crate::field::goldilocks_field::GoldilocksField; + use crate::field::types::Field; + #[allow(unused_imports)] + use crate::field::types::Field64; use crate::gates::addition_base::AdditionGate; use crate::gates::gate_testing::{test_eval_fns, test_low_degree}; + use crate::iop::target::Target; + use crate::iop::witness::{PartialWitness, WitnessWrite}; + use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; @@ -263,4 +270,129 @@ mod tests { let gate = AdditionGate::new_from_config(&CircuitConfig::standard_recursion_config()); test_eval_fns::(gate) } + + #[test] + fn test_success() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) -> Result<()> { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = AdditionGate::new_from_config(&config); + let constants = [F::ONE, F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i)); + let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i)); + let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_output); + + pairs.push((x,y, output_value)); + } + + let circuit_data = builder.build::(); + + let mut pw = PartialWitness::new(); + for (_, (x,y, output_value)) in pairs.iter().enumerate() { + let value1 = F::rand(); + let value2 = F::rand(); + let expected = value1 + value2; + pw.set_target(*x, value1)?; + pw.set_target(*y, value2)?; + pw.set_target(*output_value, expected)?; + } + + let proof = circuit_data.prove(pw)?; + circuit_data.verify(proof)?; + + Ok(()) + } + + flag_test(63)?; // flag enabled + flag_test(62)?; // flag disabled + + Ok(()) + } + + #[test] + #[should_panic] + fn test_failure() { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = AdditionGate::new_from_config(&config); + let constants = [F::ONE, F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i)); + let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i)); + let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_output); + + pairs.push((x,y, output_value)); + } + + let circuit_data = builder.build::(); + + let mut pw = PartialWitness::new(); + for (_, (x,y, output_value)) in pairs.iter().enumerate() { + let value1 = F::rand(); + let value2 = F::rand(); + let expected = value1 + value2; + let mut incorrect_value = F::rand(); + while incorrect_value == expected { + incorrect_value = F::rand(); + } + pw.set_target(*x, value1).unwrap(); + pw.set_target(*y, value2).unwrap(); + pw.set_target(*output_value, incorrect_value).unwrap(); + } + + let proof = circuit_data.prove(pw).unwrap(); + circuit_data.verify(proof).unwrap(); + + } + + flag_test(63); // flag enabled + flag_test(62); // flag disabled + + + } + } diff --git a/plonky2/src/gates/equality_base.rs b/plonky2/src/gates/equality_base.rs index 50a315e8..648bd331 100644 --- a/plonky2/src/gates/equality_base.rs +++ b/plonky2/src/gates/equality_base.rs @@ -295,6 +295,7 @@ mod tests { use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; + use plonky2_field::types::Sample; #[test] fn low_degree() { @@ -312,7 +313,7 @@ mod tests { } #[test] - fn test_succes() -> Result<()> { + fn test_succes_initial() -> Result<()> { const D: usize = 2; type C = PoseidonGoldilocksConfig; type F = >::F; @@ -356,4 +357,158 @@ mod tests { Ok(()) } + + + #[test] + #[should_panic] + fn test_failure() { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + let gate = EqualityGate::new_from_config(&config); + let ref_gate = gate.clone(); + let constants = [F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, ref_gate.wire_ith_element_0(i)); + let wire_y = Target::wire(gate_row, ref_gate.wire_ith_element_1(i)); + let wire_equal = Target::wire(gate_row, ref_gate.wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_equal); + + pairs.push((x, y, output_value)); + + } + + let circuit_data = builder.build::(); + let mut pw = PartialWitness::new(); + + for (i, (x, y, output_value)) in pairs.iter().enumerate() { + if i < 50 { + let value = F::rand(); + pw.set_target(*x, value).unwrap(); + pw.set_target(*y, value).unwrap(); + let incorrect_value = F::ZERO; + pw.set_target(*output_value, incorrect_value).unwrap(); + } else { + let value1 = F::rand(); + let mut value2 = F::rand(); + + while value2 == value1 { + value2 = F::rand(); + } + + pw.set_target(*x, value1).unwrap(); + pw.set_target(*y, value2).unwrap(); + let incorrect_value = F::ONE; + pw.set_target(*output_value, incorrect_value).unwrap(); + } + + } + + let proof = circuit_data.prove(pw).unwrap(); + circuit_data.verify(proof).unwrap(); + + } + + flag_test(63); // flag enabled + flag_test(55); // flag disabled + + + + } + + #[test] + fn test_success() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) -> Result<()> { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + let gate = EqualityGate::new_from_config(&config); + let ref_gate = gate.clone(); + let constants = [F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, ref_gate.wire_ith_element_0(i)); + let wire_y = Target::wire(gate_row, ref_gate.wire_ith_element_1(i)); + let wire_equal = Target::wire(gate_row, ref_gate.wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_equal); + + pairs.push((x, y, output_value)); + + } + + let circuit_data = builder.build::(); + let mut pw = PartialWitness::new(); + + for (i, (x, y, output_value)) in pairs.iter().enumerate() { + if i < 50 { + let value = F::rand(); + pw.set_target(*x, value)?; + pw.set_target(*y, value)?; + let expected = F::ONE; + + pw.set_target(*output_value, expected)?; + } else { + let value1 = F::rand(); + let mut value2 = F::rand(); + + while value2 == value1 { + value2 = F::rand(); + } + + pw.set_target(*x, value1)?; + pw.set_target(*y, value2)?; + let expected = F::ZERO; + pw.set_target(*output_value, expected)?; + } + + } + + let proof = circuit_data.prove(pw)?; + circuit_data.verify(proof)?; + + Ok(()) + } + + flag_test(63)?; // flag enabled + flag_test(55)?; // flag disabled + + Ok(()) + + } } diff --git a/plonky2/src/gates/multiplication_base.rs b/plonky2/src/gates/multiplication_base.rs index cfe26499..8bd4f8bd 100644 --- a/plonky2/src/gates/multiplication_base.rs +++ b/plonky2/src/gates/multiplication_base.rs @@ -231,10 +231,17 @@ impl, const D: usize> SimpleGenerator #[cfg(test)] mod tests { use anyhow::Result; + use plonky2_field::types::Sample; use crate::field::goldilocks_field::GoldilocksField; - use crate::gates::gate_testing::{test_eval_fns, test_low_degree}; + use crate::field::types::Field; + #[allow(unused_imports)] + use crate::field::types::Field64; use crate::gates::multiplication_base::MultiplicationGate; + use crate::gates::gate_testing::{test_eval_fns, test_low_degree}; + use crate::iop::target::Target; + use crate::iop::witness::{PartialWitness, WitnessWrite}; + use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; @@ -252,4 +259,133 @@ mod tests { let gate = MultiplicationGate::new_from_config(&CircuitConfig::standard_recursion_config()); test_eval_fns::(gate) } + + #[test] + fn test_success() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) -> Result<()> { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = MultiplicationGate::new_from_config(&config); + let constants = [F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, MultiplicationGate::wire_ith_multiplicand_0(i)); + let wire_y = Target::wire(gate_row, MultiplicationGate::wire_ith_multiplicand_1(i)); + let wire_output = Target::wire(gate_row, MultiplicationGate::wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_output); + + pairs.push((x,y, output_value)); + } + + let circuit_data = builder.build::(); + + let mut pw = PartialWitness::new(); + for (_, (x,y, output_value)) in pairs.iter().enumerate() { + let value1 = F::rand(); + let value2 = F::rand(); + let expected = value1 * value2; + pw.set_target(*x, value1)?; + pw.set_target(*y, value2)?; + pw.set_target(*output_value, expected)?; + } + + let proof = circuit_data.prove(pw)?; + circuit_data.verify(proof)?; + + Ok(()) + + } + + flag_test(63)?; // flag enabled + flag_test(61)?; // flag disabled + + Ok(()) + } + + + #[test] + #[should_panic] + fn test_failure() { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = MultiplicationGate::new_from_config(&config); + let constants = [F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, MultiplicationGate::wire_ith_multiplicand_0(i)); + let wire_y = Target::wire(gate_row, MultiplicationGate::wire_ith_multiplicand_1(i)); + let wire_output = Target::wire(gate_row, MultiplicationGate::wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_output); + + pairs.push((x,y, output_value)); + } + + let circuit_data = builder.build::(); + + let mut pw = PartialWitness::new(); + for (_, (x,y, output_value)) in pairs.iter().enumerate() { + let value1 = F::rand(); + let value2 = F::rand(); + let expected = value1 * value2; + let mut incorrect_value = F::rand(); + while incorrect_value == expected { + incorrect_value = F::rand(); + } + pw.set_target(*x, value1).unwrap(); + pw.set_target(*y, value2).unwrap(); + pw.set_target(*output_value, incorrect_value).unwrap(); + } + + + let proof = circuit_data.prove(pw).unwrap(); + circuit_data.verify(proof).unwrap(); + + + + } + + flag_test(63); // flag enabled + flag_test(61); // flag disabled + + + } } diff --git a/plonky2/src/gates/select_base.rs b/plonky2/src/gates/select_base.rs index 51e4070c..a4820241 100644 --- a/plonky2/src/gates/select_base.rs +++ b/plonky2/src/gates/select_base.rs @@ -280,6 +280,7 @@ mod tests { use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; + use plonky2_field::types::Sample; #[test] fn low_degree() { @@ -332,4 +333,171 @@ mod tests { circuit_data.verify(proof)?; Ok(()) } + + #[test] + fn test_success() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) -> Result<()> { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = SelectionGate::new_from_config(&config); + let ref_gate = gate.clone(); + + for _ in 0..100 { + let b = builder.add_virtual_bool_target_safe(); + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + + let (row, i) = builder.find_slot(gate.clone(), &[], &[]); + + builder.connect(b.target, Target::wire(row, ref_gate.wire_ith_selector(i))); + builder.connect(x, Target::wire(row, ref_gate.wire_ith_element_0(i))); + builder.connect(y, Target::wire(row, ref_gate.wire_ith_element_1(i))); + + let output = Target::wire(row, ref_gate.wire_ith_output(i)); + let result = builder.add_virtual_target(); + builder.connect(result, output); + + pairs.push((b, x, y, result)); + } + + let circuit_data = builder.build::(); + let mut pw = PartialWitness::new(); + + for (i, (b, x, y, result)) in pairs.iter().enumerate() { + + if i < 50 { + let x_val = F::rand(); + let y_val = F::rand(); + let b_val = true; + let expected = x_val; + + pw.set_target(*x, x_val)?; + pw.set_target(*y, y_val)?; + pw.set_bool_target(*b, b_val)?; + pw.set_target(*result, expected)?; + } else { + let x_val = F::rand(); + let y_val = F::rand(); + let b_val = false; + let expected = y_val; + + pw.set_target(*x, x_val)?; + pw.set_target(*y, y_val)?; + pw.set_bool_target(*b, b_val)?; + pw.set_target(*result, expected)?; + } + + } + + let proof = circuit_data.prove(pw)?; + circuit_data.verify(proof)?; + + Ok(()) + + + } + + flag_test(63)?; // flag enabled + flag_test(31)?; // flag disabled + + Ok(()) + + } + + + #[test] + #[should_panic] + fn test_failure() { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + fn flag_test(flag: usize) { + let config = CircuitConfig { + optimization_flags: flag, + ..CircuitConfig::standard_recursion_config() + }; + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = SelectionGate::new_from_config(&config); + let ref_gate = gate.clone(); + + for _ in 0..100 { + let b = builder.add_virtual_bool_target_safe(); + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + + let (row, i) = builder.find_slot(gate.clone(), &[], &[]); + + builder.connect(b.target, Target::wire(row, ref_gate.wire_ith_selector(i))); + builder.connect(x, Target::wire(row, ref_gate.wire_ith_element_0(i))); + builder.connect(y, Target::wire(row, ref_gate.wire_ith_element_1(i))); + + let output = Target::wire(row, ref_gate.wire_ith_output(i)); + let result = builder.add_virtual_target(); + builder.connect(result, output); + + pairs.push((b, x, y, result)); + } + + let circuit_data = builder.build::(); + let mut pw = PartialWitness::new(); + + for (i, (b, x, y, result)) in pairs.iter().enumerate() { + + if i < 50 { + let x_val = F::rand(); + let y_val = F::rand(); + let b_val = true; + let expected = x_val; + let mut incorrect_value = F::rand(); + while incorrect_value == expected { + incorrect_value = F::rand(); + } + + pw.set_target(*x, x_val).unwrap(); + pw.set_target(*y, y_val).unwrap(); + pw.set_bool_target(*b, b_val).unwrap(); + pw.set_target(*result, incorrect_value).unwrap(); + } else { + let x_val = F::rand(); + let y_val = F::rand(); + let b_val = false; + let expected = y_val; + let mut incorrect_value = F::rand(); + while incorrect_value == expected { + incorrect_value = F::rand(); + } + + pw.set_target(*x, x_val).unwrap(); + pw.set_target(*y, y_val).unwrap(); + pw.set_bool_target(*b, b_val).unwrap(); + pw.set_target(*result, incorrect_value).unwrap(); + } + + } + + let proof = circuit_data.prove(pw).unwrap(); + circuit_data.verify(proof).unwrap(); + + + + } + + flag_test(63); // flag enabled + flag_test(31); // flag disabled + + } } From a6a6ce882358b4e378b5488a87a153f7cc1596bd Mon Sep 17 00:00:00 2001 From: cezarapetrui19 Date: Wed, 9 Jul 2025 13:01:46 +0300 Subject: [PATCH 2/3] serialization tests --- plonky2/src/gates/addition_base.rs | 81 ++++++++++++++++ plonky2/src/gates/equality_base.rs | 93 +++++++++++++++++++ plonky2/src/gates/multiplication_base.rs | 74 +++++++++++++++ plonky2/src/gates/select_base.rs | 92 ++++++++++++++++++ .../util/serialization/gate_serialization.rs | 4 +- 5 files changed, 343 insertions(+), 1 deletion(-) diff --git a/plonky2/src/gates/addition_base.rs b/plonky2/src/gates/addition_base.rs index f0fa13b8..962fc7ab 100644 --- a/plonky2/src/gates/addition_base.rs +++ b/plonky2/src/gates/addition_base.rs @@ -255,6 +255,9 @@ mod tests { use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; + use crate::util::serialization::DefaultGateSerializer; + use crate::util::serialization::DefaultGeneratorSerializer; + use crate::plonk::circuit_data::CircuitData; #[test] fn low_degree() { @@ -395,4 +398,82 @@ mod tests { } + + #[test] + fn test_serialization_addition() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + + let config = CircuitConfig::standard_recursion_config(); + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = AdditionGate::new_from_config(&config); + let constants = [F::ONE, F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i)); + let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i)); + let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_output); + + pairs.push((x, y, output_value)); + } + + let circuit_data = builder.build::(); + // let filename = "test_circuit"; + let gate_serializer = DefaultGateSerializer; + let generator_serializer = DefaultGeneratorSerializer::::default(); + + let data_bytes = circuit_data + .to_bytes(&gate_serializer, &generator_serializer) + .map_err(|_| anyhow::Error::msg("Serialization failed."))?; + + // fs::write(filename, &data_bytes)?; + + // let read_data_bytes = fs::read(filename)?; + + let deserialized_circuit_data = CircuitData::::from_bytes( + &data_bytes, + &gate_serializer, + &generator_serializer, + ) + .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; + + assert_eq!( + deserialized_circuit_data, circuit_data + ); + + let mut pw = PartialWitness::new(); + + for (x, y, output_value) in pairs.iter() { + let value1 = F::rand(); + let value2 = F::rand(); + let expected = value1 + value2; + + pw.set_target(*x, value1)?; + pw.set_target(*y, value2)?; + pw.set_target(*output_value, expected)?; + } + + let proof = deserialized_circuit_data.prove(pw.clone())?; + deserialized_circuit_data.verify(proof.clone())?; + + // std::fs::remove_file(filename)?; + + Ok(()) } + +} \ No newline at end of file diff --git a/plonky2/src/gates/equality_base.rs b/plonky2/src/gates/equality_base.rs index 648bd331..2b6df4bf 100644 --- a/plonky2/src/gates/equality_base.rs +++ b/plonky2/src/gates/equality_base.rs @@ -296,6 +296,9 @@ mod tests { use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; use plonky2_field::types::Sample; + use crate::util::serialization::DefaultGateSerializer; + use crate::util::serialization::DefaultGeneratorSerializer; + use crate::plonk::circuit_data::CircuitData; #[test] fn low_degree() { @@ -511,4 +514,94 @@ mod tests { Ok(()) } + + #[test] + fn test_serialization_equality() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + let config = CircuitConfig::standard_recursion_config(); + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = EqualityGate::new_from_config(&config); + let ref_gate = gate.clone(); + let constants = [F::ONE]; + + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, ref_gate.wire_ith_element_0(i)); + let wire_y = Target::wire(gate_row, ref_gate.wire_ith_element_1(i)); + let wire_equal = Target::wire(gate_row, ref_gate.wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_equal); + + pairs.push((x, y, output_value)); + + } + + let circuit_data = builder.build::(); + let gate_serializer = DefaultGateSerializer; + let generator_serializer = DefaultGeneratorSerializer::::default(); + + let data_bytes = circuit_data + .to_bytes(&gate_serializer, &generator_serializer) + .map_err(|_| anyhow::Error::msg("Serialization failed."))?; + + + let deserialized_circuit_data = CircuitData::::from_bytes( + &data_bytes, + &gate_serializer, + &generator_serializer, + ) + .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; + + assert_eq!( + deserialized_circuit_data, circuit_data + ); + + let mut pw = PartialWitness::new(); + + for (i, (x, y, output_value)) in pairs.iter().enumerate() { + if i < 50 { + let value = F::rand(); + pw.set_target(*x, value)?; + pw.set_target(*y, value)?; + let expected = F::ONE; + + pw.set_target(*output_value, expected)?; + } else { + let value1 = F::rand(); + let mut value2 = F::rand(); + + while value2 == value1 { + value2 = F::rand(); + } + + pw.set_target(*x, value1)?; + pw.set_target(*y, value2)?; + let expected = F::ZERO; + pw.set_target(*output_value, expected)?; + } + + } + + let proof = circuit_data.prove(pw.clone())?; + circuit_data.verify(proof.clone())?; + + Ok(()) + + } + + } diff --git a/plonky2/src/gates/multiplication_base.rs b/plonky2/src/gates/multiplication_base.rs index 8bd4f8bd..3727d002 100644 --- a/plonky2/src/gates/multiplication_base.rs +++ b/plonky2/src/gates/multiplication_base.rs @@ -244,6 +244,10 @@ mod tests { use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; + use crate::util::serialization::DefaultGeneratorSerializer; + use crate::plonk::circuit_data::CircuitData; + use crate::util::serialization::DefaultGateSerializer; + #[test] fn low_degree() { @@ -388,4 +392,74 @@ mod tests { } + + #[test] + fn test_serialization_multiplication() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + let config = CircuitConfig::standard_recursion_config(); + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = MultiplicationGate::new_from_config(&config); + let constants = [F::ONE]; + + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); + + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + + let wire_x = Target::wire(gate_row, MultiplicationGate::wire_ith_multiplicand_0(i)); + let wire_y = Target::wire(gate_row, MultiplicationGate::wire_ith_multiplicand_1(i)); + let wire_output = Target::wire(gate_row, MultiplicationGate::wire_ith_output(i)); + + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_output); + + pairs.push((x,y, output_value)); + } + + let circuit_data = builder.build::(); + let gate_serializer = DefaultGateSerializer; + let generator_serializer = DefaultGeneratorSerializer::::default(); + + let data_bytes = circuit_data + .to_bytes(&gate_serializer, &generator_serializer) + .map_err(|_| anyhow::Error::msg("Serialization failed."))?; + + let deserialized_circuit_data = CircuitData::::from_bytes( + &data_bytes, + &gate_serializer, + &generator_serializer, + ) + .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; + + assert_eq!( + deserialized_circuit_data, circuit_data + ); + + let mut pw = PartialWitness::new(); + + for (x, y, output_value) in pairs.iter() { + let value1 = F::rand(); + let value2 = F::rand(); + let expected = value1 * value2; + + pw.set_target(*x, value1)?; + pw.set_target(*y, value2)?; + pw.set_target(*output_value, expected)?; + } + + let proof = deserialized_circuit_data.prove(pw)?; + deserialized_circuit_data.verify(proof)?; + + Ok(()) + + } } diff --git a/plonky2/src/gates/select_base.rs b/plonky2/src/gates/select_base.rs index a4820241..3a51e0da 100644 --- a/plonky2/src/gates/select_base.rs +++ b/plonky2/src/gates/select_base.rs @@ -281,6 +281,10 @@ mod tests { use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; use plonky2_field::types::Sample; + use crate::util::serialization::DefaultGeneratorSerializer; + use crate::plonk::circuit_data::CircuitData; + use crate::util::serialization::DefaultGateSerializer; + #[test] fn low_degree() { @@ -500,4 +504,92 @@ mod tests { flag_test(31); // flag disabled } + + #[test] + fn test_serialization_select() -> Result<()> { + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + + let config = CircuitConfig::standard_recursion_config(); + let mut builder = CircuitBuilder::::new(config.clone()); + + let mut pairs = Vec::new(); + + let gate = SelectionGate::new_from_config(&config); + let ref_gate = gate.clone(); + + for _ in 0..100 { + let b = builder.add_virtual_bool_target_safe(); + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + + let (row, i) = builder.find_slot(gate.clone(), &[], &[]); + + builder.connect(b.target, Target::wire(row, ref_gate.wire_ith_selector(i))); + builder.connect(x, Target::wire(row, ref_gate.wire_ith_element_0(i))); + builder.connect(y, Target::wire(row, ref_gate.wire_ith_element_1(i))); + + let output = Target::wire(row, ref_gate.wire_ith_output(i)); + let result = builder.add_virtual_target(); + builder.connect(result, output); + + pairs.push((b, x, y, result)); + } + + let circuit_data = builder.build::(); + let gate_serializer = DefaultGateSerializer; + let generator_serializer = DefaultGeneratorSerializer::::default(); + + let data_bytes = circuit_data + .to_bytes(&gate_serializer, &generator_serializer) + .map_err(|_| anyhow::Error::msg("Serialization failed."))?; + + let deserialized_circuit_data = CircuitData::::from_bytes( + &data_bytes, + &gate_serializer, + &generator_serializer, + ) + .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; + + assert_eq!( + deserialized_circuit_data, circuit_data + ); + + let mut pw = PartialWitness::new(); + + for (i, (b, x, y, result)) in pairs.iter().enumerate() { + + if i < 50 { + let x_val = F::rand(); + let y_val = F::rand(); + let b_val = true; + let expected = x_val; + + pw.set_target(*x, x_val)?; + pw.set_target(*y, y_val)?; + pw.set_bool_target(*b, b_val)?; + pw.set_target(*result, expected)?; + } else { + let x_val = F::rand(); + let y_val = F::rand(); + let b_val = false; + let expected = y_val; + + pw.set_target(*x, x_val)?; + pw.set_target(*y, y_val)?; + pw.set_bool_target(*b, b_val)?; + pw.set_target(*result, expected)?; + } + + } + + let proof = deserialized_circuit_data.prove(pw.clone())?; + deserialized_circuit_data.verify(proof.clone())?; + + Ok(()) + + } + + } diff --git a/plonky2/src/util/serialization/gate_serialization.rs b/plonky2/src/util/serialization/gate_serialization.rs index 46f60b9f..936726ea 100644 --- a/plonky2/src/util/serialization/gate_serialization.rs +++ b/plonky2/src/util/serialization/gate_serialization.rs @@ -115,6 +115,7 @@ pub mod default { use crate::gates::random_access::RandomAccessGate; use crate::gates::reducing::ReducingGate; use crate::gates::reducing_extension::ReducingExtensionGate; + use crate::gates::select_base::SelectionGate; use crate::hash::hash_types::RichField; use crate::util::serialization::GateSerializer; /// A gate serializer that can be used to serialize all default gates supported @@ -149,7 +150,8 @@ pub mod default { PublicInputGate, RandomAccessGate, ReducingExtensionGate, - ReducingGate + ReducingGate, + SelectionGate } } } From c7c25af308e76d0b29015c12078390fa25d20d49 Mon Sep 17 00:00:00 2001 From: Irfan Bozkurt Date: Thu, 10 Jul 2025 11:19:33 -0400 Subject: [PATCH 3/3] clippy and tests --- plonky2/src/batch_fri/oracle.rs | 2 +- plonky2/src/fri/validate_shape.rs | 2 +- plonky2/src/gates/addition_base.rs | 146 +++++++++++------------ plonky2/src/gates/equality_base.rs | 57 +++------ plonky2/src/gates/multiplication_base.rs | 56 ++++----- plonky2/src/gates/select_base.rs | 42 ++----- plonky2/src/hash/merkle_proofs.rs | 2 +- 7 files changed, 119 insertions(+), 188 deletions(-) diff --git a/plonky2/src/batch_fri/oracle.rs b/plonky2/src/batch_fri/oracle.rs index 58deeaa3..1f34cfef 100644 --- a/plonky2/src/batch_fri/oracle.rs +++ b/plonky2/src/batch_fri/oracle.rs @@ -460,7 +460,7 @@ mod test { &fri_instances, &fri_openings, &fri_challenges, - &[merkle_cap.clone()], + std::slice::from_ref(&merkle_cap), &proof, &fri_params, )?; diff --git a/plonky2/src/fri/validate_shape.rs b/plonky2/src/fri/validate_shape.rs index be675ed6..8805478f 100644 --- a/plonky2/src/fri/validate_shape.rs +++ b/plonky2/src/fri/validate_shape.rs @@ -20,7 +20,7 @@ where F: RichField + Extendable, C: GenericConfig, { - validate_batch_fri_proof_shape::(proof, &[instance.clone()], params) + validate_batch_fri_proof_shape::(proof, std::slice::from_ref(instance), params) } pub(crate) fn validate_batch_fri_proof_shape( diff --git a/plonky2/src/gates/addition_base.rs b/plonky2/src/gates/addition_base.rs index 962fc7ab..38cc04a9 100644 --- a/plonky2/src/gates/addition_base.rs +++ b/plonky2/src/gates/addition_base.rs @@ -1,7 +1,5 @@ extern crate alloc; use alloc::string::ToString; -#[cfg(not(feature = "std"))] -use alloc::{format, string::String, vec::Vec}; use anyhow::Result; @@ -253,11 +251,9 @@ mod tests { use crate::iop::target::Target; use crate::iop::witness::{PartialWitness, WitnessWrite}; use crate::plonk::circuit_builder::CircuitBuilder; - use crate::plonk::circuit_data::CircuitConfig; + use crate::plonk::circuit_data::{CircuitConfig, CircuitData}; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; - use crate::util::serialization::DefaultGateSerializer; - use crate::util::serialization::DefaultGeneratorSerializer; - use crate::plonk::circuit_data::CircuitData; + use crate::util::serialization::{DefaultGateSerializer, DefaultGeneratorSerializer}; #[test] fn low_degree() { @@ -287,8 +283,8 @@ mod tests { }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); - + let mut pairs = vec![]; + let gate = AdditionGate::new_from_config(&config); let constants = [F::ONE, F::ONE]; @@ -307,13 +303,13 @@ mod tests { builder.connect(y, wire_y); builder.connect(output_value, wire_output); - pairs.push((x,y, output_value)); + pairs.push((x, y, output_value)); } - + let circuit_data = builder.build::(); let mut pw = PartialWitness::new(); - for (_, (x,y, output_value)) in pairs.iter().enumerate() { + for (x, y, output_value) in pairs.iter() { let value1 = F::rand(); let value2 = F::rand(); let expected = value1 + value2; @@ -348,8 +344,8 @@ mod tests { }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); - + let mut pairs = vec![]; + let gate = AdditionGate::new_from_config(&config); let constants = [F::ONE, F::ONE]; @@ -368,13 +364,13 @@ mod tests { builder.connect(y, wire_y); builder.connect(output_value, wire_output); - pairs.push((x,y, output_value)); + pairs.push((x, y, output_value)); } - + let circuit_data = builder.build::(); let mut pw = PartialWitness::new(); - for (_, (x,y, output_value)) in pairs.iter().enumerate() { + for (x, y, output_value) in pairs.iter() { let value1 = F::rand(); let value2 = F::rand(); let expected = value1 + value2; @@ -389,91 +385,83 @@ mod tests { let proof = circuit_data.prove(pw).unwrap(); circuit_data.verify(proof).unwrap(); - } flag_test(63); // flag enabled flag_test(62); // flag disabled - - } - #[test] fn test_serialization_addition() -> Result<()> { - const D: usize = 2; - type C = PoseidonGoldilocksConfig; - type F = >::F; - + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; - let config = CircuitConfig::standard_recursion_config(); - let mut builder = CircuitBuilder::::new(config.clone()); + let config = CircuitConfig::standard_recursion_config(); + let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; - let gate = AdditionGate::new_from_config(&config); - let constants = [F::ONE, F::ONE]; + let gate = AdditionGate::new_from_config(&config); + let constants = [F::ONE, F::ONE]; - for _ in 0..100 { - let x = builder.add_virtual_target(); - let y = builder.add_virtual_target(); - let output_value = builder.add_virtual_target(); + for _ in 0..100 { + let x = builder.add_virtual_target(); + let y = builder.add_virtual_target(); + let output_value = builder.add_virtual_target(); - let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); + let (gate_row, i) = builder.find_slot(gate.clone(), &constants, &constants); - let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i)); - let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i)); - let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i)); + let wire_x = Target::wire(gate_row, AdditionGate::wire_ith_addend_0(i)); + let wire_y = Target::wire(gate_row, AdditionGate::wire_ith_addend_1(i)); + let wire_output = Target::wire(gate_row, AdditionGate::wire_ith_output(i)); - builder.connect(x, wire_x); - builder.connect(y, wire_y); - builder.connect(output_value, wire_output); + builder.connect(x, wire_x); + builder.connect(y, wire_y); + builder.connect(output_value, wire_output); - pairs.push((x, y, output_value)); - } + pairs.push((x, y, output_value)); + } - let circuit_data = builder.build::(); - // let filename = "test_circuit"; - let gate_serializer = DefaultGateSerializer; - let generator_serializer = DefaultGeneratorSerializer::::default(); + let circuit_data = builder.build::(); + // let filename = "test_circuit"; + let gate_serializer = DefaultGateSerializer; + let generator_serializer = DefaultGeneratorSerializer::::default(); - let data_bytes = circuit_data + let data_bytes = circuit_data .to_bytes(&gate_serializer, &generator_serializer) .map_err(|_| anyhow::Error::msg("Serialization failed."))?; - // fs::write(filename, &data_bytes)?; - - // let read_data_bytes = fs::read(filename)?; - - let deserialized_circuit_data = CircuitData::::from_bytes( - &data_bytes, - &gate_serializer, - &generator_serializer, - ) - .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; - - assert_eq!( - deserialized_circuit_data, circuit_data - ); - - let mut pw = PartialWitness::new(); - - for (x, y, output_value) in pairs.iter() { - let value1 = F::rand(); - let value2 = F::rand(); - let expected = value1 + value2; - - pw.set_target(*x, value1)?; - pw.set_target(*y, value2)?; - pw.set_target(*output_value, expected)?; - } + // fs::write(filename, &data_bytes)?; - let proof = deserialized_circuit_data.prove(pw.clone())?; - deserialized_circuit_data.verify(proof.clone())?; + // let read_data_bytes = fs::read(filename)?; - // std::fs::remove_file(filename)?; + let deserialized_circuit_data = CircuitData::::from_bytes( + &data_bytes, + &gate_serializer, + &generator_serializer, + ) + .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; - Ok(()) -} + assert_eq!(deserialized_circuit_data, circuit_data); + + let mut pw = PartialWitness::new(); + + for (x, y, output_value) in pairs.iter() { + let value1 = F::rand(); + let value2 = F::rand(); + let expected = value1 + value2; + + pw.set_target(*x, value1)?; + pw.set_target(*y, value2)?; + pw.set_target(*output_value, expected)?; + } + + let proof = deserialized_circuit_data.prove(pw.clone())?; + deserialized_circuit_data.verify(proof.clone())?; + + // std::fs::remove_file(filename)?; -} \ No newline at end of file + Ok(()) + } +} diff --git a/plonky2/src/gates/equality_base.rs b/plonky2/src/gates/equality_base.rs index 2b6df4bf..b09625c8 100644 --- a/plonky2/src/gates/equality_base.rs +++ b/plonky2/src/gates/equality_base.rs @@ -283,6 +283,7 @@ impl, const D: usize> SimpleGenerator #[cfg(test)] mod tests { use anyhow::Result; + use plonky2_field::types::Sample; use crate::field::goldilocks_field::GoldilocksField; use crate::field::types::Field; @@ -293,12 +294,9 @@ mod tests { use crate::iop::target::{BoolTarget, Target}; use crate::iop::witness::{PartialWitness, WitnessWrite}; use crate::plonk::circuit_builder::CircuitBuilder; - use crate::plonk::circuit_data::CircuitConfig; + use crate::plonk::circuit_data::{CircuitConfig, CircuitData}; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; - use plonky2_field::types::Sample; - use crate::util::serialization::DefaultGateSerializer; - use crate::util::serialization::DefaultGeneratorSerializer; - use crate::plonk::circuit_data::CircuitData; + use crate::util::serialization::{DefaultGateSerializer, DefaultGeneratorSerializer}; #[test] fn low_degree() { @@ -361,7 +359,6 @@ mod tests { Ok(()) } - #[test] #[should_panic] fn test_failure() { @@ -376,7 +373,7 @@ mod tests { }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = EqualityGate::new_from_config(&config); let ref_gate = gate.clone(); let constants = [F::ONE]; @@ -397,7 +394,6 @@ mod tests { builder.connect(output_value, wire_equal); pairs.push((x, y, output_value)); - } let circuit_data = builder.build::(); @@ -413,29 +409,24 @@ mod tests { } else { let value1 = F::rand(); let mut value2 = F::rand(); - + while value2 == value1 { value2 = F::rand(); } - + pw.set_target(*x, value1).unwrap(); pw.set_target(*y, value2).unwrap(); let incorrect_value = F::ONE; pw.set_target(*output_value, incorrect_value).unwrap(); } - } - + let proof = circuit_data.prove(pw).unwrap(); circuit_data.verify(proof).unwrap(); - } flag_test(63); // flag enabled flag_test(55); // flag disabled - - - } #[test] @@ -451,7 +442,7 @@ mod tests { }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = EqualityGate::new_from_config(&config); let ref_gate = gate.clone(); let constants = [F::ONE]; @@ -472,7 +463,6 @@ mod tests { builder.connect(output_value, wire_equal); pairs.push((x, y, output_value)); - } let circuit_data = builder.build::(); @@ -489,19 +479,18 @@ mod tests { } else { let value1 = F::rand(); let mut value2 = F::rand(); - + while value2 == value1 { value2 = F::rand(); } - + pw.set_target(*x, value1)?; pw.set_target(*y, value2)?; let expected = F::ZERO; pw.set_target(*output_value, expected)?; } - } - + let proof = circuit_data.prove(pw)?; circuit_data.verify(proof)?; @@ -512,7 +501,6 @@ mod tests { flag_test(55)?; // flag disabled Ok(()) - } #[test] @@ -524,13 +512,12 @@ mod tests { let config = CircuitConfig::standard_recursion_config(); let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = EqualityGate::new_from_config(&config); let ref_gate = gate.clone(); let constants = [F::ONE]; - for _ in 0..100 { let x = builder.add_virtual_target(); let y = builder.add_virtual_target(); @@ -547,7 +534,6 @@ mod tests { builder.connect(output_value, wire_equal); pairs.push((x, y, output_value)); - } let circuit_data = builder.build::(); @@ -555,9 +541,8 @@ mod tests { let generator_serializer = DefaultGeneratorSerializer::::default(); let data_bytes = circuit_data - .to_bytes(&gate_serializer, &generator_serializer) - .map_err(|_| anyhow::Error::msg("Serialization failed."))?; - + .to_bytes(&gate_serializer, &generator_serializer) + .map_err(|_| anyhow::Error::msg("Serialization failed."))?; let deserialized_circuit_data = CircuitData::::from_bytes( &data_bytes, @@ -566,9 +551,7 @@ mod tests { ) .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; - assert_eq!( - deserialized_circuit_data, circuit_data - ); + assert_eq!(deserialized_circuit_data, circuit_data); let mut pw = PartialWitness::new(); @@ -583,25 +566,21 @@ mod tests { } else { let value1 = F::rand(); let mut value2 = F::rand(); - + while value2 == value1 { value2 = F::rand(); } - + pw.set_target(*x, value1)?; pw.set_target(*y, value2)?; let expected = F::ZERO; pw.set_target(*output_value, expected)?; } - } - + let proof = circuit_data.prove(pw.clone())?; circuit_data.verify(proof.clone())?; Ok(()) - } - - } diff --git a/plonky2/src/gates/multiplication_base.rs b/plonky2/src/gates/multiplication_base.rs index 3727d002..f73516f3 100644 --- a/plonky2/src/gates/multiplication_base.rs +++ b/plonky2/src/gates/multiplication_base.rs @@ -237,17 +237,14 @@ mod tests { use crate::field::types::Field; #[allow(unused_imports)] use crate::field::types::Field64; - use crate::gates::multiplication_base::MultiplicationGate; use crate::gates::gate_testing::{test_eval_fns, test_low_degree}; + use crate::gates::multiplication_base::MultiplicationGate; use crate::iop::target::Target; use crate::iop::witness::{PartialWitness, WitnessWrite}; use crate::plonk::circuit_builder::CircuitBuilder; - use crate::plonk::circuit_data::CircuitConfig; + use crate::plonk::circuit_data::{CircuitConfig, CircuitData}; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; - use crate::util::serialization::DefaultGeneratorSerializer; - use crate::plonk::circuit_data::CircuitData; - use crate::util::serialization::DefaultGateSerializer; - + use crate::util::serialization::{DefaultGateSerializer, DefaultGeneratorSerializer}; #[test] fn low_degree() { @@ -277,7 +274,7 @@ mod tests { }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = MultiplicationGate::new_from_config(&config); let constants = [F::ONE]; @@ -297,13 +294,13 @@ mod tests { builder.connect(y, wire_y); builder.connect(output_value, wire_output); - pairs.push((x,y, output_value)); + pairs.push((x, y, output_value)); } - + let circuit_data = builder.build::(); let mut pw = PartialWitness::new(); - for (_, (x,y, output_value)) in pairs.iter().enumerate() { + for (x, y, output_value) in pairs.iter() { let value1 = F::rand(); let value2 = F::rand(); let expected = value1 * value2; @@ -316,31 +313,29 @@ mod tests { circuit_data.verify(proof)?; Ok(()) - } - + flag_test(63)?; // flag enabled flag_test(61)?; // flag disabled Ok(()) } - #[test] #[should_panic] - fn test_failure() { + fn test_failure() { const D: usize = 2; type C = PoseidonGoldilocksConfig; type F = >::F; - fn flag_test(flag: usize) { + fn flag_test(flag: usize) { let config = CircuitConfig { optimization_flags: flag, ..CircuitConfig::standard_recursion_config() }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = MultiplicationGate::new_from_config(&config); let constants = [F::ONE]; @@ -360,13 +355,13 @@ mod tests { builder.connect(y, wire_y); builder.connect(output_value, wire_output); - pairs.push((x,y, output_value)); + pairs.push((x, y, output_value)); } - + let circuit_data = builder.build::(); let mut pw = PartialWitness::new(); - for (_, (x,y, output_value)) in pairs.iter().enumerate() { + for (x, y, output_value) in pairs.iter() { let value1 = F::rand(); let value2 = F::rand(); let expected = value1 * value2; @@ -379,18 +374,12 @@ mod tests { pw.set_target(*output_value, incorrect_value).unwrap(); } - let proof = circuit_data.prove(pw).unwrap(); circuit_data.verify(proof).unwrap(); - - - } - + flag_test(63); // flag enabled flag_test(61); // flag disabled - - } #[test] @@ -402,7 +391,7 @@ mod tests { let config = CircuitConfig::standard_recursion_config(); let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = MultiplicationGate::new_from_config(&config); let constants = [F::ONE]; @@ -422,7 +411,7 @@ mod tests { builder.connect(y, wire_y); builder.connect(output_value, wire_output); - pairs.push((x,y, output_value)); + pairs.push((x, y, output_value)); } let circuit_data = builder.build::(); @@ -440,9 +429,7 @@ mod tests { ) .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; - assert_eq!( - deserialized_circuit_data, circuit_data - ); + assert_eq!(deserialized_circuit_data, circuit_data); let mut pw = PartialWitness::new(); @@ -450,16 +437,15 @@ mod tests { let value1 = F::rand(); let value2 = F::rand(); let expected = value1 * value2; - + pw.set_target(*x, value1)?; pw.set_target(*y, value2)?; pw.set_target(*output_value, expected)?; } - + let proof = deserialized_circuit_data.prove(pw)?; deserialized_circuit_data.verify(proof)?; - - Ok(()) + Ok(()) } } diff --git a/plonky2/src/gates/select_base.rs b/plonky2/src/gates/select_base.rs index 3a51e0da..eb6de52e 100644 --- a/plonky2/src/gates/select_base.rs +++ b/plonky2/src/gates/select_base.rs @@ -268,6 +268,7 @@ impl, const D: usize> SimpleGenerator #[cfg(test)] mod tests { use anyhow::Result; + use plonky2_field::types::Sample; use crate::field::goldilocks_field::GoldilocksField; use crate::field::types::Field; @@ -278,13 +279,9 @@ mod tests { use crate::iop::target::Target; use crate::iop::witness::{PartialWitness, WitnessWrite}; use crate::plonk::circuit_builder::CircuitBuilder; - use crate::plonk::circuit_data::CircuitConfig; + use crate::plonk::circuit_data::{CircuitConfig, CircuitData}; use crate::plonk::config::{GenericConfig, PoseidonGoldilocksConfig}; - use plonky2_field::types::Sample; - use crate::util::serialization::DefaultGeneratorSerializer; - use crate::plonk::circuit_data::CircuitData; - use crate::util::serialization::DefaultGateSerializer; - + use crate::util::serialization::{DefaultGateSerializer, DefaultGeneratorSerializer}; #[test] fn low_degree() { @@ -351,7 +348,7 @@ mod tests { }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = SelectionGate::new_from_config(&config); let ref_gate = gate.clone(); @@ -378,7 +375,6 @@ mod tests { let mut pw = PartialWitness::new(); for (i, (b, x, y, result)) in pairs.iter().enumerate() { - if i < 50 { let x_val = F::rand(); let y_val = F::rand(); @@ -400,25 +396,20 @@ mod tests { pw.set_bool_target(*b, b_val)?; pw.set_target(*result, expected)?; } - } let proof = circuit_data.prove(pw)?; circuit_data.verify(proof)?; Ok(()) - - } - + flag_test(63)?; // flag enabled flag_test(31)?; // flag disabled Ok(()) - } - #[test] #[should_panic] fn test_failure() { @@ -433,7 +424,7 @@ mod tests { }; let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = SelectionGate::new_from_config(&config); let ref_gate = gate.clone(); @@ -460,7 +451,6 @@ mod tests { let mut pw = PartialWitness::new(); for (i, (b, x, y, result)) in pairs.iter().enumerate() { - if i < 50 { let x_val = F::rand(); let y_val = F::rand(); @@ -490,19 +480,14 @@ mod tests { pw.set_bool_target(*b, b_val).unwrap(); pw.set_target(*result, incorrect_value).unwrap(); } - } let proof = circuit_data.prove(pw).unwrap(); circuit_data.verify(proof).unwrap(); - - - } - + flag_test(63); // flag enabled flag_test(31); // flag disabled - } #[test] @@ -514,7 +499,7 @@ mod tests { let config = CircuitConfig::standard_recursion_config(); let mut builder = CircuitBuilder::::new(config.clone()); - let mut pairs = Vec::new(); + let mut pairs = vec![]; let gate = SelectionGate::new_from_config(&config); let ref_gate = gate.clone(); @@ -552,14 +537,11 @@ mod tests { ) .map_err(|_| anyhow::Error::msg("Deserialization failed."))?; - assert_eq!( - deserialized_circuit_data, circuit_data - ); + assert_eq!(deserialized_circuit_data, circuit_data); let mut pw = PartialWitness::new(); for (i, (b, x, y, result)) in pairs.iter().enumerate() { - if i < 50 { let x_val = F::rand(); let y_val = F::rand(); @@ -581,15 +563,11 @@ mod tests { pw.set_bool_target(*b, b_val)?; pw.set_target(*result, expected)?; } - } let proof = deserialized_circuit_data.prove(pw.clone())?; deserialized_circuit_data.verify(proof.clone())?; - - Ok(()) + Ok(()) } - - } diff --git a/plonky2/src/hash/merkle_proofs.rs b/plonky2/src/hash/merkle_proofs.rs index 424e03ae..16791911 100644 --- a/plonky2/src/hash/merkle_proofs.rs +++ b/plonky2/src/hash/merkle_proofs.rs @@ -59,7 +59,7 @@ pub fn verify_merkle_proof_to_cap>( proof: &MerkleProof, ) -> Result<()> { verify_batch_merkle_proof_to_cap( - &[leaf_data.clone()], + std::slice::from_ref(&leaf_data), &[proof.siblings.len()], leaf_index, merkle_cap,