rm more generics when useless (#12595)

paradigmxyz · Nov 16, 2024 · dda1906 · dda1906
1 parent d9ed07a
commit dda1906
Show file tree

Hide file tree

Showing 15 changed files with 60 additions and 96 deletions.
diff --git a/crates/exex/exex/src/wal/mod.rs b/crates/exex/exex/src/wal/mod.rs
@@ -231,13 +231,13 @@ mod tests {
     use crate::wal::{cache::CachedBlock, Wal};
 
     fn read_notifications(wal: &Wal) -> eyre::Result<Vec<ExExNotification>> {
-        let Some(files_range) = wal.inner.storage.files_range()? else { return Ok(Vec::new()) };
-
-        wal.inner
-            .storage
-            .iter_notifications(files_range)
-            .map(|entry| Ok(entry?.2))
-            .collect::<eyre::Result<_>>()
+        wal.inner.storage.files_range()?.map_or(Ok(Vec::new()), |range| {
+            wal.inner
+                .storage
+                .iter_notifications(range)
+                .map(|entry| entry.map(|(_, _, n)| n))
+                .collect()
+        })
     }
 
     fn sort_committed_blocks(

diff --git a/crates/net/eth-wire-types/src/blocks.rs b/crates/net/eth-wire-types/src/blocks.rs
@@ -198,7 +198,7 @@ mod tests {
     fn encode_get_block_header_number() {
         let expected = hex!("ca820457c682270f050580");
         let mut data = vec![];
-        RequestPair::<GetBlockHeaders> {
+        RequestPair {
             request_id: 1111,
             message: GetBlockHeaders {
                 start_block: BlockHashOrNumber::Number(9999),
@@ -215,7 +215,7 @@ mod tests {
     #[test]
     fn decode_get_block_header_number() {
         let data = hex!("ca820457c682270f050580");
-        let expected = RequestPair::<GetBlockHeaders> {
+        let expected = RequestPair {
             request_id: 1111,
             message: GetBlockHeaders {
                 start_block: BlockHashOrNumber::Number(9999),
@@ -234,7 +234,7 @@ mod tests {
         // [ (f90202) 0x0457 = 1111, [ (f901fc) [ (f901f9) header ] ] ]
         let expected = hex!("f90202820457f901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000");
         let mut data = vec![];
-        RequestPair::<BlockHeaders<_>> {
+        RequestPair {
             request_id: 1111,
             message: BlockHeaders(vec![
                 Header {
@@ -269,7 +269,7 @@ mod tests {
     #[test]
     fn decode_block_header() {
         let data = hex!("f90202820457f901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000");
-        let expected = RequestPair::<BlockHeaders<_>> {
+        let expected = RequestPair {
             request_id: 1111,
             message: BlockHeaders(vec![
                 Header {
@@ -306,7 +306,7 @@ mod tests {
     fn encode_get_block_bodies() {
         let expected = hex!("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef");
         let mut data = vec![];
-        RequestPair::<GetBlockBodies> {
+        RequestPair {
             request_id: 1111,
             message: GetBlockBodies(vec![
                 hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -321,7 +321,7 @@ mod tests {
     #[test]
     fn decode_get_block_bodies() {
         let data = hex!("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef");
-        let expected = RequestPair::<GetBlockBodies> {
+        let expected = RequestPair {
             request_id: 1111,
             message: GetBlockBodies(vec![
                 hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -337,7 +337,7 @@ mod tests {
     fn encode_block_bodies() {
         let expected = hex!("f902dc820457f902d6f902d3f8d2f867088504a817c8088302e2489435353535353535353535353535353535353535358202008025a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c12a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10f867098504a817c809830334509435353535353535353535353535353535353535358202d98025a052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afba052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afbf901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000");
         let mut data = vec![];
-        let request = RequestPair::<BlockBodies<_>> {
+        let request = RequestPair {
             request_id: 1111,
             message: BlockBodies(vec![
                 BlockBody {
@@ -408,7 +408,7 @@ mod tests {
     #[test]
     fn decode_block_bodies() {
         let data = hex!("f902dc820457f902d6f902d3f8d2f867088504a817c8088302e2489435353535353535353535353535353535353535358202008025a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c12a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10f867098504a817c809830334509435353535353535353535353535353535353535358202d98025a052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afba052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afbf901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000");
-        let expected = RequestPair::<BlockBodies<_>> {
+        let expected = RequestPair {
             request_id: 1111,
             message: BlockBodies(vec![
                 BlockBody {

diff --git a/crates/net/eth-wire-types/src/broadcast.rs b/crates/net/eth-wire-types/src/broadcast.rs
@@ -733,7 +733,7 @@ impl RequestTxHashes {
 
 impl FromIterator<(TxHash, Eth68TxMetadata)> for RequestTxHashes {
     fn from_iter<I: IntoIterator<Item = (TxHash, Eth68TxMetadata)>>(iter: I) -> Self {
-        Self::new(iter.into_iter().map(|(hash, _)| hash).collect::<HashSet<_>>())
+        Self::new(iter.into_iter().map(|(hash, _)| hash).collect())
     }
 }
 

diff --git a/crates/net/eth-wire-types/src/message.rs b/crates/net/eth-wire-types/src/message.rs
@@ -77,52 +77,30 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
                     )?)
                 }
             }
-            EthMessageID::GetBlockHeaders => {
-                let request_pair = RequestPair::<GetBlockHeaders>::decode(buf)?;
-                EthMessage::GetBlockHeaders(request_pair)
-            }
-            EthMessageID::BlockHeaders => {
-                let request_pair = RequestPair::<BlockHeaders<_>>::decode(buf)?;
-                EthMessage::BlockHeaders(request_pair)
-            }
-            EthMessageID::GetBlockBodies => {
-                let request_pair = RequestPair::<GetBlockBodies>::decode(buf)?;
-                EthMessage::GetBlockBodies(request_pair)
-            }
-            EthMessageID::BlockBodies => {
-                let request_pair = RequestPair::<BlockBodies<_>>::decode(buf)?;
-                EthMessage::BlockBodies(request_pair)
-            }
+            EthMessageID::GetBlockHeaders => EthMessage::GetBlockHeaders(RequestPair::decode(buf)?),
+            EthMessageID::BlockHeaders => EthMessage::BlockHeaders(RequestPair::decode(buf)?),
+            EthMessageID::GetBlockBodies => EthMessage::GetBlockBodies(RequestPair::decode(buf)?),
+            EthMessageID::BlockBodies => EthMessage::BlockBodies(RequestPair::decode(buf)?),
             EthMessageID::GetPooledTransactions => {
-                let request_pair = RequestPair::<GetPooledTransactions>::decode(buf)?;
-                EthMessage::GetPooledTransactions(request_pair)
+                EthMessage::GetPooledTransactions(RequestPair::decode(buf)?)
             }
             EthMessageID::PooledTransactions => {
-                let request_pair = RequestPair::<PooledTransactions>::decode(buf)?;
-                EthMessage::PooledTransactions(request_pair)
+                EthMessage::PooledTransactions(RequestPair::decode(buf)?)
             }
             EthMessageID::GetNodeData => {
                 if version >= EthVersion::Eth67 {
                     return Err(MessageError::Invalid(version, EthMessageID::GetNodeData))
                 }
-                let request_pair = RequestPair::<GetNodeData>::decode(buf)?;
-                EthMessage::GetNodeData(request_pair)
+                EthMessage::GetNodeData(RequestPair::decode(buf)?)
             }
             EthMessageID::NodeData => {
                 if version >= EthVersion::Eth67 {
                     return Err(MessageError::Invalid(version, EthMessageID::GetNodeData))
                 }
-                let request_pair = RequestPair::<NodeData>::decode(buf)?;
-                EthMessage::NodeData(request_pair)
-            }
-            EthMessageID::GetReceipts => {
-                let request_pair = RequestPair::<GetReceipts>::decode(buf)?;
-                EthMessage::GetReceipts(request_pair)
-            }
-            EthMessageID::Receipts => {
-                let request_pair = RequestPair::<Receipts>::decode(buf)?;
-                EthMessage::Receipts(request_pair)
+                EthMessage::NodeData(RequestPair::decode(buf)?)
             }
+            EthMessageID::GetReceipts => EthMessage::GetReceipts(RequestPair::decode(buf)?),
+            EthMessageID::Receipts => EthMessage::Receipts(RequestPair::decode(buf)?),
         };
         Ok(Self { message_type, message })
     }

diff --git a/crates/net/eth-wire-types/src/receipts.rs b/crates/net/eth-wire-types/src/receipts.rs
@@ -54,7 +54,7 @@ mod tests {
     fn encode_get_receipts() {
         let expected = hex!("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef");
         let mut data = vec![];
-        let request = RequestPair::<GetReceipts> {
+        let request = RequestPair {
             request_id: 1111,
             message: GetReceipts(vec![
                 hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -72,7 +72,7 @@ mod tests {
         let request = RequestPair::<GetReceipts>::decode(&mut &data[..]).unwrap();
         assert_eq!(
             request,
-            RequestPair::<GetReceipts> {
+            RequestPair {
                 request_id: 1111,
                 message: GetReceipts(vec![
                     hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -88,7 +88,7 @@ mod tests {
     fn encode_receipts() {
         let expected = hex!("f90172820457f9016cf90169f901668001b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f85ff85d940000000000000000000000000000000000000011f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100ff");
         let mut data = vec![];
-        let request = RequestPair::<Receipts> {
+        let request = RequestPair {
             request_id: 1111,
             message: Receipts(vec![vec![
                 ReceiptWithBloom {
@@ -124,7 +124,7 @@ mod tests {
         let request = RequestPair::<Receipts>::decode(&mut &data[..]).unwrap();
         assert_eq!(
             request,
-            RequestPair::<Receipts> {
+            RequestPair {
                 request_id: 1111,
                 message: Receipts(vec![
                     vec![

diff --git a/crates/net/eth-wire-types/src/state.rs b/crates/net/eth-wire-types/src/state.rs
@@ -36,7 +36,7 @@ mod tests {
     fn encode_get_node_data() {
         let expected = hex!("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef");
         let mut data = vec![];
-        let request = RequestPair::<GetNodeData> {
+        let request = RequestPair {
             request_id: 1111,
             message: GetNodeData(vec![
                 hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -54,7 +54,7 @@ mod tests {
         let request = RequestPair::<GetNodeData>::decode(&mut &data[..]).unwrap();
         assert_eq!(
             request,
-            RequestPair::<GetNodeData> {
+            RequestPair {
                 request_id: 1111,
                 message: GetNodeData(vec![
                     hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -69,7 +69,7 @@ mod tests {
     fn encode_node_data() {
         let expected = hex!("ce820457ca84deadc0de84feedbeef");
         let mut data = vec![];
-        let request = RequestPair::<NodeData> {
+        let request = RequestPair {
             request_id: 1111,
             message: NodeData(vec![
                 hex!("deadc0de").as_slice().into(),
@@ -87,7 +87,7 @@ mod tests {
         let request = RequestPair::<NodeData>::decode(&mut &data[..]).unwrap();
         assert_eq!(
             request,
-            RequestPair::<NodeData> {
+            RequestPair {
                 request_id: 1111,
                 message: NodeData(vec![
                     hex!("deadc0de").as_slice().into(),

diff --git a/crates/net/eth-wire-types/src/status.rs b/crates/net/eth-wire-types/src/status.rs
@@ -338,7 +338,7 @@ mod tests {
         let total_difficulty = U256::from(rng.gen::<u64>());
 
         // create a genesis that has a random part, so we can check that the hash is preserved
-        let genesis = Genesis { nonce: rng.gen::<u64>(), ..Default::default() };
+        let genesis = Genesis { nonce: rng.gen(), ..Default::default() };
 
         // build head
         let head = Head {

diff --git a/crates/net/eth-wire-types/src/transactions.rs b/crates/net/eth-wire-types/src/transactions.rs
@@ -96,7 +96,7 @@ mod tests {
     fn encode_get_pooled_transactions() {
         let expected = hex!("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef");
         let mut data = vec![];
-        let request = RequestPair::<GetPooledTransactions> {
+        let request = RequestPair {
             request_id: 1111,
             message: GetPooledTransactions(vec![
                 hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -114,7 +114,7 @@ mod tests {
         let request = RequestPair::<GetPooledTransactions>::decode(&mut &data[..]).unwrap();
         assert_eq!(
             request,
-            RequestPair::<GetPooledTransactions> {
+            RequestPair {
                 request_id: 1111,
                 message: GetPooledTransactions(vec![
                     hex!("00000000000000000000000000000000000000000000000000000000deadc0de").into(),
@@ -182,7 +182,7 @@ mod tests {
                     .expect("Failed to convert TransactionSigned to PooledTransactionsElement")
             })
             .collect();
-        let request = RequestPair::<PooledTransactions> {
+        let request = RequestPair {
             request_id: 1111,
             message: PooledTransactions(message), /* Assuming PooledTransactions wraps a
                                                    * Vec<PooledTransactionsElement> */
@@ -248,10 +248,7 @@ mod tests {
                     .expect("Failed to convert TransactionSigned to PooledTransactionsElement")
             })
             .collect();
-        let expected = RequestPair::<PooledTransactions> {
-            request_id: 1111,
-            message: PooledTransactions(message),
-        };
+        let expected = RequestPair { request_id: 1111, message: PooledTransactions(message) };
 
         let request = RequestPair::<PooledTransactions>::decode(&mut &data[..]).unwrap();
         assert_eq!(request, expected);
@@ -383,10 +380,8 @@ mod tests {
                     .expect("Failed to convert TransactionSigned to PooledTransactionsElement")
             })
             .collect();
-        let expected_transactions = RequestPair::<PooledTransactions> {
-            request_id: 0,
-            message: PooledTransactions(message),
-        };
+        let expected_transactions =
+            RequestPair { request_id: 0, message: PooledTransactions(message) };
 
         // checking tx by tx for easier debugging if there are any regressions
         for (decoded, expected) in
@@ -522,10 +517,7 @@ mod tests {
                     .expect("Failed to convert TransactionSigned to PooledTransactionsElement")
             })
             .collect();
-        let transactions = RequestPair::<PooledTransactions> {
-            request_id: 0,
-            message: PooledTransactions(message),
-        };
+        let transactions = RequestPair { request_id: 0, message: PooledTransactions(message) };
 
         let mut encoded = vec![];
         transactions.encode(&mut encoded);

diff --git a/crates/net/nat/src/lib.rs b/crates/net/nat/src/lib.rs
@@ -111,7 +111,7 @@ impl FromStr for NatResolver {
                         "Unknown Nat Resolver: {s}"
                     )))
                 };
-                Self::ExternalIp(ip.parse::<IpAddr>()?)
+                Self::ExternalIp(ip.parse()?)
             }
         };
         Ok(r)