refactor: re-enable logs

Cargo.toml

@@ -18,39 +18,52 @@ inherits = "release"
 
 [dependencies]
 candid = { workspace = true }
+ethnum = { workspace = true }
 evm_rpc_types = { path = "evm_rpc_types" }
+futures = { workspace = true }
 getrandom = { workspace = true }
 ic-canisters-http-types = { workspace = true }
+ic-crypto-sha3 = { git = "https://github.com/dfinity/ic", rev = "release-2024-09-12_01-30-base" }
+ic-ethereum-types = { git = "https://github.com/dfinity/ic", rev = "release-2024-09-12_01-30-base" }
 ic-nervous-system-common = { workspace = true }
 ic-metrics-encoder = { workspace = true }
 ic-stable-structures = { workspace = true }
 ic-canister-log = { git = "https://github.com/dfinity/ic", rev = "1f551bea63354370b6e7a5037e96d464bdab3b41", package = "ic-canister-log" }
 ic-cdk = { workspace = true }
 ic-cdk-macros = { workspace = true }
 ic-certified-map = { workspace = true }
-cketh-common = { git = "https://github.com/dfinity/ic", rev = "1f551bea63354370b6e7a5037e96d464bdab3b41", package = "ic-cketh-minter" }
 maplit = "1.0"
+minicbor = { workspace = true }
+minicbor-derive = { workspace = true }
 num = "0.4"
+num-bigint = { workspace = true }
 num-traits = "0.2"
 num-derive = "0.4"
 serde = { workspace = true }
 serde_json = { workspace = true }
+thousands = "0.2"
 url = "2.5"
 async-trait = "0.1"
 hex = "0.4"
 ethers-core = "2.0"
-zeroize = "1.8"
+zeroize = {version = "1.8", features = ["zeroize_derive"]}
 
 [dev-dependencies]
+assert_matches = "1.5"
 ic-ic00-types = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
 ic-base-types = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
 ic-config = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
+ic-crypto-test-utils-reproducible-rng = { git = "https://github.com/dfinity/ic", rev = "release-2024-09-12_01-30-base" }
 ic-state-machine-tests = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
 ic-test-utilities-load-wasm = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
-assert_matches = "1.5"
+proptest = { workspace = true }
+serde_bytes = { workspace = true }
+rand = "0.8"
 
 [workspace.dependencies]
 candid = { version = "0.9" }
+ethnum = { version = "1.5.0", features = ["serde"] }
+futures = "0.3.30"
 getrandom = { version = "0.2", features = ["custom"] }
 hex = "0.4.3"
 ic-canisters-http-types = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
@@ -61,10 +74,13 @@ ic-certified-map = "0.4"
 ic-nervous-system-common = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
 ic-metrics-encoder = "1.1"
 ic-stable-structures = "0.5"
+minicbor = { version = "0.19.1", features = ["alloc", "derive"] }
+minicbor-derive = "0.13.0"
 num-bigint = "0.4.6"
 proptest = "1.5.0"
 serde = "1.0"
 serde_json = "1.0"
+serde_bytes = "0.11.15"
 
 [workspace]
 members = ["e2e/rust", "evm_rpc_types"]

src/candid_rpc.rs

@@ -2,21 +2,21 @@ mod cketh_conversion;
 
 use async_trait::async_trait;
 use candid::Nat;
-use cketh_common::eth_rpc_client::{EthRpcClient as CkEthRpcClient, MultiCallError, RpcTransport};
 use ethers_core::{types::Transaction, utils::rlp};
 use evm_rpc_types::{
-    Hex, Hex32, MultiRpcResult, ProviderError, RpcResult, RpcServices, ValidationError,
+    Hex, Hex32, MultiRpcResult, ProviderError, RpcApi, RpcError, RpcResult, RpcService,
+    RpcServices, ValidationError,
 };
 use ic_cdk::api::management_canister::http_request::{CanisterHttpRequestArgument, HttpResponse};
 
