feat: [EXC-1768] Add system API to get costs of management canister calls.

rs/canister_sandbox/src/sandbox_server.rs

@@ -162,7 +162,7 @@ mod tests {
     use ic_limits::SMALL_APP_SUBNET_MAX_SIZE;
     use ic_logger::replica_logger::no_op_logger;
     use ic_registry_subnet_type::SubnetType;
-    use ic_replicated_state::{Global, NumWasmPages, PageIndex, PageMap};
+    use ic_replicated_state::{Global, NetworkTopology, NumWasmPages, PageIndex, PageMap};
     use ic_system_api::{
         sandbox_safe_system_state::{CanisterStatusView, SandboxSafeSystemState},
         ApiType, ExecutionParameters, InstructionLimits,
@@ -242,6 +242,7 @@ mod tests {
             caller,
             0,
             IS_WASM64_EXECUTION,
+            NetworkTopology::default(),
         )
     }
 

rs/config/src/subnet_config.rs

@@ -513,6 +513,32 @@ impl CyclesAccountManagerConfig {
             default_reserved_balance_limit: DEFAULT_RESERVED_BALANCE_LIMIT,
         }
     }
+
+    pub fn zero_cost(subnet_size: usize) -> Self {
+        Self {
+            reference_subnet_size: subnet_size,
+            canister_creation_fee: Cycles::zero(),
+            update_message_execution_fee: Cycles::zero(),
+            ten_update_instructions_execution_fee: Cycles::zero(),
+            ten_update_instructions_execution_fee_wasm64: Cycles::zero(),
+            xnet_call_fee: Cycles::zero(),
+            xnet_byte_transmission_fee: Cycles::zero(),
+            ingress_message_reception_fee: Cycles::zero(),
+            ingress_byte_reception_fee: Cycles::zero(),
+            gib_storage_per_second_fee: Cycles::zero(),
+            compute_percent_allocated_per_second_fee: Cycles::zero(),
+            duration_between_allocation_charges: Duration::from_secs(u64::MAX),
+            ecdsa_signature_fee: Cycles::zero(),
+            schnorr_signature_fee: Cycles::zero(),
+            vetkd_fee: Cycles::zero(),
+            http_request_linear_baseline_fee: Cycles::zero(),
+            http_request_quadratic_baseline_fee: Cycles::zero(),
+            http_request_per_byte_fee: Cycles::zero(),
+            http_response_per_byte_fee: Cycles::zero(),
+            max_storage_reservation_period: Duration::from_secs(u64::MAX),
+            default_reserved_balance_limit: Cycles::zero(),
+        }
+    }
 }
 
 /// If a component has at least one static configuration that is different for

rs/cycles_account_manager/src/lib.rs

@@ -757,16 +757,15 @@ impl CyclesAccountManager {
         reveal_top_up: bool,
     ) -> Result<Vec<(CyclesUseCase, Cycles)>, CanisterOutOfCyclesError> {
         // The total amount charged consists of:
-        //   - the fee to do the xnet call (request + response)
-        //   - the fee to send the request (by size)
-        //   - the fee for the largest possible response
-        //   - the fee for executing the largest allowed response when it eventually arrives.
-        let transmission_fee = self.scale_cost(
-            self.config.xnet_call_fee
-                + self.config.xnet_byte_transmission_fee * request.payload_size_bytes().get(),
+        // the fee to do the xnet call (request + response),
+        // the fee to send the request (by size),
+        // the fee for the largest possible response,
+        let transmission_fee = self.xnet_total_transmission_fee(
+            request.payload_size_bytes(),
             subnet_size,
-        ) + prepayment_for_response_transmission;
-
+            prepayment_for_response_transmission,
+        );
+        // and the fee for executing the largest allowed response when it eventually arrives.
         let fee = transmission_fee + prepayment_for_response_execution;
 
         self.withdraw_with_threshold(
@@ -797,6 +796,40 @@ impl CyclesAccountManager {
         ]))
     }
 
+    /// The total amount for an xnet call transmission. Includes response transmission, but
+    /// excludes the response execution.
+    pub fn xnet_total_transmission_fee(
+        &self,
+        payload_size: NumBytes,
+        subnet_size: usize,
+        prepayment_for_response_transmission: Cycles,
+    ) -> Cycles {
+        self.xnet_call_performed_fee(subnet_size)
+            + self.xnet_call_bytes_transmitted_fee(payload_size, subnet_size)
+            + prepayment_for_response_transmission
+    }
+
+    /// The total fee for an xnet call, including payload size, transmission (both ways)
+    /// and the reservation for the response execution. Corresponds to the amount of
+    /// cycles above the freezing threshold a canister must be for ic0.call_perform to
+    /// succeed.
+    pub fn xnet_call_total_fee(
+        &self,
+        payload_size: NumBytes,
+        execution_mode: WasmExecutionMode,
+    ) -> Cycles {
+        let subnet_size = self.config.reference_subnet_size;
+        let prepayment_for_response_transmission =
+            self.prepayment_for_response_transmission(subnet_size);
+        let prepayment_for_response_execution =
+            self.prepayment_for_response_execution(subnet_size, execution_mode);
+        self.xnet_total_transmission_fee(
+            payload_size,
+            subnet_size,
+            prepayment_for_response_transmission,
+        ) + prepayment_for_response_execution
+    }
+
     /// Returns the amount of cycles required for executing the longest-running
     /// response callback.
     pub fn prepayment_for_response_execution(

rs/embedders/src/wasm_utils/validation.rs

@@ -657,6 +657,66 @@ fn get_valid_system_apis_common(I: ValType) -> HashMap<String, HashMap<String, F
                 },
             )],
         ),
