Internet Computer

https://docs.internetcomputer.org/
Admin
Internet Computer is a decentralized computing platform that enables developers to build sovereign,...
Tokens:439,550
Snippets:5,126
Trust Score:9.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Motoko dependencies

Source: https://docs.internetcomputer.org/guides/backends/ai-inference

Run this command to install the configured dependencies.

```sh
mops install
```

--------------------------------

### Install frontend packages

Source: https://docs.internetcomputer.org/guides/authentication/internet-identity

Install the required authentication and core SDK packages via npm.

```bash
npm install @icp-sdk/auth @icp-sdk/core
```

--------------------------------

### Verify installation

Source: https://docs.internetcomputer.org/getting-started/quickstart

Check that the CLI tools are correctly installed and accessible.

```bash
icp --version
ic-wasm --version
```

--------------------------------

### Install canbench CLI

Source: https://docs.internetcomputer.org/guides/testing/strategies

Install the canbench command-line tool via cargo.

```bash
cargo install canbench
```

--------------------------------

### Start local network

Source: https://docs.internetcomputer.org/getting-started/quickstart

Launch a local Internet Computer replica in the background.

```bash
icp network start -d
```

--------------------------------

### Install dependencies

Source: https://docs.internetcomputer.org/guides/chain-fusion/offline-key-derivation

Install the required npm packages for public key derivation.

```bash
npm install @dfinity/ic-pub-key @dfinity/principal
```

--------------------------------

### Manage canister lifecycle in Rust

Source: https://docs.internetcomputer.org/guides/testing/pocket-ic

Demonstrates creating, installing, upgrading, stopping, and starting a canister using the PocketIC instance.

```rust
use pocket_ic::PocketIc;

// WASM_V1 and WASM_V2 are defined like CANISTER_WASM above, pointing to
// different compiled versions of the same canister
// e.g.: pub const WASM_V1: &[u8] = include_bytes!("../target/.../my_canister_v1.wasm");

#[test]
fn test_upgrade() {
    let pic = PocketIc::new();
    let canister_id = pic.create_canister();
    pic.add_cycles(canister_id, 2_000_000_000_000);

    // Install initial version
    pic.install_canister(canister_id, WASM_V1.to_vec(), vec![], None);

    // Upgrade to new version
    pic.upgrade_canister(canister_id, WASM_V2.to_vec(), vec![], None)
        .expect("upgrade failed");

    // Stop and start
    pic.stop_canister(canister_id, None).unwrap();
    pic.start_canister(canister_id, None).unwrap();
}
```

--------------------------------

### Install Motoko package manager

Source: https://docs.internetcomputer.org/getting-started/quickstart

Install the Motoko package manager for projects using Motoko.

```bash
npm install -g ic-mops
```

--------------------------------

### Install SDK Dependencies

Source: https://docs.internetcomputer.org/guides/digital-assets/wallet-integration

Install the core signer packages and optional canister support for token ledger interactions.

```bash
npm install @icp-sdk/signer @icp-sdk/core
```

```bash
npm install @icp-sdk/canisters
```

--------------------------------

### Install SvelteKit static adapter

Source: https://docs.internetcomputer.org/guides/frontends/frameworks

Install the static adapter required for deploying SvelteKit apps to the asset canister.

```bash
npm install -D @sveltejs/adapter-static
```

--------------------------------

### Deploying to local network

Source: https://docs.internetcomputer.org/guides/frontends/asset-canister

Commands to start the local network and deploy canisters.

```bash
# Start the local network
icp network start -d

# Build and deploy all canisters
icp deploy

# Or deploy only the frontend
icp deploy frontend
```

--------------------------------

### Install certificate verification library

Source: https://docs.internetcomputer.org/guides/frontends/certification

Install the required package for verifying IC certificates in a JavaScript environment.

```bash
npm install @dfinity/certificate-verification
```

--------------------------------

### Example sync logs

Source: https://docs.internetcomputer.org/guides/digital-assets/rosetta

Sample output showing synchronization status for multiple tokens.

```text
INFO sync{token=ckBTC-mxzaz}: Fully synched to block height: 2365800
INFO sync{token=ckETH-ss2fx}: Fully synched to block height: 801941
```

--------------------------------

### Install ICP CLI tools

Source: https://docs.internetcomputer.org/getting-started/quickstart

Install the core CLI tools required for building and optimizing canisters.

```bash
npm install -g @icp-sdk/icp-cli @icp-sdk/ic-wasm
```

--------------------------------

### Start local Ollama server

Source: https://docs.internetcomputer.org/references/application-canisters

Commands to initialize the local Ollama environment for testing.

