remove redundant Get from response types

Author: eshaan7

verifiable-api/bin/handlers.rs

@@ -121,7 +121,7 @@ pub async fn get_account<N: NetworkSpec, R: ExecutionRpc<N>>(
         block,
     }): Query<AccountProofQuery>,
     State(ApiState { execution_client }): State<ApiState<N, R>>,
-) -> Response<GetAccountResponse> {
+) -> Response<AccountResponse> {
     // Ensure that BlockId is of block number variant
     let block = block.unwrap_or(BlockId::latest());
     let block_num = match block {
@@ -161,7 +161,7 @@ pub async fn get_account<N: NetworkSpec, R: ExecutionRpc<N>>(
         .await
         .map_err(map_server_err)?;
 
-    Ok(Json(GetAccountResponse {
+    Ok(Json(AccountResponse {
         account: Account {
             balance: proof.balance,
             nonce: proof.nonce,
@@ -183,7 +183,7 @@ pub async fn get_storage_at<N: NetworkSpec, R: ExecutionRpc<N>>(
     Path((address, key)): Path<(Address, U256)>,
     Query(BlockQuery { block }): Query<BlockQuery>,
     State(ApiState { execution_client }): State<ApiState<N, R>>,
-) -> Response<GetStorageAtResponse> {
+) -> Response<StorageAtResponse> {
     let block = block.unwrap_or(BlockId::latest());
 
     let storage_slot = execution_client
@@ -208,7 +208,7 @@ pub async fn get_storage_at<N: NetworkSpec, R: ExecutionRpc<N>>(
         }
     };
 
-    Ok(Json(GetStorageAtResponse {
+    Ok(Json(StorageAtResponse {
         storage,
         account: Account {
             balance: proof.balance,
@@ -226,7 +226,7 @@ pub async fn get_storage_at<N: NetworkSpec, R: ExecutionRpc<N>>(
 pub async fn get_block_receipts<N: NetworkSpec, R: ExecutionRpc<N>>(
     Path(block): Path<BlockId>,
     State(ApiState { execution_client }): State<ApiState<N, R>>,
-) -> Response<GetBlockReceiptsResponse<N>> {
+) -> Response<BlockReceiptsResponse<N>> {
     let receipts = execution_client
         .rpc
         .get_block_receipts(block)
@@ -243,7 +243,7 @@ pub async fn get_block_receipts<N: NetworkSpec, R: ExecutionRpc<N>>(
 pub async fn get_transaction_receipt<N: NetworkSpec, R: ExecutionRpc<N>>(
     Path(tx_hash): Path<B256>,
     State(ApiState { execution_client }): State<ApiState<N, R>>,
-) -> Response<GetTransactionReceiptResponse<N>> {
+) -> Response<TransactionReceiptResponse<N>> {
     let receipt = execution_client
         .rpc
         .get_transaction_receipt(tx_hash)
@@ -271,7 +271,7 @@ pub async fn get_transaction_receipt<N: NetworkSpec, R: ExecutionRpc<N>>(
     let receipt_proof =
         create_receipt_proof::<N>(receipts, receipt.transaction_index().unwrap() as usize);
 
-    Ok(Json(GetTransactionReceiptResponse {
+    Ok(Json(TransactionReceiptResponse {
         receipt,
         receipt_proof,
     }))
@@ -284,7 +284,7 @@ pub async fn get_transaction_receipt<N: NetworkSpec, R: ExecutionRpc<N>>(
 pub async fn get_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
     Query(logs_filter_query): Query<LogsQuery>,
     State(ApiState { execution_client }): State<ApiState<N, R>>,
-) -> Response<GetLogsResponse<N>> {
+) -> Response<LogsResponse<N>> {
     let filter: Filter = logs_filter_query.try_into().map_err(map_server_err)?;
 
     // Fetch the filter logs from RPC
@@ -299,7 +299,7 @@ pub async fn get_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
         .await
         .map_err(map_server_err)?;
 
-    Ok(Json(GetLogsResponse {
+    Ok(Json(LogsResponse {
         logs,
         receipt_proofs,
     }))
@@ -312,7 +312,7 @@ pub async fn get_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
 pub async fn get_filter_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
     Path(filter_id): Path<U256>,
     State(ApiState { execution_client }): State<ApiState<N, R>>,
-) -> Response<GetFilterLogsResponse<N>> {
+) -> Response<FilterLogsResponse<N>> {
     // Fetch the filter logs from RPC
     let logs = execution_client
         .rpc
@@ -325,7 +325,7 @@ pub async fn get_filter_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
         .await
         .map_err(map_server_err)?;
 
-    Ok(Json(GetFilterLogsResponse {
+    Ok(Json(FilterLogsResponse {
         logs,
         receipt_proofs,
     }))
@@ -339,7 +339,7 @@ pub async fn get_filter_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
 pub async fn get_filter_changes<N: NetworkSpec, R: ExecutionRpc<N>>(
     Path(filter_id): Path<U256>,
     State(ApiState { execution_client }): State<ApiState<N, R>>,
-) -> Response<GetFilterChangesResponse<N>> {
+) -> Response<FilterChangesResponse<N>> {
     let filter_changes = execution_client
         .rpc
         .get_filter_changes(filter_id)
@@ -353,14 +353,14 @@ pub async fn get_filter_changes<N: NetworkSpec, R: ExecutionRpc<N>>(
                 .await
                 .map_err(map_server_err)?;
 
-            GetFilterChangesResponse::Logs(GetFilterLogsResponse {
+            FilterChangesResponse::Logs(FilterLogsResponse {
                 logs,
                 receipt_proofs,
             })
         }
-        FilterChanges::Hashes(hashes) => GetFilterChangesResponse::Hashes(hashes),
-        FilterChanges::Empty => GetFilterChangesResponse::Hashes(vec![]),
-        FilterChanges::Transactions(txs) => GetFilterChangesResponse::Hashes(
+        FilterChanges::Hashes(hashes) => FilterChangesResponse::Hashes(hashes),
+        FilterChanges::Empty => FilterChangesResponse::Hashes(vec![]),
+        FilterChanges::Transactions(txs) => FilterChangesResponse::Hashes(
             txs.into_iter().map(|t| t.inner.tx_hash().clone()).collect(),
         ),
     }))
@@ -369,7 +369,7 @@ pub async fn get_filter_changes<N: NetworkSpec, R: ExecutionRpc<N>>(
 async fn create_receipt_proofs_for_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
     logs: &[Log],
     execution_client: Arc<ExecutionClient<N, R>>,
-) -> Result<HashMap<B256, GetTransactionReceiptResponse<N>>> {
+) -> Result<HashMap<B256, TransactionReceiptResponse<N>>> {
     // Collect all (unique) block numbers
     let block_nums = logs
         .iter()
@@ -391,7 +391,7 @@ async fn create_receipt_proofs_for_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
     let blocks_receipts = blocks_receipts.into_iter().collect::<HashMap<_, _>>();
 
     // Create a map of transaction hashes to their receipt and proof
-    let mut receipt_proofs: HashMap<B256, GetTransactionReceiptResponse<N>> = HashMap::new();
+    let mut receipt_proofs: HashMap<B256, TransactionReceiptResponse<N>> = HashMap::new();
 
     for log in logs {
         let tx_hash = log.transaction_hash.unwrap();
@@ -412,7 +412,7 @@ async fn create_receipt_proofs_for_logs<N: NetworkSpec, R: ExecutionRpc<N>>(
 
         receipt_proofs.insert(
             tx_hash,
-            GetTransactionReceiptResponse {
+            TransactionReceiptResponse {
                 receipt: receipt.clone(),
                 receipt_proof,
             },

verifiable-api/src/api_client.rs

@@ -18,21 +18,19 @@ pub trait VerifiableApi<N: NetworkSpec> {
         address: Address,
         storage_keys: Vec<B256>,
         block: Option<BlockId>,
-    ) -> Result<GetAccountResponse>;
+    ) -> Result<AccountResponse>;
     async fn get_storage_at(
         &self,
         address: Address,
         key: U256,
         block: Option<BlockId>,
-    ) -> Result<GetStorageAtResponse>;
-    async fn get_block_receipts(&self, block: BlockId) -> Result<GetBlockReceiptsResponse<N>>;
-    async fn get_transaction_receipt(
-        &self,
-        tx_hash: B256,
-    ) -> Result<GetTransactionReceiptResponse<N>>;
-    async fn get_logs(&self, filter: Filter) -> Result<GetLogsResponse<N>>;
-    async fn get_filter_logs(&self, filter_id: U256) -> Result<GetFilterLogsResponse<N>>;
-    async fn get_filter_changes(&self, filter_id: U256) -> Result<GetFilterChangesResponse<N>>;
+    ) -> Result<StorageAtResponse>;
+    async fn get_block_receipts(&self, block: BlockId) -> Result<BlockReceiptsResponse<N>>;
+    async fn get_transaction_receipt(&self, tx_hash: B256)
+        -> Result<TransactionReceiptResponse<N>>;
+    async fn get_logs(&self, filter: Filter) -> Result<LogsResponse<N>>;
+    async fn get_filter_logs(&self, filter_id: U256) -> Result<FilterLogsResponse<N>>;
+    async fn get_filter_changes(&self, filter_id: U256) -> Result<FilterChangesResponse<N>>;
 }
 
 pub struct VerifiableApiClient {
@@ -56,7 +54,7 @@ impl<N: NetworkSpec> VerifiableApi<N> for VerifiableApiClient {
         address: Address,
         storage_keys: Vec<B256>,
         block: Option<BlockId>,
-    ) -> Result<GetAccountResponse> {
+    ) -> Result<AccountResponse> {
         let url = format!("{}/eth/v1/proof/account/{}", self.base_url, address);
         let response = self
             .client
@@ -65,7 +63,7 @@ impl<N: NetworkSpec> VerifiableApi<N> for VerifiableApiClient {
             .query(&[("storageKeys", &storage_keys)])
             .send()
             .await?;
-        let response = response.json::<GetAccountResponse>().await?;
+        let response = response.json::<AccountResponse>().await?;
         Ok(response)
     }
 
@@ -74,36 +72,36 @@ impl<N: NetworkSpec> VerifiableApi<N> for VerifiableApiClient {
         address: Address,
         key: U256,
         block: Option<BlockId>,
-    ) -> Result<GetStorageAtResponse> {
+    ) -> Result<StorageAtResponse> {
         let url = format!("{}/eth/v1/proof/storage/{}/{}", self.base_url, address, key);
         let response = self
             .client
             .get(&url)
             .query(&[("block", block)])
             .send()
             .await?;
-        let response = response.json::<GetStorageAtResponse>().await?;
+        let response = response.json::<StorageAtResponse>().await?;
         Ok(response)
     }
 
-    async fn get_block_receipts(&self, block: BlockId) -> Result<GetBlockReceiptsResponse<N>> {
+    async fn get_block_receipts(&self, block: BlockId) -> Result<BlockReceiptsResponse<N>> {
         let url = format!("{}/eth/v1/proof/block_receipts/{}", self.base_url, block);
         let response = self.client.get(&url).send().await?;
-        let response = response.json::<GetBlockReceiptsResponse<N>>().await?;
+        let response = response.json::<BlockReceiptsResponse<N>>().await?;
         Ok(response)
     }
 
     async fn get_transaction_receipt(
         &self,
         tx_hash: B256,
-    ) -> Result<GetTransactionReceiptResponse<N>> {
+    ) -> Result<TransactionReceiptResponse<N>> {
         let url = format!("{}/eth/v1/proof/tx_receipt/{}", self.base_url, tx_hash);
         let response = self.client.get(&url).send().await?;
-        let response = response.json::<GetTransactionReceiptResponse<N>>().await?;
+        let response = response.json::<TransactionReceiptResponse<N>>().await?;
         Ok(response)
     }
 
-    async fn get_logs(&self, filter: Filter) -> Result<GetLogsResponse<N>> {
+    async fn get_logs(&self, filter: Filter) -> Result<LogsResponse<N>> {
         let url = format!("{}/eth/v1/proof/logs", self.base_url);
 
         let mut request = self.client.get(&url);
@@ -129,24 +127,24 @@ impl<N: NetworkSpec> VerifiableApi<N> for VerifiableApiClient {
         }
 
         let response = request.send().await?;
-        let response = response.json::<GetLogsResponse<N>>().await?;
+        let response = response.json::<LogsResponse<N>>().await?;
         Ok(response)
     }
 
-    async fn get_filter_logs(&self, filter_id: U256) -> Result<GetFilterLogsResponse<N>> {
+    async fn get_filter_logs(&self, filter_id: U256) -> Result<FilterLogsResponse<N>> {
         let url = format!("{}/eth/v1/proof/filter_logs/{}", self.base_url, filter_id);
         let response = self.client.get(&url).send().await?;
-        let response = response.json::<GetFilterLogsResponse<N>>().await?;
+        let response = response.json::<FilterLogsResponse<N>>().await?;
         Ok(response)
     }
 
-    async fn get_filter_changes(&self, filter_id: U256) -> Result<GetFilterChangesResponse<N>> {
+    async fn get_filter_changes(&self, filter_id: U256) -> Result<FilterChangesResponse<N>> {
         let url = format!(
             "{}/eth/v1/proof/filter_changes/{}",
             self.base_url, filter_id
         );
         let response = self.client.get(&url).send().await?;
-        let response = response.json::<GetFilterChangesResponse<N>>().await?;
+        let response = response.json::<FilterChangesResponse<N>>().await?;
         Ok(response)
     }
 }

verifiable-api/src/types.rs

@@ -11,7 +11,7 @@ use helios_core::{execution::types::Account, network_spec::NetworkSpec};
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GetAccountResponse {
+pub struct AccountResponse {
     pub account: TrieAccount,
     pub code: Bytes,
     pub account_proof: Vec<Bytes>,
@@ -20,46 +20,46 @@ pub struct GetAccountResponse {
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GetStorageAtResponse {
+pub struct StorageAtResponse {
     pub storage: EIP1186StorageProof,
     pub account: TrieAccount,
     pub account_proof: Vec<Bytes>,
 }
 
 #[allow(type_alias_bounds)]
-pub type GetBlockReceiptsResponse<N: NetworkSpec> = Vec<N::ReceiptResponse>;
+pub type BlockReceiptsResponse<N: NetworkSpec> = Vec<N::ReceiptResponse>;
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GetTransactionReceiptResponse<N: NetworkSpec> {
+pub struct TransactionReceiptResponse<N: NetworkSpec> {
     pub receipt: N::ReceiptResponse,
     pub receipt_proof: Vec<Bytes>,
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[serde(bound = "N: NetworkSpec")]
-pub struct GetLogsResponse<N: NetworkSpec> {
+pub struct LogsResponse<N: NetworkSpec> {
     pub logs: Vec<Log>,
-    pub receipt_proofs: HashMap<B256, GetTransactionReceiptResponse<N>>, // tx_hash -> receipt & proof
+    pub receipt_proofs: HashMap<B256, TransactionReceiptResponse<N>>, // tx_hash -> receipt & proof
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[serde(bound = "N: NetworkSpec")]
-pub struct GetFilterLogsResponse<N: NetworkSpec> {
+pub struct FilterLogsResponse<N: NetworkSpec> {
     pub logs: Vec<Log>,
-    pub receipt_proofs: HashMap<B256, GetTransactionReceiptResponse<N>>, // tx_hash -> receipt & proof
+    pub receipt_proofs: HashMap<B256, TransactionReceiptResponse<N>>, // tx_hash -> receipt & proof
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[serde(bound = "N: NetworkSpec")]
 #[serde(untagged)]
 
-pub enum GetFilterChangesResponse<N: NetworkSpec> {
+pub enum FilterChangesResponse<N: NetworkSpec> {
     Hashes(Vec<B256>),
-    Logs(GetFilterLogsResponse<N>),
+    Logs(FilterLogsResponse<N>),
 }
 
 #[derive(Serialize, Deserialize)]