+        (
+            "cost_call",
+            vec![(
+                API_VERSION_IC0,
+                FunctionSignature {
+                    param_types: vec![ValType::I64, ValType::I64, I],
+                    return_type: vec![],
+                },
+            )],
+        ),
+        (
+            "cost_create_canister",
+            vec![(
+                API_VERSION_IC0,
+                FunctionSignature {
+                    param_types: vec![I],
+                    return_type: vec![],
+                },
+            )],
+        ),
+        (
+            "cost_http_request",
+            vec![(
+                API_VERSION_IC0,
+                FunctionSignature {
+                    param_types: vec![ValType::I64, ValType::I64, I],
+                    return_type: vec![],
+                },
+            )],
+        ),
+        (
+            "cost_sign_with_ecdsa",
+            vec![(
+                API_VERSION_IC0,
+                FunctionSignature {
+                    param_types: vec![I, I, ValType::I32, I],
+                    return_type: vec![ValType::I32],
+                },
+            )],
+        ),
+        (
+            "cost_sign_with_schnorr",
+            vec![(
+                API_VERSION_IC0,
+                FunctionSignature {
+                    param_types: vec![I, I, ValType::I32, I],
+                    return_type: vec![ValType::I32],
+                },
+            )],
+        ),
+        (
+            "cost_vetkd_derive_encrypted_key",
+            vec![(
+                API_VERSION_IC0,
+                FunctionSignature {
+                    param_types: vec![I, I, ValType::I32, I],
+                    return_type: vec![ValType::I32],
+                },
+            )],
+        ),
     ];
 
     valid_system_apis

rs/embedders/src/wasmtime_embedder/system_api.rs

@@ -1248,6 +1248,100 @@ pub fn syscalls<
         })
         .unwrap();
 