```bash
# Start the Ollama server
ollama serve

# Pull the model (one-time download, ~4 GiB)
ollama pull llama3.1:8b
```

--------------------------------

### Install ICP SDK dependencies

Source: https://docs.internetcomputer.org/guides/frontends/frameworks

Installs the core SDK and build-time plugins required for React and Vite integration.

```bash
npm install @icp-sdk/core
npm install -D @icp-sdk/bindgen @vitejs/plugin-react
```

--------------------------------

### Install Rust Prerequisites

Source: https://docs.internetcomputer.org/languages/rust

Commands to add the Wasm compilation target and install the Candid extractor tool.

```bash
rustup target add wasm32-unknown-unknown
```

```bash
cargo install candid-extractor
```

--------------------------------

### Project configuration example

Source: https://docs.internetcomputer.org/getting-started/quickstart

The icp.yaml file defines the canisters included in the project.

```yaml
canisters:
  - backend
  - frontend
```

--------------------------------

### Install Pic JS

Source: https://docs.internetcomputer.org/guides/testing/pocket-ic

Command to add the PocketIC client library to your project dependencies.

```bash
npm install --save-dev @dfinity/pic
```

--------------------------------

### Start local ICP network

Source: https://docs.internetcomputer.org/guides/chain-fusion/bitcoin

Launch the local ICP environment and deploy canisters.

```bash
icp network start -d
icp deploy
```

--------------------------------

### Run Rosetta in a test environment

Source: https://docs.internetcomputer.org/guides/digital-assets/rosetta

Start a container for development using TESTICP tokens.

```bash
docker run \
    --publish 8081:8081 \
    --rm \
    dfinity/rosetta-api \
    --environment test
```

--------------------------------

### Create a new project

Source: https://docs.internetcomputer.org/getting-started/quickstart

Initialize a new fullstack project using the hello-world template.

```bash
icp new hello-icp --subfolder hello-world --silent && cd hello-icp
```

--------------------------------

### Initialize Bitcoin project

Source: https://docs.internetcomputer.org/guides/chain-fusion/bitcoin

Use the ICP CLI to scaffold a new project using the bitcoin-starter template.

```bash
icp new my-bitcoin-app --subfolder bitcoin-starter
cd my-bitcoin-app
```

--------------------------------

### Start local network and deploy

Source: https://docs.internetcomputer.org/guides/authentication/internet-identity

Commands to initialize the local network and deploy canisters with Internet Identity enabled.

```bash
icp network start
icp deploy
```

--------------------------------

### Canister Start Function Models

Source: https://docs.internetcomputer.org/references/ic-interface-spec/abstract-behavior

Models the execution of the WebAssembly start function.

```text
start : (WasmState) -> Trap { cycles_used : Nat; } | Return {
    new_state : WasmState;
    cycles_used : Nat;
  }
```

```text
start = λ (wasm_state) →
  Return {
    new_state = wasm_state;
    cycles_used = 0;
  }
```

```text
start = λ (wasm_state) →
  let es = ref {empty_execution_state with
    wasm_state = wasm_state;
    context = s;
  }
  try func<es>() with Trap then Trap {cycles_used = es.cycles_used;}
  Return {
    new_state = es.wasm_state;
    cycles_used = es.cycles_used;
  }
```

--------------------------------

### Migrate Buffer from base to core

Source: https://docs.internetcomputer.org/languages/motoko/base-core-migration

Example showing the transition from a base Buffer implementation requiring manual pre/post-upgrade hooks to a core List implementation with automatic migration.

```motoko
import Buffer "mo:base/Buffer";

persistent actor{
  type Item = Text;

  stable var items : [Item] = [];
  let buffer = Buffer.fromArray<Item>(items);

  system func preupgrade() {
    items := Buffer.toArray(buffer);
  };

  system func postupgrade() {
    items := [];
  };

  public func add(item : Item) : async () {
    buffer.add(item);
  };

  public query func getItems() : async [Item] {
    Buffer.toArray(buffer);
  };
};
```

```motoko
import List "mo:core/List";

(
  with migration = func(
    state : {
      var items : [App.Item];
    }
  ) : {
    list : List.List<App.Item>;
  } = {
    list = List.fromArray(state.items);
  }
)
persistent actorApp {
  public type Item = Text; // `public` for migration

  stable let list = List.empty<Item>();

  public func add(item : Item) : async () {
    List.add(list, item);
  };

  public query func getItems() : async [Item] {
    List.toArray(list);
  };
};
```

--------------------------------

### Run Rosetta in quickstart mode

Source: https://docs.internetcomputer.org/guides/digital-assets/rosetta

