logos-storage/proof-aggregation
1
0
Fork 0
mirror of https://github.com/logos-storage/proof-aggregation.git synced 2026-01-07 16:23:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

add monolith serialization tests

Browse Source
This commit is contained in:
M Alghazwi 2025-07-09 10:06:03 +02:00
parent fb668429ec
commit 0b7561d814
No known key found for this signature in database
GPG Key ID: 646E567CAD7DB607
1 changed files with 124 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

244
proof-input/tests/serialization.rs
View File

@ -1,20 +1,13 @@
use plonky2::hash::poseidon::PoseidonHash;
use plonky2::plonk::config::PoseidonGoldilocksConfig;
use plonky2_field::goldilocks_field::GoldilocksField; use plonky2_field::goldilocks_field::GoldilocksField;
use proof_input::params::Params;
// types used in all tests // types used in all tests
type F = GoldilocksField; type F = GoldilocksField;
const D: usize = 2; const D: usize = 2;
type H = PoseidonHash;
type C = PoseidonGoldilocksConfig;
#[cfg(test)] pub(crate) mod serialization_test_functions {
mod serialization_tests {
use super::*; use super::*;
use codex_plonky2_circuits::circuits::sample_cells::{SampleCircuit, SampleCircuitInput}; use codex_plonky2_circuits::circuits::sample_cells::SampleCircuitInput;
use plonky2::plonk::circuit_data::{CircuitConfig, ProverCircuitData, VerifierCircuitData}; use plonky2::plonk::circuit_data::{CircuitConfig, CircuitData};
use codex_plonky2_circuits::circuit_trait::Plonky2Circuit;
use proof_input::input_generator::InputGenerator; use proof_input::input_generator::InputGenerator;
use proof_input::input_generator::serialization::{export_circ_input_to_json, import_circ_input_from_json}; use proof_input::input_generator::serialization::{export_circ_input_to_json, import_circ_input_from_json};
use std::path::Path; use std::path::Path;
@ -22,23 +15,25 @@ mod serialization_tests {
use plonky2::iop::target::Target; use plonky2::iop::target::Target;
use plonky2::iop::witness::{PartialWitness, WitnessWrite}; use plonky2::iop::witness::{PartialWitness, WitnessWrite};
use plonky2::plonk::circuit_builder::CircuitBuilder; use plonky2::plonk::circuit_builder::CircuitBuilder;
use plonky2::plonk::config::PoseidonGoldilocksConfig; use plonky2::plonk::config::{AlgebraicHasher, GenericConfig, Hasher};
use plonky2::plonk::proof::ProofWithPublicInputs; use plonky2::plonk::proof::ProofWithPublicInputs;
use plonky2_field::goldilocks_field::GoldilocksField;
use plonky2_field::types::Field; use plonky2_field::types::Field;
use codex_plonky2_circuits::serialization::{export_circuit_data, export_proof_with_pi, import_proof_with_pi, import_prover_circuit_data, import_targets, import_verifier_circuit_data}; use serde::Serialize;
use codex_plonky2_circuits::serialization::{export_circuit_data, export_proof_with_pi, import_circuit_data, import_proof_with_pi, import_targets};
#[test] pub(crate) const CIRC_BASE_PATH: &str = "../output/test/circuit/";
fn test_export_and_import_circuit_data_roundtrip() -> anyhow::Result<()> {
use serde::Serialize;
#[derive(Clone, Debug, PartialEq, Serialize, serde::Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, serde::Deserialize)]
struct DummyTargets { struct DummyTargets {
a: Target, a: Target,
} }
let conf = CircuitConfig::standard_recursion_config(); fn dummy_circuit<C: GenericConfig<D, F = F> + Serialize + Default + 'static>(
let mut builder = CircuitBuilder::<F, D>::new(conf); config: CircuitConfig,
) -> anyhow::Result<(CircuitData<F, C, D>, ProofWithPublicInputs<F, C, D>, DummyTargets)> where
<C as GenericConfig<D>>::Hasher: AlgebraicHasher<F>,
{
let mut builder = CircuitBuilder::<F, D>::new(config);
for _ in 0..128 { for _ in 0..128 {
builder.add_gate(NoopGate, vec![]); builder.add_gate(NoopGate, vec![]);
} }
@ -49,49 +44,53 @@ mod serialization_tests {
pw.set_target(t, F::ZERO).expect("faulty assign"); pw.set_target(t, F::ZERO).expect("faulty assign");
let dummy_inner_proof = dummy_circuit.prove(pw).unwrap(); let dummy_inner_proof = dummy_circuit.prove(pw).unwrap();
assert!(dummy_circuit.verify(dummy_inner_proof.clone()).is_ok()); assert!(dummy_circuit.verify(dummy_inner_proof.clone()).is_ok());
let dummy_t = DummyTargets{a: t}; let dummy_t = DummyTargets{a: t};
let base_output = Path::new("../output/sampling_circ"); Ok((dummy_circuit, dummy_inner_proof, dummy_t))
}
pub(crate) fn test_export_and_import_circuit_data<C: GenericConfig<D, F = F> + Serialize + Default + 'static>(
config: CircuitConfig,
) -> anyhow::Result<()> where
<C as GenericConfig<D>>::Hasher: AlgebraicHasher<F>,
{
let (dummy_circuit, dummy_inner_proof, dummy_t) = dummy_circuit(config)?;
let base_output = Path::new(CIRC_BASE_PATH);
export_circuit_data::<F,C,D,_>(dummy_circuit, &dummy_t, base_output)?; export_circuit_data::<F,C,D,_>(dummy_circuit, &dummy_t, base_output)?;
let imported_prover: ProverCircuitData<F, C, D> = let imported_circuit: CircuitData<F, C, D> = import_circuit_data(base_output)?;
import_prover_circuit_data(base_output)?;
let imported_verifier: VerifierCircuitData<F, C, D> =
import_verifier_circuit_data(base_output)?;
let imported_target: DummyTargets = import_targets(base_output)?; let imported_target: DummyTargets = import_targets(base_output)?;
assert!(
imported_circuit.verify(dummy_inner_proof).is_ok(),
"imported circuit data failed to verify valid proof"
);
let mut pw = PartialWitness::new(); let mut pw = PartialWitness::new();
pw.set_target(imported_target.a, F::ZERO).expect("faulty assign"); pw.set_target(imported_target.a, F::ZERO).expect("faulty assign");
let proof_with_pis = imported_prover.prove(pw).unwrap(); let new_proof = imported_circuit.prove(pw).unwrap();
assert!( assert!(
imported_verifier.verify(proof_with_pis).is_ok(), imported_circuit.verify(new_proof).is_ok(),
"imported verifier failed to verify" "imported target failed usage"
); );
Ok(()) Ok(())
} }
#[test] pub(crate) fn test_export_and_import_proof_with_pi<C: GenericConfig<D, F = F> + Serialize + Default + 'static>(
fn test_export_and_import_proof_with_pi() -> anyhow::Result<()> { config: CircuitConfig,
let conf = CircuitConfig::standard_recursion_config(); ) -> anyhow::Result<()> where
let mut builder = CircuitBuilder::<F, D>::new(conf); <C as GenericConfig<D>>::Hasher: AlgebraicHasher<F>,
for _ in 0..128 { {
builder.add_gate(NoopGate, vec![]); let (dummy_circuit, dummy_inner_proof, _) = dummy_circuit(config)?;
}
let t = builder.add_virtual_public_input();
let dummy_circuit = builder.build::<C>(); let base_output = Path::new(CIRC_BASE_PATH);
let mut pw = PartialWitness::new();
pw.set_target(t, F::ZERO).expect("faulty assign");
let dummy_inner_proof = dummy_circuit.prove(pw).unwrap();
assert!(dummy_circuit.verify(dummy_inner_proof.clone()).is_ok());
let base_output = Path::new("../output/sampling_circ");
export_proof_with_pi(&dummy_inner_proof, base_output)?; export_proof_with_pi(&dummy_inner_proof, base_output)?;
let imported_proof: ProofWithPublicInputs<F, C, D> = let imported_proof: ProofWithPublicInputs<F, C, D> =
import_proof_with_pi(base_output)?; import_proof_with_pi(base_output)?;
assert_eq!(dummy_inner_proof.clone(), imported_proof.clone(), "proofs are not equal");
assert!( assert!(
dummy_circuit.verify(imported_proof).is_ok(), dummy_circuit.verify(imported_proof).is_ok(),
"Imported proof failed verification" "Imported proof failed verification"
@ -100,101 +99,110 @@ mod serialization_tests {
Ok(()) Ok(())
} }
// Test to generate the JSON file
#[test]
fn test_export_circ_input_to_json() -> anyhow::Result<()> {
// Create InputGenerator
let input_gen = InputGenerator::<F,D,H>::default();
// Export the circuit input to JSON
input_gen.generate_and_export_circ_input_to_json( "../output/test/")?;
println!("Circuit input exported to input.json");
Ok(())
}
#[test]
fn test_import_circ_input_from_json() -> anyhow::Result<()> {
// Import the circuit input from the JSON file
// NOTE: MAKE SURE THE FILE EXISTS
let _circ_input: SampleCircuitInput<F, D> = import_circ_input_from_json("../output/test/")?;
println!("circuit input imported successfully");
Ok(())
}
// export the circuit input and then import it and checks equality // export the circuit input and then import it and checks equality
#[test] pub(crate) fn test_export_import_circ_input<H: Hasher<F>>() -> anyhow::Result<()> {
fn test_export_import_circ_input() -> anyhow::Result<()> {
// Create InputGenerator // Create InputGenerator
let input_gen = InputGenerator::<F,D,H>::default(); let input_gen = InputGenerator::<F,D,H>::default();
// Export the circuit input to JSON // Export the circuit input to JSON
let original_circ_input = input_gen.gen_testing_circuit_input(); let original_circ_input = input_gen.gen_testing_circuit_input();
export_circ_input_to_json(original_circ_input.clone(), "../output/test/")?; export_circ_input_to_json(original_circ_input.clone(), CIRC_BASE_PATH)?;
println!("circuit input exported to input.json"); println!("circuit input exported to input.json");
// Import the circuit input from JSON // Import the circuit input from JSON
let imported_circ_input: SampleCircuitInput<F, D> = import_circ_input_from_json("../output/test/")?; let imported_circ_input: SampleCircuitInput<F, D> = import_circ_input_from_json(CIRC_BASE_PATH)?;
println!("circuit input imported from input.json"); println!("circuit input imported from input.json");
// Compare the original and imported circuit input // Compare the original and imported circuit input
assert_eq!(original_circ_input, imported_circ_input, "circuit input are not equal"); assert_eq!(original_circ_input, imported_circ_input, "circuit input are not equal");
// cleanup: Remove the generated JSON file
// fs::remove_file("input.json")?;
println!("Test passed: Original and imported circuit input are equal."); println!("Test passed: Original and imported circuit input are equal.");
Ok(()) Ok(())
} }
// reads the json input from file and runs the circuit }
#[cfg(test)]
mod poseidon_serialization_tests {
use plonky2::hash::poseidon::PoseidonHash;
use plonky2::plonk::circuit_data::CircuitConfig;
use plonky2::plonk::config::PoseidonGoldilocksConfig;
use super::serialization_test_functions::*;
type H = PoseidonHash;
pub type C = PoseidonGoldilocksConfig;
#[test] #[test]
fn test_read_json_and_run_circuit() -> anyhow::Result<()> { fn test_poseidon_export_import_circ_input() -> anyhow::Result<()> {
// Create the circuit test_export_import_circ_input::<H>()
let circuit_params = Params::default().circuit_params;
let circ = SampleCircuit::<F, D, H>::new(circuit_params.clone());
let (targets, data) = circ.build_with_standard_config()?;
let verifier_data: VerifierCircuitData<F, C, D> = data.verifier_data();
let prover_data: ProverCircuitData<F, C, D> = data.prover_data();
println!("circuit size = {:?}", verifier_data.common.degree_bits());
// Import the circuit input from JSON
let imported_circ_input: SampleCircuitInput<F, D> = import_circ_input_from_json("../output/test/")?;
println!("circuit input imported from input.json");
let proof = circ.prove(&targets, &imported_circ_input, &prover_data)?;
// Verify the proof
assert!(
verifier_data.verify(proof).is_ok(),
"Merkle proof verification failed"
);
Ok(())
} }
// reads the json input and verify (non-circuit)
// NOTE: expects that the json input proof uses the default params
#[test] #[test]
fn test_read_json_and_verify() -> anyhow::Result<()> { fn test_poseidon_export_and_import_circuit_data() -> anyhow::Result<()> {
// Create InputGenerator let config = CircuitConfig::standard_recursion_config();
let input_gen = InputGenerator::<F,D,H>::default(); test_export_and_import_circuit_data::<C>(config)
}
// Import the circuit input from JSON #[test]
let imported_circ_input: SampleCircuitInput<F, D> = import_circ_input_from_json("../output/test/")?; fn test_poseidon_export_and_import_proof_with_pi() -> anyhow::Result<()> {
println!("circuit input imported from input.json"); let config = CircuitConfig::standard_recursion_config();
test_export_and_import_proof_with_pi::<C>(config)
// Verify the proof }
let ver = input_gen.verify_circuit_input(imported_circ_input); }
assert!(
ver, #[cfg(test)]
"Merkle proof verification failed" mod poseidon2_serialization_tests {
); use plonky2::plonk::circuit_data::CircuitConfig;
use plonky2::plonk::config::PoseidonGoldilocksConfig;
Ok(()) use plonky2_poseidon2::poseidon2_hash::poseidon2::Poseidon2Hash;
use super::serialization_test_functions::*;
type H = Poseidon2Hash;
pub type C = PoseidonGoldilocksConfig;
#[test]
fn test_poseidon_export_import_circ_input() -> anyhow::Result<()> {
test_export_import_circ_input::<H>()
}
#[test]
fn test_poseidon_export_and_import_circuit_data() -> anyhow::Result<()> {
let config = CircuitConfig::standard_recursion_config();
test_export_and_import_circuit_data::<C>(config)
}
#[test]
fn test_poseidon_export_and_import_proof_with_pi() -> anyhow::Result<()> {
let config = CircuitConfig::standard_recursion_config();
test_export_and_import_proof_with_pi::<C>(config)
}
}
#[cfg(test)]
mod monolith_serialization_tests {
use plonky2::plonk::circuit_data::CircuitConfig;
use plonky2::plonk::config::PoseidonGoldilocksConfig;
use plonky2_monolith::monolith_hash::MonolithHash;
use super::serialization_test_functions::*;
type H = MonolithHash;
pub type C = PoseidonGoldilocksConfig;
#[test]
fn test_poseidon_export_import_circ_input() -> anyhow::Result<()> {
test_export_import_circ_input::<H>()
}
#[test]
fn test_poseidon_export_and_import_circuit_data() -> anyhow::Result<()> {
let config = CircuitConfig::standard_recursion_config();
test_export_and_import_circuit_data::<C>(config)
}
#[test]
fn test_poseidon_export_and_import_proof_with_pi() -> anyhow::Result<()> {
let config = CircuitConfig::standard_recursion_config();
test_export_and_import_proof_with_pi::<C>(config)
} }
} }