feat: [EXC-1753] Add mint_cycles128 API

rs/embedders/src/wasm_utils/validation.rs

@@ -527,6 +527,16 @@ fn get_valid_system_apis_common(I: ValType) -> HashMap<String, HashMap<String, F
                 },
             )],
         ),
+        (
+            "mint_cycles128",
+            vec![(
+                API_VERSION_IC0,
+                FunctionSignature {
+                    param_types: vec![ValType::I64, ValType::I64, I],
+                    return_type: vec![],
+                },
+            )],
+        ),
         (
             "call_cycles_add128",
             vec![(

rs/embedders/src/wasmtime_embedder/system_api.rs

@@ -1190,6 +1190,18 @@ pub fn syscalls<
         })
         .unwrap();
 
+    linker
+        .func_wrap("ic0", "mint_cycles128", {
+            move |mut caller: Caller<'_, StoreData>, amount_high: u64, amount_low: u64, dst: I| {
+                with_memory_and_system_api(&mut caller, |s, memory| {
+                    let dst: usize = dst.try_into().expect("Failed to convert I to usize");
+                    s.ic0_mint_cycles128(amount_high, amount_low, dst, memory)
+                })
+                .map_err(|e| anyhow::Error::msg(format!("ic0_mint_cycles128 failed: {}", e)))
+            }
+        })
+        .unwrap();
+
     linker
         .func_wrap("ic0", "cycles_burn128", {
             move |mut caller: Caller<'_, StoreData>, amount_high: u64, amount_low: u64, dst: I| {

rs/execution_environment/benches/system_api/diff-old-vs-new.sh

@@ -17,6 +17,11 @@ set -ue
 ##   | update/ic0_canister_status()           |   1.27G |   1.34G |     +5% |      3.73s |
 ##   | inspect/ic0_msg_method_name_size()     |       - |   1.28G |       - |     23.92s |
 
+if ! which bazel rg >/dev/null; then
+    echo "Error checking dependencies: please ensure 'bazel' and 'rg' are installed"
+    exit 1
+fi
+
 ## To quickly assess the new changes, run benchmarks just once
 QUICK=${QUICK:-}
 if [ -n "${QUICK}" ]; then

rs/execution_environment/benches/system_api/execute_update.rs

@@ -336,7 +336,7 @@ pub fn execute_update_bench(c: &mut Criterion) {
                 Result::No,
                 Wasm64::Enabled,
             ), // 10B max
-            529001006,
+            529004006,
         ),
         common::Benchmark(
             "wasm32/ic0_debug_print()/1B".into(),
@@ -736,7 +736,7 @@ pub fn execute_update_bench(c: &mut Criterion) {
                 Result::No,
                 Wasm64::Enabled,
             ),
-            517001006,
+            517004006,
         ),
         common::Benchmark(
             "wasm32/ic0_msg_cycles_available()".into(),
@@ -878,6 +878,26 @@ pub fn execute_update_bench(c: &mut Criterion) {
             Module::Test.from_ic0("mint_cycles", Param1(1_i64), Result::I64, Wasm64::Enabled),
             18000006,
         ),
+        common::Benchmark(
+            "wasm32/ic0_mint_cycles128()".into(),
+            Module::Test.from_ic0(
+                "mint_cycles128",
+                Params3(1_i64, 2_i64, 3_i32),
+                Result::No,
+                Wasm64::Disabled,
+            ),
+            19001006,
+        ),
+        common::Benchmark(
+            "wasm64/ic0_mint_cycles128()".into(),
+            Module::Test.from_ic0(
+                "mint_cycles128",
+                Params3(1_i64, 2_i64, 3_i64),
+                Result::No,
+                Wasm64::Enabled,
+            ),
+            19004006,
+        ),
         common::Benchmark(
             "wasm32/ic0_is_controller()".into(),
             Module::Test.from_ic0(
@@ -922,7 +942,7 @@ pub fn execute_update_bench(c: &mut Criterion) {
             "wasm32/ic0_cycles_burn128()".into(),
             Module::Test.from_ic0(
                 "cycles_burn128",
-                Params3(1_i64, 2_i64, 3),
+                Params3(1_i64, 2_i64, 3_i32),
                 Result::No,
                 Wasm64::Disabled,
             ),

rs/execution_environment/src/hypervisor/tests.rs

@@ -2272,6 +2272,88 @@ fn ic0_mint_cycles_succeeds_on_cmc() {
     );
 }
 
+#[test]
+fn ic0_mint_cycles128_fails_on_application_subnet() {
+    let mut test = ExecutionTestBuilder::new().build();
+    let canister_id = test.universal_canister().unwrap();
+    let initial_cycles = test.canister_state(canister_id).system_state.balance();
+    let payload = wasm()
+        .mint_cycles128(Cycles::from((1u128 << 64) + 2u128))
+        .reply_data_append()
+        .reply()
+        .build();
+    let err = test.ingress(canister_id, "update", payload).unwrap_err();
+    assert_eq!(ErrorCode::CanisterContractViolation, err.code());
+    assert!(err
+        .description()
+        .contains("ic0.mint_cycles cannot be executed"));
+    let canister_state = test.canister_state(canister_id);
+    assert_eq!(0, canister_state.system_state.queues().output_queues_len());
+    assert_balance_equals(
+        initial_cycles,
+        canister_state.system_state.balance(),
+        BALANCE_EPSILON,
+    );
+}
+
+#[test]
+fn ic0_mint_cycles128_fails_on_system_subnet_non_cmc() {
+    let mut test = ExecutionTestBuilder::new()
+        .with_subnet_type(SubnetType::System)
+        .build();
+    let canister_id = test.universal_canister().unwrap();
+    let initial_cycles = test.canister_state(canister_id).system_state.balance();
+    let payload = wasm()
+        .mint_cycles128(Cycles::from((1u128 << 64) + 2u128))
+        .reply_data_append()
+        .reply()
+        .build();
+    let err = test.ingress(canister_id, "update", payload).unwrap_err();
+    assert_eq!(ErrorCode::CanisterContractViolation, err.code());
+    assert!(err
+        .description()
+        .contains("ic0.mint_cycles cannot be executed"));
+    let canister_state = test.canister_state(canister_id);
+    assert_eq!(0, canister_state.system_state.queues().output_queues_len());
+    assert_balance_equals(
+        initial_cycles,
+        canister_state.system_state.balance(),
+        BALANCE_EPSILON,
+    );
+}
+
+#[test]
+fn ic0_mint_cycles128_succeeds_on_cmc() {
+    let mut test = ExecutionTestBuilder::new()
+        .with_subnet_type(SubnetType::System)
+        .build();
+    let mut canister_id = test.universal_canister().unwrap();
+    // This loop should finish after four iterations.
+    while canister_id != CYCLES_MINTING_CANISTER_ID {
+        canister_id = test.universal_canister().unwrap();
+    }
+    let initial_cycles = test.canister_state(canister_id).system_state.balance();
+    let payload = wasm()
+        .mint_cycles128(Cycles::from((1u128 << 64) + 2u128))
+        .reply_data_append()
+        .reply()
+        .build();
+    let result = test.ingress(canister_id, "update", payload).unwrap();
+    // (high=1, low=2) => 2^64 + 2^1
+    assert_eq!(
+        WasmResult::Reply(vec![2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]),
+        result
+    );
+    let canister_state = test.canister_state(canister_id);
+
+    assert_eq!(0, canister_state.system_state.queues().output_queues_len());
+    assert_balance_equals(
+        initial_cycles + Cycles::new(18446744073709551618),
+        canister_state.system_state.balance(),
+        BALANCE_EPSILON,
+    );
+}
+
 #[test]
 fn ic0_call_enqueues_request() {
     let mut test = ExecutionTestBuilder::new().build();

rs/execution_environment/src/query_handler/query_cache/tests.rs

@@ -1488,6 +1488,7 @@ fn query_cache_future_proof_test() {
         | SystemApiCallId::InReplicatedExecution
         | SystemApiCallId::IsController
         | SystemApiCallId::MintCycles
+        | SystemApiCallId::MintCycles128
         | SystemApiCallId::MsgArgDataCopy
         | SystemApiCallId::MsgArgDataSize
         | SystemApiCallId::MsgCallerCopy

rs/interfaces/src/execution_environment.rs

@@ -175,6 +175,8 @@ pub enum SystemApiCallId {
     IsController,
     /// Tracker for `ic0.mint_cycles()`
     MintCycles,
+    /// Tracker for `ic0.mint_cycles128()`
+    MintCycles128,
     /// Tracker for `ic0.msg_arg_data_copy()`
     MsgArgDataCopy,
     /// Tracker for `ic0.msg_arg_data_size()`
@@ -1132,6 +1134,26 @@ pub trait SystemApi {
     /// Returns the amount of cycles added to the canister's balance.
     fn ic0_mint_cycles(&mut self, amount: u64) -> HypervisorResult<u64>;
 
+    /// Mints the `amount` cycles
+    /// Adds cycles to the canister's balance.
+    ///
+    /// Adds no more cycles than `amount`.
+    ///
+    /// The canister balance afterwards does not exceed
+    /// maximum amount of cycles it can hold.
+    /// However, canisters on system subnets have no balance limit.
+    ///
+    /// The amount of cycles added to the canister's balance is
+    /// represented by a 128-bit value and is copied in the canister
+    /// memory starting starting at the location `dst`.
+    fn ic0_mint_cycles128(
+        &mut self,
+        amount_high: u64,
+        amount_low: u64,
+        dst: usize,
+        heap: &mut [u8],
+    ) -> HypervisorResult<()>;
+
     /// Checks whether the principal identified by src/size is one of the
     /// controllers of the canister. If yes, then a value of 1 is returned,
     /// otherwise a 0 is returned. It can be called multiple times.

rs/system_api/src/lib.rs

@@ -3168,7 +3168,8 @@ impl SystemApi for SystemApiImpl {
         trace_syscall!(self, CanisterStatus, result);
         result
     }
-
+    // TODO(EXC-1806): This can be removed (in favour of ic0_mint_cycles128) once the CMC is upgraded, so it
+    // doesn't make sense to deduplicate the shared code.
     fn ic0_mint_cycles(&mut self, amount: u64) -> HypervisorResult<u64> {
         let result = match self.api_type {
             ApiType::Start { .. }
@@ -3197,6 +3198,41 @@ impl SystemApi for SystemApiImpl {
         result
     }
 
+    fn ic0_mint_cycles128(
+        &mut self,
+        amount_high: u64,
+        amount_low: u64,
+        dst: usize,
+        heap: &mut [u8],
+    ) -> HypervisorResult<()> {
+        let cycles = Cycles::from_parts(amount_high, amount_low);
+        let result = match self.api_type {
+            ApiType::Start { .. }
+            | ApiType::Init { .. }
+            | ApiType::PreUpgrade { .. }
+            | ApiType::Cleanup { .. }
+            | ApiType::ReplicatedQuery { .. }
+            | ApiType::NonReplicatedQuery { .. }
+            | ApiType::InspectMessage { .. } => Err(self.error_for("ic0_mint_cycles128")),
+            ApiType::Update { .. }
+            | ApiType::SystemTask { .. }
+            | ApiType::ReplyCallback { .. }
+            | ApiType::RejectCallback { .. } => {
+                if self.execution_parameters.execution_mode == ExecutionMode::NonReplicated {
+                    // Non-replicated mode means we are handling a composite query.
+                    // Access to this syscall not permitted.
+                    Err(self.error_for("ic0_mint_cycles128"))
+                } else {
+                    self.sandbox_safe_system_state.mint_cycles(cycles)?;
+                    copy_cycles_to_heap(cycles, dst, heap, "ic0_mint_cycles_128")?;
+                    Ok(())
+                }
+            }
+        };
+        trace_syscall!(self, MintCycles128, result, cycles);
+        result
+    }
+
     fn ic0_debug_print(&self, src: usize, size: usize, heap: &[u8]) -> HypervisorResult<()> {
         const MAX_DEBUG_MESSAGE_SIZE: usize = 32 * 1024;
         let size = size.min(MAX_DEBUG_MESSAGE_SIZE);

rs/system_api/tests/sandbox_safe_system_state.rs

@@ -349,6 +349,48 @@ fn mint_cycles_fails_caller_not_on_nns() {
     );
 }
 
+#[test]
+fn mint_cycles_very_large_value() {
+    let cycles_account_manager = CyclesAccountManagerBuilder::new()
+        .with_subnet_type(SubnetType::System)
+        .build();
+    let mut system_state = SystemStateBuilder::new()
+        .canister_id(CYCLES_MINTING_CANISTER_ID)
+        .build();
+
+    system_state.add_cycles(
+        Cycles::from(1_000_000_000_000_000_u128),
+        CyclesUseCase::NonConsumed,
+    );
+
+    let api_type = ApiTypeBuilder::build_update_api();
+    let mut api = get_system_api(api_type, &system_state, cycles_account_manager);
+    let mut balance_before = [0u8; 16];
+    api.ic0_canister_cycle_balance128(0, &mut balance_before)
+        .unwrap();
+    let balance_before = u128::from_le_bytes(balance_before);
+
+    let amount_high = u64::MAX;
+    let amount_low = 50;
+    let mut heap = [0u8; 16];
+    // Canisters on the System subnet can hold any amount of cycles
+    api.ic0_mint_cycles128(amount_high, amount_low, 0, &mut heap)
+        .unwrap();
+    let cycles_minted = u128::from_le_bytes(heap);
+    assert_eq!(
+        cycles_minted,
+        Cycles::from_parts(amount_high, amount_low).get()
+    );
+    let mut balance_after = [0u8; 16];
+    api.ic0_canister_cycle_balance128(0, &mut balance_after)
+        .unwrap();
+    let balance_after = u128::from_le_bytes(balance_after);
+    assert_eq!(
+        balance_after - balance_before,
+        Cycles::from_parts(amount_high, amount_low).get()
+    );
+}
+
 #[test]
 fn is_controller_test() {
     let mut system_state = SystemStateBuilder::default().build();

rs/system_api/tests/system_api.rs

@@ -293,7 +293,8 @@ fn is_supported(api_type: SystemApiCallId, context: &str) -> bool {
         SystemApiCallId::InReplicatedExecution => vec!["*", "s"],
         SystemApiCallId::DebugPrint => vec!["*", "s"],
         SystemApiCallId::Trap => vec!["*", "s"],
-        SystemApiCallId::MintCycles => vec!["U", "Ry", "Rt", "T"]
+        SystemApiCallId::MintCycles => vec!["U", "Ry", "Rt", "T"],
+        SystemApiCallId::MintCycles128 => vec!["U", "Ry", "Rt", "T"]
     };
     // the semantics of "*" is to cover all modes except for "s"
     matrix.get(&api_type).unwrap().contains(&context)
@@ -745,6 +746,11 @@ fn api_availability_test(
             let mut api = get_system_api(api_type, &system_state, cycles_account_manager);
             assert_api_not_supported(api.ic0_mint_cycles(0));
         }
+        SystemApiCallId::MintCycles128 => {
+            // ic0.mint_cycles128 is only supported for CMC which is tested separately
+            let mut api = get_system_api(api_type, &system_state, cycles_account_manager);
+            assert_api_not_supported(api.ic0_mint_cycles128(0, 0, 0, &mut [0u8; 16]));
+        }
         SystemApiCallId::IsController => {
             assert_api_availability(
                 |api| api.ic0_is_controller(0, 0, &[42; 128]),
@@ -822,7 +828,7 @@ fn system_api_availability() {
             let api = get_system_api(api_type.clone(), &system_state, cycles_account_manager);
             check_stable_apis_support(api);
 
-            // check ic0.mint_cycles API availability for CMC
+            // check ic0.mint_cycles, ic0.mint_cycles128 API availability for CMC
             let cmc_system_state = get_cmc_system_state();
             assert_api_availability(
                 |mut api| api.ic0_mint_cycles(0),
@@ -832,6 +838,14 @@ fn system_api_availability() {
                 SystemApiCallId::MintCycles,
                 context,
             );
+            assert_api_availability(
+                |mut api| api.ic0_mint_cycles128(0, 0, 0, &mut [0u8; 16]),
+                api_type.clone(),
+                &cmc_system_state,
+                cycles_account_manager,
+                SystemApiCallId::MintCycles128,
+                context,
+            );
 
             // now check all other API availability for non-CMC
             for api_type_enum in SystemApiCallId::iter() {

rs/tests/execution/general_execution_test.rs

@@ -88,6 +88,10 @@ fn main() -> Result<()> {
                     mint_cycles_supported_only_on_cycles_minting_canister
                 ))
                 .add_test(systest!(mint_cycles_not_supported_on_application_subnet))
+                .add_test(systest!(
+                    mint_cycles128_supported_only_on_cycles_minting_canister
+                ))
+                .add_test(systest!(mint_cycles128_not_supported_on_application_subnet))
                 .add_test(systest!(no_cycle_balance_limit_on_nns_subnet))
                 .add_test(systest!(app_canister_attempt_initiating_dkg_fails))
                 .add_test(systest!(canister_heartbeat_is_called_at_regular_intervals))