refactor: apply clippy suggestions

Author: PJColombo

src/clients/beacon/mod.rs

@@ -61,10 +61,8 @@ impl CommonBeaconClient for BeaconClient {
         let path = format!("v2/beacon/blocks/{}", { block_id.to_detailed_string() });
         let url = self.base_url.join(path.as_str())?;
 
-        json_get!(&self.client, url, BlockResponse, self.exp_backoff.clone()).map(|res| match res {
-            Some(r) => Some(r.into()),
-            None => None,
-        })
+        json_get!(&self.client, url, BlockResponse, self.exp_backoff.clone())
+            .map(|res| res.map(|r| r.into()))
     }
 
     async fn get_block_header(&self, block_id: BlockId) -> ClientResult<Option<BlockHeader>> {
@@ -77,10 +75,7 @@ impl CommonBeaconClient for BeaconClient {
             BlockHeaderResponse,
             self.exp_backoff.clone()
         )
-        .map(|res| match res {
-            Some(r) => Some(r.into()),
-            None => None,
-        })
+        .map(|res| res.map(|r| r.into()))
     }
 
     async fn get_blobs(&self, block_id: BlockId) -> ClientResult<Option<Vec<Blob>>> {

src/clients/beacon/types.rs

@@ -241,7 +241,7 @@ impl BlockIdResolution for BlockId {
         match self {
             BlockId::Slot(slot) => Ok(*slot),
             _ => match beacon_client
-                .get_block_header(self.clone().into())
+                .get_block_header(self.clone())
                 .await
                 .map_err(|err| BlockIdResolutionError::FailedBlockIdResolution {
                     block_id: self.clone(),

src/indexer/mod.rs

@@ -111,17 +111,15 @@ impl Indexer<ReqwestTransport> {
             },
         };
 
-        let last_synced_block = sync_state
-            .map(|state| {
-                state
-                    .last_upper_synced_slot
-                    .map(|last_upper_synced_slot| BlockHeader {
-                        slot: last_upper_synced_slot,
-                        root: B256::ZERO,
-                        parent_root: B256::ZERO,
-                    })
-            })
-            .flatten();
+        let last_synced_block = sync_state.and_then(|state| {
+            state
+                .last_upper_synced_slot
+                .map(|last_upper_synced_slot| BlockHeader {
+                    slot: last_upper_synced_slot,
+                    root: B256::ZERO,
+                    parent_root: B256::ZERO,
+                })
+        });
 
         let upper_indexed_block_id = match &last_synced_block {
             Some(block) => block.slot.into(),

src/slots_processor/helpers.rs

@@ -12,14 +12,11 @@ pub fn create_tx_hash_versioned_hashes_mapping(
     let mut tx_to_versioned_hashes = HashMap::new();
 
     if let Some(transactions) = block.transactions.as_transactions() {
-        transactions
-            .iter()
-            .for_each(|tx| match &tx.blob_versioned_hashes {
-                Some(versioned_hashes) => {
-                    tx_to_versioned_hashes.insert(tx.hash, versioned_hashes.clone());
-                }
-                None => {}
-            });
+        transactions.iter().for_each(|tx| {
+            if let Some(versioned_hashes) = tx.blob_versioned_hashes.as_ref() {
+                tx_to_versioned_hashes.insert(tx.hash, versioned_hashes.clone());
+            }
+        });
     }
 
     Ok(tx_to_versioned_hashes)

src/slots_processor/mod.rs

@@ -309,7 +309,7 @@ impl SlotsProcessor<ReqwestTransport> {
                     if block.slot != new_head_header.slot {
                         self.process_block(block)
                             .await
-                            .with_context(|| format!("Failed to sync forwarded block"))?;
+                            .with_context(|| "Failed to sync forwarded block")?;
                     }
                 }
 
@@ -331,7 +331,7 @@ impl SlotsProcessor<ReqwestTransport> {
             rewinded_blocks.push(old_blobscan_block.hash);
         }
 
-        Err(anyhow!("No common block found").into())
+        Err(anyhow!("No common block found"))
     }
 
     /// Returns the path of blocks with execution payload from the head block to the provided block.