vacp2p/zk-explorations
1
0
Fork 0
mirror of https://github.com/vacp2p/zk-explorations.git synced 2026-01-09 20:17:59 -05:00
Code Issues Packages Projects Releases Wiki Activity

cargo fmt

Browse Source
This commit is contained in:
Rostyslav Tyshko
2024-02-28 05:38:56 +01:00
parent 98a4c7abc0
commit c25dcf2ac7
2 changed files with 111 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

224
halo2-gwc/benches/poseidon.rs
View File

@@ -1,6 +1,6 @@
use core::time::Duration;
use std::path::PathBuf;
use criterion::*;
use std::path::PathBuf;
use halo2_proofs::plonk::{create_proof, verify_proof, Circuit};
use halo2_proofs::poly::commitment::ParamsProver;
@@ -13,10 +13,7 @@ use rand::rngs::StdRng;
use rand::SeedableRng;
use snark_verifier::pcs::kzg::{Gwc19, KzgAs};
use snark_verifier_sdk::halo2::{gen_proof, gen_srs, PoseidonTranscript, POSEIDON_SPEC};
use snark_verifier_sdk::{
gen_pk,
halo2::{aggregation::AggregationCircuit},
};
use snark_verifier_sdk::{gen_pk, halo2::aggregation::AggregationCircuit};
use snark_verifier_sdk::{CircuitExt, NativeLoader, GWC};
criterion_group! {
@@ -24,140 +21,131 @@ criterion_group! {
config = Criterion::default().warm_up_time(Duration::from_millis(3000));
targets = bench_recursive_snark_proove,bench_recursive_snark_verify
}
criterion_main!(recursive_snark);
fn bench_recursive_snark_proove(c: &mut Criterion) {
let params_app = gen_srs(8);
let params = gen_srs(23);
let params_app = gen_srs(8);
let params = gen_srs(23);
let cases = vec![3, 10, 100];
let cases = vec![3, 10, 100];
for k in cases {
for k in cases {
let mut group = c.benchmark_group(format!("Halo2-GWC-Poseidon-num-steps-{}", k));
group.sample_size(10);
let mut group = c.benchmark_group(format!(
"Halo2-GWC-Poseidon-num-steps-{}",
k
));
group.sample_size(10);
let snarks: Vec<_> = vec![0; k]
.into_iter()
.map(|_| halo2_gwc::gen_application_snark(&params_app))
.collect();
let snarks: Vec<_> = vec![0; k].into_iter().map(|_| halo2_gwc::gen_application_snark(&params_app)).collect();
let agg_circuit = AggregationCircuit::<GWC>::new(&params, snarks);
let pk = gen_pk(&params, &agg_circuit.without_witnesses(), None);
let agg_circuit = AggregationCircuit::<GWC>::new(&params, snarks);
let pk = gen_pk(
&params,
&agg_circuit.without_witnesses(),
None,
);
let circuit = agg_circuit.clone();
let instances = agg_circuit.instances();
let circuit = agg_circuit.clone();
let instances = agg_circuit.instances();
let rng = StdRng::from_entropy();
let instances = instances.iter().map(Vec::as_slice).collect_vec();
let rng = StdRng::from_entropy();
let instances = instances.iter().map(Vec::as_slice).collect_vec();
group.bench_function("Prove", |b| {
b.iter(|| {
let mut transcript =
PoseidonTranscript::<NativeLoader, _>::from_spec(vec![], POSEIDON_SPEC.clone());
group.bench_function("Prove", |b| {
b.iter(|| {
create_proof::<_, ProverGWC<_>, _, _, _, _>(
&params,
&pk,
&[circuit.clone()],
&[&instances],
rng.clone(),
&mut transcript,
)
.unwrap();
let proof = transcript.finalize();
let mut transcript =
PoseidonTranscript::<NativeLoader, _>::from_spec(vec![], POSEIDON_SPEC.clone());
create_proof::<_, ProverGWC<_>, _, _, _, _>(&params, &pk, &[circuit.clone()], &[&instances], rng.clone(), &mut transcript)
.unwrap();
let proof = transcript.finalize();
// validate proof before caching
assert!({
let mut transcript_read =
PoseidonTranscript::<NativeLoader, &[u8]>::from_spec(&proof[..], POSEIDON_SPEC.clone());
VerificationStrategy::<_, VerifierGWC<_>>::finalize(
verify_proof::<_, VerifierGWC<_>, _, _, _>(
params.verifier_params(),
pk.get_vk(),
AccumulatorStrategy::new(params.verifier_params()),
&[instances.as_slice()],
&mut transcript_read,
)
.unwrap(),
)
});
})
});
group.finish();
}
// validate proof before caching
assert!({
let mut transcript_read = PoseidonTranscript::<NativeLoader, &[u8]>::from_spec(
&proof[..],
POSEIDON_SPEC.clone(),
);
VerificationStrategy::<_, VerifierGWC<_>>::finalize(
verify_proof::<_, VerifierGWC<_>, _, _, _>(
params.verifier_params(),
pk.get_vk(),
AccumulatorStrategy::new(params.verifier_params()),
&[instances.as_slice()],
&mut transcript_read,
)
.unwrap(),
)
});
})
});
group.finish();
}
}
fn bench_recursive_snark_verify(c: &mut Criterion) {
let params_app = gen_srs(8);
let params = gen_srs(23);
let params_app = gen_srs(8);
let params = gen_srs(23);
let cases = vec![3, 10, 100];
let cases = vec![3, 10, 100];
for k in cases {
for k in cases {
let mut group = c.benchmark_group(format!("Halo2-GWC-Poseidon-num-steps-{}", k));
group.sample_size(10);
let mut group = c.benchmark_group(format!(
"Halo2-GWC-Poseidon-num-steps-{}",
k
));
group.sample_size(10);
let snarks: Vec<_> = vec![0; k]
.into_iter()
.map(|_| halo2_gwc::gen_application_snark(&params_app))
.collect();
let snarks: Vec<_> = vec![0; k].into_iter().map(|_| halo2_gwc::gen_application_snark(&params_app)).collect();
let agg_circuit = AggregationCircuit::<GWC>::new(&params, snarks);
let pk = gen_pk(&params, &agg_circuit.without_witnesses(), None);
let agg_circuit = AggregationCircuit::<GWC>::new(&params, snarks);
let pk = gen_pk(
&params,
&agg_circuit.without_witnesses(),
None,
);
let circuit = agg_circuit.clone();
let instances = agg_circuit.instances();
let circuit = agg_circuit.clone();
let instances = agg_circuit.instances();
let rng = StdRng::from_entropy();
let instances = instances.iter().map(Vec::as_slice).collect_vec();
let rng = StdRng::from_entropy();
let instances = instances.iter().map(Vec::as_slice).collect_vec();
let mut transcript =
PoseidonTranscript::<NativeLoader, _>::from_spec(vec![], POSEIDON_SPEC.clone());
create_proof::<_, ProverGWC<_>, _, _, _, _>(
&params,
&pk,
&[circuit.clone()],
&[&instances],
rng.clone(),
&mut transcript,
)
.unwrap();
let proof = transcript.finalize();
let mut transcript =
PoseidonTranscript::<NativeLoader, _>::from_spec(vec![], POSEIDON_SPEC.clone());
create_proof::<_, ProverGWC<_>, _, _, _, _>(&params, &pk, &[circuit.clone()], &[&instances], rng.clone(), &mut transcript)
.unwrap();
let proof = transcript.finalize();
group.bench_function("Prove", |b| {
b.iter(|| {
// validate proof before caching
assert!({
let mut transcript_read =
PoseidonTranscript::<NativeLoader, &[u8]>::from_spec(&proof[..], POSEIDON_SPEC.clone());
VerificationStrategy::<_, VerifierGWC<_>>::finalize(
verify_proof::<_, VerifierGWC<_>, _, _, _>(
params.verifier_params(),
pk.get_vk(),
AccumulatorStrategy::new(params.verifier_params()),
&[instances.as_slice()],
&mut transcript_read,
)
.unwrap(),
)
});
})
});
group.finish();
}
}
group.bench_function("Prove", |b| {
b.iter(|| {
// validate proof before caching
assert!({
let mut transcript_read = PoseidonTranscript::<NativeLoader, &[u8]>::from_spec(
&proof[..],
POSEIDON_SPEC.clone(),
);
VerificationStrategy::<_, VerifierGWC<_>>::finalize(
verify_proof::<_, VerifierGWC<_>, _, _, _>(
params.verifier_params(),
pk.get_vk(),
AccumulatorStrategy::new(params.verifier_params()),
&[instances.as_slice()],
&mut transcript_read,
)
.unwrap(),
)
});
})
});
group.finish();
}
}