+    linker
+        .func_wrap("ic0", "cost_call", {
+            move |mut caller: Caller<'_, StoreData>,
+                  method_name_size: u64,
+                  payload_size: u64,
+                  dst: I| {
+                charge_for_cpu(&mut caller, overhead::COST_CALL)?;
+                with_memory_and_system_api(&mut caller, |s, memory| {
+                    let dst: usize = dst.try_into().expect("Failed to convert I to usize");
+                    s.ic0_cost_call(method_name_size, payload_size, dst, memory)
+                })
+                .map_err(|e| anyhow::Error::msg(format!("ic0_cost_call failed: {}", e)))
+            }
+        })
+        .unwrap();
+
+    linker
+        .func_wrap("ic0", "cost_create_canister", {
+            move |mut caller: Caller<'_, StoreData>, dst: I| {
+                charge_for_cpu(&mut caller, overhead::COST_CREATE_CANISTER)?;
+                with_memory_and_system_api(&mut caller, |s, memory| {
+                    let dst: usize = dst.try_into().expect("Failed to convert I to usize");
+                    s.ic0_cost_create_canister(dst, memory)
+                })
+                .map_err(|e| anyhow::Error::msg(format!("ic0_cost_create_canister failed: {}", e)))
+            }
+        })
+        .unwrap();
+
+    linker
+        .func_wrap("ic0", "cost_http_request", {
+            move |mut caller: Caller<'_, StoreData>,
+                  request_size: u64,
+                  max_res_bytes: u64,
+                  dst: I| {
+                charge_for_cpu(&mut caller, overhead::COST_HTTP_REQUEST)?;
+                with_memory_and_system_api(&mut caller, |s, memory| {
+                    let dst: usize = dst.try_into().expect("Failed to convert I to usize");
+                    s.ic0_cost_http_request(request_size, max_res_bytes, dst, memory)
+                })
+                .map_err(|e| anyhow::Error::msg(format!("ic0_cost_http_request failed: {}", e)))
+            }
+        })
+        .unwrap();
+
+    linker
+        .func_wrap("ic0", "cost_sign_with_ecdsa", {
+            move |mut caller: Caller<'_, StoreData>, src: I, size: I, curve: u32, dst: I| {
+                let src: usize = src.try_into().expect("Failed to convert I to usize");
+                let size: usize = size.try_into().expect("Failed to convert I to usize");
+                charge_for_cpu_and_mem(&mut caller, overhead::COST_ECDSA, size)?;
+                with_memory_and_system_api(&mut caller, |s, memory| {
+                    let dst: usize = dst.try_into().expect("Failed to convert I to usize");
+                    s.ic0_cost_sign_with_ecdsa(src, size, curve, dst, memory)
+                })
+                .map_err(|e| anyhow::Error::msg(format!("ic0_cost_sign_with_ecdsa failed: {}", e)))
+            }
+        })
+        .unwrap();
+
+    linker
+        .func_wrap("ic0", "cost_sign_with_schnorr", {
+            move |mut caller: Caller<'_, StoreData>, src: I, size: I, algorithm: u32, dst: I| {
+                let src: usize = src.try_into().expect("Failed to convert I to usize");
+                let size: usize = size.try_into().expect("Failed to convert I to usize");
+                charge_for_cpu_and_mem(&mut caller, overhead::COST_SCHNORR, size)?;
+                with_memory_and_system_api(&mut caller, |s, memory| {
+                    let dst: usize = dst.try_into().expect("Failed to convert I to usize");
+                    s.ic0_cost_sign_with_schnorr(src, size, algorithm, dst, memory)
+                })
+                .map_err(|e| {
+                    anyhow::Error::msg(format!("ic0_cost_sign_with_schnorr failed: {}", e))
+                })
+            }
+        })
+        .unwrap();
+
+    linker
+        .func_wrap("ic0", "cost_vetkd_derive_encrypted_key", {
+            move |mut caller: Caller<'_, StoreData>, src: I, size: I, curve: u32, dst: I| {
+                let src: usize = src.try_into().expect("Failed to convert I to usize");
+                let size: usize = size.try_into().expect("Failed to convert I to usize");
+                charge_for_cpu_and_mem(&mut caller, overhead::COST_VETKD, size)?;
+                with_memory_and_system_api(&mut caller, |s, memory| {
+                    let dst: usize = dst.try_into().expect("Failed to convert I to usize");
+                    s.ic0_cost_vetkd_derive_encrypted_key(src, size, curve, dst, memory)
+                })
+                .map_err(|e| {
+                    anyhow::Error::msg(format!("ic0_cost_vetkd_derive_encrypted_key failed: {}", e))
+                })
+            }
+        })
+        .unwrap();
+
     linker
         .func_wrap("ic0", "call_with_best_effort_response", {
             move |mut caller: Caller<'_, StoreData>, timeout_seconds: u32| {

rs/embedders/src/wasmtime_embedder/system_api_complexity.rs

@@ -35,6 +35,12 @@ pub mod overhead {
     pub const CERTIFIED_DATA_SET: NumInstructions = NumInstructions::new(500);
     pub const CONTROLLER_COPY: NumInstructions = NumInstructions::new(500);
     pub const CONTROLLER_SIZE: NumInstructions = NumInstructions::new(500);
+    pub const COST_CALL: NumInstructions = NumInstructions::new(100);
+    pub const COST_CREATE_CANISTER: NumInstructions = NumInstructions::new(100);
+    pub const COST_HTTP_REQUEST: NumInstructions = NumInstructions::new(100);
+    pub const COST_ECDSA: NumInstructions = NumInstructions::new(100);
+    pub const COST_SCHNORR: NumInstructions = NumInstructions::new(100);
+    pub const COST_VETKD: NumInstructions = NumInstructions::new(100);
     pub const DATA_CERTIFICATE_COPY: NumInstructions = NumInstructions::new(500);
     pub const DATA_CERTIFICATE_PRESENT: NumInstructions = NumInstructions::new(500);
     pub const DATA_CERTIFICATE_SIZE: NumInstructions = NumInstructions::new(500);

rs/execution_environment/benches/lib/src/wat.rs

@@ -349,6 +349,9 @@ pub struct Params2<P1, P2>(pub P1, pub P2);
 /// System API call with 3 parameters.
 pub struct Params3<P1, P2, P3>(pub P1, pub P2, pub P3);
 
+/// System API call with 3 parameters.
+pub struct Params4<P1, P2, P3, P4>(pub P1, pub P2, pub P3, pub P4);
+
 /// Trait to render System API call parameters.
 pub trait RenderParams {
     /// Render System API call parameter import.
@@ -427,6 +430,30 @@ impl<P1: RenderParams, P2: RenderParams, P3: RenderParams> RenderParams for Para
     }
 }
 
+/// Implement RenderParams trait for a System API call with 4 parameters.
+impl<P1: RenderParams, P2: RenderParams, P3: RenderParams, P4: RenderParams> RenderParams
+    for Params4<P1, P2, P3, P4>
+{
+    fn import(&self) -> String {
+        format!(
+            "{P1} {P2} {P3} {P4}",
+            P1 = self.0.import(),
+            P2 = self.1.import(),
+            P3 = self.2.import(),
+            P4 = self.3.import(),
+        )
+    }
+    fn call(&self) -> String {
+        format!(
+            "{P1} {P2} {P3} {P4}",
+            P1 = self.0.call(),
+            P2 = self.1.call(),
+            P3 = self.2.call(),
+            P4 = self.3.call()
+        )
+    }
+}
+
 /// System API call result.
 /// The dead code is allowed as this common module is used across a few benchmark binaries.
 #[allow(dead_code)]