update subcanister manager

Author: Gwojda

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bity-ic-subcanister-manager"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 description = "A library for managing sub-canisters on the Internet Computer"
 license = "MIT"
@@ -16,4 +16,5 @@ ic-cdk = { workspace = true }
 candid = { workspace = true }
 serde = { workspace = true }
 bity-ic-utils = "0.1.0"
-canfund = "0.8.2"
+canfund = "0.8.2"
+ic0 = { workspace = true }

src/subcanister_manager/Cargo.toml

@@ -46,46 +46,10 @@ use ic_cdk::api::management_canister::main::{
     CanisterIdRecord, CanisterInstallMode, CanisterSettings, CreateCanisterArgument,
     InstallCodeArgument, LogVisibility,
 };
-use ic_cdk::api::{
-    call::{call, call_with_payment128, CallResult},
-    canister_version,
-};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use std::{any::Any, collections::HashMap, fmt::Debug, future::Future};
 
-#[derive(CandidType, Deserialize)]
-struct CreateCanisterArg {
-    settings: Option<CanisterSettings>,
-    subnet_type: Option<String>,
-    subnet_selection: Option<SubnetSelection>,
-}
-
-#[derive(CandidType, Deserialize)]
-enum SubnetSelection {
-    Subnet { subnet: Principal },
-    Filter { filter: SubnetFilter },
-}
-
-#[derive(CandidType, Deserialize)]
-struct SubnetFilter {
-    subnet_type: Option<String>,
-}
-
-#[derive(
-    CandidType, Serialize, Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy,
-)]
-pub struct GetSubnetForCanisterResponse {
-    subnet_id: Option<Principal>,
-}
-
-#[derive(
-    CandidType, Serialize, Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy,
-)]
-pub struct GetSubnetForCanisterArgs {
-    canister_id: Option<Principal>,
-}
-
 /// Error types for storage operations
 #[derive(Debug)]
 pub enum NewStorageError {
@@ -253,22 +217,6 @@ where
             }
 
             if canister_id == Principal::anonymous() {
-                let get_subnet_result: CallResult<(GetSubnetForCanisterResponse,)> = call(
-                    Principal::from_text("rwlgt-iiaaa-aaaaa-aaaaa-cai").unwrap(), // registry canister
-                    "get_subnet_for_canister",
-                    (GetSubnetForCanisterArgs {
-                        canister_id: Some(ic_cdk::id()),
-                    },),
-                )
-                .await;
-
-                let subnet = match get_subnet_result {
-                    Ok(subnet) => subnet.0.subnet_id,
-                    Err(e) => {
-                        return Err(NewCanisterError::CreateCanisterError(format!("{e:?}")));
-                    }
-                };
-
                 // Define the initial settings for the new canister
                 let settings = CanisterSettings {
                     controllers: Some(self.controllers.clone()),
@@ -279,55 +227,23 @@ where
                     log_visibility: Some(LogVisibility::Public),
                     wasm_memory_limit: None,
                 };
-
-                let canister_call_result: CallResult<(CanisterIdRecord,)> = retry_async(
+                // Step 1: Create the canister
+                canister_id = match retry_async(
                     || {
-                        call_with_payment128(
-                            Principal::management_canister(),
-                            "create_canister",
-                            (CreateCanisterArg {
+                        create_canister(
+                            CreateCanisterArgument {
                                 settings: Some(settings.clone()),
-                                subnet_type: None,
-                                subnet_selection: Some(SubnetSelection::Subnet {
-                                    subnet: subnet.unwrap(),
-                                }),
-                            },),
+                            },
                             self.initial_cycles as u128,
                         )
                     },
                     3,
                 )
-                .await;
-
-                canister_id = match canister_call_result {
+                .await
+                {
                     Ok(canister) => canister.0.canister_id,
                     Err(e) => {
-                        // can not create canister, try to create it with a different subnet
-                        let canister_call_result: CallResult<(CanisterIdRecord,)> = retry_async(
-                            || {
-                                call_with_payment128(
-                                    Principal::management_canister(),
-                                    "create_canister",
-                                    (CreateCanisterArg {
-                                        settings: Some(settings.clone()),
-                                        subnet_type: None,
-                                        subnet_selection: None,
-                                    },),
-                                    self.initial_cycles as u128,
-                                )
-                            },
-                            3,
-                        )
-                        .await;
-
-                        match canister_call_result {
-                            Ok(canister) => canister.0.canister_id,
-                            Err(e) => {
-                                return Err(NewCanisterError::CreateCanisterError(format!(
-                                    "{e:?}"
-                                )));
-                            }
-                        }
+                        return Err(NewCanisterError::CreateCanisterError(format!("{e:?}")));
                     }
                 };