Merge pull request #83 from Blobscan/refactor/simplify-beacon-block-r…

…esponse

refactor: flatten block response from beacon client

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.data),
-            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

@@ -22,6 +22,15 @@ pub enum Topic {
     FinalizedCheckpoint,
 }
 
+#[derive(Deserialize, Debug)]
+pub struct Block {
+    pub blob_kzg_commitments: Option<Vec<String>>,
+    pub execution_payload: Option<ExecutionPayload>,
+    pub parent_root: B256,
+    #[serde(deserialize_with = "deserialize_number")]
+    pub slot: u32,
+}
+
 #[derive(Deserialize, Debug)]
 pub struct ExecutionPayload {
     pub block_hash: B256,
@@ -43,13 +52,13 @@ pub struct BlockMessage {
 }
 
 #[derive(Deserialize, Debug)]
-pub struct Block {
+pub struct BlockData {
     pub message: BlockMessage,
 }
 
 #[derive(Deserialize, Debug)]
 pub struct BlockResponse {
-    pub data: Block,
+    pub data: BlockData,
 }
 
 #[derive(Deserialize, Debug)]
@@ -194,6 +203,17 @@ impl From<BlockHeaderResponse> for BlockHeader {
     }
 }
 
+impl From<BlockResponse> for Block {
+    fn from(response: BlockResponse) -> Self {
+        Block {
+            blob_kzg_commitments: response.data.message.body.blob_kzg_commitments,
+            execution_payload: response.data.message.body.execution_payload,
+            parent_root: response.data.message.parent_root,
+            slot: response.data.message.slot,
+        }
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum BlockIdResolutionError {
     #[error("Block with id '{0}' not found")]
@@ -221,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/event_handlers/finalized_checkpoint.rs

@@ -53,7 +53,7 @@ where
                     err,
                 )
             })? {
-            Some(block) => match block.message.body.execution_payload {
+            Some(block) => match block.execution_payload {
                 Some(execution_payload) => execution_payload.block_number,
                 None => {
                     return Err(FinalizedCheckpointEventHandlerError::BlockNotFound(

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

@@ -145,7 +145,7 @@ impl SlotsProcessor<ReqwestTransport> {
             }
         };
 
-        let execution_payload = match beacon_block.message.body.execution_payload {
+        let execution_payload = match beacon_block.execution_payload {
             Some(payload) => payload,
             None => {
                 debug!(
@@ -157,7 +157,7 @@ impl SlotsProcessor<ReqwestTransport> {
             }
         };
 
-        let has_kzg_blob_commitments = match beacon_block.message.body.blob_kzg_commitments {
+        let has_kzg_blob_commitments = match beacon_block.blob_kzg_commitments {
             Some(commitments) => !commitments.is_empty(),
             None => false,
         };
@@ -324,7 +324,7 @@ impl SlotsProcessor<ReqwestTransport> {
             reorg_depth += 1;
         }
 
-        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.
@@ -343,30 +343,30 @@ impl SlotsProcessor<ReqwestTransport> {
             }
         };
 
-        if let Some(execution_payload) = &canonical_block.message.body.execution_payload {
+        if let Some(execution_payload) = &canonical_block.execution_payload {
             if execution_payload.block_hash == blobscan_block.hash {
                 return Ok(vec![]);
             }
         }
 
         let mut current_canonical_block_root = head_block_root;
 
-        while canonical_block.message.parent_root != B256::ZERO {
-            let canonical_block_parent_root = canonical_block.message.parent_root;
+        while canonical_block.parent_root != B256::ZERO {
+            let canonical_block_parent_root = canonical_block.parent_root;
 
-            if canonical_block.message.slot < blobscan_block.slot {
+            if canonical_block.slot < blobscan_block.slot {
                 return Ok(vec![]);
             }
 
-            if let Some(execution_payload) = &canonical_block.message.body.execution_payload {
+            if let Some(execution_payload) = &canonical_block.execution_payload {
                 if execution_payload.block_hash == blobscan_block.hash {
                     return Ok(canonical_execution_blocks);
                 }
 
                 canonical_execution_blocks.push(BlockData {
                     root: current_canonical_block_root,
                     parent_root: canonical_block_parent_root,
-                    slot: canonical_block.message.slot,
+                    slot: canonical_block.slot,
                     execution_block_hash: execution_payload.block_hash,
                 });
             }