test: mock HTTPS outcalls in state machine tests

Cargo.toml

@@ -38,19 +38,12 @@ async-trait = "0.1"
 hex = "0.4"
 
 [dev-dependencies]
-# assert_matches = "1.5.0"
-# ethers-core = "2.0.8"
 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-2023-09-27_23-01" }
-# ic-icrc1-ledger = { git = "https://github.com/dfinity/ic", rev = "release-2023-09-27_23-01" }
 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" }
-# maplit = "1"
-# proptest = "1.0"
-# rand = "0.8"
-# scraper = "0.17.1"
+assert_matches = "1.5"
 
 [workspace.dependencies]
 candid = { version = "0.9", features = ["parser"] }

lib/rust/src/lib.rs

@@ -8,8 +8,8 @@ pub use ethers_core as core;
 
 pub use rpc::{call_contract, get_provider, request};
 
-#[ic_cdk_macros::query(name = "__transform_ic_evm_rpc")]
-pub fn transform_evm_rpc(args: TransformArgs) -> HttpResponse {
+#[ic_cdk_macros::query(name = "__ic_evm_transform_json_rpc")]
+pub fn transform_json_rpc(args: TransformArgs) -> HttpResponse {
     HttpResponse {
         status: args.response.status,
         body: args.response.body,

lib/rust/src/rpc.rs

@@ -137,7 +137,7 @@ pub async fn request<'a, T: Serialize>(
         headers: request_headers,
         body: Some(json_rpc_payload.as_bytes().to_vec()),
         transform: Some(TransformContext::from_name(
-            "__transform_ic_evm_rpc".to_string(),
+            "__ic_evm_transform_json_rpc".to_string(),
             vec![],
         )),
     };

src/constants.rs

@@ -20,6 +20,7 @@ pub const DEFAULT_ETHEREUM_PROVIDER: EthereumProvider = EthereumProvider::Ankr;
 pub const DEFAULT_SEPOLIA_PROVIDER: SepoliaProvider = SepoliaProvider::PublicNode;
 
 pub const CONTENT_TYPE_HEADER: &str = "Content-Type";
+pub const CONTENT_TYPE_VALUE: &str = "application/json";
 
 pub const ETH_MAINNET_CHAIN_ID: u64 = 1;
 pub const ETH_SEPOLIA_CHAIN_ID: u64 = 11155111;

src/http.rs

@@ -1,8 +1,8 @@
 use cketh_common::eth_rpc::{HttpOutcallError, ProviderError, RpcError, ValidationError};
 use ic_canister_log::log;
 use ic_cdk::api::management_canister::http_request::{
-    http_request as make_http_request, CanisterHttpRequestArgument, HttpHeader, HttpMethod,
-    HttpResponse, TransformContext,
+    CanisterHttpRequestArgument, HttpHeader, HttpMethod, HttpResponse, TransformArgs,
+    TransformContext,
 };
 use num_traits::ToPrimitive;
 
@@ -19,7 +19,6 @@ pub async fn do_http_request(
         inc_metric!(request_err_no_permission);
         return Err(ProviderError::NoPermission.into());
     }
-    let cycles_available = ic_cdk::api::call::msg_cycles_available128();
     let cost = get_request_cost(&source, json_rpc_payload, max_response_bytes);
     let (api, provider) = match source {
         ResolvedSource::Api(api) => (api, None),
@@ -39,6 +38,7 @@ pub async fn do_http_request(
         return Err(ValidationError::HostNotAllowed(host.to_string()).into());
     }
     if !is_authorized(&caller, Auth::FreeRpc) {
+        let cycles_available = ic_cdk::api::call::msg_cycles_available128();
         if cycles_available < cost {
             return Err(ProviderError::TooFewCycles {
                 expected: cost,
@@ -62,7 +62,7 @@ pub async fn do_http_request(
     inc_metric_entry!(host_requests, host.to_string());
     let mut request_headers = vec![HttpHeader {
         name: CONTENT_TYPE_HEADER.to_string(),
-        value: "application/json".to_string(),
+        value: CONTENT_TYPE_VALUE.to_string(),
     }];
     request_headers.extend(api.headers);
     let request = CanisterHttpRequestArgument {
@@ -72,11 +72,11 @@ pub async fn do_http_request(
         headers: request_headers,
         body: Some(json_rpc_payload.as_bytes().to_vec()),
         transform: Some(TransformContext::from_name(
-            "__transform_evm_rpc".to_string(),
+            "__transform_json_rpc".to_string(),
             vec![],
         )),
     };
-    match make_http_request(request, cost).await {
+    match ic_cdk::api::management_canister::http_request::http_request(request, cost).await {
         Ok((response,)) => Ok(response),
         Err((code, message)) => {
             inc_metric!(request_err_http);
@@ -85,6 +85,15 @@ pub async fn do_http_request(
     }
 }
 
+pub fn do_transform_http_request(args: TransformArgs) -> HttpResponse {
+    HttpResponse {
+        status: args.response.status,
+        body: canonicalize_json(&args.response.body).unwrap_or(args.response.body),
+        // Remove headers (which may contain a timestamp) for consensus
+        headers: vec![],
+    }
+}
+
 pub fn get_http_response_status(status: candid::Nat) -> u16 {
     status.0.to_u16().unwrap_or(u16::MAX)
 }

src/main.rs

@@ -7,7 +7,7 @@ use ic_canister_log::log;
 use ic_canisters_http_types::{
     HttpRequest as AssetHttpRequest, HttpResponse as AssetHttpResponse, HttpResponseBuilder,
 };
-use ic_cdk::api::management_canister::http_request::{HttpHeader, HttpResponse, TransformArgs};
+use ic_cdk::api::management_canister::http_request::{HttpResponse, TransformArgs};
 use ic_cdk::{query, update};
 use ic_nervous_system_common::{serve_logs, serve_logs_v2, serve_metrics};
 
@@ -222,15 +222,9 @@ async fn withdraw_accumulated_cycles(provider_id: u64, canister_id: Principal) {
     };
 }
 
-#[query(name = "__transform_evm_rpc")]
+#[query(name = "__transform_json_rpc")]
 fn transform(args: TransformArgs) -> HttpResponse {
-    HttpResponse {
-        status: args.response.status,
-        body: canonicalize_json(&args.response.body).unwrap_or(args.response.body),
-        // Strip headers as they contain the Date which is not necessarily the same
-        // and will prevent consensus on the result.
-        headers: Vec::<HttpHeader>::new(),
-    }
+    do_transform_http_request(args)
 }
 
 #[ic_cdk::init]