iCAN: The Easiest Container Management Platform#
What is iCAN? -- The easiest Canister management platform on IC.
Background#
-
Currently, developers can only manage their canisters through the NNS wallet and DFX command line.
-
The NNS wallet only displays basic information about canisters. Developers cannot easily manage canisters using the NNS wallet. Only the canister ID is shown without any other information, making it inconvenient for developers to manage their canisters with the NNS wallet.
-
It is difficult to manage canister status through the DFX CLI.
Introduction#
Use the UI interface to conveniently deploy and manage your CANISTERS
-
iCAN = IC + Canister. It is an on-chain canister management tool based on IC.
-
iCAN helps developers manage canisters through a graphical interface, create contracts, download WebAssembly modules, manage canister status metrics, and more.
Features#
-
Fine-grained Management
a. Dynamic changes to canister settings
b. More convenient container management
c. Detailed descriptions of canisters
-
Status Monitoring
a. Supports direct use of ICP to recharge canisters, directly depositing cycles into canisters
b. Timely feedback on canister status, allowing developers to understand and manage the current state of canisters
-
Creation and Deletion
a. Graphical canister management interface
b. Ability to create and delete canisters, automatically reclaiming cycles
-
Support for Importing
Import previously created canisters into your own hub.
-
WebAssembly Control
Download the latest WebAssembly files
Advantages#
The iCAN developer platform helps developers manage canisters. The future goal is to become a comprehensive contract management platform on IC.
-
Create Management Hubs in Random Subnets
By creating hubs in random subnets, you can choose the subnet in which to create canisters.
-
Convenient Management
You can name canisters, tag them, or give them a description for easier management.
-
Trustless Management
Hub canisters are solely controlled by you, supporting trustless hosting services.
Architecture Diagram#
API#
Introduction to the public interfaces of iCAN Canister and Hub Canister.
Types
module{
public type Error = {
#Invalid_Caller;
#Invalid_CanisterId;
#No_Wasm;
#No_Record;
#Insufficient_Cycles;
#Ledger_Transfer_Failed : Nat; // value : log id
#Create_Canister_Failed : Nat;
};
public type Canister = {
name : Text;
description : Text;
canister_id : Principal;
wasm : ?[Nat8];
};
public type Status = {
cycle_balance : Nat;
memory : Nat;
};
public type UpdateSettingsArgs = {
canister_id : Principal;
settings : canister_settings
};
public type TransformArgs = {
icp_amount : Nat64; // e8s
to_canister_id : Principal
};
public type DeployArgs = {
name : Text;
description : Text;
settings : ?canister_settings;
deploy_arguments : ?[Nat8];
wasm : ?[Nat8];
cycle_amount : Nat;
preserve_wasm : Bool;
};
public type canister_settings = {
freezing_threshold : ?Nat;
controllers : ?[Principal];
memory_allocation : ?Nat;
compute_allocation : ?Nat;
};
};
iCAN Canister
The iCAN Canister is used to create management hubs.
// iCAN Canister Public Service Interface
public type iCAN = actor{
// get your own hubs' info (call this function use your identity)
// @return array of (Hub Name, Hub Canister Id)
getHub : query () -> async [(Text, Principal)];
// get current hub wasm and cycle withdraw wasm in use
// @return (hub wasm, cycle withdraw wasm)
getWasms : query () -> async ([Nat8], [Nat8]);
// get administrators of ican at present
// @return array of administrators
getAdministrators : query () -> async [Principal];
// create canister management hub
// @param name : hub name
// @param amount : icp e8s amount
createHub : (name : Text, amount : Nat64) -> async Result.Result<Principal, Error>;
// add hub info to your hubs
// @param name : hub name
// @param hub_id : hub canister principal
addHub : (name : Text, hub_id : Principal) -> async Text;
// delete hub from your hub set
deleteHub : (hub_id : Principal) -> async Result.Result<(), Error>;
// transform icp to cycles and deposit the cycles to target cansiter
transformIcp : (args : TransformArgs) -> async Result.Result<(), Error>;
};
Hub Canister
The Hub Canister is the personal management canister deployed by the user.
public type Hub = actor{
// get current version hub canister's wasm
// @return Wasm Version
getVersion : query() -> async Nat;
// get owners of this hub canister
// @return owners array
getOwners : query() -> async [Principal];
// get status of hub canister ( owner only )
getStatus : query() -> async Result.Result<Status, Error>;
// get canisters managed by this hub ( owner only )
getCanisters : query() -> async Result.Result<[Canister], Error>;
// get wasm of specified canister ( owner only )
getWasm : query (canister_id : Principal) -> async Result.Result<[Nat8], Error>;
// put canister into hub ( not matter if not controlled by hub canister ) ( owner only )
// @param c : should be put into hub canister
putCanister : (c : Canister) -> async Result.Result<(), Error>;
// deploy canister by hub canister ( owner only )
// @return #ok(new canister's principal) or #err(Error)
deployCanister : (args : DeployArgs) -> async Result.Result<Principal, Error>;
// update canister settings ( owner only )
updateCanisterSettings : (args : UpdateSettingsArgs) -> async Result.Result<(), Error>;
// start the specify canister, which should be controlled by hub canister ( owner only )
// @param principal : target canister's principal
startCanister : (principal : Principal) -> async Result.Result<(), Error>;
// stop canister ( owner only )
// @param principal : target canister's principal
stopCanister : (principal : Principal) -> async Result.Result<(), Error>;
// deposit cycles to target canister ( equal to top up to target canister)
// @param id : target canister principal, cycle amount : how much cycles should be top up
depositCycles(id : Principal, cycle_amount : Nat, ) : async Result.Result<(), Error>;
// delete canister from hub canister and withdraw cycles from it ( owner only )
// @param canister's principal
delCanister : ( id : Principal ) -> async Result.Result<(), Error>;
// install cycle wasm to hub canister ( owner only )
// @param wasm : cycle wasm blob (you can deploy your own cycle wasm to your hub canister)
installCycleWasm : (wasm : [Nat8]) -> async Result.Result<(), Error>;
// change hub owner ( owner only )
// @param : new owners array
changeOwner : (newOwners : [Principal]) -> async Result.Result<(), Error>;
};
Roadmap#
Q2 2022 MVP Release.
Q3 2022 Full support for current canister management.
-
Import previously created containers
-
Support deployment of Actor Class Canisters
-
Support adding more administrators to Hub Canister (support team collaboration)
-
Open source iCAN and hand it over to the community DAO
Support one-click creation of specific types of canisters (asset canisters, NFT canisters) and upload frontend assets.
Q4 2022 Launch of log management platform. Support data recovery.
Q4 2022 - 2023 Become the best canister management platform and developer infrastructure on IC.
Team#
Mixlabs is a cutting-edge technology laboratory in blockchain direction composed of top universities and community developers in Asia. Mainly engaged in cutting-edge technology research, incubation, and ecological support in the blockchain direction.
Come join us!
Website: icantool.app
Twitter: @iCAN_DAPP
Email: [email protected]