Refactor to add .cycles_cost() method

Author: lpahlavi

src/candid_rpc/mod.rs

@@ -1,56 +1,15 @@
 mod cketh_conversion;
-#[cfg(test)]
-mod tests;
 
-use crate::rpc_client::{EthRpcClient, ReducedResult};
-use crate::types::MetricRpcMethod;
-use crate::{
-    add_metric_entry,
-    providers::resolve_rpc_service,
-    types::{MetricRpcHost, ResolvedRpcService, RpcMethod},
-};
+use crate::rpc_client::EthRpcClient;
+use crate::types::RpcMethod;
 use candid::Nat;
 use canhttp::http::json::JsonRpcRequest;
-use canhttp::multi::{ReductionError, Timestamp};
+use canhttp::multi::Timestamp;
 use ethers_core::{types::Transaction, utils::rlp};
 use evm_rpc_types::{
     BlockTag, GetLogsArgs, Hex, Hex32, MultiRpcResult, Nat256, RpcError, RpcResult, ValidationError,
 };
 
-fn process_result<T>(
-    method: impl Into<MetricRpcMethod> + Clone,
-    result: ReducedResult<T>,
-) -> MultiRpcResult<T> {
-    match result {
-        Ok(value) => MultiRpcResult::Consistent(Ok(value)),
-        Err(err) => match err {
-            ReductionError::ConsistentError(err) => MultiRpcResult::Consistent(Err(err)),
-            ReductionError::InconsistentResults(multi_call_results) => {
-                let results: Vec<_> = multi_call_results.into_iter().collect();
-                results.iter().for_each(|(service, _service_result)| {
-                    if let Ok(ResolvedRpcService::Provider(provider)) =
-                        resolve_rpc_service(service.clone())
-                    {
-                        add_metric_entry!(
-                            inconsistent_responses,
-                            (
-                                method.clone().into(),
-                                MetricRpcHost(
-                                    provider
-                                        .hostname()
-                                        .unwrap_or_else(|| "(unknown)".to_string())
-                                )
-                            ),
-                            1
-                        )
-                    }
-                });
-                MultiRpcResult::Inconsistent(results)
-            }
-        },
-    }
-}
-
 /// Adapt the `EthRpcClient` to the `Candid` interface used by the EVM-RPC canister.
 pub struct CandidRpcClient {
     client: EthRpcClient,
@@ -70,70 +29,72 @@ impl CandidRpcClient {
     pub async fn eth_get_logs(
         &self,
         args: evm_rpc_types::GetLogsArgs,
-        max_block_range: u32,
     ) -> MultiRpcResult<Vec<evm_rpc_types::LogEntry>> {
         use crate::candid_rpc::cketh_conversion::{from_log_entries, into_get_logs_param};
-        process_result(
-            RpcMethod::EthGetLogs,
-            self.client.eth_get_logs(into_get_logs_param(args)).await,
-        )
-        .map(from_log_entries)
+        self.client
+            .eth_get_logs(into_get_logs_param(args))
+            .send_and_reduce()
+            .await
+            .map(from_log_entries)
+    }
+
+    pub async fn eth_get_logs_request_cost(
+        &self,
+        args: evm_rpc_types::GetLogsArgs,
+    ) -> RpcResult<u128> {
+        use crate::candid_rpc::cketh_conversion::into_get_logs_param;
+        self.client
+            .eth_get_logs(into_get_logs_param(args))
+            .cycles_cost()
+            .await
     }
 
     pub async fn eth_get_block_by_number(
         &self,
         block: BlockTag,
     ) -> MultiRpcResult<evm_rpc_types::Block> {
         use crate::candid_rpc::cketh_conversion::{from_block, into_block_spec};
-        process_result(
-            RpcMethod::EthGetBlockByNumber,
-            self.client
-                .eth_get_block_by_number(into_block_spec(block))
-                .await,
-        )
-        .map(from_block)
+        self.client
+            .eth_get_block_by_number(into_block_spec(block))
+            .send_and_reduce()
+            .await
+            .map(from_block)
     }
 
     pub async fn eth_get_transaction_receipt(
         &self,
         hash: Hex32,
     ) -> MultiRpcResult<Option<evm_rpc_types::TransactionReceipt>> {
         use crate::candid_rpc::cketh_conversion::{from_transaction_receipt, into_hash};
-        process_result(
-            RpcMethod::EthGetTransactionReceipt,
-            self.client
-                .eth_get_transaction_receipt(into_hash(hash))
-                .await,
-        )
-        .map(|option| option.map(from_transaction_receipt))
+        self.client
+            .eth_get_transaction_receipt(into_hash(hash))
+            .send_and_reduce()
+            .await
+            .map(|option| option.map(from_transaction_receipt))
     }
 
     pub async fn eth_get_transaction_count(
         &self,
         args: evm_rpc_types::GetTransactionCountArgs,
     ) -> MultiRpcResult<Nat256> {
         use crate::candid_rpc::cketh_conversion::into_get_transaction_count_params;
-        process_result(
-            RpcMethod::EthGetTransactionCount,
-            self.client
-                .eth_get_transaction_count(into_get_transaction_count_params(args))
-                .await,
-        )
-        .map(Nat256::from)
+        self.client
+            .eth_get_transaction_count(into_get_transaction_count_params(args))
+            .send_and_reduce()
+            .await
+            .map(Nat256::from)
     }
 
     pub async fn eth_fee_history(
         &self,
         args: evm_rpc_types::FeeHistoryArgs,
     ) -> MultiRpcResult<evm_rpc_types::FeeHistory> {
         use crate::candid_rpc::cketh_conversion::{from_fee_history, into_fee_history_params};
-        process_result(
-            RpcMethod::EthFeeHistory,
-            self.client
-                .eth_fee_history(into_fee_history_params(args))
-                .await,
-        )
-        .map(from_fee_history)
+        self.client
+            .eth_fee_history(into_fee_history_params(args))
+            .send_and_reduce()
+            .await
+            .map(from_fee_history)
     }
 
     pub async fn eth_send_raw_transaction(
@@ -142,25 +103,23 @@ impl CandidRpcClient {
     ) -> MultiRpcResult<evm_rpc_types::SendRawTransactionStatus> {
         use crate::candid_rpc::cketh_conversion::from_send_raw_transaction_result;
         let transaction_hash = get_transaction_hash(&raw_signed_transaction_hex);
-        process_result(
-            RpcMethod::EthSendRawTransaction,
-            self.client
-                .eth_send_raw_transaction(raw_signed_transaction_hex.to_string())
-                .await,
-        )
-        .map(|result| from_send_raw_transaction_result(transaction_hash.clone(), result))
+        self.client
+            .eth_send_raw_transaction(raw_signed_transaction_hex.to_string())
+            .send_and_reduce()
+            .await
+            .map(|result| from_send_raw_transaction_result(transaction_hash.clone(), result))
     }
 
     pub async fn eth_call(
         &self,
         args: evm_rpc_types::CallArgs,
     ) -> MultiRpcResult<evm_rpc_types::Hex> {
         use crate::candid_rpc::cketh_conversion::{from_data, into_eth_call_params};
-        process_result(
-            RpcMethod::EthCall,
-            self.client.eth_call(into_eth_call_params(args)).await,
-        )
-        .map(from_data)
+        self.client
+            .eth_call(into_eth_call_params(args))
+            .send_and_reduce()
+            .await
+            .map(from_data)
     }
 
     pub async fn multi_request(&self, json_rpc_payload: String) -> MultiRpcResult<String> {
@@ -173,19 +132,14 @@ impl CandidRpcClient {
                     )))
                 }
             };
