alloy_primitives/
sealed.rs

1use crate::B256;
2use derive_more::{AsRef, Deref};
3
4/// A consensus hashable item, with its memoized hash.
5///
6/// We do not implement any specific hashing algorithm here. Instead types
7/// implement the [`Sealable`] trait to provide define their own hash.
8#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, AsRef, Deref)]
9#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10#[cfg_attr(feature = "arbitrary", derive(proptest_derive::Arbitrary))]
11pub struct Sealed<T> {
12    /// The inner item.
13    #[as_ref]
14    #[deref]
15    #[cfg_attr(feature = "serde", serde(flatten))]
16    inner: T,
17    #[cfg_attr(feature = "serde", serde(rename = "hash"))]
18    /// Its hash.
19    seal: B256,
20}
21
22impl<T> Sealed<T> {
23    /// Seal the inner item.
24    pub fn new(inner: T) -> Self
25    where
26        T: Sealable,
27    {
28        let seal = inner.hash_slow();
29        Self { inner, seal }
30    }
31
32    /// Seal the inner item, by reference.
33    pub fn new_ref(inner: &T) -> Sealed<&T>
34    where
35        T: Sealable,
36    {
37        let seal = inner.hash_slow();
38        Sealed { inner, seal }
39    }
40
41    /// Seal the inner item with some function.
42    pub fn new_with<F>(inner: T, f: F) -> Self
43    where
44        T: Sized,
45        F: FnOnce(&T) -> B256,
46    {
47        let seal = f(&inner);
48        Self::new_unchecked(inner, seal)
49    }
50
51    /// Seal a reference to the inner item with some function.
52    pub fn new_ref_with<F>(inner: &T, f: F) -> Sealed<&T>
53    where
54        T: Sized,
55        F: FnOnce(&T) -> B256,
56    {
57        let seal = f(inner);
58        Sealed::new_unchecked(inner, seal)
59    }
60
61    /// Instantiate without performing the hash. This should be used carefully.
62    pub const fn new_unchecked(inner: T, seal: B256) -> Self {
63        Self { inner, seal }
64    }
65
66    /// Converts from `&Sealed<T>` to `Sealed<&T>`.
67    pub const fn as_sealed_ref(&self) -> Sealed<&T> {
68        Sealed { inner: &self.inner, seal: self.seal }
69    }
70
71    /// Decompose into parts.
72    #[allow(clippy::missing_const_for_fn)] // false positive
73    pub fn into_parts(self) -> (T, B256) {
74        (self.inner, self.seal)
75    }
76
77    /// Decompose into parts. Alias for [`Self::into_parts`].
78    #[allow(clippy::missing_const_for_fn)] // false positive
79    pub fn split(self) -> (T, B256) {
80        self.into_parts()
81    }
82
83    /// Clone the inner item.
84    #[inline(always)]
85    pub fn clone_inner(&self) -> T
86    where
87        T: Clone,
88    {
89        self.inner.clone()
90    }
91
92    /// Get the inner item.
93    #[inline(always)]
94    pub const fn inner(&self) -> &T {
95        &self.inner
96    }
97
98    /// Returns mutable access to the inner type.
99    ///
100    /// Caution: Modifying the inner type can cause side-effects on the `seal` hash.
101    #[inline(always)]
102    #[doc(hidden)]
103    pub fn inner_mut(&mut self) -> &mut T {
104        &mut self.inner
105    }
106
107    /// Get the hash.
108    #[inline(always)]
109    pub const fn seal(&self) -> B256 {
110        self.seal
111    }
112
113    /// Get the hash.
114    #[inline(always)]
115    pub const fn hash(&self) -> B256 {
116        self.seal
117    }
118
119    /// Get the hash.
120    #[inline(always)]
121    pub const fn hash_ref(&self) -> &B256 {
122        &self.seal
123    }
124
125    /// Unseal the inner item, discarding the hash.
126    #[inline(always)]
127    #[allow(clippy::missing_const_for_fn)] // false positive
128    pub fn into_inner(self) -> T {
129        self.inner
130    }
131
132    /// Unseal the inner item, discarding the hash. Alias for
133    /// [`Self::into_inner`].
134    #[inline(always)]
135    #[allow(clippy::missing_const_for_fn)] // false positive
136    pub fn unseal(self) -> T {
137        self.into_inner()
138    }
139}
140
141impl<T> Sealed<&T> {
142    /// Maps a `Sealed<&T>` to a `Sealed<T>` by cloning the inner value.
143    pub fn cloned(self) -> Sealed<T>
144    where
145        T: Clone,
146    {
147        let Self { inner, seal } = self;
148        Sealed::new_unchecked(inner.clone(), seal)
149    }
150}
151
152impl<T> Default for Sealed<T>
153where
154    T: Sealable + Default,
155{
156    fn default() -> Self {
157        T::default().seal_slow()
158    }
159}
160
161#[cfg(feature = "arbitrary")]
162impl<'a, T> arbitrary::Arbitrary<'a> for Sealed<T>
163where
164    T: for<'b> arbitrary::Arbitrary<'b> + Sealable,
165{
166    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
167        Ok(T::arbitrary(u)?.seal_slow())
168    }
169}
170
171/// Sealeable objects.
172pub trait Sealable: Sized {
173    /// Calculate the seal hash, this may be slow.
174    fn hash_slow(&self) -> B256;
175
176    /// Seal the object by calculating the hash. This may be slow.
177    fn seal_slow(self) -> Sealed<Self> {
178        Sealed::new(self)
179    }
180
181    /// Seal a borrowed object by calculating the hash. This may be slow.
182    fn seal_ref_slow(&self) -> Sealed<&Self> {
183        Sealed::new_ref(self)
184    }
185
186    /// Instantiate an unchecked seal. This should be used with caution.
187    fn seal_unchecked(self, seal: B256) -> Sealed<Self> {
188        Sealed::new_unchecked(self, seal)
189    }
190
191    /// Instantiate an unchecked seal. This should be used with caution.
192    fn seal_ref_unchecked(&self, seal: B256) -> Sealed<&Self> {
193        Sealed::new_unchecked(self, seal)
194    }
195}
alloy_primitives/sealed.rs

alloy_primitives/
sealed.rs
