Merge branch 'main' into fix/global-variables

Author: voith

Cargo.toml

@@ -77,6 +77,7 @@ sha3 = { version = "0.10.8", default-features = false }
 hashbrown = { version = "0.16", default-features = false }
 indexmap = { version = "2.5", default-features = false }
 foldhash = { version = "0.2", default-features = false }
+rapidhash = { version = "4", default-features = false }
 rustc-hash = { version = "2.1", default-features = false }
 
 # misc

crates/core/Cargo.toml

@@ -60,11 +60,14 @@ asm-keccak = ["alloy-primitives/asm-keccak"]
 native-keccak = ["alloy-primitives/native-keccak"]
 sha3-keccak = ["alloy-primitives/sha3-keccak"]
 tiny-keccak = ["alloy-primitives/tiny-keccak"]
+keccak-cache = ["alloy-primitives/keccak-cache"]
+keccak-cache-global = ["alloy-primitives/keccak-cache-global"]
 
 map = ["alloy-primitives/map"]
 map-hashbrown = ["alloy-primitives/map-hashbrown"]
 map-indexmap = ["alloy-primitives/map-indexmap"]
 map-foldhash = ["alloy-primitives/map-foldhash"]
+map-rapidhash = ["alloy-primitives/map-rapidhash"]
 map-fxhash = ["alloy-primitives/map-fxhash"]
 
 getrandom = ["alloy-primitives/getrandom"]

crates/primitives/Cargo.toml

@@ -86,6 +86,7 @@ hashbrown = { workspace = true, optional = true, features = [
 ] }
 indexmap = { workspace = true, optional = true }
 foldhash = { workspace = true, optional = true }
+rapidhash = { workspace = true, optional = true }
 rustc-hash = { workspace = true, optional = true }
 
 # arbitrary
