feat!: management canister types refresh 2025-10-21 (#677)

* refresh mgmt types to 2025-10-21

* update pocket-ic to 2025-10-17

* merge management_canister tests into one

* ic_cdk::management_canister add canister_metadata and snapshot APIs

* e2e test new management canister APIs

* breaking changes proposed in forum post

* merge api e2e tests, no more nonmainnet

Author: lwshang

e2e-tests/Cargo.toml

@@ -28,7 +28,7 @@ cargo_metadata = "0.21"
 futures = "0.3"
 hex.workspace = true
 ic-vetkd-utils = { git = "https://github.com/dfinity/ic", rev = "95231520" }
-pocket-ic = { git = "https://github.com/dfinity/ic", tag = "release-2025-08-21_03-19-base" }
+pocket-ic = { git = "https://github.com/dfinity/ic", tag = "release-2025-10-17_03-17-base" }
 reqwest = "0.12"
 
 [build-dependencies]

e2e-tests/src/bin/api.rs

@@ -258,6 +258,36 @@ fn call_cost_sign_with_schnorr() {
     msg_reply(vec![]);
 }
 
+#[export_name = "canister_query call_env_var_count"]
+fn call_env_var_count() {
+    let count = env_var_count();
+    assert_eq!(count, 2);
+    msg_reply(vec![]);
+}
+
+#[export_name = "canister_query call_env_var_name"]
+fn call_env_var_name() {
+    // This is expected to panic as no environment variables are set.
+    assert_eq!(env_var_name(0), "key1");
+    assert_eq!(env_var_name(1), "key2");
+    msg_reply(vec![]);
+}
+
+#[export_name = "canister_query call_env_var_name_exists"]
+fn call_env_var_name_exists() {
+    assert!(env_var_name_exists("key1"));
+    assert!(env_var_name_exists("key2"));
+    assert!(!env_var_name_exists("non_existent_var"));
+    msg_reply(vec![]);
+}
+
+#[export_name = "canister_query call_env_var_value"]
+fn call_env_var_value() {
+    assert_eq!(env_var_value("key1"), "value1");
+    assert_eq!(env_var_value("key2"), "value2");
+    msg_reply(vec![]);
+}
+
 #[export_name = "canister_update call_debug_print"]
 fn call_debug_print() {
     debug_print("Hello, world!");

e2e-tests/src/bin/api_nonmainnet.rs

@@ -59,17 +59,30 @@ async fn basic() {
     };
     update_settings(&arg).await.unwrap();
 
+    // wat2wasm "(module (@custom "icp:public X" "content of X"))"
+    let wasm_module = b"\x00asm\x01\x00\x00\x00\x00\x19\x0c\
+    icp:public\x20Xcontent\x20of\x20X"
+        .to_vec();
+
     // install_code
     let arg = InstallCodeArgs {
         mode: CanisterInstallMode::Install,
         canister_id,
         // A minimal valid wasm module
         // wat2wasm "(module)"
-        wasm_module: b"\x00asm\x01\x00\x00\x00".to_vec(),
+        wasm_module,
         arg: vec![],
     };
     install_code(&arg).await.unwrap();
 
+    // canister_metadata
+    let arg = CanisterMetadataArgs {
+        canister_id,
+        name: "X".to_string(),
+    };
+    let result = canister_metadata(&arg).await.unwrap();
+    assert_eq!(result.value, b"content of X".to_vec());
+
     // uninstall_code
     let arg = UninstallCodeArgs { canister_id };
     uninstall_code(&arg).await.unwrap();
@@ -307,12 +320,13 @@ async fn snapshots() {
 
     // Cannot take a snapshot of a canister that is empty.
     // So we install a minimal wasm module.
+    // A minimal valid wasm module
+    // wat2wasm "(module)"
+    let wasm_module = b"\x00asm\x01\x00\x00\x00".to_vec();
     let arg = InstallCodeArgs {
         mode: CanisterInstallMode::Install,
         canister_id,
-        // A minimal valid wasm module
-        // wat2wasm "(module)"
-        wasm_module: b"\x00asm\x01\x00\x00\x00".to_vec(),
+        wasm_module: wasm_module.clone(),
         arg: vec![],
     };
     install_code(&arg).await.unwrap();
@@ -322,25 +336,67 @@ async fn snapshots() {
         canister_id,
         replace_snapshot: None,
     };
-    let snapshot = take_canister_snapshot(&arg).await.unwrap();
+    let snapshot1 = take_canister_snapshot(&arg).await.unwrap();
 
     // load_canister_snapshot
     let arg = LoadCanisterSnapshotArgs {
         canister_id,
-        snapshot_id: snapshot.id.clone(),
+        snapshot_id: snapshot1.id.clone(),
     };
     assert!(load_canister_snapshot(&arg).await.is_ok());
 
+    // read_canister_snapshot_metadata
+    let arg = ReadCanisterSnapshotMetadataArgs {
+        canister_id,
+        snapshot_id: snapshot1.id.clone(),
+    };
+    let snapshot_metadata = read_canister_snapshot_metadata(&arg).await.unwrap();
+
+    // read_canister_snapshot_data
+    let arg = ReadCanisterSnapshotDataArgs {
+        canister_id,
+        snapshot_id: snapshot1.id.clone(),
+        kind: SnapshotDataKind::WasmModule { offset: 0, size: 8 },
+    };
+    let result = read_canister_snapshot_data(&arg).await.unwrap();
+    assert_eq!(result.chunk, wasm_module);
+
+    // upload_canister_snapshot_metadata
+    let globals = snapshot_metadata.globals.into_iter().flatten().collect();
+    let arg = UploadCanisterSnapshotMetadataArgs {
+        canister_id,
+        replace_snapshot: None,
+        wasm_module_size: snapshot_metadata.wasm_module_size,
+        globals,
+        wasm_memory_size: snapshot_metadata.wasm_memory_size,
+        stable_memory_size: snapshot_metadata.stable_memory_size,
+        certified_data: snapshot_metadata.certified_data,
+        global_timer: snapshot_metadata.global_timer,
+        on_low_wasm_memory_hook_status: snapshot_metadata.on_low_wasm_memory_hook_status,
+    };
+    let snapshot2 = upload_canister_snapshot_metadata(&arg).await.unwrap();
+    assert!(!snapshot2.snapshot_id.is_empty());
+
+    // upload_canister_snapshot_data
+    let arg = UploadCanisterSnapshotDataArgs {
+        canister_id,
+        snapshot_id: snapshot2.snapshot_id.clone(),
+        kind: SnapshotDataOffset::WasmModule { offset: 0 },
+        chunk: wasm_module.clone(),
+    };
+    assert!(upload_canister_snapshot_data(&arg).await.is_ok());
+
     // list_canister_snapshots
     let args = ListCanisterSnapshotsArgs { canister_id };
     let snapshots = list_canister_snapshots(&args).await.unwrap();
-    assert_eq!(snapshots.len(), 1);
-    assert_eq!(snapshots[0].id, snapshot.id);
+    assert_eq!(snapshots.len(), 2);
+    assert_eq!(snapshots[0].id, snapshot1.id);
+    assert_eq!(snapshots[1].id, snapshot2.snapshot_id);
 
     // delete_canister_snapshot
     let arg = DeleteCanisterSnapshotArgs {
         canister_id,
-        snapshot_id: snapshot.id.clone(),
+        snapshot_id: snapshot1.id.clone(),
     };
     assert!(delete_canister_snapshot(&arg).await.is_ok());
 
@@ -353,11 +409,11 @@ async fn snapshots() {
     assert_eq!(canister_info_result.total_num_changes, 3);
     assert_eq!(canister_info_result.recent_changes.len(), 1);
     if let Change {
-        details: ChangeDetails::LoadSnapshot(load_snapshot_record),
+        details: Some(ChangeDetails::LoadSnapshot(load_snapshot_record)),
         ..
     } = &canister_info_result.recent_changes[0]
     {
-        assert_eq!(load_snapshot_record.snapshot_id, snapshot.id);
+        assert_eq!(load_snapshot_record.snapshot_id, snapshot1.id);
     } else {
         panic!("Expected the most recent change to be LoadSnapshot");
     }

e2e-tests/src/bin/management_canister.rs

@@ -146,27 +146,7 @@ fn call_api() {
         .unwrap();
     assert!(res.is_empty());
 
-    let res = pic
-        .update_call(canister_id, sender, "call_debug_print", vec![])
-        .unwrap();
-    assert!(res.is_empty());
-    let rej = pic
-        .update_call(canister_id, sender, "call_trap", vec![])
-        .unwrap_err();
-    assert_eq!(rej.error_code, ErrorCode::CanisterCalledTrap);
-    assert!(rej.reject_message.contains("It's a trap!"));
-}
-
-// Test for the system API that are not enabled on the mainnet yet.
-// A canister Wasm module that imports the non-mainnet APIs would result in canister installation failure.
-#[test]
-fn call_api_nonmainnet() {
-    let wasm = cargo_build_canister("api_nonmainnet");
-    let pic = pic_base().with_nonmainnet_features(true).build();
-    let canister_id = pic.create_canister();
-    pic.add_cycles(canister_id, 100_000_000_000_000);
-    pic.install_canister(canister_id, wasm, vec![], None);
-    let sender = Principal::anonymous();
+    // env var
     let update_settings_arg = UpdateSettingsArgs {
         canister_id,
         settings: CanisterSettings {
@@ -190,8 +170,6 @@ fn call_api_nonmainnet() {
         (update_settings_arg,),
     )
     .unwrap();
-
-    // As of 2025-08, the env_var APIs are not available on mainnet yet.
     let res = pic
         .update_call(canister_id, sender, "call_env_var_count", vec![])
         .unwrap();
@@ -208,4 +186,14 @@ fn call_api_nonmainnet() {
         .update_call(canister_id, sender, "call_env_var_value", vec![])
         .unwrap();
     assert!(res.is_empty());
+
+    let res = pic
+        .update_call(canister_id, sender, "call_debug_print", vec![])
+        .unwrap();
+    assert!(res.is_empty());
+    let rej = pic
+        .update_call(canister_id, sender, "call_trap", vec![])
+        .unwrap_err();
+    assert_eq!(rej.error_code, ErrorCode::CanisterCalledTrap);
+    assert!(rej.reject_message.contains("It's a trap!"));
 }

e2e-tests/tests/api.rs

@@ -8,7 +8,7 @@ fn bindgen() {
     let wasm = cargo_build_canister("bindgen");
     let callee_wasm = cargo_build_canister("bindgen_callee");
 
-    let pic = pic_base().with_nonmainnet_features(true).build();
+    let pic = pic_base().build();
 
     let callee_canister_id = pic.create_canister();
     pic.add_cycles(callee_canister_id, 100_000_000_000_000);