Connects to the TICRC1 test token using an in-memory store.

```bash
docker run \
    --publish 8082:8082 \
    --rm \
    dfinity/ic-icrc-rosetta-api \
    --port 8082 \
    --multi-tokens 3jkp5-oyaaa-aaaaj-azwqa-cai \
    --store-type in-memory
```

--------------------------------

### Install SNS extension

Source: https://docs.internetcomputer.org/guides/governance/testing

Install the required dfx sns extension to perform configuration validation.

```bash
dfx extension install sns
```

--------------------------------

### Initialize and Deploy Rust Project

Source: https://docs.internetcomputer.org/languages/rust

Commands to create a new project and deploy it to a local network.

```bash
icp new my_project --subfolder rust
```

```bash
icp network start -d
icp deploy
```

--------------------------------

### Install Code Transition Conditions

Source: https://docs.internetcomputer.org/references/ic-interface-spec/abstract-behavior

Formal logic defining the prerequisites and environment configuration for the install_code operation.

```html
S.messages = Older_messages · CallMessage M · Younger_messages
(M.queue = Unordered) or (∀ CallMessage M' | FuncMessage M' ∈ Older_messages. M'.queue ≠ M.queue)
M.callee = ic_principal
M.method_name = 'install_code'
M.arg = candid(A)
Mod = parse_wasm_mod(A.wasm_module)
Public_custom_sections = parse_public_custom_sections(A.wasm_module);
Private_custom_sections = parse_private_custom_sections(A.wasm_module);
(A.mode = install and S.canisters[A.canister_id] = EmptyCanister) or A.mode = reinstall
M.caller ∈ S.controllers[A.canister_id]

dom(Mod.update_methods) ∩ dom(Mod.query_methods) = ∅
dom(Mod.update_methods) ∩ dom(Mod.composite_query_methods) = ∅
dom(Mod.query_methods) ∩ dom(Mod.composite_query_methods) = ∅

Env = {
  time = S.time[A.canister_id];
  controllers = S.controllers[A.canister_id];
  global_timer = 0;
  balance = S.balances[A.canister_id];
  reserved_balance = S.reserved_balances[A.canister_id];
  reserved_balance_limit = S.reserved_balance_limits[A.canister_id];
  compute_allocation = S.compute_allocation[A.canister_id];
  memory_allocation = S.memory_allocation[A.canister_id];
  memory_usage_raw_module = memory_usage_raw_module(A.wasm_module);
  memory_usage_canister_history = memory_usage_canister_history(New_canister_history);
  memory_usage_chunk_store = memory_usage_chunk_store(New_chunk_store);
  memory_usage_snapshots = memory_usage_snapshots(S.snapshots[A.canister_id]);
  freezing_threshold = S.freezing_threshold[A.canister_id];
  subnet_id = S.canister_subnet[A.canister_id].subnet_id;
  subnet_size = S.canister_subnet[A.canister_id].subnet_size;
  certificate = NoCertificate;
  status = simple_status(S.canister_status[A.canister_id]);
  canister_version = S.canister_version[A.canister_id] + 1;
}
Mod.init(A.canister_id, A.arg, M.caller, Env) = Return {new_state = New_state; new_certified_data = New_certified_data; new_global_timer = New_global_timer; cycles_used = Cycles_used;}
Cycles_reserved = cycles_to_reserve(S, A.canister_id, S.compute_allocation[A.canister_id], S.memory_allocation[A.canister_id], S.snapshots[A.canister_id], New_state)
New_balance = S.balances[A.canister_id] - Cycles_used - Cycles_reserved
New_reserved_balance = S.reserved_balances[A.canister_id] + Cycles_reserved
New_reserved_balance ≤ S.reserved_balance_limits[A.canister_id]

liquid_balance(S, A.canister_id) ≥ MAX_CYCLES_PER_MESSAGE

liquid_balance(S', A.canister_id) ≥ 0

(S.wasm_memory_limit[A.canister_id] = 0) or |New_state.wasm_memory| <= S.wasm_memory_limit[A.canister_id]

S.canister_history[A.canister_id] = {
  total_num_changes = N;
  recent_changes = H;
}
New_canister_history = {
  total_num_changes = N + 1;
  recent_changes = H · {
    timestamp_nanos = S.time[A.canister_id];
    canister_version = S.canister_version[A.canister_id] + 1
    origin = change_origin(M.caller, A.sender_canister_version, M.origin);
    details = CodeDeployment {
      mode = A.mode;
      module_hash = SHA-256(A.wasm_module);
    };
  };
}
```

--------------------------------

### Canister status output example