@@ -119,6 +120,7 @@ std = [
     "ruint/std",
     "alloy-rlp?/std",
     "foldhash?/std",
+    "rapidhash?/std",
     "indexmap?/std",
     "k256?/std",
     "keccak-asm?/std",
@@ -131,6 +133,7 @@ std = [
 ]
 nightly = [
     "foldhash?/nightly",
+    "rapidhash?/nightly",
     "hashbrown?/nightly",
     "hex/nightly",
     "ruint/nightly",
@@ -141,16 +144,19 @@ asm-keccak = ["dep:keccak-asm"]
 native-keccak = []
 sha3-keccak = ["dep:sha3"]
 tiny-keccak = []
+keccak-cache = ["std", "dep:rapidhash"]
+keccak-cache-global = ["keccak-cache"]
 
 map = ["dep:hashbrown"]
 map-hashbrown = ["map"]
 map-indexmap = ["map", "dep:indexmap"]
 map-foldhash = ["map", "dep:foldhash"]
+map-rapidhash = ["map", "dep:rapidhash"]
 map-fxhash = ["map", "dep:rustc-hash"]
 
 getrandom = ["dep:getrandom"]
 k256 = ["dep:k256"]
-rand = ["dep:rand", "getrandom", "ruint/rand-09", "rustc-hash?/rand"]
+rand = ["dep:rand", "getrandom", "ruint/rand-09", "rapidhash?/rand", "rustc-hash?/rand"]
 rayon = ["dep:rayon", "hashbrown?/rayon", "indexmap?/rayon"]
 rkyv = ["dep:rkyv", "ruint/rkyv"]
 rlp = ["dep:alloy-rlp", "ruint/alloy-rlp"]

crates/primitives/src/bits/address.rs

@@ -47,7 +47,7 @@ wrap_fixed_bytes!(
     extra_derives: [],
     /// An Ethereum address, 20 bytes in length.
     ///
-    /// This type is separate from [`B160`](crate::B160) / [`FixedBytes<20>`]
+    /// This type is separate from [`FixedBytes<20>`]
     /// and is declared with the [`wrap_fixed_bytes!`] macro. This allows us
     /// to implement address-specific functionality.
     ///

crates/primitives/src/lib.rs

@@ -6,6 +6,9 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(feature = "nightly", feature(hasher_prefixfree_extras))]
+#![cfg_attr(feature = "nightly", feature(core_intrinsics))]
+#![cfg_attr(feature = "nightly", feature(likely_unlikely))]
+#![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[macro_use]
@@ -65,12 +68,10 @@ mod signed;
 pub use signed::{BigIntConversionError, ParseSignedError, Sign, Signed};
 
 mod signature;
-#[allow(deprecated)]
-pub use signature::PrimitiveSignature;
 pub use signature::{Signature, SignatureError, normalize_v, to_eip155_v};
 
 pub mod utils;
-pub use utils::{KECCAK256_EMPTY, Keccak256, eip191_hash_message, keccak256};
+pub use utils::{KECCAK256_EMPTY, Keccak256, eip191_hash_message, keccak256, keccak256_uncached};
 
 #[doc(hidden)] // Use `hex` directly instead!
 pub mod hex_literal;
@@ -88,22 +89,6 @@ pub use {
 #[doc(no_inline)]
 pub use ::hex::serde as serde_hex;
 
-/// 20-byte [fixed byte-array][FixedBytes] type.
-///
-/// You'll likely want to use [`Address`] instead, as it is a different type
-/// from `FixedBytes<20>`, and implements methods useful for working with
-/// Ethereum addresses.
-///
-/// If you are sure you want to use this type, and you don't want the
-/// deprecation warning, you can use `aliases::B160`.
-#[deprecated(
-    since = "0.3.2",
-    note = "you likely want to use `Address` instead. \
-            `B160` and `Address` are different types, \
-            see this type's documentation for more."
-)]
-pub type B160 = FixedBytes<20>;
-
 // Not public API.
 #[doc(hidden)]
 pub mod private {

crates/primitives/src/map/hasher.rs

@@ -28,10 +28,16 @@ cfg_if! {
 #[doc(no_inline)]
 pub use foldhash;
 
+#[cfg(feature = "map-rapidhash")]
+#[doc(no_inline)]
+pub use rapidhash;
+
 // Default hasher.
 cfg_if! {
     if #[cfg(feature = "map-foldhash")] {
         type DefaultHashBuilderInner = foldhash::fast::RandomState;
+    } else if #[cfg(feature = "map-rapidhash")] {
+        type DefaultHashBuilderInner = rapidhash::fast::RandomState;
     } else if #[cfg(feature = "map-fxhash")] {
         type DefaultHashBuilderInner = FxBuildHasher;
     } else if #[cfg(any(feature = "map-hashbrown", not(feature = "std")))] {

crates/primitives/src/signature/mod.rs

@@ -6,7 +6,3 @@ pub use utils::{normalize_v, to_eip155_v};
 
 mod sig;
 pub use sig::Signature;
-
-/// Deprecated alias for [`Signature`].
-#[deprecated(since = "0.9.0", note = "use Signature instead")]
-pub type PrimitiveSignature = Signature;

crates/primitives/src/signature/sig.rs

@@ -226,14 +226,6 @@ impl Signature {
         self
     }
 
-    /// Returns the inner ECDSA signature.
-    #[cfg(feature = "k256")]
-    #[deprecated(note = "use `Signature::to_k256` instead")]
-    #[inline]
-    pub fn into_inner(self) -> k256::ecdsa::Signature {
-        self.try_into().expect("signature conversion failed")
-    }
-
     /// Returns the inner ECDSA signature.
     #[cfg(feature = "k256")]
     #[inline]
@@ -290,13 +282,6 @@ impl Signature {
         k256::ecdsa::RecoveryId::new(self.y_parity, false)
     }
 
-    #[cfg(feature = "k256")]
-    #[doc(hidden)]
-    #[deprecated(note = "use `Signature::recid` instead")]
-    pub fn recovery_id(&self) -> k256::ecdsa::RecoveryId {
-        self.recid()
-    }
-
     /// Recovers an [`Address`] from this signature and the given message by first prefixing and
     /// hashing the message according to [EIP-191](crate::eip191_hash_message).
     #[cfg(feature = "k256")]

crates/primitives/src/signed/conversions.rs

@@ -1,7 +1,7 @@
 use super::{BigIntConversionError, ParseSignedError, Sign, Signed, utils::twos_complement};
 use alloc::string::String;
 use core::str::FromStr;
-use ruint::{ToUintError, Uint, UintTryFrom};
+use ruint::{FromUintError, ToUintError, Uint, UintTryFrom, UintTryTo};
 
 impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for Signed<BITS, LIMBS> {
     type Error = BigIntConversionError;
@@ -28,7 +28,7 @@ impl<const BITS: usize, const LIMBS: usize> TryFrom<Signed<BITS, LIMBS>> for Uin
     }
 }
 
