diff --git a/crates/starknet-types-core/Cargo.toml b/crates/starknet-types-core/Cargo.toml
index 0742cdd2..f3703cda 100644
--- a/crates/starknet-types-core/Cargo.toml
+++ b/crates/starknet-types-core/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "starknet-types-core"
-version = "0.4.0"
-edition = "2021"
+version = "1.0.0"
+edition = "2024"
 license = "MIT"
 homepage = "https://github.com/starknet-io/types-rs"
 repository = "https://github.com/starknet-io/types-rs"
@@ -74,3 +74,4 @@ bincode = "1"
 [[bench]]
 name = "criterion_hashes"
 harness = false
+required-features = ["hash"]
diff --git a/crates/starknet-types-core/benches/criterion_hashes.rs b/crates/starknet-types-core/benches/criterion_hashes.rs
index 3fd5c222..3b4a6312 100644
--- a/crates/starknet-types-core/benches/criterion_hashes.rs
+++ b/crates/starknet-types-core/benches/criterion_hashes.rs
@@ -1,10 +1,9 @@
-use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
+use criterion::{BatchSize, BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
 use rand::{Rng, RngCore, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 
 use starknet_types_core::felt::Felt;
-use starknet_types_core::hash::StarkHash;
-use starknet_types_core::hash::{Pedersen, Poseidon};
+use starknet_types_core::hash::{Pedersen, Poseidon, StarkHash};
 
 const SEED: u64 = 3;
 
diff --git a/crates/starknet-types-core/src/felt/alloc_impls.rs b/crates/starknet-types-core/src/felt/alloc_impls.rs
index 52a97f78..8394de30 100644
--- a/crates/starknet-types-core/src/felt/alloc_impls.rs
+++ b/crates/starknet-types-core/src/felt/alloc_impls.rs
@@ -1,7 +1,7 @@
 use core::fmt;
 
-use super::alloc;
 use super::Felt;
+use super::alloc;
 
 impl Felt {
     /// Helper to represent the felt value as a zero-padded hexadecimal string.
diff --git a/crates/starknet-types-core/src/felt/mod.rs b/crates/starknet-types-core/src/felt/mod.rs
index dd6ca4ab..49f28c72 100644
--- a/crates/starknet-types-core/src/felt/mod.rs
+++ b/crates/starknet-types-core/src/felt/mod.rs
@@ -109,11 +109,6 @@ impl Felt {
         Self(FieldElement::<Stark252PrimeField>::from_hex_unchecked(val))
     }
 
-    #[deprecated(since = "0.3.1", note = "use `from_hex_unwrap` instead")]
-    pub const fn from_hex_unchecked(val: &str) -> Self {
-        Self(FieldElement::<Stark252PrimeField>::from_hex_unchecked(val))
-    }
-
     /// Creates a new [Felt] from its big-endian representation in a [u8; 32] array.
     /// This is as performant as [from_bytes_le](Felt::from_bytes_le).
     pub fn from_bytes_be(bytes: &[u8; 32]) -> Self {
@@ -1342,14 +1337,14 @@ mod test {
 
     #[test]
     fn felt_from_hex_upper_bound_limit() {
-        assert!(Felt::from_hex(
-            "0x800000000000011000000000000000000000000000000000000000000000001"
-        )
-        .is_ok());
-        assert!(Felt::from_hex(
-            "0x800000000000011000000000000000000000000000000000000000000000002"
-        )
-        .is_err());
+        assert!(
+            Felt::from_hex("0x800000000000011000000000000000000000000000000000000000000000001")
+                .is_ok()
+        );
+        assert!(
+            Felt::from_hex("0x800000000000011000000000000000000000000000000000000000000000002")
+                .is_err()
+        );
         assert!(Felt::from_hex(&format!("0x{}", "f".repeat(63))).is_err());
     }
 }
diff --git a/crates/starknet-types-core/src/felt/non_zero.rs b/crates/starknet-types-core/src/felt/non_zero.rs
index 58198fef..75a84d9d 100644
--- a/crates/starknet-types-core/src/felt/non_zero.rs
+++ b/crates/starknet-types-core/src/felt/non_zero.rs
@@ -116,7 +116,7 @@ mod tests {
 
     use proptest::prelude::*;
 
-    use crate::felt::{felt_arbitrary::nonzero_felt, Felt, NonZeroFelt};
+    use crate::felt::{Felt, NonZeroFelt, felt_arbitrary::nonzero_felt};
 
     #[test]
     fn nonzerofelt_from_raw() {
diff --git a/crates/starknet-types-core/src/felt/secret_felt.rs b/crates/starknet-types-core/src/felt/secret_felt.rs
index a9f929c7..f6caf2e6 100644
--- a/crates/starknet-types-core/src/felt/secret_felt.rs
+++ b/crates/starknet-types-core/src/felt/secret_felt.rs
@@ -132,8 +132,8 @@ impl SecretFelt {
 /// Constant time equality check for [SecretFelt]
 impl PartialEq for SecretFelt {
     fn eq(&self, other: &Self) -> bool {
-        let mut self_limbs = self.0 .0.representative().limbs;
-        let mut other_limbs = other.0 .0.representative().limbs;
+        let mut self_limbs = self.0.0.representative().limbs;
+        let mut other_limbs = other.0.0.representative().limbs;
 
         let is_eq: bool = self_limbs.ct_eq(&other_limbs).into();
 
@@ -146,9 +146,9 @@ impl PartialEq for SecretFelt {
 
 #[cfg(test)]
 mod test {
-    use crate::felt::{secret_felt::SecretFelt, Felt};
+    use crate::felt::{Felt, secret_felt::SecretFelt};
     use core::mem::size_of;
-    use rand_chacha::{rand_core::SeedableRng, ChaCha20Rng};
+    use rand_chacha::{ChaCha20Rng, rand_core::SeedableRng};
     use std::{ops::Deref, str::FromStr};
     use zeroize::Zeroize;
 
diff --git a/crates/starknet-types-core/src/felt/serde.rs b/crates/starknet-types-core/src/felt/serde.rs
index 8dca37d2..c37a38e1 100644
--- a/crates/starknet-types-core/src/felt/serde.rs
+++ b/crates/starknet-types-core/src/felt/serde.rs
@@ -7,8 +7,8 @@ use lambdaworks_math::field::{
     element::FieldElement, fields::fft_friendly::stark_252_prime_field::Stark252PrimeField,
 };
 use serde::{
-    de::{self},
     Deserialize, Serialize,
+    de::{self},
 };
 
 use super::Felt;
@@ -86,7 +86,7 @@ mod tests {
     use super::*;
     use bincode::Options;
     use proptest::prelude::*;
-    use serde_test::{assert_tokens, Configure, Token};
+    use serde_test::{Configure, Token, assert_tokens};
 
     #[test]
     fn serde() {
diff --git a/crates/starknet-types-core/src/hash/poseidon.rs b/crates/starknet-types-core/src/hash/poseidon.rs
index 0b243cc1..307585e7 100644
--- a/crates/starknet-types-core/src/hash/poseidon.rs
+++ b/crates/starknet-types-core/src/hash/poseidon.rs
@@ -1,6 +1,6 @@
 use crate::felt::Felt;
 use lambdaworks_crypto::hash::poseidon::{
-    starknet::PoseidonCairoStark252, Poseidon as PoseidonLambdaworks,
+    Poseidon as PoseidonLambdaworks, starknet::PoseidonCairoStark252,
 };
 use lambdaworks_math::field::{
     element::FieldElement, fields::fft_friendly::stark_252_prime_field::Stark252PrimeField,
diff --git a/crates/starknet-types-core/src/qm31/mod.rs b/crates/starknet-types-core/src/qm31/mod.rs
index ea89d8b3..ae45d605 100644
--- a/crates/starknet-types-core/src/qm31/mod.rs
+++ b/crates/starknet-types-core/src/qm31/mod.rs
@@ -9,7 +9,7 @@ use lambdaworks_math::field::{
     errors::FieldError,
     fields::mersenne31::{
         extensions::Degree4ExtensionField,
-        field::{Mersenne31Field, MERSENNE_31_PRIME_FIELD_ORDER},
+        field::{MERSENNE_31_PRIME_FIELD_ORDER, Mersenne31Field},
     },
     traits::IsField,
 };
diff --git a/crates/starknet-types-core/src/short_string/mod.rs b/crates/starknet-types-core/src/short_string/mod.rs
index 53ead6f7..644902b5 100644
--- a/crates/starknet-types-core/src/short_string/mod.rs
+++ b/crates/starknet-types-core/src/short_string/mod.rs
@@ -9,9 +9,9 @@
 //!
 //! The convesion to `Felt` is done by using the internal ascii short string as bytes and parse those as a big endian number.
 
+use crate::felt::Felt;
 #[cfg(not(feature = "std"))]
 use crate::felt::alloc::string::{String, ToString};
-use crate::felt::Felt;
 
 /// A cairo short string
 ///
diff --git a/crates/starknet-types-core/src/u256/tests/from_dec_str.rs b/crates/starknet-types-core/src/u256/tests/from_dec_str.rs
index 35dd78f3..eace0a26 100644
--- a/crates/starknet-types-core/src/u256/tests/from_dec_str.rs
+++ b/crates/starknet-types-core/src/u256/tests/from_dec_str.rs
@@ -79,7 +79,7 @@ fn test_from_dec_str_values_under_39_digits() {
 fn test_from_dec_str_values_39_digits_and_above() {
     // Test 39 digits (should use manual parsing)
     let result = U256::from_dec_str("123456789012345678901234567890123456789").unwrap(); // 39 digits
-                                                                                         // This should use the manual parsing logic
+    // This should use the manual parsing logic
     assert!(result.low() > 0 || result.high() > 0);
 
     // Test a specific known value that exceeds u128::MAX
diff --git a/crates/starknet-types-core/src/u256/tests/mod.rs b/crates/starknet-types-core/src/u256/tests/mod.rs
index 22e16749..863f56ae 100644
--- a/crates/starknet-types-core/src/u256/tests/mod.rs
+++ b/crates/starknet-types-core/src/u256/tests/mod.rs
@@ -53,8 +53,7 @@ fn try_from_hex_str_parts() {
     assert!(U256::try_from_hex_str_parts(valid_str, valid_str).is_ok());
     let valid_str = "0x123";
     assert!(U256::try_from_hex_str_parts(valid_str, valid_str).is_ok());
-    let valid_str =
-        "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123";
+    let valid_str = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123";
     assert!(U256::try_from_hex_str_parts(valid_str, valid_str).is_ok());
 
     let invalid_str = "";