Source: https://docs.internetcomputer.org/guides/canister-management/cycles-management

Example output format returned by the canister status command.

```text
Status: Running
Controllers: xxxxx-xxxxx-xxxxx-xxxxx-xxx
Memory allocation: 0
Compute allocation: 0
Freezing threshold: 2_592_000
Balance: 9_811_813_913_485 Cycles
```

--------------------------------

### Install Code Rate Limited Error

Source: https://docs.internetcomputer.org/references/execution-errors

Occurs when a canister has exceeded the instruction limit for installation messages.

```text
Canister xxx-xxx is rate limited because it executed too many instructions in the previous install_code messages. Please retry installation after several minutes.
```

--------------------------------

### Build Rosetta from source

Source: https://docs.internetcomputer.org/guides/digital-assets/rosetta

Clone the repository and build the binary using Bazel.

```bash
git clone https://github.com/dfinity/ic.git
cd ic

bazel run //rs/rosetta-api/icrc1:ic-icrc-rosetta-bin -- \
    --port 8082 \
    --multi-tokens 3jkp5-oyaaa-aaaaj-azwqa-cai \
    --store-type in-memory
```

--------------------------------

### Define and instantiate a class

Source: https://docs.internetcomputer.org/languages/motoko/fundamentals/types/objects-classes

Shows how to create a class as a blueprint for multiple objects and instantiate them with initial state.

```motoko
class Account(initialBalance : Nat) {
  var balance = initialBalance;

  public func deposit(amount : Nat) : async Nat {
    balance += amount;
    balance
  };
  public func withdraw(amount : Nat) : ?Nat {
    if (amount > balance) { return null };
      balance -= amount;
      ?balance
    };
};

// Creating multiple accounts
let account1 = Account(500);
let account2 = Account(1000);
```

--------------------------------

### Deploy project

Source: https://docs.internetcomputer.org/getting-started/quickstart

Build and deploy the project canisters to the local network.

```bash
icp deploy
```

--------------------------------

### Install reproducible npm dependencies

Source: https://docs.internetcomputer.org/guides/canister-management/reproducible-builds

Use npm ci to install exact versions from the package-lock.json file.

```bash
npm ci
```

--------------------------------

### Canister ID Range Example

Source: https://docs.internetcomputer.org/references/ic-interface-spec

Example of how canister ID ranges are represented as a list of closed intervals.

```text
[1, 3], [5, 8], [10, 12], [20, 25]
```

--------------------------------

### Deploy frontend canisters

Source: https://docs.internetcomputer.org/guides/frontends/frameworks

Commands to start the local network and deploy canisters to local or mainnet environments.

```bash
# Start local network
icp network start -d

# Deploy all canisters
icp deploy

# Deploy to mainnet
icp deploy -e ic
```

--------------------------------

### Install Code State Update

Source: https://docs.internetcomputer.org/references/ic-interface-spec/abstract-behavior

Formal definition of the canister state modification following a successful code installation.

```html
S' = S with
    canisters[A.canister_id] = {
      wasm_state = New_state;
      module = Mod;
      raw_module = A.wasm_module;
      public_custom_sections = Public_custom_sections;
      private_custom_sections = Private_custom_sections;
    }
    certified_data[A.canister_id] = New_certified_data
    if New_global_timer ≠ NoGlobalTimer:
      global_timer[A.canister_id] = New_global_timer
    else:
      global_timer[A.canister_id] = 0
    canister_version[A.canister_id] = S.canister_version[A.canister_id] + 1
    balances[A.canister_id] = New_balance
    reserved_balances[A.canister_id] = New_reserved_balance
    canister_history[A.canister_id] = New_canister_history
    canister_logs[A.canister_id] = New_canister_logs
    messages = Older_messages · Younger_messages ·
      ResponseMessage {
        origin = M.origin;
        response = Reply (candid());
        refunded_cycles = M.transferred_cycles;
      }
```

--------------------------------

### Deploy canisters via CLI

Source: https://docs.internetcomputer.org/guides/chain-fusion/ethereum

Commands to start the local replica and deploy the configured canisters.

```bash
# Start local replica
icp network start -d

# Deploy both backend and evm_rpc for local development
icp deploy -e local
```

--------------------------------

### Define ledger initialization arguments

Source: https://docs.internetcomputer.org/guides/digital-assets/ledgers

Create an argument file to initialize the ledger with token metadata, initial balances, and archive settings.

