alloy_primitives/bits/
fixed.rs

Help
1use crate::aliases;
2use core::{fmt, iter, ops, str};
3use derive_more::{Deref, DerefMut, From, Index, IndexMut, IntoIterator};
4use hex::FromHex;
5
6/// A byte array of fixed length (`[u8; N]`).
7///
8/// This type allows us to more tightly control serialization, deserialization.
9/// rlp encoding, decoding, and other type-level attributes for fixed-length
10/// byte arrays.
11///
12/// Users looking to prevent type-confusion between byte arrays of different
13/// lengths should use the [`wrap_fixed_bytes!`](crate::wrap_fixed_bytes) macro
14/// to create a new fixed-length byte array type.
15#[derive(
16    Clone,
17    Copy,
18    PartialEq,
19    Eq,
20    PartialOrd,
21    Ord,
22    Hash,
23    Deref,
24    DerefMut,
25    From,
26    Index,
27    IndexMut,
28    IntoIterator,
29)]
30#[cfg_attr(feature = "arbitrary", derive(derive_arbitrary::Arbitrary, proptest_derive::Arbitrary))]
31#[cfg_attr(feature = "allocative", derive(allocative::Allocative))]
32#[repr(transparent)]
33pub struct FixedBytes<const N: usize>(#[into_iterator(owned, ref, ref_mut)] pub [u8; N]);
34
35crate::impl_fb_traits!(FixedBytes<N>, N, const);
36
37impl<const N: usize> Default for FixedBytes<N> {
38    #[inline]
39    fn default() -> Self {
40        Self::ZERO
41    }
42}
43
44impl<const N: usize> Default for &FixedBytes<N> {
45    #[inline]
46    fn default() -> Self {
47        &FixedBytes::ZERO
48    }
49}
50
51impl<const N: usize> From<&[u8; N]> for FixedBytes<N> {
52    #[inline]
53    fn from(bytes: &[u8; N]) -> Self {
54        Self(*bytes)
55    }
56}
57
58impl<const N: usize> From<&mut [u8; N]> for FixedBytes<N> {
59    #[inline]
60    fn from(bytes: &mut [u8; N]) -> Self {
61        Self(*bytes)
62    }
63}
64
65/// Tries to create a `FixedBytes<N>` by copying from a slice `&[u8]`. Succeeds
66/// if `slice.len() == N`.
67impl<const N: usize> TryFrom<&[u8]> for FixedBytes<N> {
68    type Error = core::array::TryFromSliceError;
69
70    #[inline]
71    fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
72        <&Self>::try_from(slice).copied()
73    }
74}
75
76/// Tries to create a `FixedBytes<N>` by copying from a mutable slice `&mut
77/// [u8]`. Succeeds if `slice.len() == N`.
78impl<const N: usize> TryFrom<&mut [u8]> for FixedBytes<N> {
79    type Error = core::array::TryFromSliceError;
80
81    #[inline]
82    fn try_from(slice: &mut [u8]) -> Result<Self, Self::Error> {
83        Self::try_from(&*slice)
84    }
85}
86
87/// Tries to create a ref `FixedBytes<N>` by copying from a slice `&[u8]`.
88/// Succeeds if `slice.len() == N`.
89impl<'a, const N: usize> TryFrom<&'a [u8]> for &'a FixedBytes<N> {
90    type Error = core::array::TryFromSliceError;
91
92    #[inline]
93    fn try_from(slice: &'a [u8]) -> Result<&'a FixedBytes<N>, Self::Error> {
94        // SAFETY: `FixedBytes<N>` is `repr(transparent)` for `[u8; N]`
95        <&[u8; N]>::try_from(slice).map(|array_ref| unsafe { core::mem::transmute(array_ref) })
96    }
97}
98
99/// Tries to create a ref `FixedBytes<N>` by copying from a mutable slice `&mut
100/// [u8]`. Succeeds if `slice.len() == N`.
101impl<'a, const N: usize> TryFrom<&'a mut [u8]> for &'a mut FixedBytes<N> {
102    type Error = core::array::TryFromSliceError;
103
104    #[inline]
105    fn try_from(slice: &'a mut [u8]) -> Result<&'a mut FixedBytes<N>, Self::Error> {
106        // SAFETY: `FixedBytes<N>` is `repr(transparent)` for `[u8; N]`
107        <&mut [u8; N]>::try_from(slice).map(|array_ref| unsafe { core::mem::transmute(array_ref) })
108    }
109}
110
111// Ideally this would be:
112// `impl<const N: usize> From<FixedBytes<N>> for Uint<N * 8>`
113// `impl<const N: usize> From<Uint<N / 8>> for FixedBytes<N>`
114macro_rules! fixed_bytes_uint_conversions {
115    ($($int:ty => $fb:ty),* $(,)?) => {$(
116        impl From<$int> for $fb {
117            /// Converts a fixed-width unsigned integer into a fixed byte array
118            /// by interpreting the bytes as big-endian.
119            #[inline]
120            fn from(value: $int) -> Self {
121                Self(value.to_be_bytes())
122            }
123        }
124
125        impl From<$fb> for $int {
126            /// Converts a fixed byte array into a fixed-width unsigned integer
127            /// by interpreting the bytes as big-endian.
128            #[inline]
129            fn from(value: $fb) -> Self {
130                Self::from_be_bytes(value.0)
131            }
132        }
133
134        const _: () = assert!(<$int>::BITS as usize == <$fb>::len_bytes() * 8);
135    )*};
136}
137
138fixed_bytes_uint_conversions! {
139    u8            => aliases::B8,
140    aliases::U8   => aliases::B8,
141    i8            => aliases::B8,
142    aliases::I8   => aliases::B8,
143
144    u16           => aliases::B16,
145    aliases::U16  => aliases::B16,
146    i16           => aliases::B16,
147    aliases::I16  => aliases::B16,
148
149    u32           => aliases::B32,
150    aliases::U32  => aliases::B32,
151    i32           => aliases::B32,
152    aliases::I32  => aliases::B32,
153
154    u64           => aliases::B64,
155    aliases::U64  => aliases::B64,
156    i64           => aliases::B64,
157    aliases::I64  => aliases::B64,
158
159    u128          => aliases::B128,
160    aliases::U128 => aliases::B128,
161    i128          => aliases::B128,
162    aliases::I128 => aliases::B128,
163
164    aliases::U160 => aliases::B160,
165    aliases::I160 => aliases::B160,
166
167    aliases::U256 => aliases::B256,
168    aliases::I256 => aliases::B256,
169
170    aliases::U512 => aliases::B512,
171    aliases::I512 => aliases::B512,
172
173}
174
175impl<const N: usize> From<FixedBytes<N>> for [u8; N] {
176    #[inline]
177    fn from(s: FixedBytes<N>) -> Self {
178        s.0
179    }
180}
181
182impl<const N: usize> AsRef<[u8; N]> for FixedBytes<N> {
183    #[inline]
184    fn as_ref(&self) -> &[u8; N] {
185        &self.0
186    }
187}
188
189impl<const N: usize> AsMut<[u8; N]> for FixedBytes<N> {
190    #[inline]
191    fn as_mut(&mut self) -> &mut [u8; N] {
192        &mut self.0
193    }
194}
195
196impl<const N: usize> AsRef<[u8]> for FixedBytes<N> {
197    #[inline]
198    fn as_ref(&self) -> &[u8] {
199        &self.0
200    }
201}
202
203impl<const N: usize> AsMut<[u8]> for FixedBytes<N> {
204    #[inline]
205    fn as_mut(&mut self) -> &mut [u8] {
206        &mut self.0
207    }
208}
209
210impl<const N: usize> fmt::Debug for FixedBytes<N> {
211    #[inline]
212    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
213        self.fmt_hex::<false>(f, true)
214    }
215}
216
217impl<const N: usize> fmt::Display for FixedBytes<N> {
218    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
219        // If the alternate flag is NOT set, we write the full hex.
220        if N <= 4 || !f.alternate() {
221            return self.fmt_hex::<false>(f, true);
222        }
223
224        // If the alternate flag is set, we use middle-out compression.
225        const SEP_LEN: usize = '…'.len_utf8();
226        let mut buf = [0; 2 + 4 + SEP_LEN + 4];
227        buf[0] = b'0';
228        buf[1] = b'x';
229        hex::encode_to_slice(&self.0[0..2], &mut buf[2..6]).unwrap();
230        '…'.encode_utf8(&mut buf[6..]);
231        hex::encode_to_slice(&self.0[N - 2..N], &mut buf[6 + SEP_LEN..]).unwrap();
232
233        // SAFETY: always valid UTF-8
234        f.write_str(unsafe { str::from_utf8_unchecked(&buf) })
235    }
236}
237
238impl<const N: usize> fmt::LowerHex for FixedBytes<N> {
239    #[inline]
240    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
241        self.fmt_hex::<false>(f, f.alternate())
242    }
243}
244
245impl<const N: usize> fmt::UpperHex for FixedBytes<N> {
246    #[inline]
247    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
248        self.fmt_hex::<true>(f, f.alternate())
249    }
250}
251
252impl<const N: usize> ops::BitAnd for FixedBytes<N> {
253    type Output = Self;
254
255    #[inline]
256    fn bitand(mut self, rhs: Self) -> Self::Output {
257        self &= rhs;
258        self
259    }
260}
261
262impl<const N: usize> ops::BitAndAssign for FixedBytes<N> {
263    #[inline]
264    fn bitand_assign(&mut self, rhs: Self) {
265        // Note: `slice::Iter` has better codegen than `array::IntoIter`
266        iter::zip(self, &rhs).for_each(|(a, b)| *a &= *b);
267    }
268}
269
270impl<const N: usize> ops::BitOr for FixedBytes<N> {
271    type Output = Self;
272
273    #[inline]
274    fn bitor(mut self, rhs: Self) -> Self::Output {
275        self |= rhs;
276        self
277    }
278}
279
280impl<const N: usize> ops::BitOrAssign for FixedBytes<N> {
281    #[inline]
282    fn bitor_assign(&mut self, rhs: Self) {
283        // Note: `slice::Iter` has better codegen than `array::IntoIter`
284        iter::zip(self, &rhs).for_each(|(a, b)| *a |= *b);
285    }
286}
287
288impl<const N: usize> ops::BitXor for FixedBytes<N> {
289    type Output = Self;
290
291    #[inline]
292    fn bitxor(mut self, rhs: Self) -> Self::Output {
293        self ^= rhs;
294        self
295    }
296}
297
298impl<const N: usize> ops::BitXorAssign for FixedBytes<N> {
299    #[inline]
300    fn bitxor_assign(&mut self, rhs: Self) {
301        // Note: `slice::Iter` has better codegen than `array::IntoIter`
302        iter::zip(self, &rhs).for_each(|(a, b)| *a ^= *b);
303    }
304}
305
306impl<const N: usize> ops::Not for FixedBytes<N> {
307    type Output = Self;
308
309    #[inline]
310    fn not(mut self) -> Self::Output {
311        self.iter_mut().for_each(|byte| *byte = !*byte);
312        self
313    }
314}
315
316impl<const N: usize> str::FromStr for FixedBytes<N> {
317    type Err = hex::FromHexError;
318
319    #[inline]
320    fn from_str(s: &str) -> Result<Self, Self::Err> {
321        Self::from_hex(s)
322    }
323}
324
325#[cfg(feature = "rand")]
326impl<const N: usize> rand::distributions::Distribution<FixedBytes<N>>
327    for rand::distributions::Standard
328{
329    #[inline]
330    fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> FixedBytes<N> {
331        FixedBytes::random_with(rng)
332    }
333}
334
335impl<const N: usize> FixedBytes<N> {
336    /// Array of Zero bytes.
337    pub const ZERO: Self = Self([0u8; N]);
338
339    /// Wraps the given byte array in [`FixedBytes`].
340    #[inline]
341    pub const fn new(bytes: [u8; N]) -> Self {
342        Self(bytes)
343    }
344
345    /// Creates a new [`FixedBytes`] with the last byte set to `x`.
346    #[inline]
347    pub const fn with_last_byte(x: u8) -> Self {
348        let mut bytes = [0u8; N];
349        if N > 0 {
350            bytes[N - 1] = x;
351        }
352        Self(bytes)
353    }
354
355    /// Creates a new [`FixedBytes`] where all bytes are set to `byte`.
356    #[inline]
357    pub const fn repeat_byte(byte: u8) -> Self {
358        Self([byte; N])
359    }
360
361    /// Returns the size of this byte array (`N`).
362    #[inline(always)]
363    pub const fn len_bytes() -> usize {
364        N
365    }
366
367    /// Creates a new [`FixedBytes`] with the default cryptographic random number generator.
368    ///
369    /// This is `rand::thread_rng` if the "rand" and "std" features are enabled, otherwise
370    /// it uses `getrandom::getrandom`. Both are cryptographically secure.
371    #[cfg(feature = "getrandom")]
372    #[inline]
373    #[track_caller]
374    pub fn random() -> Self {
375        let mut bytes = Self::ZERO;
376        bytes.randomize();
377        bytes
378    }
379
380    /// Tries to create a new [`FixedBytes`] with the default cryptographic random number
381    /// generator.
382    ///
383    /// See [`random`](Self::random) for more details.
384    #[cfg(feature = "getrandom")]
385    #[inline]
386    pub fn try_random() -> Result<Self, getrandom::Error> {
387        let mut bytes = Self::ZERO;
388        bytes.try_randomize()?;
389        Ok(bytes)
390    }
391
392    /// Creates a new [`FixedBytes`] with the given random number generator.
393    ///
394    /// See [`random`](Self::random) for more details.
395    #[cfg(feature = "rand")]
396    #[inline]
397    #[doc(alias = "random_using")]
398    pub fn random_with<R: rand::RngCore + ?Sized>(rng: &mut R) -> Self {
399        let mut bytes = Self::ZERO;
400        bytes.randomize_with(rng);
401        bytes
402    }
403
404    /// Fills this [`FixedBytes`] with the default cryptographic random number generator.
405    ///
406    /// See [`random`](Self::random) for more details.
407    #[cfg(feature = "getrandom")]
408    #[inline]
409    #[track_caller]
410    pub fn randomize(&mut self) {
411        self.try_randomize().unwrap_or_else(|e| panic!("failed to fill with random bytes: {e}"));
412    }
413
414    /// Tries to fill this [`FixedBytes`] with the default cryptographic random number
415    /// generator.
416    ///
417    /// See [`random`](Self::random) for more details.
418    #[inline]
419    #[cfg(feature = "getrandom")]
420    pub fn try_randomize(&mut self) -> Result<(), getrandom::Error> {
421        #[cfg(all(feature = "rand", feature = "std"))]
422        {
423            self.randomize_with(&mut rand::thread_rng());
424            Ok(())
425        }
426        #[cfg(not(all(feature = "rand", feature = "std")))]
427        {
428            getrandom::getrandom(&mut self.0)
429        }
430    }
431
432    /// Fills this [`FixedBytes`] with the given random number generator.
433    #[cfg(feature = "rand")]
434    #[inline]
435    #[doc(alias = "randomize_using")]
436    pub fn randomize_with<R: rand::RngCore + ?Sized>(&mut self, rng: &mut R) {
437        rng.fill_bytes(&mut self.0);
438    }
439
440    /// Concatenate two `FixedBytes`.
441    ///
442    /// Due to constraints in the language, the user must specify the value of
443    /// the output size `Z`.
444    ///
445    /// # Panics
446    ///
447    /// Panics if `Z` is not equal to `N + M`.
448    pub const fn concat_const<const M: usize, const Z: usize>(
449        self,
450        other: FixedBytes<M>,
451    ) -> FixedBytes<Z> {
452        assert!(N + M == Z, "Output size `Z` must equal the sum of the input sizes `N` and `M`");
453
454        let mut result = [0u8; Z];
455        let mut i = 0;
456        while i < Z {
457            result[i] = if i >= N { other.0[i - N] } else { self.0[i] };
458            i += 1;
459        }
460        FixedBytes(result)
461    }
462
463    /// Create a new [`FixedBytes`] from the given slice `src`.
464    ///
465    /// For a fallible version, use the `TryFrom<&[u8]>` implementation.
466    ///
467    /// # Note
468    ///
469    /// The given bytes are interpreted in big endian order.
470    ///
471    /// # Panics
472    ///
473    /// If the length of `src` and the number of bytes in `Self` do not match.
474    #[inline]
475    #[track_caller]
476    pub fn from_slice(src: &[u8]) -> Self {
477        match Self::try_from(src) {
478            Ok(x) => x,
479            Err(_) => panic!("cannot convert a slice of length {} to FixedBytes<{N}>", src.len()),
480        }
481    }
482
483    /// Create a new [`FixedBytes`] from the given slice `src`, left-padding it
484    /// with zeroes if necessary.
485    ///
486    /// # Note
487    ///
488    /// The given bytes are interpreted in big endian order.
489    ///
490    /// # Panics
491    ///
492    /// Panics if `src.len() > N`.
493    #[inline]
494    #[track_caller]
495    pub fn left_padding_from(value: &[u8]) -> Self {
496        let len = value.len();
497        assert!(len <= N, "slice is too large. Expected <={N} bytes, got {len}");
498        let mut bytes = Self::ZERO;
499        bytes[N - len..].copy_from_slice(value);
500        bytes
501    }
502
503    /// Create a new [`FixedBytes`] from the given slice `src`, right-padding it
504    /// with zeroes if necessary.
505    ///
506    /// # Note
507    ///
508    /// The given bytes are interpreted in big endian order.
509    ///
510    /// # Panics
511    ///
512    /// Panics if `src.len() > N`.
513    #[inline]
514    #[track_caller]
515    pub fn right_padding_from(value: &[u8]) -> Self {
516        let len = value.len();
517        assert!(len <= N, "slice is too large. Expected <={N} bytes, got {len}");
518        let mut bytes = Self::ZERO;
519        bytes[..len].copy_from_slice(value);
520        bytes
521    }
522
523    /// Returns a slice containing the entire array. Equivalent to `&s[..]`.
524    #[inline]
525    pub const fn as_slice(&self) -> &[u8] {
526        &self.0
527    }
528
529    /// Returns a mutable slice containing the entire array. Equivalent to
530    /// `&mut s[..]`.
531    #[inline]
532    pub fn as_mut_slice(&mut self) -> &mut [u8] {
533        &mut self.0
534    }
535
536    /// Returns `true` if all bits set in `self` are also set in `b`.
537    #[inline]
538    pub fn covers(&self, other: &Self) -> bool {
539        (*self & *other) == *other
540    }
541
542    /// Returns `true` if all bits set in `self` are also set in `b`.
543    pub const fn const_covers(self, other: Self) -> bool {
544        // (self & other) == other
545        other.const_eq(&self.bit_and(other))
546    }
547
548    /// Compile-time equality. NOT constant-time equality.
549    pub const fn const_eq(&self, other: &Self) -> bool {
550        let mut i = 0;
551        while i < N {
552            if self.0[i] != other.0[i] {
553                return false;
554            }
555            i += 1;
556        }
557        true
558    }
559
560    /// Returns `true` if no bits are set.
561    #[inline]
562    pub fn is_zero(&self) -> bool {
563        *self == Self::ZERO
564    }
565
566    /// Returns `true` if no bits are set.
567    #[inline]
568    pub const fn const_is_zero(&self) -> bool {
569        self.const_eq(&Self::ZERO)
570    }
571
572    /// Computes the bitwise AND of two `FixedBytes`.
573    pub const fn bit_and(self, rhs: Self) -> Self {
574        let mut ret = Self::ZERO;
575        let mut i = 0;
576        while i < N {
577            ret.0[i] = self.0[i] & rhs.0[i];
578            i += 1;
579        }
580        ret
581    }
582
583    /// Computes the bitwise OR of two `FixedBytes`.
584    pub const fn bit_or(self, rhs: Self) -> Self {
585        let mut ret = Self::ZERO;
586        let mut i = 0;
587        while i < N {
588            ret.0[i] = self.0[i] | rhs.0[i];
589            i += 1;
590        }
591        ret
592    }
593
594    /// Computes the bitwise XOR of two `FixedBytes`.
595    pub const fn bit_xor(self, rhs: Self) -> Self {
596        let mut ret = Self::ZERO;
597        let mut i = 0;
598        while i < N {
599            ret.0[i] = self.0[i] ^ rhs.0[i];
600            i += 1;
601        }
602        ret
603    }
604
605    fn fmt_hex<const UPPER: bool>(&self, f: &mut fmt::Formatter<'_>, prefix: bool) -> fmt::Result {
606        let mut buf = hex::Buffer::<N, true>::new();
607        let s = if UPPER { buf.format_upper(self) } else { buf.format(self) };
608        // SAFETY: The buffer is guaranteed to be at least 2 bytes in length.
609        f.write_str(unsafe { s.get_unchecked((!prefix as usize) * 2..) })
610    }
611}
612
613#[cfg(test)]
614mod tests {
615    use super::*;
616
617    macro_rules! test_fmt {
618        ($($fmt:literal, $hex:literal => $expected:literal;)+) => {$(
619            assert_eq!(
620                format!($fmt, fixed_bytes!($hex)),
621                $expected
622            );
623        )+};
624    }
625
626    #[test]
627    fn concat_const() {
628        const A: FixedBytes<2> = fixed_bytes!("0x0123");
629        const B: FixedBytes<2> = fixed_bytes!("0x4567");
630        const EXPECTED: FixedBytes<4> = fixed_bytes!("0x01234567");
631        const ACTUAL: FixedBytes<4> = A.concat_const(B);
632
633        assert_eq!(ACTUAL, EXPECTED);
634    }
635
636    #[test]
637    fn display() {
638        test_fmt! {
639            "{}", "0123456789abcdef" => "0x0123456789abcdef";
640            "{:#}", "0123" => "0x0123";
641            "{:#}", "01234567" => "0x01234567";
642            "{:#}", "0123456789" => "0x0123…6789";
643        }
644    }
645
646    #[test]
647    fn debug() {
648        test_fmt! {
649            "{:?}", "0123456789abcdef" => "0x0123456789abcdef";
650            "{:#?}", "0123456789abcdef" => "0x0123456789abcdef";
651        }
652    }
653
654    #[test]
655    fn lower_hex() {
656        test_fmt! {
657            "{:x}", "0123456789abcdef" => "0123456789abcdef";
658            "{:#x}", "0123456789abcdef" => "0x0123456789abcdef";
659        }
660    }
661
662    #[test]
663    fn upper_hex() {
664        test_fmt! {
665            "{:X}", "0123456789abcdef" => "0123456789ABCDEF";
666            "{:#X}", "0123456789abcdef" => "0x0123456789ABCDEF";
667        }
668    }
669
670    #[test]
671    fn left_padding_from() {
672        assert_eq!(FixedBytes::<4>::left_padding_from(&[0x01, 0x23]), fixed_bytes!("0x00000123"));
673
674        assert_eq!(
675            FixedBytes::<4>::left_padding_from(&[0x01, 0x23, 0x45, 0x67]),
676            fixed_bytes!("0x01234567")
677        );
678    }
679
680    #[test]
681    #[should_panic(expected = "slice is too large. Expected <=4 bytes, got 5")]
682    fn left_padding_from_too_large() {
683        FixedBytes::<4>::left_padding_from(&[0x01, 0x23, 0x45, 0x67, 0x89]);
684    }
685
686    #[test]
687    fn right_padding_from() {
688        assert_eq!(FixedBytes::<4>::right_padding_from(&[0x01, 0x23]), fixed_bytes!("0x01230000"));
689
690        assert_eq!(
691            FixedBytes::<4>::right_padding_from(&[0x01, 0x23, 0x45, 0x67]),
692            fixed_bytes!("0x01234567")
693        );
694    }
695
696    #[test]
697    #[should_panic(expected = "slice is too large. Expected <=4 bytes, got 5")]
698    fn right_padding_from_too_large() {
699        FixedBytes::<4>::right_padding_from(&[0x01, 0x23, 0x45, 0x67, 0x89]);
700    }
701}
alloy_primitives/bits/fixed.rs

alloy_primitives/bits/
fixed.rs