-use crate::candid_rpc::cketh_conversion::into_rpc_error;
+use crate::constants::{
+    DEFAULT_ETH_MAINNET_SERVICES, DEFAULT_ETH_SEPOLIA_SERVICES, DEFAULT_L2_MAINNET_SERVICES,
+};
+use crate::rpc_client::{EthRpcClient, MultiCallError, RpcTransport};
 use crate::{
     accounting::get_http_request_cost,
     add_metric_entry,
-    constants::{
-        DEFAULT_ETH_MAINNET_SERVICES, DEFAULT_ETH_SEPOLIA_SERVICES, DEFAULT_L2_MAINNET_SERVICES,
-        ETH_GET_LOGS_MAX_BLOCKS,
-    },
+    constants::ETH_GET_LOGS_MAX_BLOCKS,
     http::http_request,
     providers::resolve_rpc_service,
     types::{MetricRpcHost, MetricRpcMethod, ResolvedRpcService, RpcMethod},
@@ -28,29 +28,17 @@ struct CanisterTransport;
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl RpcTransport for CanisterTransport {
-    fn resolve_api(
-        service: &cketh_common::eth_rpc_client::providers::RpcService,
-    ) -> Result<cketh_common::eth_rpc_client::providers::RpcApi, cketh_common::eth_rpc::ProviderError>
-    {
-        use crate::candid_rpc::cketh_conversion::{
-            from_rpc_service, into_provider_error, into_rpc_api,
-        };
-        Ok(into_rpc_api(
-            resolve_rpc_service(from_rpc_service(service.clone()))
-                .map_err(into_provider_error)?
-                .api(),
-        ))
+    fn resolve_api(service: &RpcService) -> Result<RpcApi, ProviderError> {
+        Ok(resolve_rpc_service(service.clone())?.api())
     }
 
     async fn http_request(
-        service: &cketh_common::eth_rpc_client::providers::RpcService,
+        service: &RpcService,
         method: &str,
         request: CanisterHttpRequestArgument,
         effective_response_size_estimate: u64,
-    ) -> Result<HttpResponse, cketh_common::eth_rpc::RpcError> {
-        use crate::candid_rpc::cketh_conversion::{from_rpc_service, into_provider_error};
-        let service =
-            resolve_rpc_service(from_rpc_service(service.clone())).map_err(into_provider_error)?;
+    ) -> Result<HttpResponse, RpcError> {
+        let service = resolve_rpc_service(service.clone())?;
         let cycles_cost = get_http_request_cost(
             request
                 .body
@@ -60,9 +48,7 @@ impl RpcTransport for CanisterTransport {
             effective_response_size_estimate,
         );
         let rpc_method = MetricRpcMethod(method.to_string());
-        http_request(rpc_method, service, request, cycles_cost)
-            .await
-            .map_err(into_rpc_error)
+        http_request(rpc_method, service, request, cycles_cost).await
     }
 }
 
@@ -76,34 +62,28 @@ fn check_services<T>(services: Vec<T>) -> RpcResult<Vec<T>> {
 fn get_rpc_client(
     source: RpcServices,
     config: evm_rpc_types::RpcConfig,
-) -> RpcResult<CkEthRpcClient<CanisterTransport>> {
-    use crate::candid_rpc::cketh_conversion::{
-        into_ethereum_network, into_rpc_config, into_rpc_services,
-    };
+) -> RpcResult<EthRpcClient<CanisterTransport>> {
+    use crate::candid_rpc::cketh_conversion::{into_ethereum_network, into_rpc_services};
 
-    let config = into_rpc_config(config);
     let chain = into_ethereum_network(&source);
     let providers = check_services(into_rpc_services(
         source,
         DEFAULT_ETH_MAINNET_SERVICES,
         DEFAULT_ETH_SEPOLIA_SERVICES,
         DEFAULT_L2_MAINNET_SERVICES,
     ))?;
-    Ok(CkEthRpcClient::new(chain, Some(providers), config))
+    Ok(EthRpcClient::new(chain, Some(providers), config))
 }
 
 fn process_result<T>(method: RpcMethod, result: Result<T, MultiCallError<T>>) -> MultiRpcResult<T> {
-    use crate::candid_rpc::cketh_conversion::{from_rpc_error, from_rpc_service};
     match result {
         Ok(value) => MultiRpcResult::Consistent(Ok(value)),
         Err(err) => match err {
-            MultiCallError::ConsistentError(err) => {
-                MultiRpcResult::Consistent(Err(from_rpc_error(err)))
-            }
+            MultiCallError::ConsistentError(err) => MultiRpcResult::Consistent(Err(err)),
             MultiCallError::InconsistentResults(multi_call_results) => {
                 multi_call_results.results.iter().for_each(|(service, _)| {
                     if let Ok(ResolvedRpcService::Provider(provider)) =
-                        resolve_rpc_service(from_rpc_service(service.clone()))
+                        resolve_rpc_service(service.clone())
                     {
                         add_metric_entry!(
                             inconsistent_responses,
@@ -119,22 +99,14 @@ fn process_result<T>(method: RpcMethod, result: Result<T, MultiCallError<T>>) ->
                         )
                     }
                 });
-                MultiRpcResult::Inconsistent(
-                    multi_call_results
-                        .results
-                        .into_iter()
-                        .map(|(service, result)| {
-                            (from_rpc_service(service), result.map_err(from_rpc_error))
-                        })
-                        .collect(),
-                )
+                MultiRpcResult::Inconsistent(multi_call_results.results.into_iter().collect())
             }
         },
     }
 }
 
 pub struct CandidRpcClient {
-    client: CkEthRpcClient<CanisterTransport>,
+    client: EthRpcClient<CanisterTransport>,
 }
 
 impl CandidRpcClient {
@@ -259,12 +231,11 @@ fn get_transaction_hash(raw_signed_transaction_hex: &Hex) -> Option<Hex32> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::candid_rpc::cketh_conversion::into_rpc_service;
+    use crate::rpc_client::{MultiCallError, MultiCallResults};
     use evm_rpc_types::RpcError;
 
     #[test]
     fn test_process_result_mapping() {
-        use cketh_common::eth_rpc_client::MultiCallResults;
         use evm_rpc_types::{EthMainnetService, RpcService};
 
         let method = RpcMethod::EthGetTransactionCount;
@@ -277,9 +248,7 @@ mod test {
             process_result(
                 method,
                 Err(MultiCallError::<()>::ConsistentError(
-                    cketh_common::eth_rpc::RpcError::ProviderError(
-                        cketh_common::eth_rpc::ProviderError::MissingRequiredProvider
-                    )
+                    RpcError::ProviderError(ProviderError::MissingRequiredProvider)
                 ))
             ),
             MultiRpcResult::Consistent(Err(RpcError::ProviderError(
@@ -301,12 +270,9 @@ mod test {
             process_result(
                 method,
                 Err(MultiCallError::InconsistentResults(MultiCallResults {
-                    results: vec![(
-                        into_rpc_service(RpcService::EthMainnet(EthMainnetService::Ankr)),
-                        Ok(5)
-                    )]
-                    .into_iter()
-                    .collect(),
+                    results: vec![(RpcService::EthMainnet(EthMainnetService::Ankr), Ok(5))]
+                        .into_iter()
+                        .collect(),
                 }))
             ),
             MultiRpcResult::Inconsistent(vec![(
@@ -319,15 +285,10 @@ mod test {
                 method,
                 Err(MultiCallError::InconsistentResults(MultiCallResults {
                     results: vec![
+                        (RpcService::EthMainnet(EthMainnetService::Ankr), Ok(5)),
                         (
-                            into_rpc_service(RpcService::EthMainnet(EthMainnetService::Ankr)),
-                            Ok(5)
-                        ),
-                        (
-                            into_rpc_service(RpcService::EthMainnet(EthMainnetService::Cloudflare)),
-                            Err(cketh_common::eth_rpc::RpcError::ProviderError(
-                                cketh_common::eth_rpc::ProviderError::NoPermission
-                            ))
+                            RpcService::EthMainnet(EthMainnetService::Cloudflare),
+                            Err(RpcError::ProviderError(ProviderError::NoPermission))
                         )
                     ]
                     .into_iter()