@@ -48,17 +48,17 @@ [dependencies]
 blake3 = { version = "1.5", default-features = false }
 clap = { version = "4.4", features = ["derive"], optional = true }
 libc = { version = "0.2", default-features = false, optional = true }
-rand_utils = { version = "0.7", package = "winter-rand-utils", optional = true }
+rand_utils = { version = "0.8", package = "winter-rand-utils", optional = true }
 serde = { version = "1.0", features = ["derive"], default-features = false, optional = true }
-winter_crypto = { version = "0.7", package = "winter-crypto", default-features = false }
-winter_math = { version = "0.7", package = "winter-math", default-features = false }
-winter_utils = { version = "0.7", package = "winter-utils", default-features = false }
+winter_crypto = { version = "0.8", package = "winter-crypto", default-features = false }
+winter_math = { version = "0.8", package = "winter-math", default-features = false }
+winter_utils = { version = "0.8", package = "winter-utils", default-features = false }
 
 [dev-dependencies]
 seq-macro = { version = "0.3" }
 criterion = { version = "0.5", features = ["html_reports"] }
 proptest = "1.4"
-rand_utils = { version = "0.7", package = "winter-rand-utils" }
+rand_utils = { version = "0.8", package = "winter-rand-utils" }
 
 [build-dependencies]
 cc = { version = "1.0", features = ["parallel"], optional = true }

@@ -4,7 +4,7 @@ PublicKeyBytes, Rpo256, SecretKeyBytes, Serializable, Signature, Word,
 };
 
 #[cfg(feature = "std")]
-use super::{ffi, NonceBytes, StarkField, NONCE_LEN, PK_LEN, SIG_LEN, SK_LEN};
+use super::{ffi, NonceBytes, NONCE_LEN, PK_LEN, SIG_LEN, SK_LEN};
 
 // PUBLIC KEY
 // ================================================================================================

@@ -4,7 +4,7 @@ utils::{
         collections::Vec, ByteReader, ByteWriter, Deserializable, DeserializationError,
         Serializable,
     },
-    Felt, StarkField, Word, ZERO,
+    Felt, Word, ZERO,
 };
 
 #[cfg(feature = "std")]

@@ -1,6 +1,6 @@
 use super::{
-    ByteReader, ByteWriter, Deserializable, DeserializationError, NonceBytes, NonceElements,
-    Polynomial, PublicKeyBytes, Rpo256, Serializable, SignatureBytes, StarkField, Word, MODULUS, N,
+    ByteReader, ByteWriter, Deserializable, DeserializationError, Felt, NonceBytes, NonceElements,
+    Polynomial, PublicKeyBytes, Rpo256, Serializable, SignatureBytes, Word, MODULUS, N,
     SIG_L2_BOUND, ZERO,
 };
 use crate::utils::string::ToString;
@@ -182,7 +182,9 @@ let mut buffer = [0_u8; 8];
     let mut result = [ZERO; 8];
     for (i, bytes) in nonce.chunks(5).enumerate() {
         buffer[..5].copy_from_slice(bytes);
-        result[i] = u64::from_le_bytes(buffer).into();
+        // we can safely (without overflow) create a new Felt from u64 value here since this value
+        // contains at most 5 bytes
+        result[i] = Felt::new(u64::from_le_bytes(buffer));
     }
 
     result

@@ -1,4 +1,4 @@
-use super::{Digest, ElementHasher, Felt, FieldElement, Hasher, StarkField};
+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,

@@ -234,15 +234,12 @@ impl TryFrom<[u64; DIGEST_SIZE]> for RpoDigest {
     type Error = RpoDigestError;
 
     fn try_from(value: [u64; DIGEST_SIZE]) -> Result<Self, RpoDigestError> {
-        if value[0] >= Felt::MODULUS
-            || value[1] >= Felt::MODULUS
-            || value[2] >= Felt::MODULUS
-            || value[3] >= Felt::MODULUS
-        {
-            return Err(RpoDigestError::InvalidInteger);
-        }
-
-        Ok(Self([value[0].into(), value[1].into(), value[2].into(), value[3].into()]))
+        Ok(Self([
+            value[0].try_into().map_err(|_| RpoDigestError::InvalidInteger)?,
+            value[1].try_into().map_err(|_| RpoDigestError::InvalidInteger)?,
+            value[2].try_into().map_err(|_| RpoDigestError::InvalidInteger)?,
+            value[3].try_into().map_err(|_| RpoDigestError::InvalidInteger)?,
+        ]))
     }
 }
 