```text
(variant { Init = record {
  token_symbol = "TEST";
  token_name = "Test Token";
  minting_account = record { owner = principal "YOUR_PRINCIPAL" };
  transfer_fee = 10_000 : nat;
  metadata = vec {};
  initial_balances = vec {
    record {
      record { owner = principal "YOUR_PRINCIPAL" };
      100_000_000_000 : nat;
    };
  };
  archive_options = record {
    num_blocks_to_archive = 1000 : nat64;
    trigger_threshold = 2000 : nat64;
    controller_id = principal "YOUR_PRINCIPAL";
  };
  feature_flags = opt record { icrc2 = true };
}})
```

--------------------------------

### Build and run Rosetta from source

Source: https://docs.internetcomputer.org/guides/digital-assets/rosetta

Compile the Rosetta API using Bazel from the IC repository.

```bash
git clone https://github.com/dfinity/ic.git
cd ic

bazel run //rs/rosetta-api/icp:ic-rosetta-api -- \
    --port 8081 \
    --environment production \
    --store-location /tmp
```

--------------------------------

### Install Wasm64 build dependencies

Source: https://docs.internetcomputer.org/guides/canister-management/large-wasm

Commands to install the required nightly toolchain and rust-src component for Wasm64 builds.

```bash
rustup toolchain install nightly
rustup component add rust-src --toolchain nightly
```

--------------------------------

### Top up and check balance

Source: https://docs.internetcomputer.org/guides/canister-management/cycles-management

Demonstrates the correct usage of environment flags for topping up canisters and checking cycle balances.

```bash
# Correct
icp canister top-up backend --amount 1T -e ic
icp cycles balance -n ic

# Incorrect (fails: canister name requires -e)
icp canister top-up backend --amount 1T -n ic
```

--------------------------------

### Deploy and verify local ledger

Source: https://docs.internetcomputer.org/guides/digital-assets/ledgers

Commands to start the local network, deploy the ledger, and verify the token symbol.

```bash
icp network start -d
icp deploy icrc1_ledger
icp canister call icrc1_ledger icrc1_symbol '()'
# Expected: ("TEST")
```

--------------------------------

### Representation-independent hash calculation example

Source: https://docs.internetcomputer.org/references/ic-interface-spec/https-interface

Example calculation showing the recursive hashing process for a map containing a nested map.

```text
hash_of_map({ "reply": { "arg": "DIDL\x00\x00" } })
  = H(concat (sort [ H("reply") · hash_of_map({ "arg": "DIDL\x00\x00" }) ]))
  = H(concat (sort [ H("reply") · H(concat (sort [ H("arg") · H("DIDL\x00\x00") ])) ]))
```

--------------------------------

### Request Credential JSON-RPC Examples

Source: https://docs.internetcomputer.org/references/verifiable-credentials-spec

Examples of JSON-RPC requests used to initiate the credential sharing flow with specific issuers and subjects.

```json
{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "request_credential",
  "params": {
    "issuer": {
      "origin": "https://employment-info.com",
      "canisterId": "rwlgt-iiaaa-aaaaa-aaaaa-cai"
    },
    "credentialSpec": {
      "credentialType": "VerifiedEmployee",
      "arguments": {
        "employerName": "XYZ Ltd."
      }
    },
    "credentialSubject": "2mdal-aedsb-hlpnv-qu3zl-ae6on-72bt5-fwha5-xzs74-5dkaz-dfywi-aqe"
  }
}
```

```json
{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "request_credential",
  "params": {
    "issuer": {
      "origin": "https://kyc-star.com",
      "canisterId": "rdmx6-jaaaa-aaaaa-aaadq-cai"
    },
    "credentialSpec": {
      "credentialType": "VerifiedAdult",
      "arguments": {
        "minAge": 21
      }
    },
    "credentialSubject": "s33qc-ctnp5-ubyz4-kubqo-p2tem-he4ls-6j23j-hwwba-37zbl-t2lv3-pae",
    "derivationOrigin": "https://vt36r-2qaaa-aaaad-aad5a-cai.icp0.io"
  }
}
```

```json
{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "request_credential",
  "params": {
    "issuer": {
      "origin": "https://kyc-resident-info.org",
      "canisterId": "rwlgt-iiaaa-aaaaa-aaaaa-cai"
    },
    "credentialSpec": {
      "credentialType": "VerifiedResident",
      "arguments": {
        "countryName": "Panama",
        "countryAlpha2": "PA"
      }
    },
    "credentialSubject": "cpehq-54hef-odjjt-bockl-3ldtg-jqle4-ysi5r-6bfah-v6lsa-xprdv-pqe"
  }
}
```

--------------------------------

### Instantiate an actor class

Source: https://docs.internetcomputer.org/languages/motoko/fundamentals/declarations/class-declarations

