Internet Computer Services - Build, Ship and Manage DApps faster on IC

Developers
1

Inspiration

It takes time for a developer to embrace new technology. Learning a new language to understand cutting-edge technological paradigms can sometimes be intimidating. We want to simplify developers’ lives in the IC ecosystem and give them the tools and technology to build, ship and manage dApps faster on IC.

What it does

At its core Internet Computer Services ( ICS ) provides easy creation and management of atomic units in IC called Canisters. But the realm of ICS expands to the scale at which AWS / GCP offers services in Web2. ICS aims to provide small, independent, developer-owned services that will become building blocks of dApps. 100% on-chain deployed websites, custom code etc., are some of the services ICS aims to provide and continuously add more as the community requires.

Apart from these services, ICS aims at providing 1-click deployment of dApps available in the marketplace, minting of NFTs, token generation for any new project, and provisioning on-chain BTC and ETH wallets with few simple clicks. ICS will support many more upcoming native integrations in the future, like SNS.

How we built it

We have written some of Motoko’s core functionalities and deployed those core modules on IC. We call them ICS-Management Canisters. The rest of the implementation is developed in the traditional stack with javascript talking to ICS-Management canisters via agent-js.

Challenges we ran into

During our implementation, we realized requests for key functionalities like creating a canister could not be sent from outside of IC. It has to be a call from another canister. This discovery introduced a bit of lag to our development process, and we had to re-design our architecture.

Accomplishments that we’re proud of

We are proud of achieving core canister management functionalities like Canister creation, deletion, starting/stopping a canister, topping up a canister with more cycles, and Installing WASM with installing/reinstalling/upgrading modes directly from UI.

We are also proud to introduce a registry that developers can use to store WASM binaries and deploy them when needed.

One of the very promising features of ICS is GitHub Deployments.GitHub Deployments allows developers to connect their GitHub repositories. From there, ICS takes care of the whole DevOps flow. It builds the canisters and deploys them to the Internet Computer. Developers can host websites 100% on-chain without even managing any wallets/identities, getting ICP and converting them to cycles.

What we learned

Every day of development in IC is a new learning opportunity. One may know how a blockchain works, but IC is a decentralized computer. With so many new native integrations and dApps coming on IC, we are sure to learn many new things, especially the ones we have not even seen in early web3 tech like ETH.

What’s next for Internet Computer Services

Internet Computer Services will keep adding new services and onboarding developers significantly faster. We know time-to-market is critical for any startup and dApp, and we want to accelerate the development of dApps by helping our fellow developers.

Website: https://internetcomputerservices.com/

Supernova DevPost: https://devpost.com/software/internet-computer-services

19 Likes
2

Brilliant – I remember seeing this during Supernova, excited to see you take it even further! Will start simple with a Token module to see how it works now that you’re accepting sign-ups

3 Likes
3

Huh? I remember seeing this feature in the dfx code. I believe there’s a way to create a new canister by sending ICP with a special flag. Is this not the case anymore?

4

Correct, there is a way. There are two ways to create canisters:

  1. management canister call: This makes a call to the management canister and carries a bunch of cycles. This will create a new canister on the same subnet the call originated from. It will deduct 0.1T cycles for creating the canister, and give the other cycles to the newly created canister.
  2. CMC flow: You send some ICP to ‘your’ account with the CMC (Cycles Minting Canister AFAIK). Then you notify the CMC that you did so. The CMC will turn these ICP into cycles, deduct 0.1T cycles for creating the canister and add the remaining cycles to the new canister. The new canister is located on a random subnet.

Option 1 requires that the function call has cycles attached. This is only possible if a call originates from a canister (users/principals cannot hold cycles). Therefore it only works if you already have a canister that can make this call for you (typically the cycles wallet).

Option 2 does not require cycles, so it can be called from the outside.

Some Motoko snippets to illustrate:

Option 1:

    // Management canister definition
    type CanisterSettings = { controllers : ?[Principal] };
    type Management = actor {
      create_canister : ({ settings : ?CanisterSettings }) -> async ({ canister_id : CanisterId });
    };
    // Actually creating the canister
    Cycles.add(cycle_to_add);
    (await IC0.create_canister({ settings = ? { controllers = ?[this]; } })).canister_id;

Option 2:


      // transfer some ICP to CMC
      let ledger_response = await LEDGER.transfer({
            memo = CANISTER_CREATE_MEMO;
            from_subaccount = null;
            to = CMC_CREATE_ADDRESS;
            amount = { e8s = amount_e8s };
            fee = { e8s = 10_000 };
            created_at_time = ?{ timestamp_nanos = Nat64.fromNat(Int.abs(Time.now()) - Nat64.toNat(n)) };
          });
      switch ledger_response {
        case (#Ok(blockIndex)) {
          block_index := blockIndex;
        };
        // error handling removed
      };

      // notify_create
      let cmc_response = await CMC.notify_create_canister({
        block_index = block_index;
        controller = THIS_CANISTERS_PRINCIPAL;
      });
3 Likes
5

@Severin has correctly mentioned two ways to create a canister. We were not aware of option 2 (CMC Flow) while participating in a supernova. So we went with approach one using a management canister call.

1 Like
6

@ritvick maybe an idea for a future service: allow users to pick which subnet to create canisters on

1 Like
7

Thank you @Severin This is very lovely feedback. We will surely prioritize this feature for users to pick a subnet to create a canister.

1 Like
8

iCAN, InternetComputer canister management Platform.
We have launched this dAPP on May 10th, and the front-end and back-end codes have been open sourced.
iCAN twitter
iCAN front-end
iCAN bacn-end

9

Many functions iCAN and Fleek have been implemented, maybe you don’t need to do repetitive work, but bring some new functions.

1 Like
10

Hello @heyuanxun
It’s nice to see similar projects in the IC ecosystem. We would like to take this opportunity to clarify the vision and mission of Internet Computer Services to the community. We believe many projects in the IC ecosystem will provide canister management at its core (the same way AWS, Google and other cloud providers all have virtual machine management at their core). Internet Computer Services is a zero DevOps automation platform enabling developers to develop their dApps with peace without worrying about DevOps at all. We give a direct GitHub repository integration to build and deploy the code on IC and then track and analyze canister performance.

Saying that we are also a custodial solution where we do identity/wallet management on behalf of the users/developers and be a partner in success with them till the dApp becomes immutable on IC and we blackhole it.
We also realize many projects, including yours, will have many cool features we might not have and would be open to collaborating in any manner possible.

1 Like