-/// Conversion between `Signed` of different `BITS` or `LIMBS` length.
+/// Conversion from `Signed` of different `BITS` or `LIMBS` length.
 impl<const BITS: usize, const LIMBS: usize, const BITS_SRC: usize, const LIMBS_SRC: usize>
     UintTryFrom<Signed<BITS_SRC, LIMBS_SRC>> for Signed<BITS, LIMBS>
 {
@@ -48,6 +48,37 @@ impl<const BITS: usize, const LIMBS: usize, const BITS_SRC: usize, const LIMBS_S
     }
 }
 
+/// Conversion to `Signed` of different `BITS` or `LIMBS` length.
+impl<const BITS: usize, const LIMBS: usize, const BITS_TARGET: usize, const LIMBS_TARGET: usize>
+    UintTryTo<Signed<BITS_TARGET, LIMBS_TARGET>> for Signed<BITS, LIMBS>
+{
+    #[inline]
+    fn uint_try_to(
+        &self,
+    ) -> Result<Signed<BITS_TARGET, LIMBS_TARGET>, FromUintError<Signed<BITS_TARGET, LIMBS_TARGET>>>
+    {
+        let (sign, abs) = self.into_sign_and_abs();
+        let resized = Signed::<BITS_TARGET, LIMBS_TARGET>::from_raw(
+            Uint::uint_try_to(&abs).map_err(|e| match e {
+                FromUintError::Overflow(b, t, v) => {
+                    FromUintError::Overflow(b, Signed(t), Signed(v))
+                }
+            })?,
+        );
+        if resized.is_negative() {
+            return Err(FromUintError::Overflow(BITS_TARGET, resized, Signed::MAX));
+        }
+        Ok(match sign {
+            Sign::Negative => resized.checked_neg().ok_or(FromUintError::Overflow(
+                BITS_TARGET,
+                resized,
+                Signed::MAX,
+            ))?,
+            Sign::Positive => resized,
+        })
+    }
+}
+
 /// Conversion from positive `Signed` to `Uint` of different `BITS` or `LIMBS` length.
 impl<const BITS: usize, const LIMBS: usize, const BITS_SRC: usize, const LIMBS_SRC: usize>
     UintTryFrom<Signed<BITS_SRC, LIMBS_SRC>> for Uint<BITS, LIMBS>
@@ -61,6 +92,22 @@ impl<const BITS: usize, const LIMBS: usize, const BITS_SRC: usize, const LIMBS_S
     }
 }
 
+/// Conversion to `Uint` from positive `Signed` of different `BITS` or `LIMBS` length.
+impl<const BITS: usize, const LIMBS: usize, const BITS_TARGET: usize, const LIMBS_TARGET: usize>
+    UintTryTo<Uint<BITS_TARGET, LIMBS_TARGET>> for Signed<BITS, LIMBS>
+{
+    #[inline]
+    fn uint_try_to(
+        &self,
+    ) -> Result<Uint<BITS_TARGET, LIMBS_TARGET>, FromUintError<Uint<BITS_TARGET, LIMBS_TARGET>>>
+    {
+        if self.is_negative() {
+            return Err(FromUintError::Overflow(BITS_TARGET, Uint::ZERO, Uint::MAX));
+        }
+        Uint::uint_try_to(&self.into_raw())
+    }
+}
+
 /// Conversion from `Uint` to positive `Signed` of different `BITS` or `LIMBS` length.
 impl<const BITS: usize, const LIMBS: usize, const BITS_SRC: usize, const LIMBS_SRC: usize>
     UintTryFrom<Uint<BITS_SRC, LIMBS_SRC>> for Signed<BITS, LIMBS>