@@ -234,15 +234,12 @@ impl TryFrom<[u64; DIGEST_SIZE]> for RpxDigest {
     type Error = RpxDigestError;
 
     fn try_from(value: [u64; DIGEST_SIZE]) -> Result<Self, RpxDigestError> {
-        if value[0] >= Felt::MODULUS
-            || value[1] >= Felt::MODULUS
-            || value[2] >= Felt::MODULUS
-            || value[3] >= Felt::MODULUS
-        {
-            return Err(RpxDigestError::InvalidInteger);
-        }
-
-        Ok(Self([value[0].into(), value[1].into(), value[2].into(), value[3].into()]))
+        Ok(Self([
+            value[0].try_into().map_err(|_| RpxDigestError::InvalidInteger)?,
+            value[1].try_into().map_err(|_| RpxDigestError::InvalidInteger)?,
+            value[2].try_into().map_err(|_| RpxDigestError::InvalidInteger)?,
+            value[3].try_into().map_err(|_| RpxDigestError::InvalidInteger)?,
+        ]))
     }
 }
 

@@ -1,4 +1,4 @@
-use super::{Felt, MerkleError, RpoDigest, StarkField};
+use super::{Felt, MerkleError, RpoDigest};
 use crate::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
 use core::fmt::Display;
 

@@ -3,7 +3,7 @@
 use super::{
     hash::rpo::{Rpo256, RpoDigest},
     utils::collections::{vec, BTreeMap, BTreeSet, KvMap, RecordingMap, Vec},
-    Felt, StarkField, Word, EMPTY_WORD, ZERO,
+    Felt, Word, EMPTY_WORD, ZERO,
 };
 
 // REEXPORTS

@@ -206,14 +206,14 @@ impl Serializable for MerklePath {
     fn write_into<W: winter_utils::ByteWriter>(&self, target: &mut W) {
         assert!(self.nodes.len() <= u8::MAX.into(), "Length enforced in the constructor");
         target.write_u8(self.nodes.len() as u8);
-        self.nodes.write_into(target);
+        target.write_many(&self.nodes);
     }
 }
 
 impl Deserializable for MerklePath {
     fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
         let count = source.read_u8()?.into();
-        let nodes = RpoDigest::read_batch_from(source, count)?;
+        let nodes = source.read_many::<RpoDigest>(count)?;
         Ok(Self { nodes })
     }
 }

@@ -1,7 +1,6 @@
 use core::cmp::Ordering;
 
 use crate::utils::{collections::Vec, string::ToString, vec};
-use winter_math::StarkField;
 use winter_utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
 
 use super::{Felt, LeafIndex, Rpo256, RpoDigest, SmtLeafError, Word, EMPTY_WORD, SMT_DEPTH};

@@ -1,5 +1,3 @@
-use winter_math::StarkField;
-
 use crate::hash::rpo::Rpo256;
 use crate::merkle::{EmptySubtreeRoots, InnerNodeInfo};
 use crate::utils::collections::{BTreeMap, BTreeSet};

@@ -60,7 +60,7 @@ // The most significant u64 used for both keys (to ensure they map to the same leaf)
     let key_msb: u64 = 42;
 
     let key_already_present: RpoDigest =
-        RpoDigest::from([2_u64.into(), 2_u64.into(), 2_u64.into(), Felt::new(key_msb)]);
+        RpoDigest::from([2_u32.into(), 2_u32.into(), 2_u32.into(), Felt::new(key_msb)]);
     let key_already_present_index: NodeIndex =
         LeafIndex::<SMT_DEPTH>::from(key_already_present).into();
     let value_already_present = [ONE + ONE + ONE; WORD_SIZE];
@@ -192,13 +192,13 @@ let raw = 0b_01101001_01101100_00011111_11111111_10010110_10010011_11100000_00000000_u64;
 
     let key_1: RpoDigest = RpoDigest::from([ONE, ONE, ONE, Felt::new(raw)]);
     let key_2: RpoDigest =
-        RpoDigest::from([2_u64.into(), 2_u64.into(), 2_u64.into(), Felt::new(raw)]);
+        RpoDigest::from([2_u32.into(), 2_u32.into(), 2_u32.into(), Felt::new(raw)]);
     let key_3: RpoDigest =
-        RpoDigest::from([3_u64.into(), 3_u64.into(), 3_u64.into(), Felt::new(raw)]);
+        RpoDigest::from([3_u32.into(), 3_u32.into(), 3_u32.into(), Felt::new(raw)]);
 
     let value_1 = [ONE; WORD_SIZE];
