rm more generics when useless (#12595)

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.files_range()?.map_or(Ok(Vec::new()), |range| {
-
+            wal.inner
-        wal.inner
+                .storage
-            .storage
+                .iter_notifications(range)
-            .iter_notifications(files_range)
+                .map(|entry| entry.map(|(_, _, n)| n))
-            .map(|entry| Ok(entry?.2))
+                .collect()
-            .collect::<eyre::Result<_>>()
+        })
     }
 
     fn sort_committed_blocks(

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 {

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())
     }
 }
 

crates/net/eth-wire-types/src/message.rs

@@ -77,52 +77,30 @@ impl<N: NetworkPrimitives> ProtocolMessage<N> {
                     )?)
                 }
             }
-            EthMessageID::GetBlockHeaders => {
+            EthMessageID::GetBlockHeaders => EthMessage::GetBlockHeaders(RequestPair::decode(buf)?),
-                let request_pair = RequestPair::<GetBlockHeaders>::decode(buf)?;
+            EthMessageID::BlockHeaders => EthMessage::BlockHeaders(RequestPair::decode(buf)?),
-                EthMessage::GetBlockHeaders(request_pair)
+            EthMessageID::GetBlockBodies => EthMessage::GetBlockBodies(RequestPair::decode(buf)?),
-            }
+            EthMessageID::BlockBodies => EthMessage::BlockBodies(RequestPair::decode(buf)?),
-            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::GetPooledTransactions => {
-                let request_pair = RequestPair::<GetPooledTransactions>::decode(buf)?;
+                EthMessage::GetPooledTransactions(RequestPair::decode(buf)?)
-                EthMessage::GetPooledTransactions(request_pair)
             }
             EthMessageID::PooledTransactions => {
-                let request_pair = RequestPair::<PooledTransactions>::decode(buf)?;
+                EthMessage::PooledTransactions(RequestPair::decode(buf)?)
-                EthMessage::PooledTransactions(request_pair)
             }
             EthMessageID::GetNodeData => {
                 if version >= EthVersion::Eth67 {
                     return Err(MessageError::Invalid(version, EthMessageID::GetNodeData))
                 }
-                let request_pair = RequestPair::<GetNodeData>::decode(buf)?;
+                EthMessage::GetNodeData(RequestPair::decode(buf)?)
-                EthMessage::GetNodeData(request_pair)
             }
             EthMessageID::NodeData => {
                 if version >= EthVersion::Eth67 {
                     return Err(MessageError::Invalid(version, EthMessageID::GetNodeData))
                 }
-                let request_pair = RequestPair::<NodeData>::decode(buf)?;
+                EthMessage::NodeData(RequestPair::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)
             }