Demonstrates importing an actor class and using the await keyword to handle the asynchronous constructor.

```motoko
import Counter "./Counter";

persistent actor {

  public func test() : async () {
    let counter = await (with cycles = 1_000_000_000_000) Counter.Counter(0);

    let newCount = await counter.inc();

    Debug.print("Count is now: " # Nat.toText(newCount));

    let currentCount = await counter.get();
    Debug.print("Current count: " # Nat.toText(currentCount));
  }
}
```

--------------------------------

### Access installer principal in actor class

Source: https://docs.internetcomputer.org/languages/motoko/icp-features/caller-identification

Use a zero-argument actor class with 'shared(msg)' to capture the principal of the actor's installer.

```motoko
shared(msg) actor class InstallerAware() {
  let installer = msg.caller; // This is the principal of the installer

  public func whoInstalled() : async Principal {
    installer
  };
}
```

--------------------------------

### Configuring local development server

Source: https://docs.internetcomputer.org/guides/frontends/asset-canister

Workflow for using a local dev server with backend canister discovery.

```bash
icp network start -d
icp deploy backend    # Only the backend needs to be deployed
npm run dev           # Start your dev server with ic_env configuration
```

--------------------------------

### Compress and install Wasm module

Source: https://docs.internetcomputer.org/guides/canister-management/lifecycle

Use gzip to compress a Wasm module exceeding the 10 MiB limit before installing it via the IC CLI.

```bash
gzip my-canister.wasm
icp canister install my-canister --wasm my-canister.wasm.gz
```

--------------------------------

### Deploy game builds using icp-cli

Source: https://docs.internetcomputer.org/guides/frontends/frameworks

Standard commands to start a local network and deploy the asset canister.

```bash
# Start local network
icp network start -d

# Deploy the asset canister
icp deploy

# Access your game locally
# http://<canister-id>.localhost:8000
```

--------------------------------

### Request ID Calculation Example

Source: https://docs.internetcomputer.org/references/ic-interface-spec/https-interface

Example calculation of a request ID using SHA-256 hashing and blob concatenation, assuming the optional nonce is omitted.

```text
hash_of_map({ request_type: "call", sender: 0x04, ingress_expiry: 1685570400000000000, canister_id: 0x00000000000004D2, method_name: "hello", arg: "DIDL\x00\xFD*"})
 = H(concat (sort
   [ H("request_type") · H("call")
   , H("sender") · H("0x04")
   , H("ingress_expiry") · H(1685570400000000000)
   , H("canister_id") · H("\x00\x00\x00\x00\x00\x00\x04\xD2")
   , H("method_name") · H("hello")
   , H("arg") · H("DIDL\x00\xFD*")
   ]))
 = H(concat (sort
   [ 769e6f87bdda39c859642b74ce9763cdd37cb1cd672733e8c54efaa33ab78af9 · 7edb360f06acaef2cc80dba16cf563f199d347db4443da04da0c8173e3f9e4ed
   , 0a367b92cf0b037dfd89960ee832d56f7fc151681bb41e53690e776f5786998a · e52d9c508c502347344d8c07ad91cbd6068afc75ff6292f062a09ca381c89e71
   , 26cec6b6a9248a96ab24305b61b9d27e203af14a580a5b1ff2f67575cab4a868 · db8e57abc8cda1525d45fdd2637af091bc1f28b35819a40df71517d1501f2c76
   , 0a3eb2ba16702a387e6321066dd952db7a31f9b5cc92981e0a92dd56802d3df9 · 4d8c47c3c1c837964011441882d745f7e92d10a40cef0520447c63029eafe396
   , 293536232cf9231c86002f4ee293176a0179c002daa9fc24be9bb51acdd642b6 · 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
   , b25f03dedd69be07f356a06fe35c1b0ddc0de77dcd9066c4be0c6bbde14b23ff · 6c0b2ae49718f6995c02ac5700c9c789d7b7862a0d53e6d40a73f1fcd2f70189
   ]))
 = H(concat
   [ 0a367b92cf0b037dfd89960ee832d56f7fc151681bb41e53690e776f5786998a · e52d9c508c502347344d8c07ad91cbd6068afc75ff6292f062a09ca381c89e71
   , 0a3eb2ba16702a387e6321066dd952db7a31f9b5cc92981e0a92dd56802d3df9 · 4d8c47c3c1c837964011441882d745f7e92d10a40cef0520447c63029eafe396
   , 26cec6b6a9248a96ab24305b61b9d27e203af14a580a5b1ff2f67575cab4a868 · db8e57abc8cda1525d45fdd2637af091bc1f28b35819a40df71517d1501f2c76
   , 293536232cf9231c86002f4ee293176a0179c002daa9fc24be9bb51acdd642b6 · 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
   , 769e6f87bdda39c859642b74ce9763cdd37cb1cd672733e8c54efaa33ab78af9 · 7edb360f06acaef2cc80dba16cf563f199d347db4443da04da0c8173e3f9e4ed
   , b25f03dedd69be07f356a06fe35c1b0ddc0de77dcd9066c4be0c6bbde14b23ff · 6c0b2ae49718f6995c02ac5700c9c789d7b7862a0d53e6d40a73f1fcd2f70189
   ])
 = 1d1091364d6bb8a6c16b203ee75467d59ead468f523eb058880ae8ec80e2b101
```

