fix: clippy warnings (#280)

CHANGELOG.md

@@ -1,3 +1,5 @@
+## 0.8.1 (TBD)
+
 ## 0.8.0 (2024-02-14)
 
 * Implemented the `PartialMmr` data structure (#195).

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "miden-crypto"
-version = "0.8.0"
+version = "0.8.1"
 description = "Miden Cryptographic primitives"
 authors = ["miden contributors"]
 readme = "README.md"
 license = "MIT"
 repository = "https://github.com/0xPolygonMiden/crypto"
-documentation = "https://docs.rs/miden-crypto/0.8.0"
+documentation = "https://docs.rs/miden-crypto/0.8.1"
 categories = ["cryptography", "no-std"]
 keywords = ["miden", "crypto", "hash", "merkle"]
 edition = "2021"

benches/smt.rs

@@ -1,4 +1,5 @@
 use core::mem::swap;
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use miden_crypto::{
     merkle::{LeafIndex, SimpleSmt},

benches/store.rs

@@ -1,9 +1,12 @@
 use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
-use miden_crypto::merkle::{
+use miden_crypto::{
-    DefaultMerkleStore as MerkleStore, LeafIndex, MerkleTree, NodeIndex, SimpleSmt, SMT_MAX_DEPTH,
+    hash::rpo::RpoDigest,
+    merkle::{
+        DefaultMerkleStore as MerkleStore, LeafIndex, MerkleTree, NodeIndex, SimpleSmt,
+        SMT_MAX_DEPTH,
+    },
+    Felt, Word,
 };
-use miden_crypto::Word;
-use miden_crypto::{hash::rpo::RpoDigest, Felt};
 use rand_utils::{rand_array, rand_value};
 
 /// Since MerkleTree can only be created when a power-of-two number of elements is used, the sample

src/dsa/rpo_falcon512/error.rs

@@ -1,6 +1,7 @@
-use super::{LOG_N, MODULUS, PK_LEN};
 use core::fmt;
 
+use super::{LOG_N, MODULUS, PK_LEN};
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum FalconError {
     KeyGenerationFailed,

src/dsa/rpo_falcon512/ffi.rs

@@ -96,9 +96,10 @@ pub struct Rpo128Context {
 
 #[cfg(all(test, feature = "std"))]
 mod tests {
+    use rand_utils::{rand_array, rand_value, rand_vector};
+
     use super::*;
     use crate::dsa::rpo_falcon512::{NONCE_LEN, PK_LEN, SIG_LEN, SK_LEN};
-    use rand_utils::{rand_array, rand_value, rand_vector};
 
     #[test]
     fn falcon_ffi() {

src/dsa/rpo_falcon512/keys.rs

@@ -1,11 +1,10 @@
+#[cfg(feature = "std")]
+use super::{ffi, NonceBytes, NONCE_LEN, PK_LEN, SIG_LEN, SK_LEN};
 use super::{
     ByteReader, ByteWriter, Deserializable, DeserializationError, FalconError, Polynomial,
     PublicKeyBytes, Rpo256, SecretKeyBytes, Serializable, Signature, Word,
 };
 
-#[cfg(feature = "std")]
-use super::{ffi, NonceBytes, NONCE_LEN, PK_LEN, SIG_LEN, SK_LEN};
-
 // PUBLIC KEY
 // ================================================================================================
 
@@ -182,9 +181,10 @@ impl Deserializable for KeyPair {
 
 #[cfg(all(test, feature = "std"))]
 mod tests {
-    use super::{super::Felt, KeyPair, NonceBytes, Word};
     use rand_utils::{rand_array, rand_vector};
 
+    use super::{super::Felt, KeyPair, NonceBytes, Word};
+
     #[test]
     fn test_falcon_verification() {
         // generate random keys

src/dsa/rpo_falcon512/mod.rs

@@ -1,9 +1,6 @@
 use crate::{
     hash::rpo::Rpo256,
-    utils::{
+    utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable},
-        collections::Vec, ByteReader, ByteWriter, Deserializable, DeserializationError,
-        Serializable,
-    },
     Felt, Word, ZERO,
 };
 

src/dsa/rpo_falcon512/polynomial.rs

@@ -1,6 +1,8 @@
-use super::{FalconError, Felt, Vec, LOG_N, MODULUS, MODULUS_MINUS_1_OVER_TWO, N, PK_LEN};
 use core::ops::{Add, Mul, Sub};
 
+use super::{FalconError, Felt, LOG_N, MODULUS, MODULUS_MINUS_1_OVER_TWO, N, PK_LEN};
+use crate::utils::collections::*;
+
 // FALCON POLYNOMIAL
 // ================================================================================================
 

src/dsa/rpo_falcon512/signature.rs

@@ -1,10 +1,11 @@
+use core::cell::OnceCell;
+
 use super::{
     ByteReader, ByteWriter, Deserializable, DeserializationError, Felt, NonceBytes, NonceElements,
     Polynomial, PublicKeyBytes, Rpo256, Serializable, SignatureBytes, Word, MODULUS, N,
     SIG_L2_BOUND, ZERO,
 };
-use crate::utils::string::ToString;
+use crate::utils::string::*;
-use core::cell::OnceCell;
 
 // FALCON SIGNATURE
 // ================================================================================================
@@ -195,13 +196,14 @@ fn decode_nonce(nonce: &NonceBytes) -> NonceElements {
 
 #[cfg(all(test, feature = "std"))]
 mod tests {
-    use super::{
-        super::{ffi::*, Felt, KeyPair},
-        *,
-    };
     use libc::c_void;
     use rand_utils::rand_vector;
 
+    use super::{
+        super::{ffi::*, KeyPair},
+        *,
+    };
+
     // Wrappers for unsafe functions
     impl Rpo128Context {
         /// Initializes the RPO state.

src/hash/blake/mod.rs

@@ -1,14 +1,15 @@
-use super::{Digest, ElementHasher, Felt, FieldElement, Hasher};
-use crate::utils::{
-    bytes_to_hex_string, hex_to_bytes, string::String, ByteReader, ByteWriter, Deserializable,
-    DeserializationError, HexParseError, Serializable,
-};
 use core::{
     mem::{size_of, transmute, transmute_copy},
     ops::Deref,
     slice::from_raw_parts,
 };
 
+use super::{Digest, ElementHasher, Felt, FieldElement, Hasher};
+use crate::utils::{
+    bytes_to_hex_string, hex_to_bytes, string::*, ByteReader, ByteWriter, Deserializable,
+    DeserializationError, HexParseError, Serializable,
+};
+
 #[cfg(test)]
 mod tests;
 

src/hash/blake/tests.rs

@@ -1,8 +1,9 @@
-use super::*;
-use crate::utils::collections::Vec;
 use proptest::prelude::*;
 use rand_utils::rand_vector;
 
+use super::*;
+use crate::utils::collections::*;
+
 #[test]
 fn blake3_hash_elements() {
     // test multiple of 8

src/hash/rescue/arch/mod.rs

@@ -1,7 +1,6 @@
 #[cfg(target_feature = "sve")]
 pub mod optimized {
-    use crate::hash::rescue::STATE_WIDTH;
+    use crate::{hash::rescue::STATE_WIDTH, Felt};
-    use crate::Felt;
 
     mod ffi {
         #[link(name = "rpo_sve", kind = "static")]
@@ -50,8 +49,10 @@ mod x86_64_avx2;
 #[cfg(target_feature = "avx2")]
 pub mod optimized {
     use super::x86_64_avx2::{apply_inv_sbox, apply_sbox};
-    use crate::hash::rescue::{add_constants, STATE_WIDTH};
+    use crate::{
-    use crate::Felt;
+        hash::rescue::{add_constants, STATE_WIDTH},
+        Felt,
+    };
 
     #[inline(always)]
     pub fn add_constants_and_apply_sbox(
@@ -80,8 +81,7 @@ pub mod optimized {
 
 #[cfg(not(any(target_feature = "avx2", target_feature = "sve")))]
 pub mod optimized {
-    use crate::hash::rescue::STATE_WIDTH;
+    use crate::{hash::rescue::STATE_WIDTH, Felt};
-    use crate::Felt;
 
     #[inline(always)]
     pub fn add_constants_and_apply_sbox(

src/hash/rescue/mds/freq.rs

@@ -157,9 +157,10 @@ const fn block3(x: [i64; 3], y: [i64; 3]) -> [i64; 3] {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{apply_mds, Felt, MDS, ZERO};
     use proptest::prelude::*;
 
+    use super::super::{apply_mds, Felt, MDS, ZERO};
+
     const STATE_WIDTH: usize = 12;
 
     #[inline(always)]

src/hash/rescue/mod.rs

@@ -1,7 +1,8 @@
+use core::ops::Range;
+
 use super::{
     CubeExtension, Digest, ElementHasher, Felt, FieldElement, Hasher, StarkField, ONE, ZERO,
 };
-use core::ops::Range;
 
 mod arch;
 pub use arch::optimized::{add_constants_and_apply_inv_sbox, add_constants_and_apply_sbox};

src/hash/rescue/rpo/digest.rs

@@ -1,10 +1,13 @@
-use super::{Digest, Felt, StarkField, DIGEST_BYTES, DIGEST_SIZE, ZERO};
-use crate::utils::{
-    bytes_to_hex_string, hex_to_bytes, string::String, ByteReader, ByteWriter, Deserializable,
-    DeserializationError, HexParseError, Serializable,
-};
 use core::{cmp::Ordering, fmt::Display, ops::Deref};
-use winter_utils::Randomizable;
+
+use super::{Digest, Felt, StarkField, DIGEST_BYTES, DIGEST_SIZE, ZERO};
+use crate::{
+    rand::Randomizable,
+    utils::{
+        bytes_to_hex_string, hex_to_bytes, string::*, ByteReader, ByteWriter, Deserializable,
+        DeserializationError, HexParseError, Serializable,
+    },
+};
 
 // DIGEST TRAIT IMPLEMENTATIONS
 // ================================================================================================
@@ -320,10 +323,11 @@ impl IntoIterator for RpoDigest {
 
 #[cfg(test)]
 mod tests {
-    use super::{Deserializable, Felt, RpoDigest, Serializable, DIGEST_BYTES, DIGEST_SIZE};
-    use crate::utils::{string::String, SliceReader};
     use rand_utils::rand_value;
 
+    use super::{Deserializable, Felt, RpoDigest, Serializable, DIGEST_BYTES, DIGEST_SIZE};
+    use crate::utils::{string::*, SliceReader};
+
     #[test]
     fn digest_serialization() {
         let e1 = Felt::new(rand_value());

src/hash/rescue/rpo/mod.rs

@@ -1,10 +1,11 @@
+use core::ops::Range;
+
 use super::{
     add_constants, add_constants_and_apply_inv_sbox, add_constants_and_apply_sbox, apply_inv_sbox,
     apply_mds, apply_sbox, Digest, ElementHasher, Felt, FieldElement, Hasher, StarkField, ARK1,
     ARK2, BINARY_CHUNK_SIZE, CAPACITY_RANGE, DIGEST_BYTES, DIGEST_RANGE, DIGEST_SIZE, INPUT1_RANGE,
     INPUT2_RANGE, MDS, NUM_ROUNDS, ONE, RATE_RANGE, RATE_WIDTH, STATE_WIDTH, ZERO,
 };
-use core::{convert::TryInto, ops::Range};
 
 mod digest;
 pub use digest::RpoDigest;

src/hash/rescue/rpo/tests.rs

@@ -1,14 +1,11 @@
+use proptest::prelude::*;
+use rand_utils::rand_value;
+
 use super::{
     super::{apply_inv_sbox, apply_sbox, ALPHA, INV_ALPHA},
     Felt, FieldElement, Hasher, Rpo256, RpoDigest, StarkField, ONE, STATE_WIDTH, ZERO,
 };
-use crate::{
+use crate::{utils::collections::*, Word};
-    utils::collections::{BTreeSet, Vec},
-    Word,
-};
-use core::convert::TryInto;
-use proptest::prelude::*;
-use rand_utils::rand_value;
 
 #[test]
 fn test_sbox() {

src/hash/rescue/rpx/digest.rs

@@ -1,10 +1,13 @@
-use super::{Digest, Felt, StarkField, DIGEST_BYTES, DIGEST_SIZE, ZERO};
-use crate::utils::{
-    bytes_to_hex_string, hex_to_bytes, string::String, ByteReader, ByteWriter, Deserializable,
-    DeserializationError, HexParseError, Serializable,
-};
 use core::{cmp::Ordering, fmt::Display, ops::Deref};
-use winter_utils::Randomizable;
+
+use super::{Digest, Felt, StarkField, DIGEST_BYTES, DIGEST_SIZE, ZERO};
+use crate::{
+    rand::Randomizable,
+    utils::{
+        bytes_to_hex_string, hex_to_bytes, string::*, ByteReader, ByteWriter, Deserializable,
+        DeserializationError, HexParseError, Serializable,
+    },
+};
 
 // DIGEST TRAIT IMPLEMENTATIONS
 // ================================================================================================
@@ -309,10 +312,11 @@ impl Deserializable for RpxDigest {
 
 #[cfg(test)]
 mod tests {
-    use super::{Deserializable, Felt, RpxDigest, Serializable, DIGEST_BYTES, DIGEST_SIZE};
-    use crate::utils::{string::String, SliceReader};
     use rand_utils::rand_value;
 
+    use super::{Deserializable, Felt, RpxDigest, Serializable, DIGEST_BYTES, DIGEST_SIZE};
+    use crate::utils::{string::*, SliceReader};
+
     #[test]
     fn digest_serialization() {
         let e1 = Felt::new(rand_value());

src/hash/rescue/rpx/mod.rs

@@ -1,3 +1,5 @@
+use core::ops::Range;
+
 use super::{
     add_constants, add_constants_and_apply_inv_sbox, add_constants_and_apply_sbox, apply_inv_sbox,
     apply_mds, apply_sbox, CubeExtension, Digest, ElementHasher, Felt, FieldElement, Hasher,
@@ -5,7 +7,6 @@ use super::{
     DIGEST_SIZE, INPUT1_RANGE, INPUT2_RANGE, MDS, NUM_ROUNDS, RATE_RANGE, RATE_WIDTH, STATE_WIDTH,
     ZERO,
 };
-use core::{convert::TryInto, ops::Range};
 
 mod digest;
 pub use digest::RpxDigest;

src/hash/rescue/tests.rs

@@ -1,6 +1,7 @@
-use super::{Felt, FieldElement, ALPHA, INV_ALPHA};
 use rand_utils::rand_value;
 
+use super::{Felt, FieldElement, ALPHA, INV_ALPHA};
+
 #[test]
 fn test_alphas() {
     let e: Felt = Felt::new(rand_value());

src/main.rs

@@ -1,3 +1,5 @@
+use std::time::Instant;
+
 use clap::Parser;
 use miden_crypto::{
     hash::rpo::{Rpo256, RpoDigest},
@@ -5,7 +7,6 @@ use miden_crypto::{
     Felt, Word, ONE,
 };
 use rand_utils::rand_value;
-use std::time::Instant;
 
 #[derive(Parser, Debug)]
 #[clap(name = "Benchmark", about = "SMT benchmark", version, rename_all = "kebab-case")]

src/merkle/empty_roots.rs

@@ -1,6 +1,7 @@
-use super::{Felt, RpoDigest, EMPTY_WORD};
 use core::slice;
 
+use super::{Felt, RpoDigest, EMPTY_WORD};
+
 // EMPTY NODES SUBTREES
 // ================================================================================================
 

src/merkle/error.rs

@@ -1,10 +1,7 @@
-use crate::{
-    merkle::{MerklePath, NodeIndex, RpoDigest},
-    utils::collections::Vec,
-};
 use core::fmt;
 
-use super::smt::SmtLeafError;
+use super::{smt::SmtLeafError, MerklePath, NodeIndex, RpoDigest};
+use crate::utils::collections::*;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum MerkleError {

src/merkle/index.rs

@@ -1,6 +1,7 @@
+use core::fmt::Display;
+
 use super::{Felt, MerkleError, RpoDigest};
 use crate::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
-use core::fmt::Display;
 
 // NODE INDEX
 // ================================================================================================
@@ -181,9 +182,10 @@ impl Deserializable for NodeIndex {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use proptest::prelude::*;
 
+    use super::*;
+
     #[test]
     fn test_node_index_value_too_high() {
         assert_eq!(NodeIndex::new(0, 0).unwrap(), NodeIndex { depth: 0, value: 0 });

src/merkle/merkle_tree.rs

@@ -1,8 +1,10 @@
-use super::{InnerNodeInfo, MerkleError, MerklePath, NodeIndex, Rpo256, RpoDigest, Vec, Word};
-use crate::utils::{string::String, uninit_vector, word_to_hex};
 use core::{fmt, ops::Deref, slice};
+
 use winter_math::log2;
 
+use super::{InnerNodeInfo, MerkleError, MerklePath, NodeIndex, Rpo256, RpoDigest, Word};
+use crate::utils::{collections::*, string::*, uninit_vector, word_to_hex};
+
 // MERKLE TREE
 // ================================================================================================
 
@@ -283,13 +285,15 @@ pub fn path_to_text(path: &MerklePath) -> Result<String, fmt::Error> {
 
 #[cfg(test)]
 mod tests {
+    use core::mem::size_of;
+
+    use proptest::prelude::*;
+
     use super::*;
     use crate::{
-        merkle::{digests_to_words, int_to_leaf, int_to_node, InnerNodeInfo},
+        merkle::{digests_to_words, int_to_leaf, int_to_node},
-        Felt, Word, WORD_SIZE,
+        Felt, WORD_SIZE,
     };
-    use core::mem::size_of;
-    use proptest::prelude::*;
 
     const LEAVES4: [RpoDigest; WORD_SIZE] =
         [int_to_node(1), int_to_node(2), int_to_node(3), int_to_node(4)];

src/merkle/mmr/delta.rs

@@ -1,4 +1,5 @@
-use super::super::{RpoDigest, Vec};
+use super::super::RpoDigest;
+use crate::utils::collections::*;
 
 /// Container for the update data of a [super::PartialMmr]
 #[derive(Debug)]

src/merkle/mmr/error.rs

@@ -1,9 +1,9 @@
-use crate::merkle::MerkleError;
 use core::fmt::{Display, Formatter};
-
 #[cfg(feature = "std")]
 use std::error::Error;
 
+use crate::merkle::MerkleError;
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum MmrError {
     InvalidPosition(usize),

src/merkle/mmr/full.rs

@@ -11,11 +11,12 @@
 //! merged, creating a new tree with depth d+1, this process is continued until the property is
 //! reestablished.
 use super::{
-    super::{InnerNodeInfo, MerklePath, Vec},
+    super::{InnerNodeInfo, MerklePath},
     bit::TrueBitPositionIterator,
     leaf_to_corresponding_tree, nodes_in_forest, MmrDelta, MmrError, MmrPeaks, MmrProof, Rpo256,
     RpoDigest,
 };
+use crate::utils::collections::*;
 
 // MMR
 // ===============================================================================================

src/merkle/mmr/inorder.rs

@@ -126,9 +126,10 @@ impl From<InOrderIndex> for u64 {
 
 #[cfg(test)]
 mod test {
-    use super::InOrderIndex;
     use proptest::prelude::*;
 
+    use super::InOrderIndex;
+
     proptest! {
         #[test]
         fn proptest_inorder_index_random(count in 1..1000usize) {

src/merkle/mmr/partial.rs

@@ -4,10 +4,7 @@ use crate::{
         mmr::{leaf_to_corresponding_tree, nodes_in_forest},
         InOrderIndex, InnerNodeInfo, MerklePath, MmrError, MmrPeaks,
     },
-    utils::{
+    utils::{collections::*, vec},
-        collections::{BTreeMap, BTreeSet, Vec},
-        vec,
-    },
 };
 
 // TYPE ALIASES
@@ -616,10 +613,13 @@ fn forest_to_rightmost_index(forest: usize) -> InOrderIndex {
 #[cfg(test)]
 mod tests {
     use super::{
-        forest_to_rightmost_index, forest_to_root_index, BTreeSet, InOrderIndex, MmrPeaks,
+        forest_to_rightmost_index, forest_to_root_index, InOrderIndex, MmrPeaks, PartialMmr,
-        PartialMmr, RpoDigest, Vec,
+        RpoDigest,
+    };
+    use crate::{
+        merkle::{int_to_node, MerkleStore, Mmr, NodeIndex},
+        utils::collections::*,
     };
-    use crate::merkle::{int_to_node, MerkleStore, Mmr, NodeIndex};
 
     const LEAVES: [RpoDigest; 7] = [
         int_to_node(0),

src/merkle/mmr/peaks.rs

@@ -1,7 +1,5 @@
-use super::{
+use super::{super::ZERO, Felt, MmrError, MmrProof, Rpo256, RpoDigest, Word};
-    super::{RpoDigest, Vec, ZERO},
+use crate::utils::collections::*;
-    Felt, MmrError, MmrProof, Rpo256, Word,
-};
 
 // MMR PEAKS
 // ================================================================================================

src/merkle/mmr/tests.rs

@@ -1,11 +1,12 @@
 use super::{
-    super::{InnerNodeInfo, Rpo256, RpoDigest, Vec},
+    super::{InnerNodeInfo, Rpo256, RpoDigest},
     bit::TrueBitPositionIterator,
     full::high_bitmask,
     leaf_to_corresponding_tree, nodes_in_forest, Mmr, MmrPeaks, PartialMmr,
 };
 use crate::{
     merkle::{int_to_node, InOrderIndex, MerklePath, MerkleTree, MmrProof, NodeIndex},
+    utils::collections::*,
     Felt, Word,
 };
 
@@ -837,9 +838,10 @@ fn test_mmr_add_invalid_odd_leaf() {
 }
 
 mod property_tests {
-    use super::leaf_to_corresponding_tree;
     use proptest::prelude::*;
 
+    use super::leaf_to_corresponding_tree;
+
     proptest! {
         #[test]
         fn test_last_position_is_always_contained_in_the_last_tree(leaves in any::<usize>().prop_filter("cant have an empty tree", |v| *v != 0)) {

src/merkle/mod.rs

@@ -2,7 +2,6 @@
 
 use super::{
     hash::rpo::{Rpo256, RpoDigest},
-    utils::collections::{vec, BTreeMap, BTreeSet, KvMap, RecordingMap, Vec},
     Felt, Word, EMPTY_WORD, ZERO,
 };
 
@@ -45,6 +44,9 @@ pub use error::MerkleError;
 // HELPER FUNCTIONS
 // ================================================================================================
 
+#[cfg(test)]
+use crate::utils::collections::*;
+
 #[cfg(test)]
 const fn int_to_node(value: u64) -> RpoDigest {
     RpoDigest::new([Felt::new(value), ZERO, ZERO, ZERO])

src/merkle/partial_mt/mod.rs

@@ -1,12 +1,13 @@
+use core::fmt;
+
 use super::{
-    BTreeMap, BTreeSet, InnerNodeInfo, MerkleError, MerklePath, NodeIndex, Rpo256, RpoDigest,
+    InnerNodeInfo, MerkleError, MerklePath, NodeIndex, Rpo256, RpoDigest, ValuePath, Word,
-    ValuePath, Vec, Word, EMPTY_WORD,
+    EMPTY_WORD,
 };
 use crate::utils::{
-    format, string::String, vec, word_to_hex, ByteReader, ByteWriter, Deserializable,
+    collections::*, format, string::*, vec, word_to_hex, ByteReader, ByteWriter, Deserializable,
     DeserializationError, Serializable,
 };
-use core::fmt;
 
 #[cfg(test)]
 mod tests;

src/merkle/partial_mt/tests.rs

@@ -1,10 +1,11 @@
 use super::{
     super::{
-        digests_to_words, int_to_node, BTreeMap, DefaultMerkleStore as MerkleStore, MerkleTree,
+        digests_to_words, int_to_node, DefaultMerkleStore as MerkleStore, MerkleTree, NodeIndex,
-        NodeIndex, PartialMerkleTree,
+        PartialMerkleTree,
     },
-    Deserializable, InnerNodeInfo, RpoDigest, Serializable, ValuePath, Vec,
+    Deserializable, InnerNodeInfo, RpoDigest, Serializable, ValuePath,
 };
+use crate::utils::collections::*;
 
 // TEST DATA
 // ================================================================================================

src/merkle/path.rs

@@ -1,8 +1,10 @@
-use crate::Word;
-
-use super::{vec, InnerNodeInfo, MerkleError, NodeIndex, Rpo256, RpoDigest, Vec};
 use core::ops::{Deref, DerefMut};
-use winter_utils::{ByteReader, Deserializable, DeserializationError, Serializable};
+
+use super::{InnerNodeInfo, MerkleError, NodeIndex, Rpo256, RpoDigest};
+use crate::{
+    utils::{collections::*, ByteReader, Deserializable, DeserializationError, Serializable},
+    Word,
+};
 
 // MERKLE PATH
 // ================================================================================================

src/merkle/smt/full/error.rs

@@ -3,7 +3,7 @@ use core::fmt;
 use crate::{
     hash::rpo::RpoDigest,
     merkle::{LeafIndex, SMT_DEPTH},
-    utils::collections::Vec,
+    utils::collections::*,
     Word,
 };
 

src/merkle/smt/full/leaf.rs

@@ -1,9 +1,10 @@
 use core::cmp::Ordering;
 
-use crate::utils::{collections::Vec, string::ToString, vec};
-use winter_utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
-
 use super::{Felt, LeafIndex, Rpo256, RpoDigest, SmtLeafError, Word, EMPTY_WORD, SMT_DEPTH};
+use crate::utils::{
+    collections::*, string::*, vec, ByteReader, ByteWriter, Deserializable, DeserializationError,
+    Serializable,
+};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]

src/merkle/smt/full/mod.rs

@@ -1,11 +1,8 @@
-use crate::hash::rpo::Rpo256;
-use crate::merkle::{EmptySubtreeRoots, InnerNodeInfo};
-use crate::utils::collections::{BTreeMap, BTreeSet};
-use crate::{Felt, EMPTY_WORD};
-
 use super::{
-    InnerNode, LeafIndex, MerkleError, MerklePath, NodeIndex, RpoDigest, SparseMerkleTree, Word,
+    EmptySubtreeRoots, Felt, InnerNode, InnerNodeInfo, LeafIndex, MerkleError, MerklePath,
+    NodeIndex, Rpo256, RpoDigest, SparseMerkleTree, Word, EMPTY_WORD,
 };
+use crate::utils::collections::*;
 
 mod error;
 pub use error::{SmtLeafError, SmtProofError};

src/merkle/smt/full/proof.rs

@@ -1,7 +1,7 @@
-use crate::utils::string::ToString;
-use winter_utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
-
 use super::{MerklePath, RpoDigest, SmtLeaf, SmtProofError, Word, SMT_DEPTH};
+use crate::utils::{
+    string::*, ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable,
+};
 
 /// A proof which can be used to assert membership (or non-membership) of key-value pairs in a
 /// [`super::Smt`].
@@ -23,7 +23,8 @@ impl SmtProof {
     /// # Errors
     /// Returns an error if the path length is not [`SMT_DEPTH`].
     pub fn new(path: MerklePath, leaf: SmtLeaf) -> Result<Self, SmtProofError> {
-        if path.len() != SMT_DEPTH.into() {
+        let depth: usize = SMT_DEPTH.into();
+        if path.len() != depth {
             return Err(SmtProofError::InvalidPathLength(path.len()));
         }
 

src/merkle/smt/full/tests.rs

@@ -1,10 +1,8 @@
-use winter_utils::{Deserializable, Serializable};
+use super::{Felt, LeafIndex, NodeIndex, Rpo256, RpoDigest, Smt, SmtLeaf, EMPTY_WORD, SMT_DEPTH};
-
-use super::*;
 use crate::{
     merkle::{EmptySubtreeRoots, MerkleStore},
-    utils::collections::Vec,
+    utils::{collections::*, Deserializable, Serializable},
-    ONE, WORD_SIZE,
+    Word, ONE, WORD_SIZE,
 };
 
 // SMT

src/merkle/smt/mod.rs

@@ -1,10 +1,10 @@
+use super::{EmptySubtreeRoots, InnerNodeInfo, MerkleError, MerklePath, NodeIndex};
 use crate::{
     hash::rpo::{Rpo256, RpoDigest},
-    Word,
+    utils::collections::*,
+    Felt, Word, EMPTY_WORD,
 };
 
-use super::{EmptySubtreeRoots, MerkleError, MerklePath, NodeIndex, Vec};
-
 mod full;
 pub use full::{Smt, SmtLeaf, SmtLeafError, SmtProof, SmtProofError, SMT_DEPTH};
 

src/merkle/smt/simple/mod.rs

@@ -1,13 +1,9 @@
-use crate::{
-    merkle::{EmptySubtreeRoots, InnerNodeInfo, MerklePath, ValuePath},
-    EMPTY_WORD,
-};
-
 use super::{
-    InnerNode, LeafIndex, MerkleError, NodeIndex, RpoDigest, SparseMerkleTree, Word, SMT_MAX_DEPTH,
+    super::ValuePath, EmptySubtreeRoots, InnerNode, InnerNodeInfo, LeafIndex, MerkleError,
+    MerklePath, NodeIndex, RpoDigest, SparseMerkleTree, Word, EMPTY_WORD, SMT_MAX_DEPTH,
     SMT_MIN_DEPTH,
 };
-use crate::utils::collections::{BTreeMap, BTreeSet};
+use crate::utils::collections::*;
 
 #[cfg(test)]
 mod tests;

src/merkle/smt/simple/tests.rs

@@ -8,7 +8,7 @@ use crate::{
         digests_to_words, int_to_leaf, int_to_node, smt::SparseMerkleTree, EmptySubtreeRoots,
         InnerNodeInfo, LeafIndex, MerkleTree,
     },
-    utils::collections::Vec,
+    utils::collections::*,
     Word, EMPTY_WORD,
 };
 

src/merkle/store/mod.rs

@@ -1,11 +1,13 @@
-use super::{
-    mmr::Mmr, BTreeMap, EmptySubtreeRoots, InnerNodeInfo, KvMap, MerkleError, MerklePath,
-    MerkleTree, NodeIndex, PartialMerkleTree, RecordingMap, RootPath, Rpo256, RpoDigest, SimpleSmt,
-    Smt, ValuePath, Vec,
-};
-use crate::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
 use core::borrow::Borrow;
 
+use super::{
+    mmr::Mmr, EmptySubtreeRoots, InnerNodeInfo, MerkleError, MerklePath, MerkleTree, NodeIndex,
+    PartialMerkleTree, RootPath, Rpo256, RpoDigest, SimpleSmt, Smt, ValuePath,
+};
+use crate::utils::{
+    collections::*, ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable,
+};
+
 #[cfg(test)]
 mod tests;
 

src/merkle/store/tests.rs

@@ -1,3 +1,5 @@
+use seq_macro::seq;
+
 use super::{
     DefaultMerkleStore as MerkleStore, EmptySubtreeRoots, MerkleError, MerklePath, NodeIndex,
     PartialMerkleTree, RecordingMerkleStore, Rpo256, RpoDigest,
@@ -10,12 +12,10 @@ use crate::{
 };
 
 #[cfg(feature = "std")]
-use super::{Deserializable, Serializable};
+use {
-
+    super::{Deserializable, Serializable},
-#[cfg(feature = "std")]
+    std::error::Error,
-use std::error::Error;
+};
-
-use seq_macro::seq;
 
 // TEST DATA
 // ================================================================================================

src/rand/mod.rs

@@ -1,6 +1,7 @@
 //! Pseudo-random element generation.
 
 pub use winter_crypto::{DefaultRandomCoin as WinterRandomCoin, RandomCoin, RandomCoinError};
+pub use winter_utils::Randomizable;
 
 use crate::{Felt, FieldElement, Word, ZERO};
 

src/rand/rpo.rs

@@ -1,12 +1,11 @@
-use super::{Felt, FeltRng, FieldElement, Word, ZERO};
+use super::{Felt, FeltRng, FieldElement, RandomCoin, RandomCoinError, Word, ZERO};
 use crate::{
     hash::rpo::{Rpo256, RpoDigest},
     utils::{
-        collections::Vec, string::ToString, vec, ByteReader, ByteWriter, Deserializable,
+        collections::*, string::*, vec, ByteReader, ByteWriter, Deserializable,
         DeserializationError, Serializable,
     },
 };
-pub use winter_crypto::{RandomCoin, RandomCoinError};
 
 // CONSTANTS
 // ================================================================================================

src/utils/kv_map.rs

@@ -1,7 +1,8 @@
 use core::cell::RefCell;
-use winter_utils::{
+
-    collections::{btree_map::IntoIter, BTreeMap, BTreeSet},
+use super::{
-    Box,
+    boxed::*,
+    collections::{btree_map::*, *},
 };
 
 // KEY-VALUE MAP TRAIT

src/utils/mod.rs

@@ -1,26 +1,29 @@
 //! Utilities used in this crate which can also be generally useful downstream.
 
-use super::{utils::string::String, Word};
 use core::fmt::{self, Display, Write};
 
+#[cfg(feature = "std")]
+pub use std::{format, vec};
+
 #[cfg(not(feature = "std"))]
 pub use alloc::{format, vec};
 
-#[cfg(feature = "std")]
+use super::Word;
-pub use std::{format, vec};
+use crate::utils::string::*;
 
 mod kv_map;
 
 // RE-EXPORTS
 // ================================================================================================
 pub use winter_utils::{
-    string, uninit_vector, Box, ByteReader, ByteWriter, Deserializable, DeserializationError,
+    boxed, string, uninit_vector, Box, ByteReader, ByteWriter, Deserializable,
-    Serializable, SliceReader,
+    DeserializationError, Serializable, SliceReader,
 };
 
 pub mod collections {
-    pub use super::kv_map::*;
     pub use winter_utils::collections::*;
+
+    pub use super::kv_map::*;
 }
 
 // UTILITY FUNCTIONS