+            EthMessageID::GetReceipts => EthMessage::GetReceipts(RequestPair::decode(buf)?),
+            EthMessageID::Receipts => EthMessage::Receipts(RequestPair::decode(buf)?),
         };
         Ok(Self { message_type, message })
     }

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![

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(),

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 {

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> {
+        let expected = RequestPair { request_id: 1111, message: PooledTransactions(message) };
-            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> {
+        let expected_transactions =
-            request_id: 0,
+            RequestPair { request_id: 0, message: PooledTransactions(message) };
-            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> {
+        let transactions = RequestPair { request_id: 0, message: PooledTransactions(message) };
-            request_id: 0,
-            message: PooledTransactions(message),
-        };
 
         let mut encoded = vec![];
         transactions.encode(&mut encoded);

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)

crates/net/network/src/transactions/fetcher.rs

@@ -289,7 +289,7 @@ impl TransactionFetcher {
 
             // tx is really big, pack request with single tx
             if size >= self.info.soft_limit_byte_size_pooled_transactions_response_on_pack_request {
-                return hashes_from_announcement_iter.collect::<RequestTxHashes>()
+                return hashes_from_announcement_iter.collect()
             }
             acc_size_response = size;
         }
@@ -688,10 +688,8 @@ impl TransactionFetcher {
         }
 
         let (response, rx) = oneshot::channel();
-        let req: PeerRequest = PeerRequest::GetPooledTransactions {
+        let req = PeerRequest::GetPooledTransactions {
-            request: GetPooledTransactions(
+            request: GetPooledTransactions(new_announced_hashes.iter().copied().collect()),
-                new_announced_hashes.iter().copied().collect::<Vec<_>>(),
-            ),
             response,
         };
 
@@ -1012,8 +1010,7 @@ impl TransactionFetcher {
                 //
                 self.try_buffer_hashes_for_retry(requested_hashes, &peer_id);
 
-                let transactions =
+                let transactions = valid_payload.into_data().into_values().collect();
-                    valid_payload.into_data().into_values().collect::<PooledTransactions>();
 
                 FetchEvent::TransactionsFetched { peer_id, transactions }
             }
@@ -1202,13 +1199,10 @@ impl DedupPayload for VerifiedPooledTransactions {
     }
 
     fn dedup(self) -> PartiallyValidData<Self::Value> {
-        let Self { txns } = self;
+        PartiallyValidData::from_raw_data(
-        let unique_fetched = txns
+            self.txns.into_iter().map(|tx| (*tx.hash(), tx)).collect(),
-            .into_iter()
+            None,
-            .map(|tx| (*tx.hash(), tx))
+        )
-            .collect::<HashMap<TxHash, PooledTransactionsElement>>();
-
-        PartiallyValidData::from_raw_data(unique_fetched, None)
     }
 }
 

crates/net/network/src/transactions/mod.rs

@@ -879,7 +879,7 @@ where
                     .into_iter()
                     .map(PooledTransactionsElement::try_from_broadcast)
                     .filter_map(Result::ok)
-                    .collect::<PooledTransactions>();
+                    .collect();
 
                 self.import_transactions(peer_id, non_blob_txs, TransactionSource::Broadcast);
 

crates/net/p2p/src/full_block.rs

@@ -351,7 +351,7 @@ where
 {
     /// Returns the block hashes for the given range, if they are available.
     pub fn range_block_hashes(&self) -> Option<Vec<B256>> {
-        self.headers.as_ref().map(|h| h.iter().map(|h| h.hash()).collect::<Vec<_>>())
+        self.headers.as_ref().map(|h| h.iter().map(|h| h.hash()).collect())
     }
 
     /// Returns whether or not the bodies map is fully populated with requested headers and bodies.

crates/rpc/rpc-eth-types/src/simulate.rs

@@ -282,7 +282,7 @@ pub fn build_block<T: TransactionCompat<Error: FromEthApiError>>(
         timestamp: block_env.timestamp.to(),
         base_fee_per_gas: Some(block_env.basefee.to()),
         gas_limit: block_env.gas_limit.to(),
-        gas_used: calls.iter().map(|c| c.gas_used).sum::<u64>(),
+        gas_used: calls.iter().map(|c| c.gas_used).sum(),
         blob_gas_used: Some(0),
         parent_hash,
         receipts_root: calculate_receipt_root(&receipts),
@@ -306,6 +306,6 @@ pub fn build_block<T: TransactionCompat<Error: FromEthApiError>>(
     let txs_kind =
         if full_transactions { BlockTransactionsKind::Full } else { BlockTransactionsKind::Hashes };
 
-    let block = from_block::<T>(block, total_difficulty, txs_kind, None, tx_resp_builder)?;
+    let block = from_block(block, total_difficulty, txs_kind, None, tx_resp_builder)?;
     Ok(SimulatedBlock { inner: block, calls })
 }

crates/stages/stages/src/stages/sender_recovery.rs

@@ -552,7 +552,7 @@ mod tests {
                         blocks[..=max_pruned_block as usize]
                             .iter()
                             .map(|block| block.body.transactions.len() as u64)
-                            .sum::<u64>(),
+                            .sum(),
                     ),
                     prune_mode: PruneMode::Full,
                 },
@@ -567,8 +567,8 @@ mod tests {
                 processed: blocks[..=max_processed_block]
                     .iter()
                     .map(|block| block.body.transactions.len() as u64)
-                    .sum::<u64>(),
+                    .sum(),
-                total: blocks.iter().map(|block| block.body.transactions.len() as u64).sum::<u64>()
+                total: blocks.iter().map(|block| block.body.transactions.len() as u64).sum()
             }
         );
     }

crates/stages/stages/src/stages/tx_lookup.rs

@@ -416,8 +416,8 @@ mod tests {
                 processed: blocks[..=max_processed_block]
                     .iter()
                     .map(|block| block.body.transactions.len() as u64)
-                    .sum::<u64>(),
+                    .sum(),
-                total: blocks.iter().map(|block| block.body.transactions.len() as u64).sum::<u64>()
+                total: blocks.iter().map(|block| block.body.transactions.len() as u64).sum()
             }
         );
     }