--------------------------------

### Send HTTP GET Request

Source: https://docs.internetcomputer.org/guides/backends/https-outcalls

Sends a GET request to an external service using replicated mode for strong integrity. Requires explicit cycle attachment for the management canister call.

```motoko
public func send_http_get_request() : async Text {
  let request : IC.http_request_args = {
    url = "https://postman-echo.com/get?greeting=hello-from-icp";
    // Always set max_response_bytes to a tight bound. The cycle cost scales
    // with this value, not the actual response size. If omitted, the system
    // assumes 2MB. Unused cycles are refunded, but you still pay for the
    // declared maximum.
    max_response_bytes = ?(3_000 : Nat64);
    headers = [{ name = "User-Agent"; value = "ic-canister" }];
    body = null;
    method = #get;
    transform = ?{ function = transform; context = Blob.fromArray([]) };
    // Replicated mode: all subnet nodes make the request independently,
    // providing strong integrity guarantees via consensus.
    is_replicated = ?true;
  };

  // Cycles must be explicitly attached to management canister calls.
  // The amount is based on request size and max_response_bytes.
  let response = await (with cycles = 230_949_972_000) IC.http_request(request);

  // postman-echo.com echoes back the request metadata as JSON, letting you
  // verify the query params and headers were sent correctly.
  switch (Text.decodeUtf8(response.body)) {
    case (?text) text;
    case null "Response is not valid UTF-8";
  };
};
```

```rust
#[ic_cdk::update]
async fn send_http_get_request() -> String {
    let request = HttpRequestArgs {
        url: "https://postman-echo.com/get?greeting=hello-from-icp".to_string(),
        method: HttpMethod::GET,
        // Always set max_response_bytes to a tight bound. The cycle cost scales
        // with this value, not the actual response size. If omitted, the system
        // assumes 2MB. Unused cycles are refunded, but you still pay for the
        // declared maximum.
        max_response_bytes: Some(3_000),
        headers: vec![HttpHeader {
            name: "User-Agent".to_string(),
            value: "ic-canister".to_string(),
        }],
        body: None,
        transform: Some(TransformContext {
            function: TransformFunc::new(canister_self(), "transform".to_string()),
            context: vec![],
        }),
        // Replicated mode: all subnet nodes make the request independently,
        // providing strong integrity guarantees via consensus.
        is_replicated: Some(true),
    };

    // http_request auto-calculates and attaches the required cycles
    match http_request(&request).await {
        // postman-echo.com echoes back the request metadata as JSON, letting you
        // verify the query params and headers were sent correctly.
        Ok(response) => String::from_utf8(response.body).unwrap_or_default(),
        Err(err) => format!("Outcall failed: {err}"),
    }
}
```

--------------------------------

### install_code

Source: https://docs.internetcomputer.org/references/ic.did

Installs code into a specified canister.

```APIDOC
## install_code

### Description
Installs or upgrades the WASM module of a canister.

### Parameters
- **mode** (canister_install_mode) - Required - The installation mode (install, reinstall, or upgrade).
- **canister_id** (canister_id) - Required - The ID of the target canister.
- **wasm_module** (wasm_module) - Required - The WASM module to install.
- **arg** (blob) - Required - Initialization arguments.
- **sender_canister_version** (opt nat64) - Optional - Version of the sender canister.
```

--------------------------------

### Run the OISY Signer Demo Locally

Source: https://docs.internetcomputer.org/guides/digital-assets/wallet-integration

Commands to clone, install, and deploy the oisy-signer-demo project for local testing.

```bash
git clone https://github.com/dfinity/examples
cd examples/hosting/oisy-signer-demo
icp network start -d
npm install
icp deploy
```

--------------------------------

### Start a canister

Source: https://docs.internetcomputer.org/guides/canister-management/lifecycle

Returns a stopped canister to the running state.

```bash
icp canister start my-canister
```

--------------------------------