18
halo2-gwc/src/lib.rs
View File

@@ -1,21 +1,17 @@
use ark_std::{end_timer, start_timer};
use halo2_common::application;
use halo2_curves::bn256::Fr;
use halo2_proofs::circuit::Value;
use halo2_proofs::halo2curves as halo2_curves;
use halo2_proofs::plonk::Circuit;
use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
use rand::RngCore;
use rand::rngs::OsRng;
use snark_verifier_sdk::halo2::{gen_srs, gen_snark_gwc};
use snark_verifier_sdk::{
gen_pk,
halo2::{aggregation::AggregationCircuit},
Snark,
};
use rand::RngCore;
use snark_verifier_sdk::halo2::{gen_snark_gwc, gen_srs};
use snark_verifier_sdk::{gen_pk, halo2::aggregation::AggregationCircuit, Snark};
use snark_verifier_sdk::{CircuitExt, GWC};
use std::marker::PhantomData;
use std::path::Path;
use halo2_common::application;
pub fn gen_application_snark(params: &ParamsKZG<Bn256>) -> Snark {
let mut rng = OsRng;
@@ -44,11 +40,7 @@ fn main_function() {
let params = gen_srs(23);
let agg_circuit = AggregationCircuit::<GWC>::new(&params, snarks);
let start0 = start_timer!(|| "gen vk & pk");
let pk = gen_pk(
&params,
&agg_circuit.without_witnesses(),
None,
);
let pk = gen_pk(&params, &agg_circuit.without_witnesses(), None);
end_timer!(start0);
snark_verifier_sdk::halo2::gen_proof_gwc(