Type inference

.github/workflows/test.yml

@@ -72,6 +72,7 @@ jobs:
                     "examples/bytes",
                     "examples/call_raw",
                     "examples/candid_encoding",
+                    "examples/canister",
                     "examples/complex_init",
                     "examples/composite_queries",
                     "examples/counter",
@@ -115,7 +116,6 @@ jobs:
                     "examples/randomness",
                     "examples/rejections",
                     "examples/robust_imports",
-                    "examples/service",
                     "examples/simple_erc20",
                     "examples/simple_user_accounts",
                     "examples/stable_memory",

canisters/ledger/index.ts

@@ -8,15 +8,14 @@
 
 import {
     blob,
+    Canister,
     nat,
     nat8,
     nat32,
     nat64,
     Null,
     Opt,
-    Principal,
     Record,
-    Service,
     query,
     update,
     text,
@@ -298,7 +297,7 @@ export const DecimalsResult = Record({
 export type Address = text;
 export const Address = text;
 
-export const Ledger = Service({
+export const Ledger = Canister({
     // Transfers tokens from a subaccount of the caller to the destination address.
     // The source address is computed from the principal of the caller and the specified subaccount.
     // When successful, returns the index of the block containing the transaction.

canisters/management/index.ts

@@ -1,7 +1,7 @@
 import {
     blob,
+    Canister,
     Principal,
-    Service,
     update,
     Vec,
     Void
@@ -44,7 +44,7 @@ export * from './canister_management';
 export * from './http_request';
 export * from './t_ecdsa';
 
-export const managementCanister = Service({
+export const managementCanister = Canister({
     // bitcoin
     bitcoin_get_balance: update([GetBalanceArgs], Satoshi),
     bitcoin_get_current_fee_percentiles: update(

examples/async_await/src/async_await.ts

@@ -1,7 +1,7 @@
-import { blob, ic, Service, update, Void } from 'azle';
+import { blob, Canister, ic, update, Void } from 'azle';
 import { managementCanister } from 'azle/canisters/management';
 
-export default Service({
+export default Canister({
     getRandomnessDirectly: update([], blob, async () => {
         return await ic.call(managementCanister.raw_rand);
     }),

examples/audio_recorder/src/index.ts

@@ -1,5 +1,6 @@
 import {
     blob,
+    Canister,
     ic,
     nat64,
     Opt,
@@ -8,7 +9,6 @@ import {
     query,
     Record,
     Result,
-    Service,
     StableBTreeMap,
     text,
     update,
@@ -39,7 +39,7 @@ const AudioRecorderError = Variant({
 let users = StableBTreeMap(principal, User, 0);
 let recordings = StableBTreeMap(principal, Recording, 1);
 
-export default Service({
+export default Canister({
     createUser: update([text], User, (username) => {
         const id = generateId();
         const user: typeof User = {

examples/bitcoin/src/index.ts

@@ -1,4 +1,4 @@
-import { blob, bool, ic, None, Service, text, update, Vec } from 'azle';
+import { blob, bool, Canister, ic, None, text, update, Vec } from 'azle';
 import {
     GetUtxosResult,
     managementCanister,
@@ -10,7 +10,7 @@ const BITCOIN_API_CYCLE_COST = 100_000_000n;
 const BITCOIN_BASE_TRANSACTION_COST = 5_000_000_000n;
 const BITCOIN_CYCLE_COST_PER_TRANSACTION_BYTE = 20_000_000n;
 
-export default Service({
+export default Canister({
     getBalance: update([text], Satoshi, async (address) => {
         return await ic.call(managementCanister.bitcoin_get_balance, {
             args: [

examples/blob_array/src/index.ts

@@ -1,6 +1,6 @@
-import { blob, query, Service, Vec } from 'azle';
+import { blob, Canister, query, Vec } from 'azle';
 
-export default Service({
+export default Canister({
     getBlob: query([], blob, () => {
         return stringToBlob('hello');
     }),

examples/bytes/src/index.ts

@@ -1,6 +1,6 @@
-import { blob, Service, update } from 'azle';
+import { blob, Canister, update } from 'azle';
 
-export default Service({
+export default Canister({
     getBytes: update([blob], blob, (bytes) => {
         return bytes;
     })

examples/call_raw/src/call_raw.ts

@@ -1,6 +1,15 @@
-import { ic, nat, nat64, principal, Result, Service, text, update } from 'azle';
+import {
+    Canister,
+    ic,
+    nat,
+    nat64,
+    principal,
+    Result,
+    text,
+    update
+} from 'azle';
 
-export default Service({
+export default Canister({
     executeCallRaw: update(
         [principal, text, text, nat64],
         Result(text, text),

examples/candid_encoding/src/index.ts

@@ -1,6 +1,6 @@
-import { blob, ic, query, Service, text } from 'azle';
+import { blob, Canister, ic, query, text } from 'azle';
 
-export default Service({
+export default Canister({
     // encodes a Candid string to Candid bytes
     candidEncode: query([text], blob, (candidString) => {
         return ic.candidEncode(candidString);

examples/canister/dfx.json

@@ -0,0 +1,31 @@
+{
+    "canisters": {
+        "canister": {
+            "type": "custom",
+            "build": "npx azle canister",
+            "root": "src",
+            "ts": "src/index.ts",
+            "candid": "src/index.did",
+            "wasm": ".azle/canister/canister.wasm",
+            "gzip": true,
+            "declarations": {
+                "output": "test/dfx_generated/canister",
+                "node_compatibility": true
+            },
+            "env": ["SOME_CANISTER_PRINCIPAL"]
+        },
+        "some_canister": {
+            "type": "custom",
+            "build": "npx azle some_canister",
+            "root": "src",
+            "ts": "src/some_canister.ts",
+            "candid": "src/some_canister.did",
+            "wasm": ".azle/some_canister/some_canister.wasm",
+            "gzip": true,
+            "declarations": {
+                "output": "test/dfx_generated/some_canister",
+                "node_compatibility": true
+            }
+        }
+    }
+}

examples/canister/src/index.did

@@ -0,0 +1,8 @@
+type rec_0 = record {someCanister:service {query1:() -> (bool) query; update1:() -> (text) }};
+service: () -> {
+    canisterParam: (service {query1:() -> (bool) query; update1:() -> (text) }) -> (service {query1:() -> (bool) query; update1:() -> (text) }) query;
+    canisterReturnType: () -> (service {query1:() -> (bool) query; update1:() -> (text) }) query;
+    canisterNestedReturnType: () -> (rec_0);
+    canisterList: (vec service {query1:() -> (bool) query; update1:() -> (text) }) -> (vec service {query1:() -> (bool) query; update1:() -> (text) });
+    canisterCrossCanisterCall: (service {query1:() -> (bool) query; update1:() -> (text) }) -> (text);
+}

examples/canister/src/index.ts

@@ -0,0 +1,55 @@
+import {
+    Canister,
+    ic,
+    Principal,
+    query,
+    Record,
+    text,
+    update,
+    Vec
+} from 'azle';
+import SomeCanister from './some_canister';
+
+const Wrapper = Record({
+    someCanister: SomeCanister
+});
+
+export default Canister({
+    canisterParam: query([SomeCanister], SomeCanister, (someCanister) => {
+        return someCanister;
+    }),
+    canisterReturnType: query([], SomeCanister, () => {
+        return SomeCanister(
+            Principal.fromText(
+                process.env.SOME_CANISTER_PRINCIPAL ??
+                    ic.trap('process.env.SOME_CANISTER_PRINCIPAL is undefined')
+            )
+        );
+    }),
+    canisterNestedReturnType: update([], Wrapper, () => {
+        return {
+            someCanister: SomeCanister(
+                Principal.fromText(
+                    process.env.SOME_CANISTER_PRINCIPAL ??
+                        ic.trap(
+                            'process.env.SOME_CANISTER_PRINCIPAL is undefined'
+                        )
+                )
+            )
+        };
+    }),
+    canisterList: update(
+        [Vec(SomeCanister)],
+        Vec(SomeCanister),
+        (someCanisters) => {
+            return someCanisters;
+        }
+    ),
+    canisterCrossCanisterCall: update(
+        [SomeCanister],
+        text,
+        async (someCanister) => {
+            return await ic.call(someCanister.update1);
+        }
+    )
+});

examples/canister/src/some_canister.ts

@@ -0,0 +1,10 @@
+import { bool, Canister, query, text, update } from 'azle';
+
+export default Canister({
+    query1: query([], bool, () => {
+        return true;
+    }),
+    update1: update([], text, () => {
+        return 'SomeCanister update1';
+    })
+});

examples/service/test/pretest.ts → examples/canister/test/pretest.ts

@@ -4,20 +4,20 @@ import { getCanisterId } from 'azle/test';
 async function pretest() {
     await new Promise((resolve) => setTimeout(resolve, 5000));
 
-    execSync(`dfx canister uninstall-code service || true`, {
+    execSync(`dfx canister uninstall-code canister || true`, {
         stdio: 'inherit'
     });
 
-    execSync(`dfx canister uninstall-code some_service || true`, {
+    execSync(`dfx canister uninstall-code some_canister || true`, {
         stdio: 'inherit'
     });
 
-    execSync(`dfx canister create some_service || true`, {
+    execSync(`dfx canister create some_canister || true`, {
         stdio: 'inherit'
     });
 
     execSync(
-        `SOME_SERVICE_PRINCIPAL=${getCanisterId('some_service')} dfx deploy`,
+        `SOME_CANISTER_PRINCIPAL=${getCanisterId('some_canister')} dfx deploy`,
         {
             stdio: 'inherit'
         }

examples/canister/test/test.ts

@@ -0,0 +1,11 @@
+import { getCanisterId, runTests } from 'azle/test';
+import { createActor } from './dfx_generated/canister';
+import { getTests } from './tests';
+
+const canister = createActor(getCanisterId('canister'), {
+    agentOptions: {
+        host: 'http://127.0.0.1:8000'
+    }
+});
+
+runTests(getTests(canister));