diff --git a/benches/arithmetic.rs b/benches/arithmetic.rs
index aeb3f5e..67d51a6 100644
--- a/benches/arithmetic.rs
+++ b/benches/arithmetic.rs
@@ -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);
diff --git a/benches/plonk.rs b/benches/plonk.rs
index 84eace6..33c0533 100644
--- a/benches/plonk.rs
+++ b/benches/plonk.rs
@@ -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());
diff --git a/examples/performance_model.rs b/examples/performance_model.rs
index ddca377..2d382cc 100644
--- a/examples/performance_model.rs
+++ b/examples/performance_model.rs
@@ -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());
diff --git a/src/plonk.rs b/src/plonk.rs
index cdf304c..56825ca 100644
--- a/src/plonk.rs
+++ b/src/plonk.rs
@@ -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();
         {
diff --git a/src/poly/commitment.rs b/src/poly/commitment.rs
index 3ec9ad3..9e19369 100644
--- a/src/poly/commitment.rs
+++ b/src/poly/commitment.rs
@@ -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);
diff --git a/src/transcript.rs b/src/transcript.rs
index b18119d..16a1162 100644
--- a/src/transcript.rs
+++ b/src/transcript.rs
@@ -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,