refactor: add small tweaks to clients' types

Author: PJColombo

src/beacon_client/mod.rs

@@ -2,7 +2,7 @@ use reqwest::{Client, StatusCode};
 use std::time::Duration;
 
 use self::types::{
-    BeaconClientError, BeaconClientResult, BlobData, BlobsResponse, BlockMessage as Block,
+    BeaconClientError, BeaconClientResult, Blob, BlobsResponse, BlockMessage as Block,
     BlockResponse,
 };
 
@@ -47,7 +47,7 @@ impl BeaconClient {
         }
     }
 
-    pub async fn get_blobs(&self, slot: u32) -> BeaconClientResult<Option<Vec<BlobData>>> {
+    pub async fn get_blobs(&self, slot: u32) -> BeaconClientResult<Option<Vec<Blob>>> {
         let url = self.build_url(&format!("eth/v1/beacon/blobs/{slot}"));
 
         let blobs_response = self.client.get(url).send().await?;

src/beacon_client/types.rs

@@ -1,43 +1,43 @@
 use anyhow::Result;
 use ethers::types::{Bytes, H256};
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 pub struct ExecutionPayload {
     pub block_hash: H256,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 pub struct BlockBody {
     pub execution_payload: Option<ExecutionPayload>,
     pub blob_kzg_commitments: Option<Vec<String>>,
 }
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 pub struct BlockMessage {
     pub slot: String,
     pub body: BlockBody,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 pub struct Block {
     pub message: BlockMessage,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 pub struct BlockResponse {
     pub data: Block,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct BlobData {
+#[derive(Deserialize, Debug)]
+pub struct Blob {
     pub index: String,
     pub kzg_commitment: String,
     pub blob: Bytes,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 pub struct BlobsResponse {
-    pub data: Vec<BlobData>,
+    pub data: Vec<Blob>,
 }
 
 #[derive(Debug, thiserror::Error)]

src/blobscan_client/mod.rs

@@ -5,9 +5,9 @@ use reqwest::{Client, StatusCode};
 use self::{
     jwt_manager::{Config as JWTManagerConfig, JWTManager},
     types::{
-        BlobEntity, BlobscanClientError, BlobscanClientResult, BlockEntity, FailedSlotsChunkEntity,
-        FailedSlotsChunksRequest, GetFailedSlotsChunksResponse, IndexRequest,
-        RemoveFailedSlotsChunksRequest, SlotRequest, SlotResponse, TransactionEntity,
+        Blob, BlobscanClientError, BlobscanClientResult, Block, FailedSlotsChunk,
+        FailedSlotsChunksRequest, FailedSlotsChunksResponse, IndexRequest,
+        RemoveFailedSlotsChunksRequest, SlotRequest, SlotResponse, Transaction,
     },
 };
 
@@ -47,9 +47,9 @@ impl BlobscanClient {
 
     pub async fn index(
         &self,
-        block: BlockEntity,
-        transactions: Vec<TransactionEntity>,
-        blobs: Vec<BlobEntity>,
+        block: Block,
+        transactions: Vec<Transaction>,
+        blobs: Vec<Blob>,
     ) -> BlobscanClientResult<()> {
         let path = String::from("index");
         let url = self.build_url(&path);
@@ -70,9 +70,7 @@ impl BlobscanClient {
 
         match index_response.status() {
             StatusCode::OK => Ok(()),
-            _ => Err(BlobscanClientError::BlobscanClientError(
-                index_response.text().await?,
-            )),
+            _ => Err(BlobscanClientError::ApiError(index_response.text().await?)),
         }
     }
 
@@ -91,9 +89,7 @@ impl BlobscanClient {
 
         match slot_response.status() {
             StatusCode::OK => Ok(()),
-            _ => Err(BlobscanClientError::BlobscanClientError(
-                slot_response.text().await?,
-            )),
+            _ => Err(BlobscanClientError::ApiError(slot_response.text().await?)),
         }
     }
 
@@ -106,15 +102,11 @@ impl BlobscanClient {
         match slot_response.status() {
             StatusCode::OK => Ok(Some(slot_response.json::<SlotResponse>().await?.slot)),
             StatusCode::NOT_FOUND => Ok(None),
-            _ => Err(BlobscanClientError::BlobscanClientError(
-                slot_response.text().await?,
-            )),
+            _ => Err(BlobscanClientError::ApiError(slot_response.text().await?)),
         }
     }
 
-    pub async fn get_failed_slots_chunks(
-        &self,
-    ) -> BlobscanClientResult<Vec<FailedSlotsChunkEntity>> {
+    pub async fn get_failed_slots_chunks(&self) -> BlobscanClientResult<Vec<FailedSlotsChunk>> {
         let path = String::from("failed-slots-chunks");
         let url = self.build_url(&path);
         let token = self.jwt_manager.get_token()?;
@@ -123,18 +115,18 @@ impl BlobscanClient {
 
         match failed_slots_chunks_response.status() {
             StatusCode::OK => Ok(failed_slots_chunks_response
-                .json::<GetFailedSlotsChunksResponse>()
+                .json::<FailedSlotsChunksResponse>()
                 .await?
                 .chunks),
-            _ => Err(BlobscanClientError::BlobscanClientError(
+            _ => Err(BlobscanClientError::ApiError(
                 failed_slots_chunks_response.text().await?,
             )),
         }
     }
 
     pub async fn add_failed_slots_chunks(
         &self,
-        slots_chunks: Vec<FailedSlotsChunkEntity>,
+        slots_chunks: Vec<FailedSlotsChunk>,
     ) -> BlobscanClientResult<()> {
         let path = String::from("failed-slots-chunks");
         let url = self.build_url(&path);
@@ -152,7 +144,7 @@ impl BlobscanClient {
 
         match failed_slots_response.status() {
             StatusCode::OK => Ok(()),
-            _ => Err(BlobscanClientError::BlobscanClientError(
+            _ => Err(BlobscanClientError::ApiError(
                 failed_slots_response.text().await?,
             )),
         }
@@ -176,7 +168,7 @@ impl BlobscanClient {
 
         match failed_slots_response.status() {
             StatusCode::OK => Ok(()),
-            _ => Err(BlobscanClientError::BlobscanClientError(
+            _ => Err(BlobscanClientError::ApiError(
                 failed_slots_response.text().await?,
             )),
         }

src/blobscan_client/types.rs

@@ -4,10 +4,10 @@ use ethers::types::{
 };
 use serde::{Deserialize, Serialize};
 
-use crate::{beacon_client::types::BlobData, utils::web3::calculate_versioned_hash};
+use crate::{beacon_client::types::Blob as BeaconBlob, utils::web3::calculate_versioned_hash};
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct BlockEntity {
+pub struct Block {
     pub number: U64,
     pub hash: H256,
     pub timestamp: U256,
@@ -16,7 +16,7 @@ pub struct BlockEntity {
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct TransactionEntity {
+pub struct Transaction {
     pub hash: H256,
     pub from: Address,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -26,7 +26,7 @@ pub struct TransactionEntity {
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct BlobEntity {
+pub struct Blob {
     pub versioned_hash: H256,
     pub commitment: String,
     pub data: Bytes,
@@ -36,7 +36,7 @@ pub struct BlobEntity {
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct FailedSlotsChunkEntity {
+pub struct FailedSlotsChunk {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub id: Option<u32>,
     pub initial_slot: u32,
@@ -45,12 +45,12 @@ pub struct FailedSlotsChunkEntity {
 
 #[derive(Serialize, Debug)]
 pub struct FailedSlotsChunksRequest {
-    pub chunks: Vec<FailedSlotsChunkEntity>,
+    pub chunks: Vec<FailedSlotsChunk>,
 }
 
 #[derive(Deserialize, Debug)]
-pub struct GetFailedSlotsChunksResponse {
-    pub chunks: Vec<FailedSlotsChunkEntity>,
+pub struct FailedSlotsChunksResponse {
+    pub chunks: Vec<FailedSlotsChunk>,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -59,38 +59,37 @@ pub struct RemoveFailedSlotsChunksRequest {
     pub chunk_ids: Vec<u32>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct SlotResponse {
+#[derive(Serialize, Debug)]
+pub struct SlotRequest {
     pub slot: u32,
 }
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct SlotRequest {
+#[derive(Deserialize, Debug)]
+pub struct SlotResponse {
     pub slot: u32,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Debug)]
 pub struct IndexRequest {
-    pub block: BlockEntity,
-    pub transactions: Vec<TransactionEntity>,
-    pub blobs: Vec<BlobEntity>,
+    pub block: Block,
+    pub transactions: Vec<Transaction>,
+    pub blobs: Vec<Blob>,
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum BlobscanClientError {
     #[error(transparent)]
     Reqwest(#[from] reqwest::Error),
 
-    #[error("Blobscan client error: {0}")]
-    BlobscanClientError(String),
+    #[error("API usage error: {0}")]
+    ApiError(String),
 
     #[error(transparent)]
-    JWTError(#[from] anyhow::Error),
+    Other(#[from] anyhow::Error),
 }
 
 pub type BlobscanClientResult<T> = Result<T, BlobscanClientError>;
 
-impl From<(u32, u32)> for FailedSlotsChunkEntity {
+impl From<(u32, u32)> for FailedSlotsChunk {
     fn from((initial_slot, final_slot): (u32, u32)) -> Self {
         Self {
             id: None,
@@ -100,7 +99,7 @@ impl From<(u32, u32)> for FailedSlotsChunkEntity {
     }
 }
 
-impl<'a> TryFrom<(&'a EthersBlock<EthersTransaction>, u32)> for BlockEntity {
+impl<'a> TryFrom<(&'a EthersBlock<EthersTransaction>, u32)> for Block {
     type Error = anyhow::Error;
 
     fn try_from(
@@ -121,9 +120,7 @@ impl<'a> TryFrom<(&'a EthersBlock<EthersTransaction>, u32)> for BlockEntity {
     }
 }
 
-impl<'a> TryFrom<(&'a EthersTransaction, &'a EthersBlock<EthersTransaction>)>
-    for TransactionEntity
-{
+impl<'a> TryFrom<(&'a EthersTransaction, &'a EthersBlock<EthersTransaction>)> for Transaction {
     type Error = anyhow::Error;
 
     fn try_from(
@@ -142,11 +139,11 @@ impl<'a> TryFrom<(&'a EthersTransaction, &'a EthersBlock<EthersTransaction>)>
     }
 }
 
-impl<'a> TryFrom<(&'a BlobData, u32, H256)> for BlobEntity {
+impl<'a> TryFrom<(&'a BeaconBlob, u32, H256)> for Blob {
     type Error = anyhow::Error;
 
     fn try_from(
-        (blob_data, index, tx_hash): (&'a BlobData, u32, H256),
+        (blob_data, index, tx_hash): (&'a BeaconBlob, u32, H256),
     ) -> Result<Self, Self::Error> {
         Ok(Self {
             tx_hash,
@@ -158,9 +155,9 @@ impl<'a> TryFrom<(&'a BlobData, u32, H256)> for BlobEntity {
     }
 }
 
-impl<'a> From<(&'a BlobData, &'a H256, usize, &'a H256)> for BlobEntity {
+impl<'a> From<(&'a BeaconBlob, &'a H256, usize, &'a H256)> for Blob {
     fn from(
-        (blob_data, versioned_hash, index, tx_hash): (&'a BlobData, &'a H256, usize, &'a H256),
+        (blob_data, versioned_hash, index, tx_hash): (&'a BeaconBlob, &'a H256, usize, &'a H256),
     ) -> Self {
         Self {
             tx_hash: *tx_hash,

src/context.rs

@@ -1,6 +1,6 @@
 use std::{sync::Arc, time::Duration};
 
-use anyhow::Result;
+use anyhow::Result as AnyhowResult;
 use ethers::prelude::*;
 
 use crate::{
@@ -28,7 +28,7 @@ pub struct Context {
 }
 
 impl Context {
-    pub fn try_new(config: Config) -> Result<Self> {
+    pub fn try_new(config: Config) -> AnyhowResult<Self> {
         let Config {
             blobscan_api_endpoint,
             beacon_node_rpc,

src/slot_processor_manager/mod.rs

@@ -4,7 +4,7 @@ use tokio::task::{JoinError, JoinHandle};
 use tracing::{error, Instrument};
 
 use self::slot_processor::{errors::SlotProcessorError, SlotProcessor};
-use crate::{blobscan_client::types::FailedSlotsChunkEntity, context::Context};
+use crate::{blobscan_client::types::FailedSlotsChunk, context::Context};
 
 mod slot_processor;
 
@@ -16,7 +16,7 @@ pub struct SlotProcessorManager {
 #[derive(Debug, thiserror::Error)]
 pub enum SlotProcessorManagerError {
     #[error("Slot processor manager failed to process the following slots chunks: {chunks:?}")]
-    FailedSlotsProcessing { chunks: Vec<FailedSlotsChunkEntity> },
+    FailedSlotsProcessing { chunks: Vec<FailedSlotsChunk> },
 
     #[error(transparent)]
     Other(#[from] anyhow::Error),
@@ -99,14 +99,14 @@ impl SlotProcessorManager {
     async fn get_failed_slots_chunks(
         &self,
         thread_outputs: &[Result<Result<u32, SlotProcessorError>, JoinError>],
-    ) -> Result<Vec<FailedSlotsChunkEntity>, SlotProcessorManagerError> {
+    ) -> Result<Vec<FailedSlotsChunk>, SlotProcessorManagerError> {
         let failed_threads = thread_outputs
             .iter()
             .filter(|thread_join| match thread_join {
                 Ok(thread_result) => thread_result.is_err(),
                 Err(_) => true,
             });
-        let mut failed_slots_chunks: Vec<FailedSlotsChunkEntity> = vec![];
+        let mut failed_slots_chunks: Vec<FailedSlotsChunk> = vec![];
 
         for thread in failed_threads.into_iter() {
             match thread {
@@ -117,7 +117,7 @@ impl SlotProcessorManager {
                         reason: _,
                     } => {
                         error!("Failed to process slots from {} to {}", slot, target_slot);
-                        failed_slots_chunks.push(FailedSlotsChunkEntity::from((
+                        failed_slots_chunks.push(FailedSlotsChunk::from((
                             slot.to_owned(),
                             target_slot.to_owned(),
                         )))
@@ -133,6 +133,6 @@ impl SlotProcessorManager {
             }
         }
 
-        return Ok(failed_slots_chunks);
+        Ok(failed_slots_chunks)
     }
 }