-        process_result(
-            MetricRpcMethod {
-                method: request.method().to_string(),
-                is_manual_request: true,
-            },
-            self.client
-                .multi_request(
-                    RpcMethod::Custom(request.method().to_string()),
-                    request.params(),
-                )
-                .await,
-        )
-        .map(String::from)
+        self.client
+            .multi_request(
+                RpcMethod::Custom(request.method().to_string()),
+                request.params(),
+            )
+            .send_and_reduce()
+            .await
+            .map(String::from)
     }
 }
 

src/candid_rpc/tests.rs

@@ -47,11 +47,29 @@ pub async fn eth_get_logs(
         return MultiRpcResult::Consistent(Err(err));
     }
     match CandidRpcClient::new(source, Some(RpcConfig::from(config)), now()) {
-        Ok(source) => source.eth_get_logs(args, max_block_range).await,
+        Ok(source) => source.eth_get_logs(args).await,
         Err(err) => Err(err).into(),
     }
 }
 
+#[update(name = "eth_getLogsRequestCost")]
+pub async fn eth_get_logs_request_cost(
+    source: RpcServices,
+    config: Option<evm_rpc_types::GetLogsRpcConfig>,
+    args: evm_rpc_types::GetLogsArgs,
+) -> RpcResult<u128> {
+    let config = config.unwrap_or_default();
+    let max_block_range = config.max_block_range_or_default();
+    validate_get_logs_block_range(&args, max_block_range)?;
+    if is_demo_active() {
+        return Ok(0);
+    }
+    match CandidRpcClient::new(source, Some(RpcConfig::from(config)), now()) {
+        Ok(source) => source.eth_get_logs_request_cost(args).await,
+        Err(err) => Err(err),
+    }
+}
+
 #[update(name = "eth_getBlockByNumber")]
 pub async fn eth_get_block_by_number(
     source: RpcServices,