@@ -76,6 +123,29 @@ impl<const BITS: usize, const LIMBS: usize, const BITS_SRC: usize, const LIMBS_S
     }
 }
 
+/// Conversion to positive `Signed` from `Uint` of different `BITS` or `LIMBS` length.
+impl<const BITS: usize, const LIMBS: usize, const BITS_TARGET: usize, const LIMBS_TARGET: usize>
+    UintTryTo<Signed<BITS_TARGET, LIMBS_TARGET>> for Uint<BITS, LIMBS>
+{
+    #[inline]
+    fn uint_try_to(
+        &self,
+    ) -> Result<Signed<BITS_TARGET, LIMBS_TARGET>, FromUintError<Signed<BITS_TARGET, LIMBS_TARGET>>>
+    {
+        let resized = Signed::<BITS_TARGET, LIMBS_TARGET>::from_raw(
+            Self::uint_try_to(self).map_err(|e| match e {
+                FromUintError::Overflow(b, t, v) => {
+                    FromUintError::Overflow(b, Signed(t), Signed(v))
+                }
+            })?,
+        );
+        if resized.is_negative() {
+            return Err(FromUintError::Overflow(BITS_TARGET, resized, Signed::MAX));
+        }
+        Ok(resized)
+    }
+}
+
 fn signed_err<const BITS: usize, const LIMBS: usize>(
     err: ToUintError<Uint<BITS, LIMBS>>,
 ) -> ToUintError<Signed<BITS, LIMBS>> {

crates/primitives/src/signed/int.rs

@@ -1692,28 +1692,39 @@ mod tests {
         let m_i256 = I256::unchecked_from(-4);
         let m_i24 = I24::from(m_i256);
         assert_eq!(m_i24, I24::from_dec_str("-4").unwrap());
+        assert_eq!(m_i24.to::<I256>(), m_i256);
         let m_i56 = I56::from(m_i24);
         assert_eq!(m_i56, I56::from_dec_str("-4").unwrap());
+        assert_eq!(m_i56.to::<I24>(), m_i24);
         let m_i128 = I128::from(m_i56);
         assert_eq!(m_i128, I128::from_dec_str("-4").unwrap());
+        assert_eq!(m_i128.to::<I56>(), m_i56);
         let m_i96 = I96::from(m_i128);
         assert_eq!(m_i96, I96::from_dec_str("-4").unwrap());
+        assert_eq!(m_i96.to::<I128>(), m_i128);
 
         // convert positive signed to unsigned
         assert_eq!(U24::from(I24::from_hex_str("0x7FFFFF").unwrap()), U24::from(0x7FFFFF));
+        assert_eq!(I24::from_hex_str("0x7FFFFF").unwrap().to::<U24>(), U24::from(0x7FFFFF));
 
         // convert unsigned to positive signed
         assert_eq!(I24::from(U24::from(0x7FFFFF)), I24::from_hex_str("0x7FFFFF").unwrap());
+        assert_eq!(U24::from(0x7FFFFF).to::<I24>(), I24::from_hex_str("0x7FFFFF").unwrap());
         assert_eq!(I24::from(U96::from(0x7FFFFF)), I24::from_hex_str("0x7FFFFF").unwrap());
+        assert_eq!(U96::from(0x7FFFFF).to::<I24>(), I24::from_hex_str("0x7FFFFF").unwrap());
 
         // can't convert negative signed to unsigned
         assert!(U24::uint_try_from(m_i24).is_err());
+        assert!(<I24 as UintTryTo<U24>>::uint_try_to(&m_i24).is_err());
 
         // can't convert unsigned to positive signed if too large
         assert!(I24::uint_try_from(U24::from(0x800000)).is_err());
+        assert!(<U24 as UintTryTo<I24>>::uint_try_to(&U24::from(0x800000)).is_err());
 
         // out-of-bounds conversions
         assert!(I24::uint_try_from(I128::MIN).is_err());
+        assert!(<I128 as UintTryTo<I24>>::uint_try_to(&I128::MIN).is_err());
         assert!(I24::uint_try_from(I128::MAX).is_err());
+        assert!(<I128 as UintTryTo<I24>>::uint_try_to(&I128::MAX).is_err());
     }
 }