### GET /api/v2/status

Source: https://docs.internetcomputer.org/references/ic-interface-spec/https-interface

Retrieves status information about the Internet Computer.

```APIDOC
## GET /api/v2/status

### Description
Retrieves diagnostic status information about the Internet Computer.

### Method
GET

### Endpoint
/api/v2/status
```

--------------------------------

### Benchmark output example

Source: https://docs.internetcomputer.org/guides/testing/strategies

Sample output showing instruction counts and memory usage for a benchmark.

```text
---------------------------------------------------
Benchmark: fibonacci_20 (new)
  total:
    instructions: 2301 (new)
    heap_increase: 0 pages (new)
    stable_memory_increase: 0 pages (new)
---------------------------------------------------
Executed 1 of 1 benchmarks.
```

--------------------------------

### Result of Array.repeat

Source: https://docs.internetcomputer.org/languages/motoko/fundamentals/types/mutable-arrays

The resulting mutable array structure from the repeat example.

```motoko
[var null, null, null, null, null, null, null, null, null, null]
```

--------------------------------

### Write a basic Rust integration test

Source: https://docs.internetcomputer.org/guides/testing/pocket-ic

Demonstrates creating a PocketIC instance, deploying a canister, and performing query and update calls.

```rust
use candid::{decode_one, encode_one, Principal};
use pocket_ic::PocketIc;

// Path to the compiled canister WASM
pub const CANISTER_WASM: &[u8] =
    include_bytes!("../target/wasm32-unknown-unknown/release/my_canister.wasm");

#[test]
fn test_counter() {
    // Create a new PocketIC instance with one application subnet
    let pic = PocketIc::new();

    // Create a canister and fund it with 2T cycles
    let canister_id = pic.create_canister();
    pic.add_cycles(canister_id, 2_000_000_000_000);

    // Install the canister WASM
    pic.install_canister(canister_id, CANISTER_WASM.to_vec(), vec![], None);

    // Make a query call
    let result = pic
        .query_call(
            canister_id,
            Principal::anonymous(),
            "get_count",
            encode_one(()).unwrap(),
        )
        .expect("query failed");

    let count: u64 = decode_one(&result).unwrap();
    assert_eq!(count, 0);

    // Make an update call
    pic.update_call(
        canister_id,
        Principal::anonymous(),
        "increment",
        encode_one(()).unwrap(),
    )
    .expect("update failed");

    // Verify the counter incremented
    let result = pic
        .query_call(
            canister_id,
            Principal::anonymous(),
            "get_count",
            encode_one(()).unwrap(),
        )
        .expect("query failed");

    let count: u64 = decode_one(&result).unwrap();
    assert_eq!(count, 1);
}
```

--------------------------------

### Result of tabulateVar

Source: https://docs.internetcomputer.org/languages/motoko/fundamentals/types/mutable-arrays

The resulting mutable array structure from the tabulateVar example.

```motoko
[var "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
```

--------------------------------

### While loop example

Source: https://docs.internetcomputer.org/languages/motoko/fundamentals/control-flow/loops

Executes a block of code while the condition remains true.

```motoko
import Debug "mo:core/Debug";

var count = 3;
while (count > 0) {
  Debug.print("Counting down...");
  count -= 1;
};
```

--------------------------------

### ic0.env_var_value_size

Source: https://docs.internetcomputer.org/references/ic-interface-spec/canister-interface

Gets the size in bytes of the value for a specific environment variable.

```APIDOC
## ic0.env_var_value_size

### Description
Gets the size in bytes of the value for the environment variable with the given name.

### Signature
`ic0.env_var_value_size : (name_src: I, name_size: I) -> I` (where I is i32 or i64)
```

--------------------------------

### Inspect project configuration

Source: https://docs.internetcomputer.org/getting-started/project-structure

Displays the effective configuration after template rendering, including all expanded recipe steps and implicit defaults.

```bash
icp project show
```

--------------------------------

### Switch over to the new canister

Source: https://docs.internetcomputer.org/guides/canister-management/canister-migration

Starts the target canister and deletes the source canister.

```bash
icp canister start <target-id> -n ic
```

```bash
# Delete it if no longer needed
icp canister delete my-canister -e ic
```

--------------------------------

### Productive Type Definitions

Source: https://docs.internetcomputer.org/languages/motoko/reference/language-manual

Examples of valid, productive type declarations in Motoko.

```motoko
  type Person = { first : Text; last : Text };

  type List<T> = ?(T, List<T>);

  type Fst<T, U> = T;

  type Ok<T> = Fst<Any, Ok<T>>;
```
Tokens:
Raw