saymrwulf/pasta_curves-source
1
0
Fork 0
mirror of https://github.com/saymrwulf/pasta_curves-source.git synced 2026-09-04 20:03:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename DummyHash{Reader,Writer} to DummyHash{Read,Write}.

Browse source
This commit is contained in:
Sean Bowe 2020-12-23 15:40:09 -07:00
parent 7ffd28a1b5
commit a2999accb5
No known key found for this signature in database
GPG key ID: 95684257D8F8B031
6 changed files with 34 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
benches/arithmetic.rs
View file

@ -5,7 +5,7 @@ extern crate halo2;
use crate::arithmetic::{small_multiexp, FieldExt};
use crate::pasta::{EqAffine, Fp};
use crate::poly::commitment::Params;
use crate::transcript::DummyHashWriter;
use crate::transcript::DummyHashWrite;
use halo2::*;
use criterion::{black_box, Criterion};
@ -13,7 +13,7 @@ use criterion::{black_box, Criterion};
fn criterion_benchmark(c: &mut Criterion) {
// small multiexp
{
let params: Params<EqAffine> = Params::new::<DummyHashWriter<_, _>>(5);
let params: Params<EqAffine> = Params::new::<DummyHashWrite<_, _>>(5);
let g = &mut params.get_g();
let len = g.len() / 2;
let (g_lo, g_hi) = g.split_at_mut(len);

10
benches/plonk.rs
View file

@ -6,7 +6,7 @@ use halo2::arithmetic::FieldExt;
use halo2::pasta::{EqAffine, Fp, Fq};
use halo2::plonk::*;
use halo2::poly::commitment::Params;
use halo2::transcript::{DummyHashReader, DummyHashWriter, TranscriptRead, TranscriptWrite};
use halo2::transcript::{DummyHashRead, DummyHashWrite, TranscriptRead, TranscriptWrite};
use std::marker::PhantomData;
@ -18,7 +18,7 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
pub struct Variable(Column<Advice>, usize);
// Initialize the polynomial commitment parameters
let params: Params<EqAffine> = Params::new::<DummyHashWriter<_, _>>(k);
let params: Params<EqAffine> = Params::new::<DummyHashWrite<_, _>>(k);
struct PLONKConfig {
a: Column<Advice>,
@ -239,7 +239,7 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
};
// Create a proof
let mut transcript = DummyHashWriter::init(vec![], Fq::one());
let mut transcript = DummyHashWrite::init(vec![], Fq::one());
create_proof(&params, &pk, &circuit, &[], &mut transcript)
.expect("proof generation should not fail")
});
@ -251,7 +251,7 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
};
// Create a proof
let mut transcript = DummyHashWriter::init(vec![], Fq::one());
let mut transcript = DummyHashWrite::init(vec![], Fq::one());
create_proof(&params, &pk, &circuit, &[], &mut transcript)
.expect("proof generation should not fail");
let proof = transcript.finalize();
@ -259,7 +259,7 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
c.bench_function(&verifier_name, |b| {
b.iter(|| {
let msm = params.empty_msm();
let mut transcript = DummyHashReader::init(&proof[..], Fq::one());
let mut transcript = DummyHashRead::init(&proof[..], Fq::one());
let guard = verify_proof(&params, pk.get_vk(), msm, &[], &mut transcript).unwrap();
let msm = guard.clone().use_challenges();
assert!(msm.eval());

8
examples/performance_model.rs
View file

@ -4,7 +4,7 @@ use halo2::{
pasta::{EqAffine, Fp, Fq},
plonk::*,
poly::commitment::{Blind, Params},
transcript::{DummyHashReader, DummyHashWriter, TranscriptRead, TranscriptWrite},
transcript::{DummyHashRead, DummyHashWrite, TranscriptRead, TranscriptWrite},
};
use std::io;
@ -250,7 +250,7 @@ fn main() {
let k = 11;
// Initialize the polynomial commitment parameters
let params: Params<EqAffine> = Params::new::<DummyHashWriter<io::Sink, _>>(k);
let params: Params<EqAffine> = Params::new::<DummyHashWrite<io::Sink, _>>(k);
let empty_circuit: MyCircuit<Fp> = MyCircuit { a: None, k };
@ -274,7 +274,7 @@ fn main() {
};
// Create a proof
let mut transcript = DummyHashWriter::init(vec![], Fq::one());
let mut transcript = DummyHashWrite::init(vec![], Fq::one());
create_proof(&params, &pk, &circuit, &[pubinputs], &mut transcript)
.expect("proof generation should not fail");
let proof: Vec<u8> = transcript.finalize();
@ -284,7 +284,7 @@ fn main() {
let pubinput_slice = &[pubinput];
let msm = params.empty_msm();
let mut transcript = DummyHashReader::init(&proof[..], Fq::one());
let mut transcript = DummyHashRead::init(&proof[..], Fq::one());
let guard = verify_proof(&params, pk.get_vk(), msm, pubinput_slice, &mut transcript).unwrap();
let msm = guard.clone().use_challenges();
assert!(msm.eval());

10
src/plonk.rs
View file

@ -105,7 +105,7 @@ fn test_proving() {
use crate::arithmetic::{Curve, FieldExt};
use crate::pasta::{EqAffine, Fp, Fq};
use crate::poly::commitment::{Blind, Params};
use crate::transcript::{DummyHashReader, DummyHashWriter, TranscriptRead, TranscriptWrite};
use crate::transcript::{DummyHashRead, DummyHashWrite, TranscriptRead, TranscriptWrite};
use circuit::{Advice, Column, Fixed};
use std::io;
use std::marker::PhantomData;
@ -116,7 +116,7 @@ fn test_proving() {
pub struct Variable(Column<Advice>, usize);
// Initialize the polynomial commitment parameters
let params: Params<EqAffine> = Params::new::<DummyHashWriter<io::Sink, _>>(K);
let params: Params<EqAffine> = Params::new::<DummyHashWrite<io::Sink, _>>(K);
struct PLONKConfig {
a: Column<Advice>,
@ -448,7 +448,7 @@ fn test_proving() {
.to_affine();
for _ in 0..100 {
let mut transcript = DummyHashWriter::init(vec![], Fq::one());
let mut transcript = DummyHashWrite::init(vec![], Fq::one());
// Create a proof
create_proof(
&params,
@ -462,7 +462,7 @@ fn test_proving() {
let pubinput_slice = &[pubinput];
let msm = params.empty_msm();
let mut transcript = DummyHashReader::init(&proof[..], Fq::one());
let mut transcript = DummyHashRead::init(&proof[..], Fq::one());
let guard =
verify_proof(&params, pk.get_vk(), msm, pubinput_slice, &mut transcript).unwrap();
{
@ -476,7 +476,7 @@ fn test_proving() {
}
let msm = guard.clone().use_challenges();
assert!(msm.clone().eval());
let mut transcript = DummyHashReader::init(&proof[..], Fq::one());
let mut transcript = DummyHashRead::init(&proof[..], Fq::one());
let guard =
verify_proof(&params, pk.get_vk(), msm, pubinput_slice, &mut transcript).unwrap();
{

17
src/poly/commitment.rs
View file

@ -229,8 +229,8 @@ fn test_commit_lagrange_epaffine() {
const K: u32 = 6;
use crate::pasta::{EpAffine, Fq};
use crate::transcript::DummyHashWriter;
let params = Params::<EpAffine>::new::<DummyHashWriter<std::io::Sink, _>>(K);
use crate::transcript::DummyHashWrite;
let params = Params::<EpAffine>::new::<DummyHashWrite<std::io::Sink, _>>(K);
let domain = super::EvaluationDomain::new(1, K);
let mut a = domain.empty_lagrange();
@ -251,8 +251,8 @@ fn test_commit_lagrange_eqaffine() {
const K: u32 = 6;
use crate::pasta::{EqAffine, Fp};
use crate::transcript::DummyHashWriter;
let params = Params::<EqAffine>::new::<DummyHashWriter<std::io::Sink, _>>(K);
use crate::transcript::DummyHashWrite;
let params = Params::<EqAffine>::new::<DummyHashWrite<std::io::Sink, _>>(K);
let domain = super::EvaluationDomain::new(1, K);
let mut a = domain.empty_lagrange();
@ -281,11 +281,10 @@ fn test_opening_proof() {
use crate::arithmetic::{eval_polynomial, Curve, FieldExt};
use crate::pasta::{EpAffine, Fq};
use crate::transcript::{
ChallengeScalar, DummyHashReader, DummyHashWriter, Transcript, TranscriptRead,
TranscriptWrite,
ChallengeScalar, DummyHashRead, DummyHashWrite, Transcript, TranscriptRead, TranscriptWrite,
};
let params = Params::<EpAffine>::new::<DummyHashWriter<std::io::Sink, _>>(K);
let params = Params::<EpAffine>::new::<DummyHashWrite<std::io::Sink, _>>(K);
let domain = EvaluationDomain::new(1, K);
let mut px = domain.empty_coeff();
@ -298,7 +297,7 @@ fn test_opening_proof() {
let p = params.commit(&px, blind).to_affine();
let mut transcript = DummyHashWriter::<Vec<u8>, EpAffine>::init(vec![], Field::zero());
let mut transcript = DummyHashWrite::<Vec<u8>, EpAffine>::init(vec![], Field::zero());
transcript.write_point(p).unwrap();
let x = ChallengeScalar::<_, ()>::get(&mut transcript);
// Evaluate the polynomial
@ -312,7 +311,7 @@ fn test_opening_proof() {
};
// Verify the opening proof
let mut transcript = DummyHashReader::<&[u8], EpAffine>::init(&proof[..], Field::zero());
let mut transcript = DummyHashRead::<&[u8], EpAffine>::init(&proof[..], Field::zero());
let p_prime = transcript.read_point().unwrap();
assert_eq!(p, p_prime);
let x_prime = ChallengeScalar::<_, ()>::get(&mut transcript);

20
src/transcript.rs
View file

@ -60,16 +60,16 @@ pub trait TranscriptWrite<W: Write, C: CurveAffine>: Transcript<C> {
/// implementation, standing in for some algebraic hash function that we'll
/// switch to later.
#[derive(Debug, Clone)]
pub struct DummyHashReader<R: Read, C: CurveAffine> {
pub struct DummyHashRead<R: Read, C: CurveAffine> {
base_state: C::Base,
scalar_state: C::Scalar,
read_scalar: bool,
reader: R,
}
impl<R: Read, C: CurveAffine> TranscriptRead<R, C> for DummyHashReader<R, C> {
impl<R: Read, C: CurveAffine> TranscriptRead<R, C> for DummyHashRead<R, C> {
fn init(reader: R, key: C::Base) -> Self {
DummyHashReader {
DummyHashRead {
base_state: key + &C::Base::from_u64(1013),
scalar_state: C::Scalar::from_u64(1013),
read_scalar: false,
@ -104,7 +104,7 @@ impl<R: Read, C: CurveAffine> TranscriptRead<R, C> for DummyHashReader<R, C> {
}
}
impl<R: Read, C: CurveAffine> Transcript<C> for DummyHashReader<R, C> {
impl<R: Read, C: CurveAffine> Transcript<C> for DummyHashRead<R, C> {
fn common_point(&mut self, point: C) -> io::Result<()> {
let (x, y) = Option::from(point.get_xy()).ok_or(io::Error::new(
io::ErrorKind::Other,
@ -142,18 +142,18 @@ impl<R: Read, C: CurveAffine> Transcript<C> for DummyHashReader<R, C> {
/// implementation, standing in for some algebraic hash function that we'll
/// switch to later.
#[derive(Debug, Clone)]
pub struct DummyHashWriter<W: Write, C: CurveAffine> {
pub struct DummyHashWrite<W: Write, C: CurveAffine> {
base_state: C::Base,
scalar_state: C::Scalar,
written_scalar: bool,
writer: W,
}
impl<W: Write, C: CurveAffine> TranscriptWrite<W, C> for DummyHashWriter<W, C> {
type ForkedTranscript = DummyHashWriter<io::Sink, C>;
impl<W: Write, C: CurveAffine> TranscriptWrite<W, C> for DummyHashWrite<W, C> {
type ForkedTranscript = DummyHashWrite<io::Sink, C>;
fn init(writer: W, key: C::Base) -> Self {
DummyHashWriter {
DummyHashWrite {
base_state: key + &C::Base::from_u64(1013),
scalar_state: C::Scalar::from_u64(1013),
written_scalar: false,
@ -173,7 +173,7 @@ impl<W: Write, C: CurveAffine> TranscriptWrite<W, C> for DummyHashWriter<W, C> {
self.writer.write_all(&data[..])
}
fn fork(&self) -> Self::ForkedTranscript {
DummyHashWriter {
DummyHashWrite {
base_state: self.base_state,
scalar_state: self.scalar_state,
written_scalar: self.written_scalar,
@ -186,7 +186,7 @@ impl<W: Write, C: CurveAffine> TranscriptWrite<W, C> for DummyHashWriter<W, C> {
}
}
impl<W: Write, C: CurveAffine> Transcript<C> for DummyHashWriter<W, C> {
impl<W: Write, C: CurveAffine> Transcript<C> for DummyHashWrite<W, C> {
fn common_point(&mut self, point: C) -> io::Result<()> {
let (x, y) = Option::from(point.get_xy()).ok_or(io::Error::new(
io::ErrorKind::Other,