-    let value_2 = [2_u64.into(); WORD_SIZE];
-    let value_3: [Felt; 4] = [3_u64.into(); WORD_SIZE];
+    let value_2 = [2_u32.into(); WORD_SIZE];
+    let value_3: [Felt; 4] = [3_u32.into(); WORD_SIZE];
 
     // insert key-value 1
     {
@@ -265,10 +265,10 @@ let raw = 0b_01101001_01101100_00011111_11111111_10010110_10010011_11100000_00000000_u64;
 
     let key_1: RpoDigest = RpoDigest::from([ONE, ONE, ONE, Felt::new(raw)]);
     let key_2: RpoDigest =
-        RpoDigest::from([2_u64.into(), 2_u64.into(), 2_u64.into(), Felt::new(raw)]);
+        RpoDigest::from([2_u32.into(), 2_u32.into(), 2_u32.into(), Felt::new(raw)]);
 
     let value_1 = [ONE; WORD_SIZE];
-    let value_2 = [2_u64.into(); WORD_SIZE];
+    let value_2 = [2_u32.into(); WORD_SIZE];
 
     let smt = Smt::with_entries([(key_1, value_1), (key_2, value_2)]).unwrap();
 
@@ -289,10 +289,10 @@ #[test]
 fn test_smt_get_value() {
     let key_1: RpoDigest = RpoDigest::from([ONE, ONE, ONE, ONE]);
     let key_2: RpoDigest =
-        RpoDigest::from([2_u64.into(), 2_u64.into(), 2_u64.into(), 2_u64.into()]);
+        RpoDigest::from([2_u32.into(), 2_u32.into(), 2_u32.into(), 2_u32.into()]);
 
     let value_1 = [ONE; WORD_SIZE];
-    let value_2 = [2_u64.into(); WORD_SIZE];
+    let value_2 = [2_u32.into(); WORD_SIZE];
 
     let smt = Smt::with_entries([(key_1, value_1), (key_2, value_2)]).unwrap();
 
@@ -304,7 +304,7 @@ assert_eq!(value_2, returned_value_2);
 
     // Check that a key with no inserted value returns the empty word
     let key_no_value =
-        RpoDigest::from([42_u64.into(), 42_u64.into(), 42_u64.into(), 42_u64.into()]);
+        RpoDigest::from([42_u32.into(), 42_u32.into(), 42_u32.into(), 42_u32.into()]);
 
     assert_eq!(EMPTY_WORD, smt.get_value(&key_no_value));
 }
@@ -314,10 +314,10 @@ #[test]
 fn test_smt_entries() {
     let key_1: RpoDigest = RpoDigest::from([ONE, ONE, ONE, ONE]);
     let key_2: RpoDigest =
-        RpoDigest::from([2_u64.into(), 2_u64.into(), 2_u64.into(), 2_u64.into()]);
+        RpoDigest::from([2_u32.into(), 2_u32.into(), 2_u32.into(), 2_u32.into()]);
 
     let value_1 = [ONE; WORD_SIZE];
-    let value_2 = [2_u64.into(); WORD_SIZE];
+    let value_2 = [2_u32.into(); WORD_SIZE];
 
     let smt = Smt::with_entries([(key_1, value_1), (key_2, value_2)]).unwrap();
 
@@ -348,8 +348,8 @@
 #[test]
 fn test_single_smt_leaf_serialization() {
     let single_leaf = SmtLeaf::new_single(
-        RpoDigest::from([10_u64.into(), 11_u64.into(), 12_u64.into(), 13_u64.into()]),
-        [1_u64.into(), 2_u64.into(), 3_u64.into(), 4_u64.into()],
+        RpoDigest::from([10_u32.into(), 11_u32.into(), 12_u32.into(), 13_u32.into()]),
+        [1_u32.into(), 2_u32.into(), 3_u32.into(), 4_u32.into()],
     );
 
     let mut serialized = single_leaf.to_bytes();
@@ -364,12 +364,12 @@ #[test]
 fn test_multiple_smt_leaf_serialization_success() {
     let multiple_leaf = SmtLeaf::new_multiple(vec![
         (
-            RpoDigest::from([10_u64.into(), 11_u64.into(), 12_u64.into(), 13_u64.into()]),
-            [1_u64.into(), 2_u64.into(), 3_u64.into(), 4_u64.into()],
+            RpoDigest::from([10_u32.into(), 11_u32.into(), 12_u32.into(), 13_u32.into()]),
+            [1_u32.into(), 2_u32.into(), 3_u32.into(), 4_u32.into()],
         ),
         (
-            RpoDigest::from([100_u64.into(), 101_u64.into(), 102_u64.into(), 13_u64.into()]),
-            [11_u64.into(), 12_u64.into(), 13_u64.into(), 14_u64.into()],
+            RpoDigest::from([100_u32.into(), 101_u32.into(), 102_u32.into(), 13_u32.into()]),
+            [11_u32.into(), 12_u32.into(), 13_u32.into(), 14_u32.into()],
         ),
     ])
     .unwrap();

@@ -2,7 +2,7 @@ //! Pseudo-random element generation.
 
 pub use winter_crypto::{DefaultRandomCoin as WinterRandomCoin, RandomCoin, RandomCoinError};
 
-use crate::{Felt, FieldElement, StarkField, Word, ZERO};
+use crate::{Felt, FieldElement, Word, ZERO};
 
 mod rpo;
 pub use rpo::RpoRandomCoin;

@@ -1,4 +1,4 @@
-use super::{Felt, FeltRng, FieldElement, StarkField, Word, ZERO};
+use super::{Felt, FeltRng, FieldElement, Word, ZERO};
 use crate::{
     hash::rpo::{Rpo256, RpoDigest},
     utils::{