fixed_bytes crate

Cargo.toml

@@ -204,6 +204,7 @@ eth2_keystore = { path = "crypto/eth2_keystore" }
 eth2_network_config = { path = "common/eth2_network_config" }
 eth2_wallet = { path = "crypto/eth2_wallet" }
 execution_layer = { path = "beacon_node/execution_layer" }
+fixed_bytes = { path = "consensus/fixed_bytes" }
 filesystem = { path = "common/filesystem" }
 fork_choice = { path = "consensus/fork_choice" }
 genesis = { path = "beacon_node/genesis" }

consensus/fixed_bytes/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "fixed_bytes"
+version = "0.1.0"
+authors = ["Eitan Seri-Levi <eitan@sigmaprime.io>"]
+edition = { workspace = true }
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+alloy-primitives = { workspace = true }
+safe_arith = { workspace = true }

consensus/types/src/fixed_bytes.rs → consensus/fixed_bytes/src/lib.rs

@@ -1,6 +1,11 @@
-use alloy_primitives::{Address, FixedBytes};
+use alloy_primitives::FixedBytes;
 use safe_arith::SafeArith;
 
+pub type Hash64 = alloy_primitives::B64;
+pub type Hash256 = alloy_primitives::B256;
+pub type Uint256 = alloy_primitives::U256;
+pub type Address = alloy_primitives::Address;
+
 pub trait FixedBytesExtended {
     fn from_low_u64_be(value: u64) -> Self;
     fn from_low_u64_le(value: u64) -> Self;
@@ -16,7 +21,7 @@ impl<const N: usize> FixedBytesExtended for FixedBytes<N> {
         let start_index = buffer
             .len()
             .safe_sub(bytes_to_copy)
-            .expect("byte_to_copy <= buffer.len()");
+            .expect("bytes_to_copy <= buffer.len()");
         // Panic-free because start_index <= buffer.len()
         // and bytes_to_copy <= value_bytes.len()
         buffer
@@ -34,7 +39,7 @@ impl<const N: usize> FixedBytesExtended for FixedBytes<N> {
         let value_bytes = value.to_le_bytes();
         let mut buffer = [0x0; N];
         let bytes_to_copy = value_bytes.len().min(buffer.len());
-        // Panic-free because bytes_to_copy <= buffer.len()
+        // Panic-free because bytes_to_copy <= buffer.len(),
         // and bytes_to_copy <= value_bytes.len()
         buffer
             .get_mut(..bytes_to_copy)
@@ -52,7 +57,7 @@ impl<const N: usize> FixedBytesExtended for FixedBytes<N> {
     }
 }
 
-impl FixedBytesExtended for Address {
+impl FixedBytesExtended for alloy_primitives::Address {
     fn from_low_u64_be(value: u64) -> Self {
         FixedBytes::<20>::from_low_u64_be(value).into()
     }

consensus/merkle_proof/Cargo.toml

@@ -8,6 +8,7 @@ edition = { workspace = true }
 alloy-primitives = { workspace = true }
 ethereum_hashing = { workspace = true }
 safe_arith = { workspace = true }
+fixed_bytes = { workspace = true }
 
 [dev-dependencies]
 quickcheck = { workspace = true }

consensus/merkle_proof/src/lib.rs

@@ -1,60 +1,9 @@
-use alloy_primitives::FixedBytes;
 use ethereum_hashing::{hash, hash32_concat, ZERO_HASHES};
-use safe_arith::{ArithError, SafeArith};
+use safe_arith::ArithError;
 use std::sync::LazyLock;
 
-type H256 = alloy_primitives::B256;
-
-pub trait FixedBytesExtended {
-    fn from_low_u64_be(value: u64) -> Self;
-    fn from_low_u64_le(value: u64) -> Self;
-    fn zero() -> Self;
-}
-
-impl<const N: usize> FixedBytesExtended for FixedBytes<N> {
-    fn from_low_u64_be(value: u64) -> Self {
-        let value_bytes = value.to_be_bytes();
-        let mut buffer = [0x0; N];
-        let bytes_to_copy = value_bytes.len().min(buffer.len());
-        // Panic-free because bytes_to_copy <= buffer.len()
-        let start_index = buffer
-            .len()
-            .safe_sub(bytes_to_copy)
-            .expect("bytes_to_copy <= buffer.len()");
-        // Panic-free because start_index <= buffer.len()
-        // and bytes_to_copy <= value_bytes.len()
-        buffer
-            .get_mut(start_index..)
-            .expect("start_index <= buffer.len()")
-            .copy_from_slice(
-                value_bytes
-                    .get(..bytes_to_copy)
-                    .expect("bytes_to_copy <= value_byte.len()"),
-            );
-        Self::from(buffer)
-    }
-
-    fn from_low_u64_le(value: u64) -> Self {
-        let value_bytes = value.to_le_bytes();
-        let mut buffer = [0x0; N];
-        let bytes_to_copy = value_bytes.len().min(buffer.len());
-        // Panic-free because bytes_to_copy <= buffer.len()
-        // and bytes_to_copy <= value_bytes.len()
-        buffer
-            .get_mut(..bytes_to_copy)
-            .expect("bytes_to_copy <= buffer.len()")
-            .copy_from_slice(
-                value_bytes
-                    .get(..bytes_to_copy)
-                    .expect("bytes_to_copy <= value_byte.len()"),
-            );
-        Self::from(buffer)
-    }
-
-    fn zero() -> Self {
-        Self::ZERO
-    }
-}
+type H256 = fixed_bytes::Hash256;
+pub use fixed_bytes::FixedBytesExtended;
 
 const MAX_TREE_DEPTH: usize = 32;
 const EMPTY_SLICE: &[H256] = &[];

consensus/swap_or_not_shuffle/Cargo.toml

@@ -14,6 +14,7 @@ criterion = { workspace = true }
 [dependencies]
 alloy-primitives = { workspace = true }
 ethereum_hashing = { workspace = true }
+fixed_bytes = { workspace = true }
 
 [features]
 arbitrary = ["alloy-primitives/arbitrary"]

consensus/swap_or_not_shuffle/src/lib.rs

@@ -20,4 +20,4 @@ mod shuffle_list;
 pub use compute_shuffled_index::compute_shuffled_index;
 pub use shuffle_list::shuffle_list;
 
-type Hash256 = alloy_primitives::B256;
+type Hash256 = fixed_bytes::Hash256;

consensus/types/Cargo.toml

@@ -52,6 +52,7 @@ maplit = { workspace = true }
 alloy-rlp = { version = "0.3.4", features = ["derive"] }
 milhouse = { workspace = true }
 rpds = { workspace = true }
+fixed_bytes = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }

consensus/types/src/beacon_state.rs

@@ -1,7 +1,7 @@
 use self::committee_cache::get_active_validator_indices;
-use crate::fixed_bytes::FixedBytesExtended;
 use crate::historical_summary::HistoricalSummary;
 use crate::test_utils::TestRandom;
+use crate::FixedBytesExtended;
 use crate::*;
 use compare_fields::CompareFields;
 use compare_fields_derive::CompareFields;

consensus/types/src/lib.rs

@@ -41,7 +41,6 @@ pub mod eth_spec;
 pub mod execution_block_hash;
 pub mod execution_payload;
 pub mod execution_payload_header;
-pub mod fixed_bytes;
 pub mod fork;
 pub mod fork_data;
 pub mod fork_name;
@@ -170,7 +169,6 @@ pub use crate::execution_payload_header::{
     ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderRef,
     ExecutionPayloadHeaderRefMut,
 };
-pub use crate::fixed_bytes::FixedBytesExtended;
 pub use crate::fork::Fork;
 pub use crate::fork_context::ForkContext;
 pub use crate::fork_data::ForkData;
@@ -254,11 +252,12 @@ pub use crate::voluntary_exit::VoluntaryExit;
 pub use crate::withdrawal::Withdrawal;
 pub use crate::withdrawal_credentials::WithdrawalCredentials;
 pub use crate::withdrawal_request::WithdrawalRequest;
+pub use fixed_bytes::FixedBytesExtended;
 
 pub type CommitteeIndex = u64;
-pub type Hash256 = alloy_primitives::B256;
-pub type Uint256 = alloy_primitives::U256;
-pub type Address = alloy_primitives::Address;
+pub type Hash256 = fixed_bytes::Hash256;
+pub type Uint256 = fixed_bytes::Uint256;
+pub type Address = fixed_bytes::Address;
 pub type ForkVersion = [u8; 4];
 pub type BLSFieldElement = Uint256;
 pub type Blob<E> = FixedVector<u8, <E as EthSpec>::BytesPerBlob>;

crypto/bls/Cargo.toml

@@ -17,6 +17,7 @@ arbitrary = { workspace = true }
 zeroize = { workspace = true }
 blst = { version = "0.3.3", optional = true }
 safe_arith = { workspace = true }
+fixed_bytes = { workspace = true }
 
 [features]
 arbitrary = []

crypto/bls/src/lib.rs

@@ -33,70 +33,19 @@ mod zeroize_hash;
 
 pub mod impls;
 
-use alloy_primitives::FixedBytes;
 pub use generic_public_key::{
     INFINITY_PUBLIC_KEY, PUBLIC_KEY_BYTES_LEN, PUBLIC_KEY_UNCOMPRESSED_BYTES_LEN,
 };
 pub use generic_secret_key::SECRET_KEY_BYTES_LEN;
 pub use generic_signature::{INFINITY_SIGNATURE, SIGNATURE_BYTES_LEN};
 pub use get_withdrawal_credentials::get_withdrawal_credentials;
-use safe_arith::SafeArith;
 pub use zeroize_hash::ZeroizeHash;
 
 #[cfg(feature = "supranational")]
 use blst::BLST_ERROR as BlstError;
 
-pub type Hash256 = alloy_primitives::B256;
-pub trait FixedBytesExtended {
-    fn from_low_u64_be(value: u64) -> Self;
-    fn from_low_u64_le(value: u64) -> Self;
-    fn zero() -> Self;
-}
-
-impl<const N: usize> FixedBytesExtended for FixedBytes<N> {
-    fn from_low_u64_be(value: u64) -> Self {
-        let value_bytes = value.to_be_bytes();
-        let mut buffer = [0x0; N];
-        let bytes_to_copy = value_bytes.len().min(buffer.len());
-        // Panic-free because bytes_to_copy <= buffer.len()
-        let start_index = buffer
-            .len()
-            .safe_sub(bytes_to_copy)
-            .expect("bytes_to_copy <= buffer.len()");
-        // Panic-free because start_index <= buffer.len()
-        // and bytes_to_copy <= value_bytes.len()
-        buffer
-            .get_mut(start_index..)
-            .expect("start_index <= buffer.len()")
-            .copy_from_slice(
-                value_bytes
-                    .get(..bytes_to_copy)
-                    .expect("bytes_to_copy <= value_byte.len()"),
-            );
-        Self::from(buffer)
-    }
-
-    fn from_low_u64_le(value: u64) -> Self {
-        let value_bytes = value.to_le_bytes();
-        let mut buffer = [0x0; N];
-        let bytes_to_copy = value_bytes.len().min(buffer.len());
-        // Panic-free because bytes_to_copy <= buffer.len(),
-        // and bytes_to_copy <= value_bytes.len()
-        buffer
-            .get_mut(..bytes_to_copy)
-            .expect("bytes_to_copy <= buffer.len()")
-            .copy_from_slice(
-                value_bytes
-                    .get(..bytes_to_copy)
-                    .expect("bytes_to_copy <= value_byte.len()"),
-            );
-        Self::from(buffer)
-    }
-
-    fn zero() -> Self {
-        Self::ZERO
-    }
-}
+pub type Hash256 = fixed_bytes::Hash256;
+pub use fixed_bytes::FixedBytesExtended;
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Error {