Merge pull request #3290 from o1-labs/dw/misc-mina-hasher

mina-hasher: wrap 80 chars

Author: dannywillems

hasher/src/lib.rs

@@ -15,7 +15,8 @@ use ark_ff::PrimeField;
 use o1_utils::FieldHelpers;
 
 /// The domain parameter trait is used during hashing to convey extra
-/// arguments to domain string generation.  It is also used by generic signing code.
+/// arguments to domain string generation. It is also used by generic signing
+/// code.
 pub trait DomainParameter: Clone {
     /// Conversion into vector of bytes
     fn into_bytes(self) -> Vec<u8>;
@@ -41,13 +42,16 @@ impl DomainParameter for u64 {
 
 /// Interface for hashable objects
 ///
-/// Mina uses fixed-length hashing with domain separation for each type of object hashed.
-/// The prior means that `Hashable` only supports types whose size is not variable.
+/// Mina uses fixed-length hashing with domain separation for each type of
+/// object hashed. The prior means that `Hashable` only supports types whose
+/// size is not variable.
 ///
-/// **Important:** The developer MUST assure that all domain strings used throughout the
-/// system are unique and that all structures hashed are of fixed size.
+/// **Important:** The developer MUST assure that all domain strings used
+/// throughout the system are unique and that all structures hashed are of fixed
+/// size.
 ///
-/// Here is an example of how to implement the `Hashable` trait for am `Example` type.
+/// Here is an example of how to implement the `Hashable` trait for am `Example`
+/// type.
 ///
 /// ```rust
 /// use mina_hasher::{Hashable, ROInput};
@@ -81,8 +85,8 @@ pub trait Hashable: Clone {
 
     /// Generate unique domain string of length `<= 20`.
     ///
-    /// The length bound is guarded by an assertion, but uniqueness must
-    /// be enforced by the developer implementing the traits (see [`Hashable`] for
+    /// The length bound is guarded by an assertion, but uniqueness must be
+    /// enforced by the developer implementing the traits (see [`Hashable`] for
     /// more details). The domain string may be parameterized by the contents of
     /// the generic `domain_param` argument.
     ///
@@ -93,9 +97,11 @@ pub trait Hashable: Clone {
 
 /// Interface for hashing [`Hashable`] inputs
 ///
-/// Mina uses a unique hasher configured with domain separation for each type of object hashed.
-/// The underlying hash parameters are large and costly to initialize, so the [`Hasher`] interface
-/// provides a reusable context for efficient hashing with domain separation.
+/// Mina uses a unique hasher configured with domain separation for each type of
+/// object hashed.
+/// The underlying hash parameters are large and costly to initialize, so the
+/// [`Hasher`] interface provides a reusable context for efficient hashing with
+/// domain separation.
 ///
 /// Example usage
 ///
@@ -124,8 +130,8 @@ pub trait Hashable: Clone {
 /// ```
 ///
 pub trait Hasher<H: Hashable> {
-    /// Set the initial state based on domain separation string
-    /// generated from `H::domain_string(domain_param)`
+    /// Set the initial state based on domain separation string generated from
+    /// `H::domain_string(domain_param)`
     fn init(&mut self, domain_param: H::D) -> &mut dyn Hasher<H>;
 
     /// Restore the initial state that was set most recently

hasher/src/poseidon.rs

@@ -73,8 +73,10 @@ where
     }
 
     fn init(&mut self, domain_param: H::D) -> &mut dyn Hasher<H> {
-        // Set sponge initial state and save it so the hasher context can be reused efficiently
-        // N.B. Mina sets the sponge's initial state by hashing the input type's domain bytes
+        // Set sponge initial state and save it so the hasher context can be
+        // reused efficiently
+        // N.B. Mina sets the sponge's initial state by hashing the input type's
+        // domain bytes
         self.sponge.reset();
 
         if let Some(domain_string) = H::domain_string(domain_param) {

hasher/src/roinput.rs

@@ -17,15 +17,19 @@ const SINGLE_HEADER_SIZE: usize = 4; // number of bytes for each part of the hea
 
 /// Random oracle input structure
 ///
-/// The random oracle input encapsulates the serialization format and methods using during hashing.
+/// The random oracle input encapsulates the serialization format and methods
+/// using during hashing.
 ///
-/// When implementing the [`Hashable`] trait to enable hashing for a type, you must implement
-/// its `to_roinput()` serialization method using the [`ROInput`] functions below.
+/// When implementing the [`Hashable`] trait to enable hashing for a type, you
+/// must implement its `to_roinput()` serialization method using the [`ROInput`]
+/// functions below.
 ///
-/// The random oracle input structure is used (by generic code) to serialize the object into
-/// both a vector of `pasta::Fp` field elements and into a vector of bytes, depending on the situation.
+/// The random oracle input structure is used (by generic code) to serialize the
+/// object into both a vector of `pasta::Fp` field elements and into a vector of
+/// bytes, depending on the situation.
 ///
-/// Here is an example of how `ROInput` is used during the definition of the `Hashable` trait.
+/// Here is an example of how `ROInput` is used during the definition of the
+/// `Hashable` trait.
 ///
 /// ```rust
 /// use mina_hasher::{Hashable, ROInput};
@@ -53,11 +57,12 @@ const SINGLE_HEADER_SIZE: usize = 4; // number of bytes for each part of the hea
 ///     }
 /// }
 /// ```
-/// **Details:** For technical reasons related to our proof system and performance,
-/// non-field-element members are serialized for signing differently than other types.
-/// Additionally, during signing all members of the random oracle input get serialized
-/// together in two different ways: both as *bytes* and as a vector of *field elements*.
-/// The random oracle input automates and encapsulates this complexity.
+/// **Details:** For technical reasons related to our proof system and
+/// performance, non-field-element members are serialized for signing
+/// differently than other types. Additionally, during signing all members of
+/// the random oracle input get serialized together in two different ways: both
+/// as *bytes* and as a vector of *field elements*. The random oracle input
+/// automates and encapsulates this complexity.
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct ROInput {
     fields: Vec<Fp>,

hasher/tests/hasher.rs

@@ -96,23 +96,30 @@ fn interfaces() {
     // Usage 1: incremental interface
     let mut hasher = create_legacy::<Foo>(0);
     hasher.update(&Foo { x: 3, y: 1 });
-    let x1 = hasher.digest(); // Resets to previous init state (0)
+    // Resets to previous init state (0)
+    let x1 = hasher.digest();
     hasher.update(&Foo { x: 82, y: 834 });
     hasher.update(&Foo { x: 1235, y: 93 });
-    hasher.digest(); // Resets to previous init state (0)
+    // Resets to previous init state (0)
+    hasher.digest();
     hasher.init(1);
     hasher.update(&Foo { x: 82, y: 834 });
-    let x2 = hasher.digest(); // Resets to previous init state (1)
+    // Resets to previous init state (1)
+    let x2 = hasher.digest();
 
     // Usage 2: builder interface with one-shot pattern
     let mut hasher = create_legacy::<Foo>(0);
-    let y1 = hasher.update(&Foo { x: 3, y: 1 }).digest(); // Resets to previous init state (0)
+    // Resets to previous init state (0)
+    let y1 = hasher.update(&Foo { x: 3, y: 1 }).digest();
+
     hasher.update(&Foo { x: 31, y: 21 }).digest();
 
     // Usage 3: builder interface with one-shot pattern also setting init state
     let mut hasher = create_legacy::<Foo>(0);
-    let y2 = hasher.init(0).update(&Foo { x: 3, y: 1 }).digest(); // Resets to previous init state (1)
-    let y3 = hasher.init(1).update(&Foo { x: 82, y: 834 }).digest(); // Resets to previous init state (2)
+    // Resets to previous init state (1)
+    let y2 = hasher.init(0).update(&Foo { x: 3, y: 1 }).digest();
+    // Resets to previous init state (2)
+    let y3 = hasher.init(1).update(&Foo { x: 82, y: 834 }).digest();
 
     // Usage 4: one-shot interfaces
     let mut hasher = create_legacy::<Foo>(0);