chore: bump 1.0.0 (#177)

Author: tdelabro

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"]

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;
 

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.

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());
     }
 }

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() {

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;
 

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() {

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,

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,
 };

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
 ///