feat: Falcon 512 signature

src/merkle/merkle_tree.rs

@@ -371,21 +371,9 @@ mod tests {
 
         let nodes: Vec<InnerNodeInfo> = tree.inner_nodes().collect();
         let expected = vec![
-            InnerNodeInfo {
-                value: root,
-                left: l1n0,
-                right: l1n1,
-            },
-            InnerNodeInfo {
-                value: l1n0,
-                left: l2n0,
-                right: l2n1,
-            },
-            InnerNodeInfo {
-                value: l1n1,
-                left: l2n2,
-                right: l2n3,
-            },
+            InnerNodeInfo { value: root, left: l1n0, right: l1n1 },
+            InnerNodeInfo { value: l1n0, left: l2n0, right: l2n1 },
+            InnerNodeInfo { value: l1n1, left: l2n2, right: l2n3 },
         ];
         assert_eq!(nodes, expected);
 

src/merkle/mmr/full.rs

@@ -71,10 +71,7 @@ impl Mmr {
 
     /// Constructor for an empty `Mmr`.
     pub fn new() -> Mmr {
-        Mmr {
-            forest: 0,
-            nodes: Vec::new(),
-        }
+        Mmr { forest: 0, nodes: Vec::new() }
     }
 
     // ACCESSORS
@@ -188,10 +185,7 @@ impl Mmr {
             .map(|offset| self.nodes[offset - 1])
             .collect();
 
-        MmrPeaks {
-            num_leaves: self.forest,
-            peaks,
-        }
+        MmrPeaks { num_leaves: self.forest, peaks }
     }
 
     /// An iterator over inner nodes in the MMR. The order of iteration is unspecified.

src/merkle/mmr/tests.rs

@@ -380,11 +380,7 @@ fn test_mmr_inner_nodes() {
             left: LEAVES[2],
             right: LEAVES[3],
         },
-        InnerNodeInfo {
-            value: h0123,
-            left: h01,
-            right: h23,
-        },
+        InnerNodeInfo { value: h0123, left: h01, right: h23 },
         InnerNodeInfo {
             value: h45,
             left: LEAVES[4],

src/merkle/partial_mt/mod.rs

@@ -158,11 +158,7 @@ impl PartialMerkleTree {
             }
         }
 
-        Ok(PartialMerkleTree {
-            max_depth,
-            nodes,
-            leaves,
-        })
+        Ok(PartialMerkleTree { max_depth, nodes, leaves })
     }
 
     // PUBLIC ACCESSORS

src/merkle/path.rs

@@ -137,11 +137,7 @@ impl<'a> Iterator for InnerNodeIterator<'a> {
             self.value = Rpo256::merge(&[left, right]);
             self.index.move_up();
 
-            Some(InnerNodeInfo {
-                value: self.value,
-                left,
-                right,
-            })
+            Some(InnerNodeInfo { value: self.value, left, right })
         } else {
             None
         }
@@ -163,10 +159,7 @@ pub struct ValuePath {
 impl ValuePath {
     /// Returns a new [ValuePath] instantiated from the specified value and path.
     pub fn new(value: RpoDigest, path: Vec<RpoDigest>) -> Self {
-        Self {
-            value,
-            path: MerklePath::new(path),
-        }
+        Self { value, path: MerklePath::new(path) }
     }
 }
 

src/merkle/simple_smt/mod.rs

@@ -249,10 +249,7 @@ impl SimpleSmt {
     fn get_branch_node(&self, index: &NodeIndex) -> BranchNode {
         self.branches.get(index).cloned().unwrap_or_else(|| {
             let node = self.empty_hashes[index.depth() as usize + 1];
-            BranchNode {
-                left: node,
-                right: node,
-            }
+            BranchNode { left: node, right: node }
         })
     }
 

src/merkle/simple_smt/tests.rs

@@ -123,21 +123,9 @@ fn test_inner_node_iterator() -> Result<(), MerkleError> {
 
     let nodes: Vec<InnerNodeInfo> = tree.inner_nodes().collect();
     let expected = vec![
-        InnerNodeInfo {
-            value: root,
-            left: l1n0,
-            right: l1n1,
-        },
-        InnerNodeInfo {
-            value: l1n0,
-            left: l2n0,
-            right: l2n1,
-        },
-        InnerNodeInfo {
-            value: l1n1,
-            left: l2n2,
-            right: l2n3,
-        },
+        InnerNodeInfo { value: root, left: l1n0, right: l1n1 },
+        InnerNodeInfo { value: l1n0, left: l2n0, right: l2n1 },
+        InnerNodeInfo { value: l1n1, left: l2n2, right: l2n3 },
     ];
     assert_eq!(nodes, expected);
 

src/merkle/store/mod.rs

@@ -326,11 +326,9 @@ impl<T: KvMap<RpoDigest, StoreNode>> MerkleStore<T> {
 
     /// Iterator over the inner nodes of the [MerkleStore].
     pub fn inner_nodes(&self) -> impl Iterator<Item = InnerNodeInfo> + '_ {
-        self.nodes.iter().map(|(r, n)| InnerNodeInfo {
-            value: *r,
-            left: n.left,
-            right: n.right,
-        })
+        self.nodes
+            .iter()
+            .map(|(r, n)| InnerNodeInfo { value: *r, left: n.left, right: n.right })
     }
 
     /// Iterator over the non-empty leaves of the Merkle tree associated with the specified `root`
@@ -450,13 +448,7 @@ impl<T: KvMap<RpoDigest, StoreNode>> MerkleStore<T> {
         right_root: RpoDigest,
     ) -> Result<RpoDigest, MerkleError> {
         let parent = Rpo256::merge(&[left_root, right_root]);
-        self.nodes.insert(
-            parent,
-            StoreNode {
-                left: left_root,
-                right: right_root,
-            },
-        );
+        self.nodes.insert(parent, StoreNode { left: left_root, right: right_root });
 
         Ok(parent)
     }
@@ -551,15 +543,10 @@ impl<T: KvMap<RpoDigest, StoreNode>> FromIterator<(RpoDigest, StoreNode)> for Me
 // ================================================================================================
 impl<T: KvMap<RpoDigest, StoreNode>> Extend<InnerNodeInfo> for MerkleStore<T> {
     fn extend<I: IntoIterator<Item = InnerNodeInfo>>(&mut self, iter: I) {
-        self.nodes.extend(iter.into_iter().map(|info| {
-            (
-                info.value,
-                StoreNode {
-                    left: info.left,
-                    right: info.right,
-                },
-            )
-        }));
+        self.nodes.extend(
+            iter.into_iter()
+                .map(|info| (info.value, StoreNode { left: info.left, right: info.right })),
+        );
     }
 }
 
@@ -646,17 +633,12 @@ impl<T: KvMap<RpoDigest, StoreNode>> Deserializable for MerkleStore<T> {
 /// Creates empty hashes for all the subtrees of a tree with a max depth of 255.
 fn empty_hashes() -> impl IntoIterator<Item = (RpoDigest, StoreNode)> {
     let subtrees = EmptySubtreeRoots::empty_hashes(255);
-    subtrees.iter().rev().copied().zip(subtrees.iter().rev().skip(1).copied()).map(
-        |(child, parent)| {
-            (
-                parent,
-                StoreNode {
-                    left: child,
-                    right: child,
-                },
-            )
-        },
-    )
+    subtrees
+        .iter()
+        .rev()
+        .copied()
+        .zip(subtrees.iter().rev().skip(1).copied())
+        .map(|(child, parent)| (parent, StoreNode { left: child, right: child }))
 }
 
 /// Consumes an iterator of [InnerNodeInfo] and returns an iterator of `(value, node)` tuples
@@ -666,14 +648,6 @@ fn combine_nodes_with_empty_hashes(
 ) -> impl Iterator<Item = (RpoDigest, StoreNode)> {
     nodes
         .into_iter()
-        .map(|info| {
-            (
-                info.value,
-                StoreNode {
-                    left: info.left,
-                    right: info.right,
-                },
-            )
-        })
+        .map(|info| (info.value, StoreNode { left: info.left, right: info.right }))
         .chain(empty_hashes())
 }

src/merkle/tiered_smt/values.rs

@@ -213,10 +213,7 @@ impl StoreEntry {
 
     /// Returns an iterator over all key-value pairs in this entry.
     pub fn iter(&self) -> impl Iterator<Item = &(RpoDigest, Word)> {
-        EntryIterator {
-            entry: self,
-            pos: 0,
-        }
+        EntryIterator { entry: self, pos: 0 }
     }
 
     // STATE MUTATORS