saymrwulf/pasta_curves-source
1
0
Fork 0
mirror of https://github.com/saymrwulf/pasta_curves-source.git synced 2026-09-07 20:30:34 +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::arithmetic::{small_multiexp, FieldExt};
use crate::pasta::{EqAffine, Fp}; use crate::pasta::{EqAffine, Fp};
use crate::poly::commitment::Params; use crate::poly::commitment::Params;
use crate::transcript::DummyHashWriter; use crate::transcript::DummyHashWrite;
use halo2::*; use halo2::*;
use criterion::{black_box, Criterion}; use criterion::{black_box, Criterion};
@ -13,7 +13,7 @@ use criterion::{black_box, Criterion};
fn criterion_benchmark(c: &mut Criterion) { fn criterion_benchmark(c: &mut Criterion) {
// small multiexp // 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 g = &mut params.get_g();
let len = g.len() / 2; let len = g.len() / 2;
let (g_lo, g_hi) = g.split_at_mut(len); 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::pasta::{EqAffine, Fp, Fq};
use halo2::plonk::*; use halo2::plonk::*;
use halo2::poly::commitment::Params; use halo2::poly::commitment::Params;
use halo2::transcript::{DummyHashReader, DummyHashWriter, TranscriptRead, TranscriptWrite}; use halo2::transcript::{DummyHashRead, DummyHashWrite, TranscriptRead, TranscriptWrite};
use std::marker::PhantomData; 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); pub struct Variable(Column<Advice>, usize);
// Initialize the polynomial commitment parameters // Initialize the polynomial commitment parameters
let params: Params<EqAffine> = Params::new::<DummyHashWriter<_, _>>(k); let params: Params<EqAffine> = Params::new::<DummyHashWrite<_, _>>(k);
struct PLONKConfig { struct PLONKConfig {
a: Column<Advice>, a: Column<Advice>,
@ -239,7 +239,7 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
}; };
// Create a proof // 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) create_proof(&params, &pk, &circuit, &[], &mut transcript)
.expect("proof generation should not fail") .expect("proof generation should not fail")
}); });
@ -251,7 +251,7 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
}; };
// Create a proof // 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) create_proof(&params, &pk, &circuit, &[], &mut transcript)
.expect("proof generation should not fail"); .expect("proof generation should not fail");
let proof = transcript.finalize(); 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| { c.bench_function(&verifier_name, |b| {
b.iter(|| { b.iter(|| {
let msm = params.empty_msm(); 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 guard = verify_proof(&params, pk.get_vk(), msm, &[], &mut transcript).unwrap();
let msm = guard.clone().use_challenges(); let msm = guard.clone().use_challenges();
assert!(msm.eval()); assert!(msm.eval());

8
examples/performance_model.rs
View file

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

10
src/plonk.rs
View file

@ -105,7 +105,7 @@ fn test_proving() {
use crate::arithmetic::{Curve, FieldExt}; use crate::arithmetic::{Curve, FieldExt};
use crate::pasta::{EqAffine, Fp, Fq}; use crate::pasta::{EqAffine, Fp, Fq};
use crate::poly::commitment::{Blind, Params}; 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 circuit::{Advice, Column, Fixed};
use std::io; use std::io;
use std::marker::PhantomData; use std::marker::PhantomData;
@ -116,7 +116,7 @@ fn test_proving() {
pub struct Variable(Column<Advice>, usize); pub struct Variable(Column<Advice>, usize);
// Initialize the polynomial commitment parameters // 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 { struct PLONKConfig {
a: Column<Advice>, a: Column<Advice>,
@ -448,7 +448,7 @@ fn test_proving() {
.to_affine(); .to_affine();
for _ in 0..100 { for _ in 0..100 {
let mut transcript = DummyHashWriter::init(vec![], Fq::one()); let mut transcript = DummyHashWrite::init(vec![], Fq::one());
// Create a proof // Create a proof
create_proof( create_proof(
&params, &params,
@ -462,7 +462,7 @@ fn test_proving() {
let pubinput_slice = &[pubinput]; let pubinput_slice = &[pubinput];
let msm = params.empty_msm(); let msm = params.empty_msm();
let mut transcript = DummyHashReader::init(&proof[..], Fq::one()); let mut transcript = DummyHashRead::init(&proof[..], Fq::one());
let guard = let guard =
verify_proof(&params, pk.get_vk(), msm, pubinput_slice, &mut transcript).unwrap(); 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(); let msm = guard.clone().use_challenges();
assert!(msm.clone().eval()); assert!(msm.clone().eval());
let mut transcript = DummyHashReader::init(&proof[..], Fq::one()); let mut transcript = DummyHashRead::init(&proof[..], Fq::one());
let guard = let guard =
verify_proof(&params, pk.get_vk(), msm, pubinput_slice, &mut transcript).unwrap(); 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; const K: u32 = 6;
use crate::pasta::{EpAffine, Fq}; use crate::pasta::{EpAffine, Fq};
use crate::transcript::DummyHashWriter; use crate::transcript::DummyHashWrite;
let params = Params::<EpAffine>::new::<DummyHashWriter<std::io::Sink, _>>(K); let params = Params::<EpAffine>::new::<DummyHashWrite<std::io::Sink, _>>(K);
let domain = super::EvaluationDomain::new(1, K); let domain = super::EvaluationDomain::new(1, K);
let mut a = domain.empty_lagrange(); let mut a = domain.empty_lagrange();
@ -251,8 +251,8 @@ fn test_commit_lagrange_eqaffine() {
const K: u32 = 6; const K: u32 = 6;
use crate::pasta::{EqAffine, Fp}; use crate::pasta::{EqAffine, Fp};
use crate::transcript::DummyHashWriter; use crate::transcript::DummyHashWrite;
let params = Params::<EqAffine>::new::<DummyHashWriter<std::io::Sink, _>>(K); let params = Params::<EqAffine>::new::<DummyHashWrite<std::io::Sink, _>>(K);
let domain = super::EvaluationDomain::new(1, K); let domain = super::EvaluationDomain::new(1, K);
let mut a = domain.empty_lagrange(); let mut a = domain.empty_lagrange();
@ -281,11 +281,10 @@ fn test_opening_proof() {
use crate::arithmetic::{eval_polynomial, Curve, FieldExt}; use crate::arithmetic::{eval_polynomial, Curve, FieldExt};
use crate::pasta::{EpAffine, Fq}; use crate::pasta::{EpAffine, Fq};
use crate::transcript::{ use crate::transcript::{
ChallengeScalar, DummyHashReader, DummyHashWriter, Transcript, TranscriptRead, ChallengeScalar, DummyHashRead, DummyHashWrite, Transcript, TranscriptRead, TranscriptWrite,
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 domain = EvaluationDomain::new(1, K);
let mut px = domain.empty_coeff(); let mut px = domain.empty_coeff();
@ -298,7 +297,7 @@ fn test_opening_proof() {
let p = params.commit(&px, blind).to_affine(); 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(); transcript.write_point(p).unwrap();
let x = ChallengeScalar::<_, ()>::get(&mut transcript); let x = ChallengeScalar::<_, ()>::get(&mut transcript);
// Evaluate the polynomial // Evaluate the polynomial
@ -312,7 +311,7 @@ fn test_opening_proof() {
}; };
// Verify the 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(); let p_prime = transcript.read_point().unwrap();
assert_eq!(p, p_prime); assert_eq!(p, p_prime);
let x_prime = ChallengeScalar::<_, ()>::get(&mut transcript); 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 /// implementation, standing in for some algebraic hash function that we'll
/// switch to later. /// switch to later.
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct DummyHashReader<R: Read, C: CurveAffine> { pub struct DummyHashRead<R: Read, C: CurveAffine> {
base_state: C::Base, base_state: C::Base,
scalar_state: C::Scalar, scalar_state: C::Scalar,
read_scalar: bool, read_scalar: bool,
reader: R, 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 { fn init(reader: R, key: C::Base) -> Self {
DummyHashReader { DummyHashRead {
base_state: key + &C::Base::from_u64(1013), base_state: key + &C::Base::from_u64(1013),
scalar_state: C::Scalar::from_u64(1013), scalar_state: C::Scalar::from_u64(1013),
read_scalar: false, 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<()> { fn common_point(&mut self, point: C) -> io::Result<()> {
let (x, y) = Option::from(point.get_xy()).ok_or(io::Error::new( let (x, y) = Option::from(point.get_xy()).ok_or(io::Error::new(
io::ErrorKind::Other, 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 /// implementation, standing in for some algebraic hash function that we'll
/// switch to later. /// switch to later.
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct DummyHashWriter<W: Write, C: CurveAffine> { pub struct DummyHashWrite<W: Write, C: CurveAffine> {
base_state: C::Base, base_state: C::Base,
scalar_state: C::Scalar, scalar_state: C::Scalar,
written_scalar: bool, written_scalar: bool,
writer: W, writer: W,
} }
impl<W: Write, C: CurveAffine> TranscriptWrite<W, C> for DummyHashWriter<W, C> { impl<W: Write, C: CurveAffine> TranscriptWrite<W, C> for DummyHashWrite<W, C> {
type ForkedTranscript = DummyHashWriter<io::Sink, C>; type ForkedTranscript = DummyHashWrite<io::Sink, C>;
fn init(writer: W, key: C::Base) -> Self { fn init(writer: W, key: C::Base) -> Self {
DummyHashWriter { DummyHashWrite {
base_state: key + &C::Base::from_u64(1013), base_state: key + &C::Base::from_u64(1013),
scalar_state: C::Scalar::from_u64(1013), scalar_state: C::Scalar::from_u64(1013),
written_scalar: false, written_scalar: false,
@ -173,7 +173,7 @@ impl<W: Write, C: CurveAffine> TranscriptWrite<W, C> for DummyHashWriter<W, C> {
self.writer.write_all(&data[..]) self.writer.write_all(&data[..])
} }
fn fork(&self) -> Self::ForkedTranscript { fn fork(&self) -> Self::ForkedTranscript {
DummyHashWriter { DummyHashWrite {
base_state: self.base_state, base_state: self.base_state,
scalar_state: self.scalar_state, scalar_state: self.scalar_state,
written_scalar: self.written_scalar, 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<()> { fn common_point(&mut self, point: C) -> io::Result<()> {
let (x, y) = Option::from(point.get_xy()).ok_or(io::Error::new( let (x, y) = Option::from(point.get_xy()).ok_or(io::Error::new(
io::ErrorKind::Other, io::ErrorKind::Other,