relax static

paradigmxyz · Jan 11, 2025 · 2fe6d51 · 2fe6d51
1 parent 7b68cc7
commit 2fe6d51
Show file tree

Hide file tree

Showing 8 changed files with 55 additions and 39 deletions.
diff --git a/crates/evm/execution-types/src/chain.rs b/crates/evm/execution-types/src/chain.rs
@@ -557,22 +557,25 @@ pub(super) mod serde_bincode_compat {
     #[derive(Debug, Serialize, Deserialize)]
     pub struct Chain<'a, N = EthPrimitives>
     where
-        N: NodePrimitives<Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>,
+        N: NodePrimitives<
+            Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
+        >,
     {
-        blocks: SealedBlocksWithSenders<'a, N::Block>,
+        blocks: RecoveredB<'a, N::Block>,
         execution_outcome: Cow<'a, ExecutionOutcome<N::Receipt>>,
         trie_updates: Option<TrieUpdates<'a>>,
     }
 
     #[derive(Debug)]
-    struct SealedBlocksWithSenders<
+    struct RecoveredB<
         'a,
-        B: reth_primitives_traits::Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>,
+        B: reth_primitives_traits::Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>
+            + 'static,
     >(Cow<'a, BTreeMap<BlockNumber, reth_primitives::RecoveredBlock<B>>>);
 
-    impl<B> Serialize for SealedBlocksWithSenders<'_, B>
+    impl<B> Serialize for RecoveredB<'_, B>
     where
-        B: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>,
+        B: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
     {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
@@ -588,9 +591,9 @@ pub(super) mod serde_bincode_compat {
         }
     }
 
-    impl<'de, B> Deserialize<'de> for SealedBlocksWithSenders<'_, B>
+    impl<'de, B> Deserialize<'de> for RecoveredB<'_, B>
     where
-        B: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>,
+        B: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
     {
         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where
@@ -605,11 +608,13 @@ pub(super) mod serde_bincode_compat {
 
     impl<'a, N> From<&'a super::Chain<N>> for Chain<'a, N>
     where
-        N: NodePrimitives<Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>,
+        N: NodePrimitives<
+            Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
+        >,
     {
         fn from(value: &'a super::Chain<N>) -> Self {
             Self {
-                blocks: SealedBlocksWithSenders(Cow::Borrowed(&value.blocks)),
+                blocks: RecoveredB(Cow::Borrowed(&value.blocks)),
                 execution_outcome: Cow::Borrowed(&value.execution_outcome),
                 trie_updates: value.trie_updates.as_ref().map(Into::into),
             }
@@ -618,7 +623,9 @@ pub(super) mod serde_bincode_compat {
 
     impl<'a, N> From<Chain<'a, N>> for super::Chain<N>
     where
-        N: NodePrimitives<Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>,
+        N: NodePrimitives<
+            Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
+        >,
     {
         fn from(value: Chain<'a, N>) -> Self {
             Self {
@@ -631,7 +638,9 @@ pub(super) mod serde_bincode_compat {
 
     impl<N> SerializeAs<super::Chain<N>> for Chain<'_, N>
     where
-        N: NodePrimitives<Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>,
+        N: NodePrimitives<
+            Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
+        >,
     {
         fn serialize_as<S>(source: &super::Chain<N>, serializer: S) -> Result<S::Ok, S::Error>
         where
@@ -643,7 +652,9 @@ pub(super) mod serde_bincode_compat {
 
     impl<'de, N> DeserializeAs<'de, super::Chain<N>> for Chain<'de, N>
     where
-        N: NodePrimitives<Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>,
+        N: NodePrimitives<
+            Block: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
+        >,
     {
         fn deserialize_as<D>(deserializer: D) -> Result<super::Chain<N>, D::Error>
         where

diff --git a/crates/net/downloaders/src/bodies/bodies.rs b/crates/net/downloaders/src/bodies/bodies.rs
@@ -285,7 +285,7 @@ where
 
 impl<B, C, Provider> BodiesDownloader<B, C, Provider>
 where
-    B: Block,
+    B: Block + 'static,
     C: BodiesClient<Body = B::Body> + 'static,
     Provider: HeaderProvider<Header = B::Header> + Unpin + 'static,
 {
@@ -305,7 +305,7 @@ where
 
 impl<B, C, Provider> BodyDownloader for BodiesDownloader<B, C, Provider>
 where
-    B: Block,
+    B: Block + 'static,
     C: BodiesClient<Body = B::Body> + 'static,
     Provider: HeaderProvider<Header = B::Header> + Unpin + 'static,
 {
@@ -356,7 +356,7 @@ where
 
 impl<B, C, Provider> Stream for BodiesDownloader<B, C, Provider>
 where
-    B: Block,
+    B: Block + 'static,
     C: BodiesClient<Body = B::Body> + 'static,
     Provider: HeaderProvider<Header = B::Header> + Unpin + 'static,
 {

diff --git a/crates/net/downloaders/src/bodies/noop.rs b/crates/net/downloaders/src/bodies/noop.rs
@@ -14,15 +14,15 @@ pub struct NoopBodiesDownloader<B> {
     _block: std::marker::PhantomData<B>,
 }
 
-impl<B: Block> BodyDownloader for NoopBodiesDownloader<B> {
+impl<B: Block + 'static> BodyDownloader for NoopBodiesDownloader<B> {
     type Block = B;
 
     fn set_download_range(&mut self, _: RangeInclusive<BlockNumber>) -> DownloadResult<()> {
         Ok(())
     }
 }
 
-impl<B: Block> Stream for NoopBodiesDownloader<B> {
+impl<B: Block + 'static> Stream for NoopBodiesDownloader<B> {
     type Item = Result<Vec<BlockResponse<B>>, DownloadError>;
 
     fn poll_next(

diff --git a/crates/net/downloaders/src/bodies/task.rs b/crates/net/downloaders/src/bodies/task.rs
@@ -50,7 +50,7 @@ impl<B: Block + 'static> TaskDownloader<B> {
     /// use std::{fmt::Debug, sync::Arc};
     ///
     /// fn t<
-    ///     B: Block,
+    ///     B: Block + 'static,
     ///     C: BodiesClient<Body = B::Body> + 'static,
     ///     Provider: HeaderProvider<Header = B::Header> + Unpin + 'static,
     /// >(
@@ -92,7 +92,7 @@ impl<B: Block + 'static> TaskDownloader<B> {
     }
 }
 
-impl<B: Block> BodyDownloader for TaskDownloader<B> {
+impl<B: Block + 'static> BodyDownloader for TaskDownloader<B> {
     type Block = B;
 
     fn set_download_range(&mut self, range: RangeInclusive<BlockNumber>) -> DownloadResult<()> {
@@ -101,7 +101,7 @@ impl<B: Block> BodyDownloader for TaskDownloader<B> {
     }
 }
 
-impl<B: Block> Stream for TaskDownloader<B> {
+impl<B: Block + 'static> Stream for TaskDownloader<B> {
     type Item = BodyDownloaderResult<B>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {

diff --git a/crates/primitives-traits/src/block/mod.rs b/crates/primitives-traits/src/block/mod.rs
@@ -62,7 +62,6 @@ pub trait Block:
     + MaybeSerde
     + Encodable
     + Decodable
-    + 'static
 {
     /// Header part of the block.
     type Header: BlockHeader;

diff --git a/crates/primitives-traits/src/block/recovered.rs b/crates/primitives-traits/src/block/recovered.rs
@@ -526,37 +526,40 @@ pub(super) mod serde_bincode_compat {
     ///
     /// #[serde_as]
     /// #[derive(Serialize, Deserialize)]
-    /// struct Data<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>> {
+    /// struct Data<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static> {
     ///     #[serde_as(as = "serde_bincode_compat::RecoveredBlock<'_, T>")]
     ///     block: RecoveredBlock<T>,
     /// }
     /// ```
     #[derive(derive_more::Debug, Serialize, Deserialize)]
-    pub struct RecoveredBlock<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>> {
+    pub struct RecoveredBlock<
+        'a,
+        T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
+    > {
         #[serde(
             bound = "serde_bincode_compat::SealedBlock<'a, T>: Serialize + serde::de::DeserializeOwned"
         )]
         block: serde_bincode_compat::SealedBlock<'a, T>,
         senders: Cow<'a, Vec<Address>>,
     }
 
-    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         From<&'a super::RecoveredBlock<T>> for RecoveredBlock<'a, T>
     {
         fn from(value: &'a super::RecoveredBlock<T>) -> Self {
             Self { block: (&value.block).into(), senders: Cow::Borrowed(&value.senders) }
         }
     }
 
-    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         From<RecoveredBlock<'a, T>> for super::RecoveredBlock<T>
     {
         fn from(value: RecoveredBlock<'a, T>) -> Self {
             Self::new_sealed(value.block.into(), value.senders.into_owned())
         }
     }
 
-    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         SerializeAs<super::RecoveredBlock<T>> for RecoveredBlock<'_, T>
     {
         fn serialize_as<S>(
@@ -570,7 +573,7 @@ pub(super) mod serde_bincode_compat {
         }
     }
 
-    impl<'de, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<'de, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         DeserializeAs<'de, super::RecoveredBlock<T>> for RecoveredBlock<'de, T>
     {
         fn deserialize_as<D>(deserializer: D) -> Result<super::RecoveredBlock<T>, D::Error>
@@ -581,8 +584,8 @@ pub(super) mod serde_bincode_compat {
         }
     }
 
-    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>> SerdeBincodeCompat
-        for super::RecoveredBlock<T>
+    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
+        SerdeBincodeCompat for super::RecoveredBlock<T>
     {
         type BincodeRepr<'a> = RecoveredBlock<'a, T>;
     }

diff --git a/crates/primitives-traits/src/block/sealed.rs b/crates/primitives-traits/src/block/sealed.rs
@@ -380,38 +380,41 @@ pub(super) mod serde_bincode_compat {
     ///
     /// #[serde_as]
     /// #[derive(Serialize, Deserialize)]
-    /// struct Data<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>> {
+    /// struct Data<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static> {
     ///     #[serde_as(as = "serde_bincode_compat::SealedBlock<'_, T>")]
     ///     block: SealedBlock<T>,
     /// }
     /// ```
     #[serde_as]
     #[derive(derive_more::Debug, Serialize, Deserialize)]
-    pub struct SealedBlock<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>> {
+    pub struct SealedBlock<
+        'a,
+        T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static,
+    > {
         #[serde(
             bound = "serde_bincode_compat::SealedHeader<'a, T::Header>: Serialize + serde::de::DeserializeOwned"
         )]
         header: serde_bincode_compat::SealedHeader<'a, T::Header>,
         body: BincodeReprFor<'a, T::Body>,
     }
 
-    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         From<&'a super::SealedBlock<T>> for SealedBlock<'a, T>
     {
         fn from(value: &'a super::SealedBlock<T>) -> Self {
             Self { header: (&value.header).into(), body: (&value.body).into() }
         }
     }
 
-    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<'a, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         From<SealedBlock<'a, T>> for super::SealedBlock<T>
     {
         fn from(value: SealedBlock<'a, T>) -> Self {
             Self::from_sealed_parts(value.header.into(), value.body.into())
         }
     }
 
-    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         SerializeAs<super::SealedBlock<T>> for SealedBlock<'_, T>
     {
         fn serialize_as<S>(source: &super::SealedBlock<T>, serializer: S) -> Result<S::Ok, S::Error>
@@ -422,7 +425,7 @@ pub(super) mod serde_bincode_compat {
         }
     }
 
-    impl<'de, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>>
+    impl<'de, T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
         DeserializeAs<'de, super::SealedBlock<T>> for SealedBlock<'de, T>
     {
         fn deserialize_as<D>(deserializer: D) -> Result<super::SealedBlock<T>, D::Error>
@@ -433,8 +436,8 @@ pub(super) mod serde_bincode_compat {
         }
     }
 
-    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat>> SerdeBincodeCompat
-        for super::SealedBlock<T>
+    impl<T: Block<Header: SerdeBincodeCompat, Body: SerdeBincodeCompat> + 'static>
+        SerdeBincodeCompat for super::SealedBlock<T>
     {
         type BincodeRepr<'a> = SealedBlock<'a, T>;
     }

diff --git a/crates/primitives-traits/src/header/sealed.rs b/crates/primitives-traits/src/header/sealed.rs
@@ -60,7 +60,7 @@ impl<H> SealedHeader<H> {
         self.header
     }
 
-    /// Converts from &`SealedHeader`<H> to `SealedHeader`<&H>.
+    /// Converts from &`SealedHeader<H>` to `SealedHeader<&H>`.
     pub fn sealed_ref(&self) -> SealedHeader<&H> {
         SealedHeader { hash: self.hash.clone(), header: &self.header }
     }