Update JS SDK version and migrate to the new JS API (#11)

.prettierrc.js

@@ -0,0 +1,8 @@
+module.exports = {
+    semi: true,
+    trailingComma: 'all',
+    singleQuote: true,
+    printWidth: 120,
+    tabWidth: 4,
+    useTabs: false,
+};

aqua/dht/dht-example.aqua

@@ -2,6 +2,8 @@ import "@fluencelabs/aqua-dht/pubsub.aqua"
 import "@fluencelabs/aqua-dht/dht.aqua"
 import "@fluencelabs/aqua-lib/builtin.aqua"
 
+export getNeighbours, initTopicAndSubscribe, findSubscribers
+
 func put_value(initial_peer: string, value: string) -> string:
     initTopicAndSubscribe(initial_peer, "some-const3", value, nil, nil)
     <- "OK"

aqua/examples/imports_exports/declare.aqua

@@ -1,4 +1,5 @@
 module FooBars declares decl_foo, decl_bar, SuperFoo, DECLARE_CONST, DECLARE_CONST2
+export SuperFoo
 
 const DECLARE_CONST = "declare_const"
 const DECLARE_CONST2 = "declare_const2"

aqua/examples/imports_exports/exports.aqua

@@ -1,6 +1,5 @@
 module Exports declares some_string, MyExportSrv, EXPORT_CONST, some_random_func
 
--- TODO: check it in TS after it will be implemented
 export some_string as string_from_lib
 export MyExportSrv
 

aqua/examples/new-api-full.aqua

@@ -0,0 +1,25 @@
+service ServiceWithDefaultId("defaultId"):
+    hello(s: string)
+
+service ServiceWithOUTDefaultId:
+    hello(s: string)
+
+service MoreMembers:
+    member1()
+    member2(s1: string)
+    member3(s1: string, s2: string)
+    member4(s1: string, s2: string, i: i32) -> i32
+    member5(s1: string, s2: string, i: i32) -> i32
+
+func f1(callback: string, i32 -> ()):
+    callback("hello, world", 42)
+
+func f2(num: i32, callback: string, i32 -> ()):
+    callback("hello, world", 42)
+
+func f3(num: i32, callback: string, i32 -> ()) -> string:
+    callback("hello, world", 42)
+    <- "hello world"
+
+func callBackZeroArgs(callback: -> ()):
+    callback()

aqua/examples/new-api.aqua

@@ -0,0 +1,6 @@
+service HelloWorld("default"):
+    sayHello(s: string)
+    getNumber() -> i32
+
+func callMeBack(callback: string, i32 -> ()):
+    callback("hello, world", 42)

package.json

@@ -1,41 +1,42 @@
 {
-  "name": "aquamarine-template",
+    "name": "aquamarine-template",
-  "version": "0.3.9",
+    "version": "0.3.9",
-  "keywords": [
+    "keywords": [
-    "typescript",
+        "typescript",
-    "template"
+        "template"
-  ],
+    ],
-  "author": "FluenceLabs (https://github.com/fluencelabs)",
+    "author": "FluenceLabs (https://github.com/fluencelabs)",
-  "license": "MIT",
+    "license": "MIT",
-  "main": "dist/index.js",
+    "main": "dist/index.js",
-  "bin": {
+    "bin": {
-    "fldist": "./dist/index.js"
+        "fldist": "./dist/index.js"
-  },
+    },
-  "types": "dist/index.d.ts",
+    "types": "dist/index.d.ts",
-  "files": [
+    "files": [
-    "dist/"
+        "dist/"
-  ],
+    ],
-  "scripts": {
+    "scripts": {
-    "build": "tsc",
+        "build": "tsc",
-    "examples": "node -r ts-node/register src/run-examples.ts",
+        "examples": "node -r ts-node/register src/run-examples.ts",
-    "pubsub": "node -r ts-node/register src/pubsub.ts",
+        "pubsub": "node -r ts-node/register src/pubsub.ts",
-    "exec": "npm run compile-aqua && node -r ts-node/register src/index.ts",
+        "exec": "npm run compile-aqua && node -r ts-node/register src/index.ts",
-    "run": "node -r ts-node/register src/index.ts",
+        "run": "node -r ts-node/register src/index.ts",
-    "compile-aqua": "aqua-cli -i ./aqua/ -o ./src/compiled",
+        "compile-aqua": "aqua-cli -i ./aqua/ -o ./src/compiled",
-    "compile-aqua:air": "aqua-cli -i ./aqua/ -o ./compiled-air -a"
+        "compile-aqua:air": "aqua-cli -i ./aqua/ -o ./compiled-air -a",
-  },
+        "prettify-compiled": "prettier --write src/compiled"
-  "devDependencies": {
+    },
-    "@fluencelabs/aqua-cli": "^0.2.2-221",
+    "devDependencies": {
-    "@fluencelabs/aqua-lib": "0.1.14",
+        "@fluencelabs/aqua-cli": "0.2.0-208",
-    "@fluencelabs/aqua-dht": "0.1.38",
+        "@fluencelabs/aqua-dht": "0.1.36",
-    "ts-node": "^9.1.1",
+        "@fluencelabs/aqua-lib": "0.1.14",
-    "typescript": "^4.2.4"
+        "ts-node": "^9.1.1",
-  },
+        "typescript": "^4.2.4"
-  "dependencies": {
+    },
-    "@fluencelabs/fluence": "0.10.1",
+    "dependencies": {
-    "@fluencelabs/fluence-network-environment": "1.0.10",
+        "@fluencelabs/aqua-dht-ts": "0.1.36",
-    "@fluencelabs/aqua-dht-ts": "0.1.38",
+        "@fluencelabs/fluence": "0.11.0",
-    "deep-equal": "^2.0.5"
+        "@fluencelabs/fluence-network-environment": "^1.0.10",
-  },
+        "deep-equal": "^2.0.5"
-  "description": "Minimal template for aquamarine project."
+    },
+    "description": "Minimal template for aquamarine project."
 }

src/compiled/dht/dht-example.ts

@@ -0,0 +1,710 @@
+/**
+ *
+ * This file is auto-generated. Do not edit manually: changes may be erased.
+ * Generated by Aqua compiler: https://github.com/fluencelabs/aqua/.
+ * If you find any bugs, please write an issue on GitHub: https://github.com/fluencelabs/aqua/issues
+ * Aqua version: 0.3.0-SNAPSHOT
+ *
+ */
+import { FluencePeer } from '@fluencelabs/fluence';
+import {
+    ResultCodes,
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
+
+// Services
+
+// Functions
+
+export function put_value(initial_peer: string, value: string, config?: { ttl?: number }): Promise<string>;
+export function put_value(
+    peer: FluencePeer,
+    initial_peer: string,
+    value: string,
+    config?: { ttl?: number },
+): Promise<string>;
+export function put_value(...args) {
+    let peer: FluencePeer;
+    let initial_peer;
+    let value;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        initial_peer = args[1];
+        value = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        initial_peer = args[0];
+        value = args[1];
+        config = args[2];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (seq
+    (seq
+     (seq
+      (seq
+       (seq
+        (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+        (call %init_peer_id% ("getDataSrv" "initial_peer") [] initial_peer)
+       )
+       (call %init_peer_id% ("getDataSrv" "value") [] value)
+      )
+      (call -relay- ("op" "noop") [])
+     )
+     (xor
+      (seq
+       (call initial_peer ("op" "string_to_b58") ["some-const3"] k)
+       (call initial_peer ("kad" "neighborhood") [k [] []] nodes)
+      )
+      (seq
+       (call -relay- ("op" "noop") [])
+       (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+      )
+     )
+    )
+    (call -relay- ("op" "noop") [])
+   )
+   (fold nodes n
+    (par
+     (xor
+      (seq
+       (seq
+        (call n ("peer" "timestamp_sec") [] t)
+        (call n ("aqua-dht" "register_key") ["some-const3" t false 0])
+       )
+       (call n ("aqua-dht" "put_value") ["some-const3" value t [] [] 0])
+      )
+      (null)
+     )
+     (seq
+      (call -relay- ("op" "noop") [])
+      (next n)
+     )
+    )
+   )
+  )
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") ["OK"])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'initial_peer', () => {
+                    return initial_peer;
+                });
+                h.on('getDataSrv', 'value', () => {
+                    return value;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for put_value');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function registerKeyPutValue(
+    node_id: string,
+    key: string,
+    value: string,
+    relay_id: string | null,
+    service_id: string | null,
+    config?: { ttl?: number },
+): Promise<string[]>;
+export function registerKeyPutValue(
+    peer: FluencePeer,
+    node_id: string,
+    key: string,
+    value: string,
+    relay_id: string | null,
+    service_id: string | null,
+    config?: { ttl?: number },
+): Promise<string[]>;
+export function registerKeyPutValue(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let key;
+    let value;
+    let relay_id;
+    let service_id;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        key = args[2];
+        value = args[3];
+        relay_id = args[4];
+        service_id = args[5];
+        config = args[6];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        key = args[1];
+        value = args[2];
+        relay_id = args[3];
+        service_id = args[4];
+        config = args[5];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string[]>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (seq
+    (seq
+     (seq
+      (seq
+       (seq
+        (seq
+         (seq
+          (seq
+           (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+           (call %init_peer_id% ("getDataSrv" "node_id") [] node_id)
+          )
+          (call %init_peer_id% ("getDataSrv" "key") [] key)
+         )
+         (call %init_peer_id% ("getDataSrv" "value") [] value)
+        )
+        (call %init_peer_id% ("getDataSrv" "relay_id") [] relay_id)
+       )
+       (call %init_peer_id% ("getDataSrv" "service_id") [] service_id)
+      )
+      (call -relay- ("op" "noop") [])
+     )
+     (xor
+      (seq
+       (call key ("op" "string_to_b58") [node_id] k)
+       (call key ("kad" "neighborhood") [k [] []] nodes)
+      )
+      (seq
+       (call -relay- ("op" "noop") [])
+       (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+      )
+     )
+    )
+    (call -relay- ("op" "noop") [])
+   )
+   (fold nodes n
+    (par
+     (xor
+      (call n ("peer" "timestamp_sec") [] t)
+      (seq
+       (call -relay- ("op" "noop") [])
+       (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+      )
+     )
+     (seq
+      (call -relay- ("op" "noop") [])
+      (next n)
+     )
+    )
+   )
+  )
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") [nodes])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 4])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
+                });
+                h.on('getDataSrv', 'key', () => {
+                    return key;
+                });
+                h.on('getDataSrv', 'value', () => {
+                    return value;
+                });
+                h.on('getDataSrv', 'relay_id', () => {
+                    return relay_id === null ? [] : [relay_id];
+                });
+                h.on('getDataSrv', 'service_id', () => {
+                    return service_id === null ? [] : [service_id];
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for registerKeyPutValue');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function getNeighbours(node_id: string, topic: string, config?: { ttl?: number }): Promise<string[]>;
+export function getNeighbours(
+    peer: FluencePeer,
+    node_id: string,
+    topic: string,
+    config?: { ttl?: number },
+): Promise<string[]>;
+export function getNeighbours(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let topic;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        topic = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        topic = args[1];
+        config = args[2];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string[]>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (seq
+    (seq
+     (seq
+      (seq
+       (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+       (call %init_peer_id% ("getDataSrv" "node_id") [] node_id)
+      )
+      (call %init_peer_id% ("getDataSrv" "topic") [] topic)
+     )
+     (call -relay- ("op" "noop") [])
+    )
+    (xor
+     (seq
+      (call node_id ("op" "string_to_b58") [topic] k)
+      (call node_id ("kad" "neighborhood") [k [] []] nodes)
+     )
+     (seq
+      (call -relay- ("op" "noop") [])
+      (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+     )
+    )
+   )
+   (call -relay- ("op" "noop") [])
+  )
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") [nodes])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
+                });
+                h.on('getDataSrv', 'topic', () => {
+                    return topic;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for getNeighbours');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function findSubscribers(
+    node_id: string,
+    topic: string,
+    config?: { ttl?: number },
+): Promise<
+    {
+        peer_id: string;
+        relay_id: string[];
+        service_id: string[];
+        set_by: string;
+        timestamp_created: number;
+        value: string;
+        weight: number;
+    }[]
+>;
+export function findSubscribers(
+    peer: FluencePeer,
+    node_id: string,
+    topic: string,
+    config?: { ttl?: number },
+): Promise<
+    {
+        peer_id: string;
+        relay_id: string[];
+        service_id: string[];
+        set_by: string;
+        timestamp_created: number;
+        value: string;
+        weight: number;
+    }[]
+>;
+export function findSubscribers(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let topic;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        topic = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        topic = args[1];
+        config = args[2];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<
+        {
+            peer_id: string;
+            relay_id: string[];
+            service_id: string[];
+            set_by: string;
+            timestamp_created: number;
+            value: string;
+            weight: number;
+        }[]
+    >((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (seq
+    (seq
+     (seq
+      (seq
+       (seq
+        (seq
+         (seq
+          (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+          (call %init_peer_id% ("getDataSrv" "node_id") [] node_id)
+         )
+         (call %init_peer_id% ("getDataSrv" "topic") [] topic)
+        )
+        (call -relay- ("op" "noop") [])
+       )
+       (xor
+        (seq
+         (call node_id ("op" "string_to_b58") [topic] k)
+         (call node_id ("kad" "neighborhood") [k [] []] nodes)
+        )
+        (seq
+         (seq
+          (call -relay- ("op" "noop") [])
+          (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+         )
+         (call -relay- ("op" "noop") [])
+        )
+       )
+      )
+      (call -relay- ("op" "noop") [])
+     )
+     (fold nodes n
+      (par
+       (seq
+        (xor
+         (seq
+          (call n ("peer" "timestamp_sec") [] t)
+          (call n ("aqua-dht" "get_values") [topic t] $res)
+         )
+         (null)
+        )
+        (call node_id ("op" "noop") [])
+       )
+       (seq
+        (call -relay- ("op" "noop") [])
+        (next n)
+       )
+      )
+     )
+    )
+    (xor
+     (call node_id ("aqua-dht" "merge_two") [$res.$.[0].result! $res.$.[1].result!] v)
+     (seq
+      (call -relay- ("op" "noop") [])
+      (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+     )
+    )
+   )
+   (call -relay- ("op" "noop") [])
+  )
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") [v.$.result!])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 4])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
+                });
+                h.on('getDataSrv', 'topic', () => {
+                    return topic;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for findSubscribers');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function initTopicAndSubscribe(
+    node_id: string,
+    topic: string,
+    value: string,
+    relay_id: string | null,
+    service_id: string | null,
+    config?: { ttl?: number },
+): Promise<void>;
+export function initTopicAndSubscribe(
+    peer: FluencePeer,
+    node_id: string,
+    topic: string,
+    value: string,
+    relay_id: string | null,
+    service_id: string | null,
+    config?: { ttl?: number },
+): Promise<void>;
+export function initTopicAndSubscribe(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let topic;
+    let value;
+    let relay_id;
+    let service_id;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        topic = args[2];
+        value = args[3];
+        relay_id = args[4];
+        service_id = args[5];
+        config = args[6];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        topic = args[1];
+        value = args[2];
+        relay_id = args[3];
+        service_id = args[4];
+        config = args[5];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<void>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (seq
+    (seq
+     (seq
+      (seq
+       (seq
+        (seq
+         (seq
+          (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+          (call %init_peer_id% ("getDataSrv" "node_id") [] node_id)
+         )
+         (call %init_peer_id% ("getDataSrv" "topic") [] topic)
+        )
+        (call %init_peer_id% ("getDataSrv" "value") [] value)
+       )
+       (call %init_peer_id% ("getDataSrv" "relay_id") [] relay_id)
+      )
+      (call %init_peer_id% ("getDataSrv" "service_id") [] service_id)
+     )
+     (call -relay- ("op" "noop") [])
+    )
+    (xor
+     (seq
+      (call node_id ("op" "string_to_b58") [topic] k)
+      (call node_id ("kad" "neighborhood") [k [] []] nodes)
+     )
+     (seq
+      (call -relay- ("op" "noop") [])
+      (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+     )
+    )
+   )
+   (call -relay- ("op" "noop") [])
+  )
+  (fold nodes n
+   (par
+    (xor
+     (seq
+      (seq
+       (call n ("peer" "timestamp_sec") [] t)
+       (call n ("aqua-dht" "register_key") [topic t false 0])
+      )
+      (call n ("aqua-dht" "put_value") [topic value t relay_id service_id 0])
+     )
+     (null)
+    )
+    (seq
+     (call -relay- ("op" "noop") [])
+     (next n)
+    )
+   )
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
+                });
+                h.on('getDataSrv', 'topic', () => {
+                    return topic;
+                });
+                h.on('getDataSrv', 'value', () => {
+                    return value;
+                });
+                h.on('getDataSrv', 'relay_id', () => {
+                    return relay_id === null ? [] : [relay_id];
+                });
+                h.on('getDataSrv', 'service_id', () => {
+                    return service_id === null ? [] : [service_id];
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for initTopicAndSubscribe');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return Promise.race([promise, Promise.resolve()]);
+}

src/compiled/examples/assignment.ts

@@ -6,32 +6,109 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//OpHa
+export interface OpHaDef {
-//defaultId = "op"
+    array: (a: string, b: string, callParams: CallParams<'a' | 'b'>) => string[];
+    identity: (a: string, callParams: CallParams<'a'>) => string;
+}
 
-//array: (a: string, b: string) => string[]
+export function registerOpHa(service: OpHaDef): void;
-//identity: (a: string) => string
+export function registerOpHa(serviceId: string, service: OpHaDef): void;
-//END OpHa
+export function registerOpHa(peer: FluencePeer, service: OpHaDef): void;
+export function registerOpHa(peer: FluencePeer, serviceId: string, service: OpHaDef): void;
+export function registerOpHa(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'op';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'array') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    a: req.tetraplets[0],
+                    b: req.tetraplets[1],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.array(req.args[0], req.args[1], callParams);
+        }
+
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    a: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.identity(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function doSmth(client: FluenceClient, arg: {value:string}, config?: {ttl?: number}): Promise<string[]> {
+export function doSmth(arg: { value: string }, config?: { ttl?: number }): Promise<string[]>;
+export function doSmth(peer: FluencePeer, arg: { value: string }, config?: { ttl?: number }): Promise<string[]>;
+export function doSmth(...args) {
+    let peer: FluencePeer;
+    let arg;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        arg = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        arg = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -51,20 +128,21 @@ export async function doSmth(client: FluenceClient, arg: {value:string}, config?
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'arg', () => {
+                    return arg;
                 });
-                h.on('getDataSrv', 'arg', () => {return arg;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -72,13 +150,12 @@ export async function doSmth(client: FluenceClient, arg: {value:string}, config?
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for doSmth');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/callArrow.ts

@@ -6,24 +6,58 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-
 // Functions
 
-export async function passFunctionAsArg(client: FluenceClient, node: string, str: string, c: (arg0: string) => string, config?: {ttl?: number}): Promise<void> {
+export function passFunctionAsArg(
+    node: string,
+    str: string,
+    c: (arg0: string, callParams: CallParams<'arg0'>) => string,
+    config?: { ttl?: number },
+): Promise<void>;
+export function passFunctionAsArg(
+    peer: FluencePeer,
+    node: string,
+    str: string,
+    c: (arg0: string, callParams: CallParams<'arg0'>) => string,
+    config?: { ttl?: number },
+): Promise<void>;
+export function passFunctionAsArg(...args) {
+    let peer: FluencePeer;
+    let node;
+    let str;
+    let c;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node = args[1];
+        str = args[2];
+        c = args[3];
+        config = args[4];
+    } else {
+        peer = FluencePeer.default;
+        node = args[0];
+        str = args[1];
+        c = args[2];
+        config = args[3];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -67,18 +101,36 @@ export async function passFunctionAsArg(client: FluenceClient, node: string, str
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'node', () => {return node;});
+                h.on('getDataSrv', 'node', () => {
-h.on('getDataSrv', 'str', () => {return str;});
+                    return node;
-h.on('callbackSrv', 'c', (args) => {return c(args[0]);});
+                });
+                h.on('getDataSrv', 'str', () => {
+                    return str;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'c') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        resp.result = c(req.args[0], callParams);
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -86,13 +138,12 @@ h.on('callbackSrv', 'c', (args) => {return c(args[0]);});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for passFunctionAsArg');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/co.ts

@@ -6,31 +6,106 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//CoService
+export interface CoServiceDef {
-//defaultId = "coservice-id"
+    call: (callParams: CallParams<null>) => string;
+}
 
-//call: () => string
+export function registerCoService(service: CoServiceDef): void;
-//END CoService
+export function registerCoService(serviceId: string, service: CoServiceDef): void;
+export function registerCoService(peer: FluencePeer, service: CoServiceDef): void;
+export function registerCoService(peer: FluencePeer, serviceId: string, service: CoServiceDef): void;
+export function registerCoService(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'coservice-id';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'call') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.call(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function coFunc(client: FluenceClient, node: string, c: (arg0: {external_addresses:string[]}) => void, config?: {ttl?: number}): Promise<void> {
+export function coFunc(
+    node: string,
+    c: (arg0: { external_addresses: string[] }, callParams: CallParams<'arg0'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function coFunc(
+    peer: FluencePeer,
+    node: string,
+    c: (arg0: { external_addresses: string[] }, callParams: CallParams<'arg0'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function coFunc(...args) {
+    let peer: FluencePeer;
+    let node;
+    let c;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node = args[1];
+        c = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        node = args[0];
+        c = args[1];
+        config = args[2];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -65,17 +140,34 @@ export async function coFunc(client: FluenceClient, node: string, c: (arg0: {ext
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'node', () => {return node;});
+                h.on('getDataSrv', 'node', () => {
-h.on('callbackSrv', 'c', (args) => {c(args[0]); return {};});
+                    return node;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'c') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        c(req.args[0], callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -83,13 +175,12 @@ h.on('callbackSrv', 'c', (args) => {c(args[0]); return {};});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for coFunc');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/complex.ts

@@ -6,32 +6,147 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//TestS
+export interface TestSDef {
-//defaultId = "some-id"
+    multiline: (a: string, b: string, c: boolean, callParams: CallParams<'a' | 'b' | 'c'>) => string;
+    t: (arg0: string, callParams: CallParams<'arg0'>) => string;
+}
 
-//multiline: (a: string, b: string, c: boolean) => string
+export function registerTestS(service: TestSDef): void;
-//t: (arg0: string) => string
+export function registerTestS(serviceId: string, service: TestSDef): void;
-//END TestS
+export function registerTestS(peer: FluencePeer, service: TestSDef): void;
+export function registerTestS(peer: FluencePeer, serviceId: string, service: TestSDef): void;
+export function registerTestS(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'some-id';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'multiline') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    a: req.tetraplets[0],
+                    b: req.tetraplets[1],
+                    c: req.tetraplets[2],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.multiline(req.args[0], req.args[1], req.args[2], callParams);
+        }
+
+        if (req.fnName === 't') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.t(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function doStuff(client: FluenceClient, a: string, b: string, c: boolean, d: boolean, e: string[], g: string[], str: string, config?: {ttl?: number}): Promise<string[]> {
+export function doStuff(
+    a: string,
+    b: string,
+    c: boolean,
+    d: boolean,
+    e: string[],
+    g: string[],
+    str: string,
+    config?: { ttl?: number },
+): Promise<string[]>;
+export function doStuff(
+    peer: FluencePeer,
+    a: string,
+    b: string,
+    c: boolean,
+    d: boolean,
+    e: string[],
+    g: string[],
+    str: string,
+    config?: { ttl?: number },
+): Promise<string[]>;
+export function doStuff(...args) {
+    let peer: FluencePeer;
+    let a;
+    let b;
+    let c;
+    let d;
+    let e;
+    let g;
+    let str;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        a = args[1];
+        b = args[2];
+        c = args[3];
+        d = args[4];
+        e = args[5];
+        g = args[6];
+        str = args[7];
+        config = args[8];
+    } else {
+        peer = FluencePeer.default;
+        a = args[0];
+        b = args[1];
+        c = args[2];
+        d = args[3];
+        e = args[4];
+        g = args[5];
+        str = args[6];
+        config = args[7];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -143,26 +258,39 @@ export async function doStuff(client: FluenceClient, a: string, b: string, c: bo
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 5])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'a', () => {
+                    return a;
+                });
+                h.on('getDataSrv', 'b', () => {
+                    return b;
+                });
+                h.on('getDataSrv', 'c', () => {
+                    return c;
+                });
+                h.on('getDataSrv', 'd', () => {
+                    return d;
+                });
+                h.on('getDataSrv', 'e', () => {
+                    return e;
+                });
+                h.on('getDataSrv', 'g', () => {
+                    return g;
+                });
+                h.on('getDataSrv', 'str', () => {
+                    return str;
                 });
-                h.on('getDataSrv', 'a', () => {return a;});
-h.on('getDataSrv', 'b', () => {return b;});
-h.on('getDataSrv', 'c', () => {return c;});
-h.on('getDataSrv', 'd', () => {return d;});
-h.on('getDataSrv', 'e', () => {return e;});
-h.on('getDataSrv', 'g', () => {return g;});
-h.on('getDataSrv', 'str', () => {return str;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -170,13 +298,12 @@ h.on('getDataSrv', 'str', () => {return str;});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for doStuff');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/constants.ts

@@ -6,40 +6,149 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Getter
+export interface GetterDef {
-//defaultId = "test"
+    createStr: (arg0: number, callParams: CallParams<'arg0'>) => string;
+}
 
-//createStr: (arg0: number) => string
+export function registerGetter(service: GetterDef): void;
-//END Getter
+export function registerGetter(serviceId: string, service: GetterDef): void;
+export function registerGetter(peer: FluencePeer, service: GetterDef): void;
+export function registerGetter(peer: FluencePeer, serviceId: string, service: GetterDef): void;
+export function registerGetter(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'test';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
 
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
 
-//OpO
+        if (req.fnName === 'createStr') {
-//defaultId = "op"
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.createStr(req.args[0], callParams);
+        }
 
-//identity: (arg0: string) => string
+        next();
-//END OpO
+    });
+}
 
+export interface OpODef {
+    identity: (arg0: string, callParams: CallParams<'arg0'>) => string;
+}
 
+export function registerOpO(service: OpODef): void;
+export function registerOpO(serviceId: string, service: OpODef): void;
+export function registerOpO(peer: FluencePeer, service: OpODef): void;
+export function registerOpO(peer: FluencePeer, serviceId: string, service: OpODef): void;
+export function registerOpO(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'op';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.identity(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function callConstant(client: FluenceClient, config?: {ttl?: number}): Promise<string[]> {
+export function callConstant(config?: { ttl?: number }): Promise<string[]>;
+export function callConstant(peer: FluencePeer, config?: { ttl?: number }): Promise<string[]>;
+export function callConstant(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -56,20 +165,19 @@ export async function callConstant(client: FluenceClient, config?: {ttl?: number
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -77,13 +185,12 @@ export async function callConstant(client: FluenceClient, config?: {ttl?: number
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for callConstant');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/dataAlias.ts

@@ -6,31 +6,92 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//NodeIdGetter
+export interface NodeIdGetterDef {
-//defaultId = "somesrv"
+    get: (callParams: CallParams<null>) => { name: string; peerId: string };
+}
 
-//get: () => {name:string;peerId:string}
+export function registerNodeIdGetter(service: NodeIdGetterDef): void;
-//END NodeIdGetter
+export function registerNodeIdGetter(serviceId: string, service: NodeIdGetterDef): void;
+export function registerNodeIdGetter(peer: FluencePeer, service: NodeIdGetterDef): void;
+export function registerNodeIdGetter(peer: FluencePeer, serviceId: string, service: NodeIdGetterDef): void;
+export function registerNodeIdGetter(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'somesrv';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'get') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.get(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function getAliasedData(client: FluenceClient, config?: {ttl?: number}): Promise<string> {
+export function getAliasedData(config?: { ttl?: number }): Promise<string>;
+export function getAliasedData(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function getAliasedData(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -44,20 +105,19 @@ export async function getAliasedData(client: FluenceClient, config?: {ttl?: numb
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -65,13 +125,12 @@ export async function getAliasedData(client: FluenceClient, config?: {ttl?: numb
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for getAliasedData');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/example.ts

@@ -6,50 +6,213 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Peer
+export interface PeerDef {
-//defaultId = "peer"
+    is_connected: (arg0: string, callParams: CallParams<'arg0'>) => boolean;
+}
 
-//is_connected: (arg0: string) => boolean
+export function registerPeer(service: PeerDef): void;
-//END Peer
+export function registerPeer(serviceId: string, service: PeerDef): void;
+export function registerPeer(peer: FluencePeer, service: PeerDef): void;
+export function registerPeer(peer: FluencePeer, serviceId: string, service: PeerDef): void;
+export function registerPeer(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'peer';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
 
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
 
-//Op
+        if (req.fnName === 'is_connected') {
-//defaultId = "op"
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.is_connected(req.args[0], callParams);
+        }
 
-//identity: () => void
+        next();
-//END Op
+    });
+}
 
+export interface OpDef {
+    identity: (callParams: CallParams<null>) => void;
+}
 
+export function registerOp(service: OpDef): void;
+export function registerOp(serviceId: string, service: OpDef): void;
+export function registerOp(peer: FluencePeer, service: OpDef): void;
+export function registerOp(peer: FluencePeer, serviceId: string, service: OpDef): void;
+export function registerOp(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'op';
+    }
 
-//Test
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
-//defaultId = "test"
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
 
-//doSomething: () => boolean
+    peer.internals.callServiceHandler.use((req, resp, next) => {
-//getUserList: () => {name:string;peer_id:string;relay_id:string}[]
+        if (req.serviceId !== serviceId) {
-//END Test
+            next();
+            return;
+        }
 
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            service.identity(callParams);
+            resp.result = {};
+        }
 
+        next();
+    });
+}
+
+export interface TestDef {
+    doSomething: (callParams: CallParams<null>) => boolean;
+    getUserList: (callParams: CallParams<null>) => { name: string; peer_id: string; relay_id: string }[];
+}
+
+export function registerTest(service: TestDef): void;
+export function registerTest(serviceId: string, service: TestDef): void;
+export function registerTest(peer: FluencePeer, service: TestDef): void;
+export function registerTest(peer: FluencePeer, serviceId: string, service: TestDef): void;
+export function registerTest(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'test';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'doSomething') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.doSomething(callParams);
+        }
+
+        if (req.fnName === 'getUserList') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getUserList(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function betterMessage(client: FluenceClient, relay: string, config?: {ttl?: number}): Promise<void> {
+export function betterMessage(relay: string, config?: { ttl?: number }): Promise<void>;
+export function betterMessage(peer: FluencePeer, relay: string, config?: { ttl?: number }): Promise<void>;
+export function betterMessage(...args) {
+    let peer: FluencePeer;
+    let relay;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        relay = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        relay = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -83,16 +246,18 @@ export async function betterMessage(client: FluenceClient, relay: string, config
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'relay', () => {return relay;});
+                h.on('getDataSrv', 'relay', () => {
+                    return relay;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -100,13 +265,12 @@ export async function betterMessage(client: FluenceClient, relay: string, config
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for betterMessage');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/fldist-sample.ts

@@ -6,31 +6,97 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Return
+export interface ReturnDef {
-//defaultId = "returnService"
+    run: (arg0: { external_addresses: string[] }, callParams: CallParams<'arg0'>) => void;
+}
 
-//run: (arg0: {external_addresses:string[]}) => void
+export function registerReturn(service: ReturnDef): void;
-//END Return
+export function registerReturn(serviceId: string, service: ReturnDef): void;
+export function registerReturn(peer: FluencePeer, service: ReturnDef): void;
+export function registerReturn(peer: FluencePeer, serviceId: string, service: ReturnDef): void;
+export function registerReturn(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'returnService';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'run') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.run(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function test(client: FluenceClient, node: string, config?: {ttl?: number}): Promise<void> {
+export function test(node: string, config?: { ttl?: number }): Promise<void>;
+export function test(peer: FluencePeer, node: string, config?: { ttl?: number }): Promise<void>;
+export function test(...args) {
+    let peer: FluencePeer;
+    let node;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        node = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -56,16 +122,18 @@ export async function test(client: FluenceClient, node: string, config?: {ttl?:
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'node', () => {return node;});
+                h.on('getDataSrv', 'node', () => {
+                    return node;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -73,13 +141,12 @@ export async function test(client: FluenceClient, node: string, config?: {ttl?:
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for test');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/fold.ts

@@ -6,24 +6,41 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-
 // Functions
 
-export async function iterateAndPrint(client: FluenceClient, strings: string[], config?: {ttl?: number}): Promise<void> {
+export function iterateAndPrint(strings: string[], config?: { ttl?: number }): Promise<void>;
+export function iterateAndPrint(peer: FluencePeer, strings: string[], config?: { ttl?: number }): Promise<void>;
+export function iterateAndPrint(...args) {
+    let peer: FluencePeer;
+    let strings;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        strings = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        strings = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -39,16 +56,18 @@ export async function iterateAndPrint(client: FluenceClient, strings: string[],
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'strings', () => {return strings;});
+                h.on('getDataSrv', 'strings', () => {
+                    return strings;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -56,26 +75,51 @@ export async function iterateAndPrint(client: FluenceClient, strings: string[],
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for iterateAndPrint');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
 
+export function iterateAndPrintParallel(
+    nodes: string[],
+    c: (arg0: { external_addresses: string[] }, callParams: CallParams<'arg0'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function iterateAndPrintParallel(
+    peer: FluencePeer,
+    nodes: string[],
+    c: (arg0: { external_addresses: string[] }, callParams: CallParams<'arg0'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function iterateAndPrintParallel(...args) {
+    let peer: FluencePeer;
+    let nodes;
+    let c;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        nodes = args[1];
+        c = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        nodes = args[0];
+        c = args[1];
+        config = args[2];
+    }
 
-
-export async function iterateAndPrintParallel(client: FluenceClient, nodes: string[], c: (arg0: {external_addresses:string[]}) => void, config?: {ttl?: number}): Promise<void> {
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -106,17 +150,34 @@ export async function iterateAndPrintParallel(client: FluenceClient, nodes: stri
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'nodes', () => {return nodes;});
+                h.on('getDataSrv', 'nodes', () => {
-h.on('callbackSrv', 'c', (args) => {c(args[0]); return {};});
+                    return nodes;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'c') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        c(req.args[0], callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -124,13 +185,12 @@ h.on('callbackSrv', 'c', (args) => {c(args[0]); return {};});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for iterateAndPrintParallel');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/foldJoin.ts

@@ -6,31 +6,97 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Op2
+export interface Op2Def {
-//defaultId = "op"
+    identity: (s: number, callParams: CallParams<'s'>) => void;
+}
 
-//identity: (s: number) => void
+export function registerOp2(service: Op2Def): void;
-//END Op2
+export function registerOp2(serviceId: string, service: Op2Def): void;
+export function registerOp2(peer: FluencePeer, service: Op2Def): void;
+export function registerOp2(peer: FluencePeer, serviceId: string, service: Op2Def): void;
+export function registerOp2(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'op';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.identity(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function getTwoResults(client: FluenceClient, relay: string, config?: {ttl?: number}): Promise<number[]> {
+export function getTwoResults(relay: string, config?: { ttl?: number }): Promise<number[]>;
+export function getTwoResults(peer: FluencePeer, relay: string, config?: { ttl?: number }): Promise<number[]>;
+export function getTwoResults(...args) {
+    let peer: FluencePeer;
+    let relay;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        relay = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        relay = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<number[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -85,20 +151,21 @@ export async function getTwoResults(client: FluenceClient, relay: string, config
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'relay', () => {
+                    return relay;
                 });
-                h.on('getDataSrv', 'relay', () => {return relay;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -106,13 +173,12 @@ export async function getTwoResults(client: FluenceClient, relay: string, config
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for getTwoResults');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/func.ts

@@ -6,31 +6,92 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//TestSrv
+export interface TestSrvDef {
-//defaultId = "test-service-id"
+    str: (callParams: CallParams<null>) => string;
+}
 
-//str: () => string
+export function registerTestSrv(service: TestSrvDef): void;
-//END TestSrv
+export function registerTestSrv(serviceId: string, service: TestSrvDef): void;
+export function registerTestSrv(peer: FluencePeer, service: TestSrvDef): void;
+export function registerTestSrv(peer: FluencePeer, serviceId: string, service: TestSrvDef): void;
+export function registerTestSrv(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'test-service-id';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'str') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.str(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function testFunc(client: FluenceClient, config?: {ttl?: number}): Promise<string> {
+export function testFunc(config?: { ttl?: number }): Promise<string>;
+export function testFunc(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function testFunc(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -44,20 +105,19 @@ export async function testFunc(client: FluenceClient, config?: {ttl?: number}):
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -65,13 +125,12 @@ export async function testFunc(client: FluenceClient, config?: {ttl?: number}):
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for testFunc');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/helloWorld.ts

@@ -6,31 +6,96 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//StringExtra
+export interface StringExtraDef {
-//defaultId = "service-id"
+    addNameToHello: (arg0: string, callParams: CallParams<'arg0'>) => string;
+}
 
-//addNameToHello: (arg0: string) => string
+export function registerStringExtra(service: StringExtraDef): void;
-//END StringExtra
+export function registerStringExtra(serviceId: string, service: StringExtraDef): void;
+export function registerStringExtra(peer: FluencePeer, service: StringExtraDef): void;
+export function registerStringExtra(peer: FluencePeer, serviceId: string, service: StringExtraDef): void;
+export function registerStringExtra(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'service-id';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'addNameToHello') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.addNameToHello(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function helloWorld(client: FluenceClient, name: string, config?: {ttl?: number}): Promise<string> {
+export function helloWorld(name: string, config?: { ttl?: number }): Promise<string>;
+export function helloWorld(peer: FluencePeer, name: string, config?: { ttl?: number }): Promise<string>;
+export function helloWorld(...args) {
+    let peer: FluencePeer;
+    let name;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        name = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        name = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -47,20 +112,21 @@ export async function helloWorld(client: FluenceClient, name: string, config?: {
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'name', () => {
+                    return name;
                 });
-                h.on('getDataSrv', 'name', () => {return name;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -68,13 +134,12 @@ export async function helloWorld(client: FluenceClient, name: string, config?: {
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for helloWorld');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/if.ts

@@ -6,24 +6,41 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-
 // Functions
 
-export async function ifElseCall(client: FluenceClient, condition: boolean, config?: {ttl?: number}): Promise<void> {
+export function ifElseCall(condition: boolean, config?: { ttl?: number }): Promise<void>;
+export function ifElseCall(peer: FluencePeer, condition: boolean, config?: { ttl?: number }): Promise<void>;
+export function ifElseCall(...args) {
+    let peer: FluencePeer;
+    let condition;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        condition = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        condition = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -42,16 +59,18 @@ export async function ifElseCall(client: FluenceClient, condition: boolean, conf
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'condition', () => {return condition;});
+                h.on('getDataSrv', 'condition', () => {
+                    return condition;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -59,26 +78,39 @@ export async function ifElseCall(client: FluenceClient, condition: boolean, conf
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for ifElseCall');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
 
+export function ifElseNumCall(condition: number, config?: { ttl?: number }): Promise<void>;
+export function ifElseNumCall(peer: FluencePeer, condition: number, config?: { ttl?: number }): Promise<void>;
+export function ifElseNumCall(...args) {
+    let peer: FluencePeer;
+    let condition;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        condition = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        condition = args[0];
+        config = args[1];
+    }
 
-
-export async function ifElseNumCall(client: FluenceClient, condition: number, config?: {ttl?: number}): Promise<void> {
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -97,16 +129,18 @@ export async function ifElseNumCall(client: FluenceClient, condition: number, co
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'condition', () => {return condition;});
+                h.on('getDataSrv', 'condition', () => {
+                    return condition;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -114,13 +148,12 @@ export async function ifElseNumCall(client: FluenceClient, condition: number, co
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for ifElseNumCall');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/imports_exports/declare.ts

@@ -0,0 +1,72 @@
+/**
+ *
+ * This file is auto-generated. Do not edit manually: changes may be erased.
+ * Generated by Aqua compiler: https://github.com/fluencelabs/aqua/.
+ * If you find any bugs, please write an issue on GitHub: https://github.com/fluencelabs/aqua/issues
+ * Aqua version: 0.3.0-SNAPSHOT
+ *
+ */
+import { FluencePeer } from '@fluencelabs/fluence';
+import {
+    ResultCodes,
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
+
+// Services
+
+export interface SuperFooDef {
+    small_foo: (callParams: CallParams<null>) => string;
+}
+
+export function registerSuperFoo(service: SuperFooDef): void;
+export function registerSuperFoo(serviceId: string, service: SuperFooDef): void;
+export function registerSuperFoo(peer: FluencePeer, service: SuperFooDef): void;
+export function registerSuperFoo(peer: FluencePeer, serviceId: string, service: SuperFooDef): void;
+export function registerSuperFoo(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'super_foo';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'small_foo') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.small_foo(callParams);
+        }
+
+        next();
+    });
+}
+
+// Functions

src/compiled/examples/imports_exports/exports.ts

@@ -6,31 +6,92 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//MyExportSrv
+export interface MyExportSrvDef {
-//defaultId = "my_export_srv"
+    another_str: (callParams: CallParams<null>) => string;
+}
 
-//another_str: () => string
+export function registerMyExportSrv(service: MyExportSrvDef): void;
-//END MyExportSrv
+export function registerMyExportSrv(serviceId: string, service: MyExportSrvDef): void;
+export function registerMyExportSrv(peer: FluencePeer, service: MyExportSrvDef): void;
+export function registerMyExportSrv(peer: FluencePeer, serviceId: string, service: MyExportSrvDef): void;
+export function registerMyExportSrv(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'my_export_srv';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'another_str') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.another_str(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function string_from_lib(client: FluenceClient, config?: {ttl?: number}): Promise<string> {
+export function string_from_lib(config?: { ttl?: number }): Promise<string>;
+export function string_from_lib(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function string_from_lib(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
   (xor
@@ -41,20 +102,19 @@ export async function string_from_lib(client: FluenceClient, config?: {ttl?: num
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -62,13 +122,12 @@ export async function string_from_lib(client: FluenceClient, config?: {ttl?: num
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for string_from_lib');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/imports_exports/gen/OneMore.ts

@@ -6,20 +6,64 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//OneMore
+export interface OneMoreDef {
-//defaultId = undefined
+    more_call: (callParams: CallParams<null>) => void;
+}
 
-//more_call: () => void
+export function registerOneMore(serviceId: string, service: OneMoreDef): void;
-//END OneMore
+export function registerOneMore(peer: FluencePeer, serviceId: string, service: OneMoreDef): void;
+export function registerOneMore(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'more_call') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            service.more_call(callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
 
 // Functions
-

src/compiled/examples/imports_exports/import2.ts

@@ -6,24 +6,39 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-
 // Functions
 
-export async function wrap(client: FluenceClient, config?: {ttl?: number}): Promise<string> {
+export function wrap(config?: { ttl?: number }): Promise<string>;
+export function wrap(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function wrap(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -40,20 +55,19 @@ export async function wrap(client: FluenceClient, config?: {ttl?: number}): Prom
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -61,26 +75,37 @@ export async function wrap(client: FluenceClient, config?: {ttl?: number}): Prom
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for wrap');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function barfoo(config?: { ttl?: number }): Promise<string[]>;
+export function barfoo(peer: FluencePeer, config?: { ttl?: number }): Promise<string[]>;
+export function barfoo(...args) {
+    let peer: FluencePeer;
 
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
 
-export async function barfoo(client: FluenceClient, config?: {ttl?: number}): Promise<string[]> {
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -97,20 +122,19 @@ export async function barfoo(client: FluenceClient, config?: {ttl?: number}): Pr
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -118,13 +142,12 @@ export async function barfoo(client: FluenceClient, config?: {ttl?: number}): Pr
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for barfoo');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/imports_exports/imports-empty.ts

@@ -0,0 +1,573 @@
+/**
+ *
+ * This file is auto-generated. Do not edit manually: changes may be erased.
+ * Generated by Aqua compiler: https://github.com/fluencelabs/aqua/.
+ * If you find any bugs, please write an issue on GitHub: https://github.com/fluencelabs/aqua/issues
+ * Aqua version: 0.3.0-SNAPSHOT
+ *
+ */
+import { FluencePeer } from '@fluencelabs/fluence';
+import {
+    ResultCodes,
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
+
+// Services
+
+export interface NoopDef {
+    array: (
+        a: string,
+        b: string | null,
+        c: string | null,
+        d: string | null,
+        callParams: CallParams<'a' | 'b' | 'c' | 'd'>,
+    ) => string[];
+    array_length: (array: string[], callParams: CallParams<'array'>) => number;
+    bytes_from_b58: (b: string, callParams: CallParams<'b'>) => number[];
+    bytes_to_b58: (bs: number[], callParams: CallParams<'bs'>) => string;
+    concat: (
+        a: string[],
+        b: string[] | null,
+        c: string[] | null,
+        d: string[] | null,
+        callParams: CallParams<'a' | 'b' | 'c' | 'd'>,
+    ) => string[];
+    concat_strings: (a: string, b: string, callParams: CallParams<'a' | 'b'>) => string;
+    identity: (s: string | null, callParams: CallParams<'s'>) => string | null;
+    noop: (callParams: CallParams<null>) => void;
+    sha256_string: (s: string, callParams: CallParams<'s'>) => string;
+    string_from_b58: (b: string, callParams: CallParams<'b'>) => string;
+    string_to_b58: (s: string, callParams: CallParams<'s'>) => string;
+}
+
+export function registerNoop(service: NoopDef): void;
+export function registerNoop(serviceId: string, service: NoopDef): void;
+export function registerNoop(peer: FluencePeer, service: NoopDef): void;
+export function registerNoop(peer: FluencePeer, serviceId: string, service: NoopDef): void;
+export function registerNoop(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'op';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'array') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    a: req.tetraplets[0],
+                    b: req.tetraplets[1],
+                    c: req.tetraplets[2],
+                    d: req.tetraplets[3],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.array(req.args[0], req.args[1], req.args[2], req.args[3], callParams);
+        }
+
+        if (req.fnName === 'array_length') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    array: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.array_length(req.args[0], callParams);
+        }
+
+        if (req.fnName === 'bytes_from_b58') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    b: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.bytes_from_b58(req.args[0], callParams);
+        }
+
+        if (req.fnName === 'bytes_to_b58') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    bs: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.bytes_to_b58(req.args[0], callParams);
+        }
+
+        if (req.fnName === 'concat') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    a: req.tetraplets[0],
+                    b: req.tetraplets[1],
+                    c: req.tetraplets[2],
+                    d: req.tetraplets[3],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.concat(req.args[0], req.args[1], req.args[2], req.args[3], callParams);
+        }
+
+        if (req.fnName === 'concat_strings') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    a: req.tetraplets[0],
+                    b: req.tetraplets[1],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.concat_strings(req.args[0], req.args[1], callParams);
+        }
+
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.identity(req.args[0], callParams);
+        }
+
+        if (req.fnName === 'noop') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            service.noop(callParams);
+            resp.result = {};
+        }
+
+        if (req.fnName === 'sha256_string') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.sha256_string(req.args[0], callParams);
+        }
+
+        if (req.fnName === 'string_from_b58') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    b: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.string_from_b58(req.args[0], callParams);
+        }
+
+        if (req.fnName === 'string_to_b58') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.string_to_b58(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
+
+export interface MyExportSrvDef {
+    another_str: (callParams: CallParams<null>) => string;
+}
+
+export function registerMyExportSrv(service: MyExportSrvDef): void;
+export function registerMyExportSrv(serviceId: string, service: MyExportSrvDef): void;
+export function registerMyExportSrv(peer: FluencePeer, service: MyExportSrvDef): void;
+export function registerMyExportSrv(peer: FluencePeer, serviceId: string, service: MyExportSrvDef): void;
+export function registerMyExportSrv(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'my_export_srv';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'another_str') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.another_str(callParams);
+        }
+
+        next();
+    });
+}
+
+// Functions
+
+export function some_str(config?: { ttl?: number }): Promise<string>;
+export function some_str(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function some_str(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") ["some_string_func"])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for some_str');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function some_string(config?: { ttl?: number }): Promise<string>;
+export function some_string(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function some_string(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") ["some_string_func"])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for some_string');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function decl_foo(config?: { ttl?: number }): Promise<string>;
+export function decl_foo(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function decl_foo(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+   (call %init_peer_id% ("super_foo" "small_foo") [] res1)
+  )
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") [res1])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for decl_foo');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function decl_bar(config?: { ttl?: number }): Promise<string>;
+export function decl_bar(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function decl_bar(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") ["declare all bar"])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for decl_bar');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function some_random_func(config?: { ttl?: number }): Promise<string>;
+export function some_random_func(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function some_random_func(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") ["wow, so random"])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for some_random_func');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}

src/compiled/examples/imports_exports/imports.ts

@@ -6,31 +6,95 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//StringService
+export interface StringServiceDef {
-//defaultId = "string_service"
+    concat: (a: string, b: string, callParams: CallParams<'a' | 'b'>) => string;
+}
 
-//concat: (a: string, b: string) => string
+export function registerStringService(service: StringServiceDef): void;
-//END StringService
+export function registerStringService(serviceId: string, service: StringServiceDef): void;
+export function registerStringService(peer: FluencePeer, service: StringServiceDef): void;
+export function registerStringService(peer: FluencePeer, serviceId: string, service: StringServiceDef): void;
+export function registerStringService(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'string_service';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'concat') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    a: req.tetraplets[0],
+                    b: req.tetraplets[1],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.concat(req.args[0], req.args[1], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function concat_foobars(client: FluenceClient, config?: {ttl?: number}): Promise<string> {
+export function concat_foobars(config?: { ttl?: number }): Promise<string>;
+export function concat_foobars(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function concat_foobars(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -62,20 +126,19 @@ export async function concat_foobars(client: FluenceClient, config?: {ttl?: numb
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -83,13 +146,12 @@ export async function concat_foobars(client: FluenceClient, config?: {ttl?: numb
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for concat_foobars');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/imports_exports/subImport.ts

@@ -6,31 +6,94 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//SubService
+export interface SubServiceDef {
-//defaultId = "sub_service"
+    sub: (s: string, callParams: CallParams<'s'>) => { one: string; two: number };
+}
 
-//sub: (s: string) => {one:string;two:number}
+export function registerSubService(service: SubServiceDef): void;
-//END SubService
+export function registerSubService(serviceId: string, service: SubServiceDef): void;
+export function registerSubService(peer: FluencePeer, service: SubServiceDef): void;
+export function registerSubService(peer: FluencePeer, serviceId: string, service: SubServiceDef): void;
+export function registerSubService(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'sub_service';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'sub') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.sub(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function subImport(client: FluenceClient, config?: {ttl?: number}): Promise<{one:string;two:number}> {
+export function subImport(config?: { ttl?: number }): Promise<{ one: string; two: number }>;
+export function subImport(peer: FluencePeer, config?: { ttl?: number }): Promise<{ one: string; two: number }>;
+export function subImport(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
-    const promise = new Promise<{one:string;two:number}>((resolve, reject) => {
+    const promise = new Promise<{ one: string; two: number }>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -44,20 +107,19 @@ export async function subImport(client: FluenceClient, config?: {ttl?: number}):
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -65,13 +127,12 @@ export async function subImport(client: FluenceClient, config?: {ttl?: number}):
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for subImport');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/multiReturn.ts

@@ -6,40 +6,147 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//GetStr
+export interface GetStrDef {
-//defaultId = "multiret-test"
+    retStr: (arg0: string, callParams: CallParams<'arg0'>) => string;
+}
 
-//retStr: (arg0: string) => string
+export function registerGetStr(service: GetStrDef): void;
-//END GetStr
+export function registerGetStr(serviceId: string, service: GetStrDef): void;
+export function registerGetStr(peer: FluencePeer, service: GetStrDef): void;
+export function registerGetStr(peer: FluencePeer, serviceId: string, service: GetStrDef): void;
+export function registerGetStr(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'multiret-test';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
 
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
 
-//GetNum
+        if (req.fnName === 'retStr') {
-//defaultId = "multiret-num"
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.retStr(req.args[0], callParams);
+        }
 
-//retNum: () => number
+        next();
-//END GetNum
+    });
+}
 
+export interface GetNumDef {
+    retNum: (callParams: CallParams<null>) => number;
+}
 
+export function registerGetNum(service: GetNumDef): void;
+export function registerGetNum(serviceId: string, service: GetNumDef): void;
+export function registerGetNum(peer: FluencePeer, service: GetNumDef): void;
+export function registerGetNum(peer: FluencePeer, serviceId: string, service: GetNumDef): void;
+export function registerGetNum(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'multiret-num';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'retNum') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.retNum(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function tupleFunc(client: FluenceClient, config?: {ttl?: number}): Promise<[string, number]> {
+export function tupleFunc(config?: { ttl?: number }): Promise<[string, number]>;
+export function tupleFunc(peer: FluencePeer, config?: { ttl?: number }): Promise<[string, number]>;
+export function tupleFunc(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<[string, number]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -56,21 +163,20 @@ export async function tupleFunc(client: FluenceClient, config?: {ttl?: number}):
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-   let opt: any = args;
+                    let opt: any = args;
 
- return resolve(opt);
+                    return resolve(opt);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -78,26 +184,51 @@ export async function tupleFunc(client: FluenceClient, config?: {ttl?: number}):
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for tupleFunc');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function multiReturnFunc(
+    somethingToReturn: number[],
+    smthOption: string | null,
+    config?: { ttl?: number },
+): Promise<[string[], number, string, number[], string | null, number]>;
+export function multiReturnFunc(
+    peer: FluencePeer,
+    somethingToReturn: number[],
+    smthOption: string | null,
+    config?: { ttl?: number },
+): Promise<[string[], number, string, number[], string | null, number]>;
+export function multiReturnFunc(...args) {
+    let peer: FluencePeer;
+    let somethingToReturn;
+    let smthOption;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        somethingToReturn = args[1];
+        smthOption = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        somethingToReturn = args[0];
+        smthOption = args[1];
+        config = args[2];
+    }
 
-
-export async function multiReturnFunc(client: FluenceClient, somethingToReturn: number[], smthOption: string | null, config?: {ttl?: number}): Promise<[string[], number, string, number[], string | null, number]> {
     let request: RequestFlow;
     const promise = new Promise<[string[], number, string, number[], string | null, number]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -129,26 +260,32 @@ export async function multiReturnFunc(client: FluenceClient, somethingToReturn:
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'somethingToReturn', () => {
+                    return somethingToReturn;
+                });
+                h.on('getDataSrv', 'smthOption', () => {
+                    return smthOption === null ? [] : [smthOption];
                 });
-                h.on('getDataSrv', 'somethingToReturn', () => {return somethingToReturn;});
-h.on('getDataSrv', 'smthOption', () => {return smthOption === null ? [] : [smthOption];});
                 h.onEvent('callbackSrv', 'response', (args) => {
-   let opt: any = args;
+                    let opt: any = args;
 
-  if(Array.isArray(opt[4])) {
+                    if (Array.isArray(opt[4])) {
-     if (opt[4].length === 0) { opt[4] = null; }
+                        if (opt[4].length === 0) {
-     else {opt[4] = opt[4][0]; }
+                            opt[4] = null;
-  }
+                        } else {
- return resolve(opt);
+                            opt[4] = opt[4][0];
-});
+                        }
+                    }
+                    return resolve(opt);
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -156,13 +293,12 @@ h.on('getDataSrv', 'smthOption', () => {return smthOption === null ? [] : [smthO
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for multiReturnFunc');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/nestedFuncs.ts

@@ -6,31 +6,96 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//OpH
+export interface OpHDef {
-//defaultId = "opa"
+    identity: (s: string, callParams: CallParams<'s'>) => string;
+}
 
-//identity: (s: string) => string
+export function registerOpH(service: OpHDef): void;
-//END OpH
+export function registerOpH(serviceId: string, service: OpHDef): void;
+export function registerOpH(peer: FluencePeer, service: OpHDef): void;
+export function registerOpH(peer: FluencePeer, serviceId: string, service: OpHDef): void;
+export function registerOpH(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'opa';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.identity(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function a(client: FluenceClient, b: string, config?: {ttl?: number}): Promise<string> {
+export function a(b: string, config?: { ttl?: number }): Promise<string>;
+export function a(peer: FluencePeer, b: string, config?: { ttl?: number }): Promise<string>;
+export function a(...args) {
+    let peer: FluencePeer;
+    let b;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        b = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        b = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -47,20 +112,21 @@ export async function a(client: FluenceClient, b: string, config?: {ttl?: number
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'b', () => {
+                    return b;
                 });
-                h.on('getDataSrv', 'b', () => {return b;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -68,26 +134,39 @@ export async function a(client: FluenceClient, b: string, config?: {ttl?: number
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for a');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function d(e: string, config?: { ttl?: number }): Promise<string>;
+export function d(peer: FluencePeer, e: string, config?: { ttl?: number }): Promise<string>;
+export function d(...args) {
+    let peer: FluencePeer;
+    let e;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        e = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        e = args[0];
+        config = args[1];
+    }
 
-
-export async function d(client: FluenceClient, e: string, config?: {ttl?: number}): Promise<string> {
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -104,20 +183,21 @@ export async function d(client: FluenceClient, e: string, config?: {ttl?: number
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'e', () => {
+                    return e;
                 });
-                h.on('getDataSrv', 'e', () => {return e;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -125,13 +205,12 @@ export async function d(client: FluenceClient, e: string, config?: {ttl?: number
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for d');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/new-api-full.ts

@@ -0,0 +1,600 @@
+/**
+ *
+ * This file is auto-generated. Do not edit manually: changes may be erased.
+ * Generated by Aqua compiler: https://github.com/fluencelabs/aqua/.
+ * If you find any bugs, please write an issue on GitHub: https://github.com/fluencelabs/aqua/issues
+ * Aqua version: 0.3.0-SNAPSHOT
+ *
+ */
+import { FluencePeer } from '@fluencelabs/fluence';
+import {
+    ResultCodes,
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
+
+// Services
+
+export interface ServiceWithDefaultIdDef {
+    hello: (s: string, callParams: CallParams<'s'>) => void;
+}
+
+export function registerServiceWithDefaultId(service: ServiceWithDefaultIdDef): void;
+export function registerServiceWithDefaultId(serviceId: string, service: ServiceWithDefaultIdDef): void;
+export function registerServiceWithDefaultId(peer: FluencePeer, service: ServiceWithDefaultIdDef): void;
+export function registerServiceWithDefaultId(
+    peer: FluencePeer,
+    serviceId: string,
+    service: ServiceWithDefaultIdDef,
+): void;
+export function registerServiceWithDefaultId(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'defaultId';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'hello') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.hello(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
+
+export interface ServiceWithOUTDefaultIdDef {
+    hello: (s: string, callParams: CallParams<'s'>) => void;
+}
+
+export function registerServiceWithOUTDefaultId(serviceId: string, service: ServiceWithOUTDefaultIdDef): void;
+export function registerServiceWithOUTDefaultId(
+    peer: FluencePeer,
+    serviceId: string,
+    service: ServiceWithOUTDefaultIdDef,
+): void;
+export function registerServiceWithOUTDefaultId(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'hello') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.hello(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
+
+export interface MoreMembersDef {
+    member1: (callParams: CallParams<null>) => void;
+    member2: (s1: string, callParams: CallParams<'s1'>) => void;
+    member3: (s1: string, s2: string, callParams: CallParams<'s1' | 's2'>) => void;
+    member4: (s1: string, s2: string, i: number, callParams: CallParams<'s1' | 's2' | 'i'>) => number;
+    member5: (s1: string, s2: string, i: number, callParams: CallParams<'s1' | 's2' | 'i'>) => number;
+}
+
+export function registerMoreMembers(serviceId: string, service: MoreMembersDef): void;
+export function registerMoreMembers(peer: FluencePeer, serviceId: string, service: MoreMembersDef): void;
+export function registerMoreMembers(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'member1') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            service.member1(callParams);
+            resp.result = {};
+        }
+
+        if (req.fnName === 'member2') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s1: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.member2(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        if (req.fnName === 'member3') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s1: req.tetraplets[0],
+                    s2: req.tetraplets[1],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.member3(req.args[0], req.args[1], callParams);
+            resp.result = {};
+        }
+
+        if (req.fnName === 'member4') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s1: req.tetraplets[0],
+                    s2: req.tetraplets[1],
+                    i: req.tetraplets[2],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.member4(req.args[0], req.args[1], req.args[2], callParams);
+        }
+
+        if (req.fnName === 'member5') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s1: req.tetraplets[0],
+                    s2: req.tetraplets[1],
+                    i: req.tetraplets[2],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.member5(req.args[0], req.args[1], req.args[2], callParams);
+        }
+
+        next();
+    });
+}
+
+// Functions
+
+export function f1(
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function f1(
+    peer: FluencePeer,
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function f1(...args) {
+    let peer: FluencePeer;
+    let callback;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        callback = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        callback = args[0];
+        config = args[1];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<void>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+  (xor
+   (call %init_peer_id% ("callbackSrv" "callback") ["hello, world" 42])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'callback') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                                arg1: req.tetraplets[1],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        callback(req.args[0], req.args[1], callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for f1');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return Promise.race([promise, Promise.resolve()]);
+}
+
+export function f2(
+    num: number,
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function f2(
+    peer: FluencePeer,
+    num: number,
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function f2(...args) {
+    let peer: FluencePeer;
+    let num;
+    let callback;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        num = args[1];
+        callback = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        num = args[0];
+        callback = args[1];
+        config = args[2];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<void>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+   (call %init_peer_id% ("getDataSrv" "num") [] num)
+  )
+  (xor
+   (call %init_peer_id% ("callbackSrv" "callback") ["hello, world" 42])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'num', () => {
+                    return num;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'callback') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                                arg1: req.tetraplets[1],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        callback(req.args[0], req.args[1], callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for f2');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return Promise.race([promise, Promise.resolve()]);
+}
+
+export function f3(
+    num: number,
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<string>;
+export function f3(
+    peer: FluencePeer,
+    num: number,
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<string>;
+export function f3(...args) {
+    let peer: FluencePeer;
+    let num;
+    let callback;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        num = args[1];
+        callback = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        num = args[0];
+        callback = args[1];
+        config = args[2];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<string>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (seq
+   (seq
+    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+    (call %init_peer_id% ("getDataSrv" "num") [] num)
+   )
+   (xor
+    (call %init_peer_id% ("callbackSrv" "callback") ["hello, world" 42])
+    (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+   )
+  )
+  (xor
+   (call %init_peer_id% ("callbackSrv" "response") ["hello world"])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'num', () => {
+                    return num;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'callback') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                                arg1: req.tetraplets[1],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        callback(req.args[0], req.args[1], callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {
+                    const [res] = args;
+                    resolve(res);
+                });
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for f3');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return promise;
+}
+
+export function callBackZeroArgs(
+    callback: (callParams: CallParams<null>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function callBackZeroArgs(
+    peer: FluencePeer,
+    callback: (callParams: CallParams<null>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function callBackZeroArgs(...args) {
+    let peer: FluencePeer;
+    let callback;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        callback = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        callback = args[0];
+        config = args[1];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<void>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+  (xor
+   (call %init_peer_id% ("callbackSrv" "callback") [])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'callback') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {},
+                        };
+                        resp.retCode = ResultCodes.success;
+                        callback(callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for callBackZeroArgs');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return Promise.race([promise, Promise.resolve()]);
+}

src/compiled/examples/new-api.ts

@@ -0,0 +1,168 @@
+/**
+ *
+ * This file is auto-generated. Do not edit manually: changes may be erased.
+ * Generated by Aqua compiler: https://github.com/fluencelabs/aqua/.
+ * If you find any bugs, please write an issue on GitHub: https://github.com/fluencelabs/aqua/issues
+ * Aqua version: 0.3.0-SNAPSHOT
+ *
+ */
+import { FluencePeer } from '@fluencelabs/fluence';
+import {
+    ResultCodes,
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
+
+// Services
+
+export interface HelloWorldDef {
+    getNumber: (callParams: CallParams<null>) => number;
+    sayHello: (s: string, callParams: CallParams<'s'>) => void;
+}
+
+export function registerHelloWorld(service: HelloWorldDef): void;
+export function registerHelloWorld(serviceId: string, service: HelloWorldDef): void;
+export function registerHelloWorld(peer: FluencePeer, service: HelloWorldDef): void;
+export function registerHelloWorld(peer: FluencePeer, serviceId: string, service: HelloWorldDef): void;
+export function registerHelloWorld(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'default';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'getNumber') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getNumber(callParams);
+        }
+
+        if (req.fnName === 'sayHello') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.sayHello(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
+
+// Functions
+
+export function callMeBack(
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function callMeBack(
+    peer: FluencePeer,
+    callback: (arg0: string, arg1: number, callParams: CallParams<'arg0' | 'arg1'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function callMeBack(...args) {
+    let peer: FluencePeer;
+    let callback;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        callback = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        callback = args[0];
+        config = args[1];
+    }
+
+    let request: RequestFlow;
+    const promise = new Promise<void>((resolve, reject) => {
+        const r = new RequestFlowBuilder()
+            .disableInjections()
+            .withRawScript(
+                `
+     (xor
+ (seq
+  (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
+  (xor
+   (call %init_peer_id% ("callbackSrv" "callback") ["hello, world" 42])
+   (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
+  )
+ )
+ (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
+)
+
+                 `,
+            )
+            .configHandler((h) => {
+                h.on('getDataSrv', '-relay-', () => {
+                    return peer.connectionInfo.connectedRelay;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'callback') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                                arg1: req.tetraplets[1],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        callback(req.args[0], req.args[1], callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
+
+                h.onEvent('errorHandlingSrv', 'error', (args) => {
+                    const [err] = args;
+                    reject(err);
+                });
+            })
+            .handleScriptError(reject)
+            .handleTimeout(() => {
+                reject('Request timed out for callMeBack');
+            });
+        if (config && config.ttl) {
+            r.withTTL(config.ttl);
+        }
+        request = r.build();
+    });
+    peer.internals.initiateFlow(request!);
+    return Promise.race([promise, Promise.resolve()]);
+}

src/compiled/examples/on.ts

@@ -6,24 +6,45 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-
 // Functions
 
-export async function getPeerExternalAddresses(client: FluenceClient, otherNodePeerId: string, config?: {ttl?: number}): Promise<string[]> {
+export function getPeerExternalAddresses(otherNodePeerId: string, config?: { ttl?: number }): Promise<string[]>;
+export function getPeerExternalAddresses(
+    peer: FluencePeer,
+    otherNodePeerId: string,
+    config?: { ttl?: number },
+): Promise<string[]>;
+export function getPeerExternalAddresses(...args) {
+    let peer: FluencePeer;
+    let otherNodePeerId;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        otherNodePeerId = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        otherNodePeerId = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -52,20 +73,21 @@ export async function getPeerExternalAddresses(client: FluenceClient, otherNodeP
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'otherNodePeerId', () => {
+                    return otherNodePeerId;
                 });
-                h.on('getDataSrv', 'otherNodePeerId', () => {return otherNodePeerId;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -73,26 +95,47 @@ export async function getPeerExternalAddresses(client: FluenceClient, otherNodeP
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for getPeerExternalAddresses');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function getDistantAddresses(target: string, viaNode: string, config?: { ttl?: number }): Promise<string[]>;
+export function getDistantAddresses(
+    peer: FluencePeer,
+    target: string,
+    viaNode: string,
+    config?: { ttl?: number },
+): Promise<string[]>;
+export function getDistantAddresses(...args) {
+    let peer: FluencePeer;
+    let target;
+    let viaNode;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        target = args[1];
+        viaNode = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        target = args[0];
+        viaNode = args[1];
+        config = args[2];
+    }
 
-
-export async function getDistantAddresses(client: FluenceClient, target: string, viaNode: string, config?: {ttl?: number}): Promise<string[]> {
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -136,21 +179,24 @@ export async function getDistantAddresses(client: FluenceClient, target: string,
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'target', () => {
+                    return target;
+                });
+                h.on('getDataSrv', 'viaNode', () => {
+                    return viaNode;
                 });
-                h.on('getDataSrv', 'target', () => {return target;});
-h.on('getDataSrv', 'viaNode', () => {return viaNode;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -158,13 +204,12 @@ h.on('getDataSrv', 'viaNode', () => {return viaNode;});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for getDistantAddresses');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/option.ts

@@ -6,33 +6,118 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//SomeS
+export interface SomeSDef {
-//defaultId = "test2"
+    getStr: (arg0: string | null, callParams: CallParams<'arg0'>) => string | null;
+    getStr1: (callParams: CallParams<null>) => string | null;
+    getStr2: (arg0: string, callParams: CallParams<'arg0'>) => string;
+}
 
-//getStr: (arg0: string | null) => string | null
+export function registerSomeS(service: SomeSDef): void;
-//getStr1: () => string | null
+export function registerSomeS(serviceId: string, service: SomeSDef): void;
-//getStr2: (arg0: string) => string
+export function registerSomeS(peer: FluencePeer, service: SomeSDef): void;
-//END SomeS
+export function registerSomeS(peer: FluencePeer, serviceId: string, service: SomeSDef): void;
+export function registerSomeS(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'test2';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'getStr') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getStr(req.args[0], callParams);
+        }
+
+        if (req.fnName === 'getStr1') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getStr1(callParams);
+        }
+
+        if (req.fnName === 'getStr2') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getStr2(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function useOptional(client: FluenceClient, opt: string | null, config?: {ttl?: number}): Promise<string> {
+export function useOptional(opt: string | null, config?: { ttl?: number }): Promise<string>;
+export function useOptional(peer: FluencePeer, opt: string | null, config?: { ttl?: number }): Promise<string>;
+export function useOptional(...args) {
+    let peer: FluencePeer;
+    let opt;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        opt = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        opt = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -57,20 +142,21 @@ export async function useOptional(client: FluenceClient, opt: string | null, con
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'opt', () => {
+                    return opt === null ? [] : [opt];
                 });
-                h.on('getDataSrv', 'opt', () => {return opt === null ? [] : [opt];});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -78,26 +164,37 @@ export async function useOptional(client: FluenceClient, opt: string | null, con
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for useOptional');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function returnOptional(config?: { ttl?: number }): Promise<string | null>;
+export function returnOptional(peer: FluencePeer, config?: { ttl?: number }): Promise<string | null>;
+export function returnOptional(...args) {
+    let peer: FluencePeer;
 
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
 
-export async function returnOptional(client: FluenceClient, config?: {ttl?: number}): Promise<string | null> {
     let request: RequestFlow;
     const promise = new Promise<string | null>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -111,24 +208,25 @@ export async function returnOptional(client: FluenceClient, config?: {ttl?: numb
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    let [opt] = args;
+                    let [opt] = args;
-  if (Array.isArray(opt)) {
+                    if (Array.isArray(opt)) {
-      if (opt.length === 0) { resolve(null); }
+                        if (opt.length === 0) {
-      opt = opt[0];
+                            resolve(null);
-  }          
+                        }
-  return resolve(opt);
+                        opt = opt[0];
-});
+                    }
+                    return resolve(opt);
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -136,26 +234,37 @@ export async function returnOptional(client: FluenceClient, config?: {ttl?: numb
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for returnOptional');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function returnNone(config?: { ttl?: number }): Promise<string | null>;
+export function returnNone(peer: FluencePeer, config?: { ttl?: number }): Promise<string | null>;
+export function returnNone(...args) {
+    let peer: FluencePeer;
 
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
 
-export async function returnNone(client: FluenceClient, config?: {ttl?: number}): Promise<string | null> {
     let request: RequestFlow;
     const promise = new Promise<string | null>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -169,24 +278,25 @@ export async function returnNone(client: FluenceClient, config?: {ttl?: number})
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    let [opt] = args;
+                    let [opt] = args;
-  if (Array.isArray(opt)) {
+                    if (Array.isArray(opt)) {
-      if (opt.length === 0) { resolve(null); }
+                        if (opt.length === 0) {
-      opt = opt[0];
+                            resolve(null);
-  }          
+                        }
-  return resolve(opt);
+                        opt = opt[0];
-});
+                    }
+                    return resolve(opt);
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -194,13 +304,12 @@ export async function returnNone(client: FluenceClient, config?: {ttl?: number})
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for returnNone');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/par.ts

@@ -6,31 +6,106 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//ParService
+export interface ParServiceDef {
-//defaultId = "parservice-id"
+    call: (callParams: CallParams<null>) => string;
+}
 
-//call: () => string
+export function registerParService(service: ParServiceDef): void;
-//END ParService
+export function registerParService(serviceId: string, service: ParServiceDef): void;
+export function registerParService(peer: FluencePeer, service: ParServiceDef): void;
+export function registerParService(peer: FluencePeer, serviceId: string, service: ParServiceDef): void;
+export function registerParService(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'parservice-id';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'call') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.call(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function parFunc(client: FluenceClient, node: string, c: (arg0: {external_addresses:string[]}) => void, config?: {ttl?: number}): Promise<void> {
+export function parFunc(
+    node: string,
+    c: (arg0: { external_addresses: string[] }, callParams: CallParams<'arg0'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function parFunc(
+    peer: FluencePeer,
+    node: string,
+    c: (arg0: { external_addresses: string[] }, callParams: CallParams<'arg0'>) => void,
+    config?: { ttl?: number },
+): Promise<void>;
+export function parFunc(...args) {
+    let peer: FluencePeer;
+    let node;
+    let c;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node = args[1];
+        c = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        node = args[0];
+        c = args[1];
+        config = args[2];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -62,17 +137,34 @@ export async function parFunc(client: FluenceClient, node: string, c: (arg0: {ex
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'node', () => {return node;});
+                h.on('getDataSrv', 'node', () => {
-h.on('callbackSrv', 'c', (args) => {c(args[0]); return {};});
+                    return node;
+                });
+
+                h.use((req, resp, next) => {
+                    if (req.serviceId === 'callbackSrv' && req.fnName === 'c') {
+                        const callParams = {
+                            ...req.particleContext,
+                            tetraplets: {
+                                arg0: req.tetraplets[0],
+                            },
+                        };
+                        resp.retCode = ResultCodes.success;
+                        c(req.args[0], callParams);
+                        resp.result = {};
+                    }
+                    next();
+                });
+
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -80,13 +172,12 @@ h.on('callbackSrv', 'c', (args) => {c(args[0]); return {};});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for parFunc');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/passArgs.ts

@@ -6,31 +6,120 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//AquaDHT
+export interface AquaDHTDef {
-//defaultId = "test-dht"
+    put_host_value: (
+        key: string,
+        value: string,
+        service_id: string[],
+        callParams: CallParams<'key' | 'value' | 'service_id'>,
+    ) => string;
+}
 
-//put_host_value: (key: string, value: string, service_id: string[]) => string
+export function registerAquaDHT(service: AquaDHTDef): void;
-//END AquaDHT
+export function registerAquaDHT(serviceId: string, service: AquaDHTDef): void;
+export function registerAquaDHT(peer: FluencePeer, service: AquaDHTDef): void;
+export function registerAquaDHT(peer: FluencePeer, serviceId: string, service: AquaDHTDef): void;
+export function registerAquaDHT(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'test-dht';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'put_host_value') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    key: req.tetraplets[0],
+                    value: req.tetraplets[1],
+                    service_id: req.tetraplets[2],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.put_host_value(req.args[0], req.args[1], req.args[2], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function putHostValue(client: FluenceClient, key: string, value: string, service_id: string | null, config?: {ttl?: number}): Promise<string> {
+export function putHostValue(
+    key: string,
+    value: string,
+    service_id: string | null,
+    config?: { ttl?: number },
+): Promise<string>;
+export function putHostValue(
+    peer: FluencePeer,
+    key: string,
+    value: string,
+    service_id: string | null,
+    config?: { ttl?: number },
+): Promise<string>;
+export function putHostValue(...args) {
+    let peer: FluencePeer;
+    let key;
+    let value;
+    let service_id;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        key = args[1];
+        value = args[2];
+        service_id = args[3];
+        config = args[4];
+    } else {
+        peer = FluencePeer.default;
+        key = args[0];
+        value = args[1];
+        service_id = args[2];
+        config = args[3];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -53,22 +142,27 @@ export async function putHostValue(client: FluenceClient, key: string, value: st
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'key', () => {
+                    return key;
+                });
+                h.on('getDataSrv', 'value', () => {
+                    return value;
+                });
+                h.on('getDataSrv', 'service_id', () => {
+                    return service_id === null ? [] : [service_id];
                 });
-                h.on('getDataSrv', 'key', () => {return key;});
-h.on('getDataSrv', 'value', () => {return value;});
-h.on('getDataSrv', 'service_id', () => {return service_id === null ? [] : [service_id];});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -76,26 +170,39 @@ h.on('getDataSrv', 'service_id', () => {return service_id === null ? [] : [servi
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for putHostValue');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function create_client_util(service_id: string, config?: { ttl?: number }): Promise<string>;
+export function create_client_util(peer: FluencePeer, service_id: string, config?: { ttl?: number }): Promise<string>;
+export function create_client_util(...args) {
+    let peer: FluencePeer;
+    let service_id;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        service_id = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        service_id = args[0];
+        config = args[1];
+    }
 
-
-export async function create_client_util(client: FluenceClient, service_id: string, config?: {ttl?: number}): Promise<string> {
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -112,20 +219,21 @@ export async function create_client_util(client: FluenceClient, service_id: stri
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'service_id', () => {
+                    return service_id;
                 });
-                h.on('getDataSrv', 'service_id', () => {return service_id;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -133,13 +241,12 @@ export async function create_client_util(client: FluenceClient, service_id: stri
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for create_client_util');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/println.ts

@@ -6,31 +6,97 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Println
+export interface PrintlnDef {
-//defaultId = "println-service-id"
+    print: (arg0: string, callParams: CallParams<'arg0'>) => void;
+}
 
-//print: (arg0: string) => void
+export function registerPrintln(service: PrintlnDef): void;
-//END Println
+export function registerPrintln(serviceId: string, service: PrintlnDef): void;
+export function registerPrintln(peer: FluencePeer, service: PrintlnDef): void;
+export function registerPrintln(peer: FluencePeer, serviceId: string, service: PrintlnDef): void;
+export function registerPrintln(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'println-service-id';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'print') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.print(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function print(client: FluenceClient, str: string, config?: {ttl?: number}): Promise<void> {
+export function print(str: string, config?: { ttl?: number }): Promise<void>;
+export function print(peer: FluencePeer, str: string, config?: { ttl?: number }): Promise<void>;
+export function print(...args) {
+    let peer: FluencePeer;
+    let str;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        str = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        str = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
@@ -41,16 +107,18 @@ export async function print(client: FluenceClient, str: string, config?: {ttl?:
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'str', () => {return str;});
+                h.on('getDataSrv', 'str', () => {
+                    return str;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -58,13 +126,12 @@ export async function print(client: FluenceClient, str: string, config?: {ttl?:
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for print');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
-      

src/compiled/examples/pushToStream.ts

@@ -6,31 +6,92 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//OpA
+export interface OpADef {
-//defaultId = "pop"
+    get_str: (callParams: CallParams<null>) => string;
+}
 
-//get_str: () => string
+export function registerOpA(service: OpADef): void;
-//END OpA
+export function registerOpA(serviceId: string, service: OpADef): void;
+export function registerOpA(peer: FluencePeer, service: OpADef): void;
+export function registerOpA(peer: FluencePeer, serviceId: string, service: OpADef): void;
+export function registerOpA(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'pop';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'get_str') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.get_str(callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function get_results(client: FluenceClient, config?: {ttl?: number}): Promise<string[]> {
+export function get_results(config?: { ttl?: number }): Promise<string[]>;
+export function get_results(peer: FluencePeer, config?: { ttl?: number }): Promise<string[]>;
+export function get_results(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -50,20 +111,19 @@ export async function get_results(client: FluenceClient, config?: {ttl?: number}
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -71,13 +131,12 @@ export async function get_results(client: FluenceClient, config?: {ttl?: number}
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for get_results');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/returnLiteral.ts

@@ -6,24 +6,39 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-
 // Functions
 
-export async function returnLiteral(client: FluenceClient, config?: {ttl?: number}): Promise<string> {
+export function returnLiteral(config?: { ttl?: number }): Promise<string>;
+export function returnLiteral(peer: FluencePeer, config?: { ttl?: number }): Promise<string>;
+export function returnLiteral(...args) {
+    let peer: FluencePeer;
+
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        config = args[1];
+    } else {
+        peer = FluencePeer.default;
+        config = args[0];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (call %init_peer_id% ("getDataSrv" "-relay-") [] -relay-)
   (xor
@@ -34,20 +49,19 @@ export async function returnLiteral(client: FluenceClient, config?: {ttl?: numbe
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
 
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -55,13 +69,12 @@ export async function returnLiteral(client: FluenceClient, config?: {ttl?: numbe
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for returnLiteral');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/stream.ts

@@ -6,31 +6,96 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Stringer
+export interface StringerDef {
-//defaultId = "stringer-id"
+    returnString: (arg0: string, callParams: CallParams<'arg0'>) => string;
+}
 
-//returnString: (arg0: string) => string
+export function registerStringer(service: StringerDef): void;
-//END Stringer
+export function registerStringer(serviceId: string, service: StringerDef): void;
+export function registerStringer(peer: FluencePeer, service: StringerDef): void;
+export function registerStringer(peer: FluencePeer, serviceId: string, service: StringerDef): void;
+export function registerStringer(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'stringer-id';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'returnString') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.returnString(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function checkStreams(client: FluenceClient, ch: string[], config?: {ttl?: number}): Promise<string[]> {
+export function checkStreams(ch: string[], config?: { ttl?: number }): Promise<string[]>;
+export function checkStreams(peer: FluencePeer, ch: string[], config?: { ttl?: number }): Promise<string[]>;
+export function checkStreams(...args) {
+    let peer: FluencePeer;
+    let ch;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        ch = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        ch = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -58,20 +123,21 @@ export async function checkStreams(client: FluenceClient, ch: string[], config?:
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'ch', () => {
+                    return ch;
                 });
-                h.on('getDataSrv', 'ch', () => {return ch;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -79,13 +145,12 @@ export async function checkStreams(client: FluenceClient, ch: string[], config?:
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for checkStreams');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/streamArgs.ts

@@ -6,31 +6,104 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//TestService
+export interface TestServiceDef {
-//defaultId = "test-service"
+    get_records: (key: string, callParams: CallParams<'key'>) => string[];
+}
 
-//get_records: (key: string) => string[]
+export function registerTestService(service: TestServiceDef): void;
-//END TestService
+export function registerTestService(serviceId: string, service: TestServiceDef): void;
+export function registerTestService(peer: FluencePeer, service: TestServiceDef): void;
+export function registerTestService(peer: FluencePeer, serviceId: string, service: TestServiceDef): void;
+export function registerTestService(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'test-service';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'get_records') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    key: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.get_records(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function append_records(client: FluenceClient, peer: string, srum: string[][], config?: {ttl?: number}): Promise<void> {
+export function append_records(peer_: string, srum: string[][], config?: { ttl?: number }): Promise<void>;
+export function append_records(
+    peer: FluencePeer,
+    peer_: string,
+    srum: string[][],
+    config?: { ttl?: number },
+): Promise<void>;
+export function append_records(...args) {
+    let peer: FluencePeer;
+    let peer_;
+    let srum;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        peer_ = args[1];
+        srum = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        peer_ = args[0];
+        srum = args[1];
+        config = args[2];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<void>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -52,17 +125,21 @@ export async function append_records(client: FluenceClient, peer: string, srum:
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 1])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
                 });
-                h.on('getDataSrv', 'peer', () => {return peer;});
+                h.on('getDataSrv', 'peer', () => {
-h.on('getDataSrv', 'srum', () => {return srum;});
+                    return peer_;
+                });
+                h.on('getDataSrv', 'srum', () => {
+                    return srum;
+                });
+                h.onEvent('callbackSrv', 'response', (args) => {});
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -70,26 +147,39 @@ h.on('getDataSrv', 'srum', () => {return srum;});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for append_records');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return Promise.race([promise, Promise.resolve()]);
 }
 
+export function retrieve_records(peer_: string, config?: { ttl?: number }): Promise<string[][]>;
+export function retrieve_records(peer: FluencePeer, peer_: string, config?: { ttl?: number }): Promise<string[][]>;
+export function retrieve_records(...args) {
+    let peer: FluencePeer;
+    let peer_;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        peer_ = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        peer_ = args[0];
+        config = args[1];
+    }
 
-
-export async function retrieve_records(client: FluenceClient, peer: string, config?: {ttl?: number}): Promise<string[][]> {
     let request: RequestFlow;
     const promise = new Promise<string[][]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -106,20 +196,21 @@ export async function retrieve_records(client: FluenceClient, peer: string, conf
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'peer', () => {
+                    return peer_;
                 });
-                h.on('getDataSrv', 'peer', () => {return peer;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -127,13 +218,12 @@ export async function retrieve_records(client: FluenceClient, peer: string, conf
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for retrieve_records');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/streamResults.ts

@@ -6,31 +6,96 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//DTGetter
+export interface DTGetterDef {
-//defaultId = "get-dt"
+    get_dt: (s: string, callParams: CallParams<'s'>) => { field: string };
+}
 
-//get_dt: (s: string) => {field:string}
+export function registerDTGetter(service: DTGetterDef): void;
-//END DTGetter
+export function registerDTGetter(serviceId: string, service: DTGetterDef): void;
+export function registerDTGetter(peer: FluencePeer, service: DTGetterDef): void;
+export function registerDTGetter(peer: FluencePeer, serviceId: string, service: DTGetterDef): void;
+export function registerDTGetter(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'get-dt';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'get_dt') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.get_dt(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function use_name1(client: FluenceClient, name: string, config?: {ttl?: number}): Promise<string> {
+export function use_name1(name: string, config?: { ttl?: number }): Promise<string>;
+export function use_name1(peer: FluencePeer, name: string, config?: { ttl?: number }): Promise<string>;
+export function use_name1(...args) {
+    let peer: FluencePeer;
+    let name;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        name = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        name = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -47,20 +112,21 @@ export async function use_name1(client: FluenceClient, name: string, config?: {t
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'name', () => {
+                    return name;
                 });
-                h.on('getDataSrv', 'name', () => {return name;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -68,26 +134,39 @@ export async function use_name1(client: FluenceClient, name: string, config?: {t
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for use_name1');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function use_name2(name: string, config?: { ttl?: number }): Promise<string[]>;
+export function use_name2(peer: FluencePeer, name: string, config?: { ttl?: number }): Promise<string[]>;
+export function use_name2(...args) {
+    let peer: FluencePeer;
+    let name;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        name = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        name = args[0];
+        config = args[1];
+    }
 
-
-export async function use_name2(client: FluenceClient, name: string, config?: {ttl?: number}): Promise<string[]> {
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -119,20 +198,21 @@ export async function use_name2(client: FluenceClient, name: string, config?: {t
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'name', () => {
+                    return name;
                 });
-                h.on('getDataSrv', 'name', () => {return name;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -140,13 +220,12 @@ export async function use_name2(client: FluenceClient, name: string, config?: {t
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for use_name2');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/subImportUsage.ts

@@ -6,31 +6,105 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//ConcatSubs
+export interface ConcatSubsDef {
-//defaultId = "concat_subs"
+    get_some: (
+        s: string,
+        sr: { one: string; two: number },
+        callParams: CallParams<'s' | 'sr'>,
+    ) => { one: string; two: number };
+}
 
-//get_some: (s: string, sr: {one:string;two:number}) => {one:string;two:number}
+export function registerConcatSubs(service: ConcatSubsDef): void;
-//END ConcatSubs
+export function registerConcatSubs(serviceId: string, service: ConcatSubsDef): void;
+export function registerConcatSubs(peer: FluencePeer, service: ConcatSubsDef): void;
+export function registerConcatSubs(peer: FluencePeer, serviceId: string, service: ConcatSubsDef): void;
+export function registerConcatSubs(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'concat_subs';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'get_some') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                    sr: req.tetraplets[1],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.get_some(req.args[0], req.args[1], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function subImportUsage(client: FluenceClient, s: string, config?: {ttl?: number}): Promise<{one:string;two:number}> {
+export function subImportUsage(s: string, config?: { ttl?: number }): Promise<{ one: string; two: number }>;
+export function subImportUsage(
+    peer: FluencePeer,
+    s: string,
+    config?: { ttl?: number },
+): Promise<{ one: string; two: number }>;
+export function subImportUsage(...args) {
+    let peer: FluencePeer;
+    let s;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        s = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        s = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
-    const promise = new Promise<{one:string;two:number}>((resolve, reject) => {
+    const promise = new Promise<{ one: string; two: number }>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -53,20 +127,21 @@ export async function subImportUsage(client: FluenceClient, s: string, config?:
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 2])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 's', () => {
+                    return s;
                 });
-                h.on('getDataSrv', 's', () => {return s;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -74,13 +149,12 @@ export async function subImportUsage(client: FluenceClient, s: string, config?:
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for subImportUsage');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/topology.ts

@@ -6,40 +6,174 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Testo
+export interface TestoDef {
-//defaultId = "testo"
+    getString: (arg0: string, callParams: CallParams<'arg0'>) => string;
+}
 
-//getString: (arg0: string) => string
+export function registerTesto(service: TestoDef): void;
-//END Testo
+export function registerTesto(serviceId: string, service: TestoDef): void;
+export function registerTesto(peer: FluencePeer, service: TestoDef): void;
+export function registerTesto(peer: FluencePeer, serviceId: string, service: TestoDef): void;
+export function registerTesto(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'testo';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
 
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
 
-//LocalPrint
+        if (req.fnName === 'getString') {
-//defaultId = "lp"
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getString(req.args[0], callParams);
+        }
 
-//print: (arg0: string) => void
+        next();
-//END LocalPrint
+    });
+}
 
+export interface LocalPrintDef {
+    print: (arg0: string, callParams: CallParams<'arg0'>) => void;
+}
 
+export function registerLocalPrint(service: LocalPrintDef): void;
+export function registerLocalPrint(serviceId: string, service: LocalPrintDef): void;
+export function registerLocalPrint(peer: FluencePeer, service: LocalPrintDef): void;
+export function registerLocalPrint(peer: FluencePeer, serviceId: string, service: LocalPrintDef): void;
+export function registerLocalPrint(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'lp';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'print') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    arg0: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            service.print(req.args[0], callParams);
+            resp.result = {};
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function topologyTest(client: FluenceClient, me: string, myRelay: string, friend: string, friendRelay: string, config?: {ttl?: number}): Promise<string> {
+export function topologyTest(
+    me: string,
+    myRelay: string,
+    friend: string,
+    friendRelay: string,
+    config?: { ttl?: number },
+): Promise<string>;
+export function topologyTest(
+    peer: FluencePeer,
+    me: string,
+    myRelay: string,
+    friend: string,
+    friendRelay: string,
+    config?: { ttl?: number },
+): Promise<string>;
+export function topologyTest(...args) {
+    let peer: FluencePeer;
+    let me;
+    let myRelay;
+    let friend;
+    let friendRelay;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        me = args[1];
+        myRelay = args[2];
+        friend = args[3];
+        friendRelay = args[4];
+        config = args[5];
+    } else {
+        peer = FluencePeer.default;
+        me = args[0];
+        myRelay = args[1];
+        friend = args[2];
+        friendRelay = args[3];
+        config = args[4];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -95,23 +229,30 @@ export async function topologyTest(client: FluenceClient, me: string, myRelay: s
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'me', () => {
+                    return me;
+                });
+                h.on('getDataSrv', 'myRelay', () => {
+                    return myRelay;
+                });
+                h.on('getDataSrv', 'friend', () => {
+                    return friend;
+                });
+                h.on('getDataSrv', 'friendRelay', () => {
+                    return friendRelay;
                 });
-                h.on('getDataSrv', 'me', () => {return me;});
-h.on('getDataSrv', 'myRelay', () => {return myRelay;});
-h.on('getDataSrv', 'friend', () => {return friend;});
-h.on('getDataSrv', 'friendRelay', () => {return friendRelay;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -119,13 +260,12 @@ h.on('getDataSrv', 'friendRelay', () => {return friendRelay;});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for topologyTest');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/tryCatch.ts

@@ -6,40 +6,149 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Unexisted
+export interface UnexistedDef {
-//defaultId = "unex"
+    getStr: (callParams: CallParams<null>) => string;
+}
 
-//getStr: () => string
+export function registerUnexisted(service: UnexistedDef): void;
-//END Unexisted
+export function registerUnexisted(serviceId: string, service: UnexistedDef): void;
+export function registerUnexisted(peer: FluencePeer, service: UnexistedDef): void;
+export function registerUnexisted(peer: FluencePeer, serviceId: string, service: UnexistedDef): void;
+export function registerUnexisted(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'unex';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
 
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
 
-//OpA
+        if (req.fnName === 'getStr') {
-//defaultId = "op"
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getStr(callParams);
+        }
 
-//identity: (s: string) => string
+        next();
-//END OpA
+    });
+}
 
+export interface OpADef {
+    identity: (s: string, callParams: CallParams<'s'>) => string;
+}
 
+export function registerOpA(service: OpADef): void;
+export function registerOpA(serviceId: string, service: OpADef): void;
+export function registerOpA(peer: FluencePeer, service: OpADef): void;
+export function registerOpA(peer: FluencePeer, serviceId: string, service: OpADef): void;
+export function registerOpA(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'op';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.identity(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function tryCatchTest(client: FluenceClient, node_id: string, config?: {ttl?: number}): Promise<string[]> {
+export function tryCatchTest(node_id: string, config?: { ttl?: number }): Promise<string[]>;
+export function tryCatchTest(peer: FluencePeer, node_id: string, config?: { ttl?: number }): Promise<string[]>;
+export function tryCatchTest(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string[]>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -77,20 +186,21 @@ export async function tryCatchTest(client: FluenceClient, node_id: string, confi
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
                 });
-                h.on('getDataSrv', 'node_id', () => {return node_id;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -98,13 +208,12 @@ export async function tryCatchTest(client: FluenceClient, node_id: string, confi
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for tryCatchTest');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/tryOtherwise.ts

@@ -6,40 +6,149 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//Unexisted
+export interface UnexistedDef {
-//defaultId = "unex"
+    getStr: (callParams: CallParams<null>) => string;
+}
 
-//getStr: () => string
+export function registerUnexisted(service: UnexistedDef): void;
-//END Unexisted
+export function registerUnexisted(serviceId: string, service: UnexistedDef): void;
+export function registerUnexisted(peer: FluencePeer, service: UnexistedDef): void;
+export function registerUnexisted(peer: FluencePeer, serviceId: string, service: UnexistedDef): void;
+export function registerUnexisted(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'unex';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
 
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
 
-//OpE
+        if (req.fnName === 'getStr') {
-//defaultId = "op"
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {},
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.getStr(callParams);
+        }
 
-//identity: (s: string) => string
+        next();
-//END OpE
+    });
+}
 
+export interface OpEDef {
+    identity: (s: string, callParams: CallParams<'s'>) => string;
+}
 
+export function registerOpE(service: OpEDef): void;
+export function registerOpE(serviceId: string, service: OpEDef): void;
+export function registerOpE(peer: FluencePeer, service: OpEDef): void;
+export function registerOpE(peer: FluencePeer, serviceId: string, service: OpEDef): void;
+export function registerOpE(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
+
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'op';
+    }
+
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'identity') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.identity(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function tryOtherwiseTest(client: FluenceClient, node_id: string, config?: {ttl?: number}): Promise<string> {
+export function tryOtherwiseTest(node_id: string, config?: { ttl?: number }): Promise<string>;
+export function tryOtherwiseTest(peer: FluencePeer, node_id: string, config?: { ttl?: number }): Promise<string>;
+export function tryOtherwiseTest(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        config = args[2];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        config = args[1];
+    }
+
     let request: RequestFlow;
     const promise = new Promise<string>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -71,20 +180,21 @@ export async function tryOtherwiseTest(client: FluenceClient, node_id: string, c
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
                 });
-                h.on('getDataSrv', 'node_id', () => {return node_id;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -92,13 +202,12 @@ export async function tryOtherwiseTest(client: FluenceClient, node_id: string, c
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for tryOtherwiseTest');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/compiled/examples/via.ts

@@ -6,31 +6,108 @@
  * Aqua version: 0.3.0-SNAPSHOT
  *
  */
-import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
+import { FluencePeer } from '@fluencelabs/fluence';
-import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
+import {
-import { RequestFlow } from '@fluencelabs/fluence/dist/internal/RequestFlow';
+    ResultCodes,
-
+    RequestFlow,
+    RequestFlowBuilder,
+    CallParams,
+} from '@fluencelabs/fluence/dist/internal/compilerSupport/v1';
 
 // Services
 
-//CustomId
+export interface CustomIdDef {
-//defaultId = "cid"
+    id: (s: string, callParams: CallParams<'s'>) => string;
+}
 
-//id: (s: string) => string
+export function registerCustomId(service: CustomIdDef): void;
-//END CustomId
+export function registerCustomId(serviceId: string, service: CustomIdDef): void;
+export function registerCustomId(peer: FluencePeer, service: CustomIdDef): void;
+export function registerCustomId(peer: FluencePeer, serviceId: string, service: CustomIdDef): void;
+export function registerCustomId(...args) {
+    let peer: FluencePeer;
+    let serviceId;
+    let service;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+    } else {
+        peer = FluencePeer.default;
+    }
 
+    if (typeof args[0] === 'string') {
+        serviceId = args[0];
+    } else if (typeof args[1] === 'string') {
+        serviceId = args[1];
+    } else {
+        serviceId = 'cid';
+    }
 
+    if (!(args[0] instanceof FluencePeer) && typeof args[0] === 'object') {
+        service = args[0];
+    } else if (typeof args[1] === 'object') {
+        service = args[1];
+    } else {
+        service = args[2];
+    }
+
+    peer.internals.callServiceHandler.use((req, resp, next) => {
+        if (req.serviceId !== serviceId) {
+            next();
+            return;
+        }
+
+        if (req.fnName === 'id') {
+            const callParams = {
+                ...req.particleContext,
+                tetraplets: {
+                    s: req.tetraplets[0],
+                },
+            };
+            resp.retCode = ResultCodes.success;
+            resp.result = service.id(req.args[0], callParams);
+        }
+
+        next();
+    });
+}
 
 // Functions
 
-export async function viaArr(client: FluenceClient, node_id: string, viaAr: string[], config?: {ttl?: number}): Promise<{external_addresses:string[]}> {
+export function viaArr(
+    node_id: string,
+    viaAr: string[],
+    config?: { ttl?: number },
+): Promise<{ external_addresses: string[] }>;
+export function viaArr(
+    peer: FluencePeer,
+    node_id: string,
+    viaAr: string[],
+    config?: { ttl?: number },
+): Promise<{ external_addresses: string[] }>;
+export function viaArr(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let viaAr;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        viaAr = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        viaAr = args[1];
+        config = args[2];
+    }
+
     let request: RequestFlow;
-    const promise = new Promise<{external_addresses:string[]}>((resolve, reject) => {
+    const promise = new Promise<{ external_addresses: string[] }>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -89,21 +166,24 @@ export async function viaArr(client: FluenceClient, node_id: string, viaAr: stri
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
+                });
+                h.on('getDataSrv', 'viaAr', () => {
+                    return viaAr;
                 });
-                h.on('getDataSrv', 'node_id', () => {return node_id;});
-h.on('getDataSrv', 'viaAr', () => {return viaAr;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -111,26 +191,51 @@ h.on('getDataSrv', 'viaAr', () => {return viaAr;});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for viaArr');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function viaStream(
+    node_id: string,
+    viaStr: string[],
+    config?: { ttl?: number },
+): Promise<{ external_addresses: string[] }>;
+export function viaStream(
+    peer: FluencePeer,
+    node_id: string,
+    viaStr: string[],
+    config?: { ttl?: number },
+): Promise<{ external_addresses: string[] }>;
+export function viaStream(...args) {
+    let peer: FluencePeer;
+    let node_id;
+    let viaStr;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        node_id = args[1];
+        viaStr = args[2];
+        config = args[3];
+    } else {
+        peer = FluencePeer.default;
+        node_id = args[0];
+        viaStr = args[1];
+        config = args[2];
+    }
 
-
-export async function viaStream(client: FluenceClient, node_id: string, viaStr: string[], config?: {ttl?: number}): Promise<{external_addresses:string[]}> {
     let request: RequestFlow;
-    const promise = new Promise<{external_addresses:string[]}>((resolve, reject) => {
+    const promise = new Promise<{ external_addresses: string[] }>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -197,21 +302,24 @@ export async function viaStream(client: FluenceClient, node_id: string, viaStr:
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
+                });
+                h.on('getDataSrv', 'viaStr', () => {
+                    return viaStr;
                 });
-                h.on('getDataSrv', 'node_id', () => {return node_id;});
-h.on('getDataSrv', 'viaStr', () => {return viaStr;});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -219,26 +327,56 @@ h.on('getDataSrv', 'viaStr', () => {return viaStr;});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for viaStream');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
 
+export function viaOpt(
+    relay: string,
+    node_id: string,
+    viaOpt: string | null,
+    config?: { ttl?: number },
+): Promise<{ external_addresses: string[] }>;
+export function viaOpt(
+    peer: FluencePeer,
+    relay: string,
+    node_id: string,
+    viaOpt: string | null,
+    config?: { ttl?: number },
+): Promise<{ external_addresses: string[] }>;
+export function viaOpt(...args) {
+    let peer: FluencePeer;
+    let relay;
+    let node_id;
+    let viaOpt;
+    let config;
+    if (args[0] instanceof FluencePeer) {
+        peer = args[0];
+        relay = args[1];
+        node_id = args[2];
+        viaOpt = args[3];
+        config = args[4];
+    } else {
+        peer = FluencePeer.default;
+        relay = args[0];
+        node_id = args[1];
+        viaOpt = args[2];
+        config = args[3];
+    }
 
-
-export async function viaOpt(client: FluenceClient, relay: string, node_id: string, viaOpt: string | null, config?: {ttl?: number}): Promise<{external_addresses:string[]}> {
     let request: RequestFlow;
-    const promise = new Promise<{external_addresses:string[]}>((resolve, reject) => {
+    const promise = new Promise<{ external_addresses: string[] }>((resolve, reject) => {
         const r = new RequestFlowBuilder()
             .disableInjections()
             .withRawScript(
                 `
-(xor
+     (xor
  (seq
   (seq
    (seq
@@ -300,22 +438,27 @@ export async function viaOpt(client: FluenceClient, relay: string, node_id: stri
  (call %init_peer_id% ("errorHandlingSrv" "error") [%last_error% 3])
 )
 
-            `,
+                 `,
             )
             .configHandler((h) => {
                 h.on('getDataSrv', '-relay-', () => {
-                    return client.relayPeerId!;
+                    return peer.connectionInfo.connectedRelay;
+                });
+                h.on('getDataSrv', 'relay', () => {
+                    return relay;
+                });
+                h.on('getDataSrv', 'node_id', () => {
+                    return node_id;
+                });
+                h.on('getDataSrv', 'viaOpt', () => {
+                    return viaOpt === null ? [] : [viaOpt];
                 });
-                h.on('getDataSrv', 'relay', () => {return relay;});
-h.on('getDataSrv', 'node_id', () => {return node_id;});
-h.on('getDataSrv', 'viaOpt', () => {return viaOpt === null ? [] : [viaOpt];});
                 h.onEvent('callbackSrv', 'response', (args) => {
-    const [res] = args;
+                    const [res] = args;
-  resolve(res);
+                    resolve(res);
-});
+                });
 
                 h.onEvent('errorHandlingSrv', 'error', (args) => {
-                    // assuming error is the single argument
                     const [err] = args;
                     reject(err);
                 });
@@ -323,13 +466,12 @@ h.on('getDataSrv', 'viaOpt', () => {return viaOpt === null ? [] : [viaOpt];});
             .handleScriptError(reject)
             .handleTimeout(() => {
                 reject('Request timed out for viaOpt');
-            })
+            });
-        if(config && config.ttl) {
+        if (config && config.ttl) {
-            r.withTTL(config.ttl)
+            r.withTTL(config.ttl);
         }
         request = r.build();
     });
-    await client.initiateFlow(request!);
+    peer.internals.initiateFlow(request!);
     return promise;
 }
-      

src/examples/assignment.ts

@@ -1,7 +1,6 @@
-import {FluenceClient} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {passFunctionAsArg} from "../compiled/examples/callArrow";
+import { doSmth } from '../compiled/examples/assignment';
-import {doSmth} from "../compiled/examples/assignment";
 
-export async function assignmentCall(client: FluenceClient): Promise<string[]> {
+export async function assignmentCall(): Promise<string[]> {
-  return await doSmth(client, {value: "abc"}, {ttl: 6000})
+    return await doSmth({ value: 'abc' }, { ttl: 6000 });
 }

src/examples/callArrowCall.ts

@@ -1,12 +1,13 @@
-import {FluenceClient} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {passFunctionAsArg} from "../compiled/examples/callArrow";
+import { passFunctionAsArg } from '../compiled/examples/callArrow';
 
-export async function callArrowCall(client: FluenceClient): Promise<string> {
+export async function callArrowCall(): Promise<string> {
-  return new Promise<string>((resolve, reject) => {
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
-    passFunctionAsArg(client, client.relayPeerId!, "callArrow call", (a: string) => {
+    return new Promise<string>((resolve, reject) => {
-      let result = "Hello, " + a + "!";
+        passFunctionAsArg(relayPeerId, 'callArrow call', (a: string) => {
-      resolve(result)
+            let result = 'Hello, ' + a + '!';
-      return result;
+            resolve(result);
+            return result;
+        });
     });
-  })
 }

src/examples/coCall.ts

@@ -1,15 +1,19 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {parFunc} from "../compiled/examples/par";
+import { parFunc } from '../compiled/examples/par';
+import { registerCoService } from '../compiled/examples/co';
 
-export async function coCall(client: FluenceClient): Promise<string[]> {
+export async function coCall(): Promise<string[]> {
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
 
-    registerServiceFunction(client, "coservice-id", "call", (args: any[], _) => {
+    registerCoService({
-        return "hello"
+        call: () => {
-    })
+            return 'hello';
+        },
+    });
 
     return new Promise<string[]>((resolve, reject) => {
-        parFunc(client, client.relayPeerId!, (c) => {
+        parFunc(relayPeerId, (c) => {
-            resolve(c.external_addresses)
+            resolve(c.external_addresses);
-        })
+        });
-    })
+    });
 }

src/examples/complex.ts

@@ -1,16 +1,18 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {doStuff} from "../compiled/examples/complex";
+import { doStuff, registerTestS } from '../compiled/examples/complex';
-import {testNet} from "@fluencelabs/fluence-network-environment";
 
-export async function complexCall(client: FluenceClient) {
+export async function complexCall() {
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
+    const selfPeerId = FluencePeer.default.connectionInfo.selfPeerId;
 
-    registerServiceFunction(client, "some-id", "t", (args: any[], _) => {
+    registerTestS({
-        return args[0]
+        t: (arg0) => {
-    })
+            return arg0;
+        },
+        multiline: (a, b, c) => {
+            return b;
+        },
+    });
 
-    registerServiceFunction(client, "some-id", "multiline", (args: any[], _) => {
+    return await doStuff(relayPeerId, selfPeerId, true, true, ['1', '2'], ['3', '4'], 'some str');
-        return args[1]
-    })
-
-    return await doStuff(client, client.relayPeerId!, client.selfPeerId, true, true, ["1", "2"], ["3", "4"], "some str")
 }

src/examples/constantsCall.ts

@@ -1,11 +1,12 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {callConstant} from "../compiled/examples/constants";
+import { callConstant, registerGetter } from '../compiled/examples/constants';
 
-export async function constantsCall(client: FluenceClient): Promise<string[]> {
+export async function constantsCall(): Promise<string[]> {
-    registerServiceFunction(client, "test", "createStr", (args: any[], _) => {
+    registerGetter({
-        return "" + args[0]
+        createStr: (arg0) => {
-    })
+            return '' + arg0;
+        },
+    });
 
-
+    return await callConstant();
-    return await callConstant(client);
 }

src/examples/dataAliasCall.ts

@@ -1,13 +1,15 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {getAliasedData} from "../compiled/examples/dataAlias";
+import { getAliasedData, registerNodeIdGetter } from '../compiled/examples/dataAlias';
 
-export async function dataAliasCall(client: FluenceClient) {
+export async function dataAliasCall() {
-    registerServiceFunction(client, "somesrv", "get", (args: any[], _) => {
+    registerNodeIdGetter({
-        return {
+        get: () => {
-            peerId: "peer id str",
+            return {
-            name: "name str"
+                peerId: 'peer id str',
-        }
+                name: 'name str',
-    })
+            };
+        },
+    });
 
-    return await getAliasedData(client)
+    return await getAliasedData();
 }

src/examples/declareCall.ts

@@ -1,18 +1,23 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { concat_foobars, registerStringService } from '../compiled/examples/imports_exports/imports';
-import {concat_foobars} from "../compiled/examples/imports_exports/imports";
+import { registerMyExportSrv } from '../compiled/examples/imports_exports/exports';
+import { registerSuperFoo } from '../compiled/examples/imports_exports/declare';
 
-export async function declareCall(client: FluenceClient) {
+export async function declareCall() {
-    registerServiceFunction(client, "super_foo", "small_foo", (args: any[], _) => {
+    registerSuperFoo({
-        return "small_foo"
+        small_foo: () => {
-    })
+            return 'small_foo';
+        },
+    });
 
-    registerServiceFunction(client, "string_service", "concat", (args: any[], _) => {
+    registerStringService({
-        return args[0] + args[1]
+        concat: (a, b) => {
-    })
+            return a + b;
-
+        },
-    registerServiceFunction(client, "my_export_srv", "another_str", (args: any[], _) => {
+    });
-        return "str_from_my_export_srv"
+    registerMyExportSrv({
-    })
+        another_str: () => {
-
+            return 'str_from_my_export_srv';
-    return await concat_foobars(client)
+        },
+    });
+    return await concat_foobars();
 }

src/examples/foldCall.ts

@@ -1,13 +1,15 @@
-    import {FluenceClient} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-    import {iterateAndPrint, iterateAndPrintParallel} from "../compiled/examples/fold";
+import { iterateAndPrint, iterateAndPrintParallel } from '../compiled/examples/fold';
 
-    export async function foldCall(client: FluenceClient) {
+export async function foldCall() {
-        await iterateAndPrint(client, [client.relayPeerId!])
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
 
-        return new Promise<string[]>((resolve, reject) => {
+    await iterateAndPrint([relayPeerId]);
-            iterateAndPrintParallel(client, [client.relayPeerId!], (c) => {
+
-                console.log("iterateAndPrintParallel. external addresses: " + c.external_addresses)
+    return new Promise<string[]>((resolve, reject) => {
-                resolve(c.external_addresses)
+        iterateAndPrintParallel([relayPeerId], (c) => {
-            })
+            console.log('iterateAndPrintParallel. external addresses: ' + c.external_addresses);
-        })
+            resolve(c.external_addresses);
-    }
+        });
+    });
+}

src/examples/foldJoinCall.ts

@@ -1,6 +1,7 @@
-import {FluenceClient} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {getTwoResults} from "../compiled/examples/foldJoin";
+import { getTwoResults } from '../compiled/examples/foldJoin';
 
-export async function foldJoinCall(client: FluenceClient): Promise<number[]> {
+export async function foldJoinCall(): Promise<number[]> {
-    return await getTwoResults(client, client.relayPeerId!, {ttl: 10000})
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
+    return await getTwoResults(relayPeerId);
 }

src/examples/funcCall.ts

@@ -1,10 +1,11 @@
-import {testFunc} from "../compiled/examples/func";
+import { testFunc, registerTestSrv } from '../compiled/examples/func';
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
 
-export async function funcCall(client: FluenceClient) {
+export async function funcCall() {
-    registerServiceFunction(client, "test-service-id", "str", (args: any[], _) => {
+    registerTestSrv({
-        return `some str`
+        str: () => {
-    })
+            return `some str`;
+        },
+    });
 
-    return await testFunc(client);
+    return await testFunc();
 }

src/examples/helloWorldCall.ts

@@ -1,11 +1,13 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {helloWorld} from "../compiled/examples/helloWorld";
+import { helloWorld, registerStringExtra } from '../compiled/examples/helloWorld';
 
-export async function helloWorldCall(client: FluenceClient) {
+export async function helloWorldCall() {
     // helloWorld.aqua
-    registerServiceFunction(client, "service-id", "addNameToHello", (args: any[], _) => {
+    registerStringExtra({
-        return `Hello, ${args[0]}!`
+        addNameToHello: (args0) => {
-    })
+            return `Hello, ${args0}!`;
+        },
+    });
 
-    return await helloWorld(client, "NAME");
+    return await helloWorld('NAME');
 }

src/examples/if.ts

@@ -1,10 +1,10 @@
-import {FluenceClient} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {ifElseCall, ifElseNumCall} from "../compiled/examples/if";
+import { ifElseCall, ifElseNumCall } from '../compiled/examples/if';
 
-export async function ifCall(client: FluenceClient) {
+export async function ifCall() {
-    await ifElseCall(client, false)
+    await ifElseCall(false);
-    await ifElseCall(client, true)
+    await ifElseCall(true);
 
-    await ifElseNumCall(client, 1)
+    await ifElseNumCall(1);
-    await ifElseNumCall(client, 5)
+    await ifElseNumCall(5);
 }

src/examples/import2Call.ts

@@ -1,18 +1,21 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { registerOneMore } from '../compiled/examples/imports_exports/gen/OneMore';
-import {barfoo, wrap} from "../compiled/examples/imports_exports/import2";
+import { barfoo, wrap } from '../compiled/examples/imports_exports/import2';
 
-export async function import2Call(client: FluenceClient) {
+export async function import2Call() {
+    registerOneMore('hello', {
+        more_call: () => {
+            return {};
+        },
+    });
 
-    registerServiceFunction(client, "hello", "more_call", (args: any[], _) => {
+    registerOneMore('ohmygod', {
-        return {}
+        more_call: () => {
-    })
+            return {};
+        },
+    });
 
-    registerServiceFunction(client, "ohmygod", "more_call", (args: any[], _) => {
+    let first = await wrap();
-        return {}
+    let second = await barfoo();
-    })
 
-    let first = await wrap(client)
+    return { first, second };
-    let second = await barfoo(client)
-
-    return { first, second }
 }

src/examples/multiReturnCall.ts

@@ -1,14 +1,18 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {multiReturnFunc} from "../compiled/examples/multiReturn";
+import { multiReturnFunc, registerGetStr, registerGetNum } from '../compiled/examples/multiReturn';
 
-export async function multiReturnCall(client: FluenceClient): Promise<[string[], number, string, number[], string | null, number]> {
+export async function multiReturnCall(): Promise<[string[], number, string, number[], string | null, number]> {
-    registerServiceFunction(client, "multiret-test", "retStr", (args: any[], _) => {
+    registerGetStr({
-        return args[0]
+        retStr: (args0) => {
-    })
+            return args0;
+        },
+    });
 
-    registerServiceFunction(client, "multiret-num", "retNum", (args: any[], _) => {
+    registerGetNum({
-        return 10
+        retNum: () => {
-    })
+            return 10;
+        },
+    });
 
-    return await multiReturnFunc(client, [1, 2], null)
+    return await multiReturnFunc([1, 2], null);
 }

src/examples/nestedFuncsCall.ts

@@ -1,10 +1,12 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {d} from "../compiled/examples/nestedFuncs";
+import { d, registerOpH } from '../compiled/examples/nestedFuncs';
 
-export async function nestedFuncsCall(client: FluenceClient): Promise<string> {
+export async function nestedFuncsCall(): Promise<string> {
-    registerServiceFunction(client, "opa", "identity", (args: any[], _) => {
+    registerOpH({
-        return args[0]
+        identity: (args0) => {
-    })
+            return args0;
+        },
+    });
 
-    return await d(client, "some-str")
+    return await d('some-str');
 }

src/examples/onCall.ts

@@ -1,6 +1,7 @@
-import {FluenceClient} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {getPeerExternalAddresses} from "../compiled/examples/on";
+import { getPeerExternalAddresses } from '../compiled/examples/on';
 
-export async function onCall(client: FluenceClient): Promise<string[]> {
+export async function onCall(): Promise<string[]> {
-    return await getPeerExternalAddresses(client, client.relayPeerId!)
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
+    return await getPeerExternalAddresses(relayPeerId);
 }

src/examples/parCall.ts

@@ -1,20 +1,23 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {parFunc} from "../compiled/examples/par";
+import { parFunc, registerParService } from '../compiled/examples/par';
 
-export async function parCall(client: FluenceClient) {
+export async function parCall() {
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
 
     let promise = new Promise<string>((resolve, reject) => {
-        registerServiceFunction(client, "parservice-id", "call", (args: any[], _) => {
+        registerParService({
-            console.log("hello from parservice-id")
+            call: () => {
-            let result = "hello"
+                console.log('hello from parservice-id');
-            resolve(result)
+                let result = 'hello';
-            return result
+                resolve(result);
-        })
+                return result;
-    })
+            },
+        });
+    });
 
-    await parFunc(client, client.relayPeerId!, (c) => {
+    await parFunc(relayPeerId, (c) => {
-        console.log("parFunc. external addresses par: " + c.external_addresses)
+        console.log('parFunc. external addresses par: ' + c.external_addresses);
-    })
+    });
 
-    return promise
+    return promise;
 }

src/examples/passArgsCall.ts

@@ -1,10 +1,12 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {create_client_util} from "../compiled/examples/passArgs";
+import { create_client_util, registerAquaDHT } from '../compiled/examples/passArgs';
 
-export async function passArgsCall(client: FluenceClient) {
+export async function passArgsCall() {
-    registerServiceFunction(client, "test-dht", "put_host_value", (args: any[], _) => {
+    registerAquaDHT({
-        return args[0] + args[1]
+        put_host_value: (args0, args1) => {
-    })
+            return args0 + args1;
+        },
+    });
 
-    return await create_client_util(client, "sid")
+    return await create_client_util('sid');
 }

src/examples/pushToStreamCall.ts

@@ -1,10 +1,12 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {get_results} from "../compiled/examples/pushToStream";
+import { get_results, registerOpA } from '../compiled/examples/pushToStream';
 
-export async function pushToStreamCall(client: FluenceClient) {
+export async function pushToStreamCall() {
-    registerServiceFunction(client, "pop", "get_str", (args: any[], _) => {
+    registerOpA({
-        return "get_string"
+        get_str: () => {
-    })
+            return 'get_string';
+        },
+    });
 
-    return await get_results(client)
+    return await get_results();
 }

src/examples/returnLiteralCall.ts

@@ -1,6 +1,6 @@
-import {FluenceClient} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {returnLiteral} from "../compiled/examples/returnLiteral";
+import { returnLiteral } from '../compiled/examples/returnLiteral';
 
-export async function literalCall(client: FluenceClient) {
+export async function literalCall() {
-    return returnLiteral(client)
+    return returnLiteral();
 }

src/examples/streamArgsCall.ts

@@ -1,10 +1,12 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {retrieve_records} from "../compiled/examples/streamArgs";
+import { retrieve_records, registerTestService } from '../compiled/examples/streamArgs';
 
-export async function streamArgsCall(client: FluenceClient) {
+export async function streamArgsCall() {
-    registerServiceFunction(client, "test-service", "get_records", (args: any[], _) => {
+    registerTestService({
-        return [args[0], args[0]]
+        get_records: (key) => {
-    })
+            return [key, key];
+        },
+    });
 
-    return await retrieve_records(client, "peer_id")
+    return await retrieve_records('peer_id');
 }

src/examples/streamCall.ts

@@ -1,10 +1,12 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {checkStreams} from "../compiled/examples/stream";
+import { checkStreams, registerStringer } from '../compiled/examples/stream';
 
-export async function streamCall(client: FluenceClient) {
+export async function streamCall() {
-    registerServiceFunction(client, "stringer-id", "returnString", (args: any[], _) => {
+    registerStringer({
-        return args[0] + " updated"
+        returnString: (args0) => {
-    })
+            return args0 + ' updated';
+        },
+    });
 
-    return checkStreams(client, ["third", "fourth"])
+    return checkStreams(['third', 'fourth']);
 }

src/examples/streamResultsCall.ts

@@ -1,12 +1,14 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {use_name2} from "../compiled/examples/streamResults";
+import { use_name2, registerDTGetter } from '../compiled/examples/streamResults';
 
-export async function streamResultsCall(client: FluenceClient) {
+export async function streamResultsCall() {
-    registerServiceFunction(client, "get-dt", "get_dt", (args: any[], _) => {
+    registerDTGetter({
-        return {
+        get_dt: (args0) => {
-            field: args[0]
+            return {
-        }
+                field: args0,
-    })
+            };
+        },
+    });
 
-    return await use_name2(client, "new_name")
+    return await use_name2('new_name');
 }

src/examples/subImportUsageCall.ts

@@ -1,21 +1,24 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { registerSubService } from '../compiled/examples/imports_exports/subImport';
-import {subImportUsage} from "../compiled/examples/subImportUsage";
+import { registerConcatSubs, subImportUsage } from '../compiled/examples/subImportUsage';
 
-export async function subImportCall(client: FluenceClient) {
+export async function subImportCall() {
     // helloWorld.aqua
-    registerServiceFunction(client, "sub_service", "sub", (args: any[], _) => {
+    registerSubService({
-        return {
+        sub: (s) => {
-            one: args[0],
+            return {
-            two: 42
+                one: s,
-        }
+                two: 42,
-    })
+            };
+        },
+    });
+    registerConcatSubs({
+        get_some: (s, sr) => {
+            return {
+                one: s,
+                two: sr.two,
+            };
+        },
+    });
 
-    registerServiceFunction(client, "concat_subs", "get_some", (args: any[], _) => {
+    return await subImportUsage('random_string');
-        return {
-            one: args[0],
-            two: args[1].two
-        }
-    })
-
-    return await subImportUsage(client, "random_string");
 }

src/examples/topologyCall.ts

@@ -1,17 +1,27 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {topologyTest} from "../compiled/examples/topology";
+import { topologyTest, registerTesto, registerLocalPrint } from '../compiled/examples/topology';
 
-export async function topologyCall(client: FluenceClient, client2: FluenceClient): Promise<string> {
+export async function topologyCall(peer2: FluencePeer): Promise<string> {
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
+    const selfPeerId = FluencePeer.default.connectionInfo.selfPeerId;
 
-    registerServiceFunction(client2, "testo", "getString", (args: any[], _) => {
+    const relayPeerId2 = peer2.connectionInfo.connectedRelay;
-        console.log("hello from client2: " + args[0])
+    const selfPeerId2 = peer2.connectionInfo.selfPeerId;
-        return "hello from client2: " + args[0]
-    })
 
-    registerServiceFunction(client, "lp", "print", (args: any[], _) => {
+    registerTesto(peer2, {
-        console.log("print on client1: " + args[0])
+        getString: (args0) => {
-        return {}
+            console.log('hello from client2: ' + args0);
-    })
+            return 'hello from client2: ' + args0;
+        },
+    });
 
-    return await topologyTest(client, client.selfPeerId, client.relayPeerId!, client2.selfPeerId, client2.relayPeerId!, {ttl: 10000})
+    registerLocalPrint({
+        print: (args0) => {
+            console.log('print on client1: ' + args0);
+        },
+    });
+
+    return await topologyTest(selfPeerId, relayPeerId, selfPeerId2, relayPeerId2, {
+        ttl: 10000,
+    });
 }

src/examples/tryCatchCall.ts

@@ -1,8 +1,7 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {topologyTest} from "../compiled/examples/topology";
+import { tryCatchTest } from '../compiled/examples/tryCatch';
-import {tryCatchTest} from "../compiled/examples/tryCatch";
 
-export async function tryCatchCall(client: FluenceClient): Promise<string[]> {
+export async function tryCatchCall(): Promise<string[]> {
-
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
-    return await tryCatchTest(client, client.relayPeerId!)
+    return await tryCatchTest(relayPeerId);
 }

src/examples/tryOtherwiseCall.ts

@@ -1,7 +1,7 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {tryOtherwiseTest} from "../compiled/examples/tryOtherwise";
+import { tryOtherwiseTest } from '../compiled/examples/tryOtherwise';
 
-export async function tryOtherwiseCall(client: FluenceClient): Promise<string> {
+export async function tryOtherwiseCall(): Promise<string> {
-
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
-    return await tryOtherwiseTest(client, client.relayPeerId!)
+    return await tryOtherwiseTest(relayPeerId);
 }

src/examples/useOptionalCall.ts

@@ -1,27 +1,28 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {returnNone, returnOptional, useOptional} from "../compiled/examples/option";
+import { returnNone, returnOptional, useOptional, registerSomeS } from '../compiled/examples/option';
 
-export async function useOptionalCall(client: FluenceClient): Promise<string> {
+export function registerHandlers(): void {
-    registerServiceFunction(client, "test2", "getStr", (args: any[], _) => {
+    registerSomeS({
-        return args[0]
+        getStr: (arg0) => {
-    })
+            return arg0;
-
+        },
-    registerServiceFunction(client, "test2", "getStr2", (args: any[], _) => {
+        getStr1: () => {
-        return args[0]
+            return 'optional';
-    })
+        },
-
+        getStr2: (arg0) => {
-    return await useOptional(client, "hello")
+            return arg0;
+        },
+    });
 }
 
-export async function returnOptionalCall(client: FluenceClient): Promise<string | null> {
+export async function useOptionalCall(): Promise<string> {
-    registerServiceFunction(client, "test2", "getStr1", (args: any[], _) => {
+    return await useOptional('hello');
-        return ["optional"]
-    })
-
-    return await returnOptional(client)
 }
 
-export async function returnNull(client: FluenceClient): Promise<string | null> {
+export async function returnOptionalCall(): Promise<string | null> {
-
+    return await returnOptional();
-    return await returnNone(client)
+}
+
+export async function returnNull(): Promise<string | null> {
+    return await returnNone();
 }

src/examples/viaCall.ts

@@ -1,17 +1,20 @@
-import {FluenceClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {krasnodar, stage} from "@fluencelabs/fluence-network-environment";
+import { krasnodar } from '@fluencelabs/fluence-network-environment';
-import {viaArr, viaOpt, viaStream} from "../compiled/examples/via";
+import { viaArr, viaOpt, viaStream, registerCustomId } from '../compiled/examples/via';
 
-export async function viaCall(client: FluenceClient): Promise<string[][]> {
+export async function viaCall(): Promise<string[][]> {
+    const relayPeerId = FluencePeer.default.connectionInfo.connectedRelay;
 
-    registerServiceFunction(client, "cid", "id", (args: any[], _) => {
+    registerCustomId({
-        return args[0]
+        id: (args0) => {
-    })
+            return args0;
+        },
+    });
 
-    let res = await viaArr(client, stage[3].peerId, [stage[2].peerId, stage[1].peerId])
+    let res = await viaArr(krasnodar[3].peerId, [krasnodar[2].peerId, krasnodar[1].peerId]);
-    let res2 = await viaOpt(client, client.relayPeerId!, stage[3].peerId, stage[2].peerId)
+    let res2 = await viaOpt(relayPeerId, krasnodar[3].peerId, krasnodar[2].peerId);
-    let res3 = await viaOpt(client, client.relayPeerId!, stage[3].peerId, stage[2].peerId || null)
+    let res3 = await viaOpt(relayPeerId, krasnodar[3].peerId, krasnodar[2].peerId || null);
-    let res4 = await viaStream(client, stage[3].peerId, [stage[2].peerId, stage[1].peerId])
+    let res4 = await viaStream(krasnodar[3].peerId, [krasnodar[2].peerId, krasnodar[1].peerId]);
 
-    return [res.external_addresses, res2.external_addresses, res3.external_addresses, res4.external_addresses]
+    return [res.external_addresses, res2.external_addresses, res3.external_addresses, res4.external_addresses];
 }

src/index.ts

@@ -1,30 +1,32 @@
 #!/usr/bin/env node
 
-import {createClient, registerServiceFunction} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {krasnodar} from "@fluencelabs/fluence-network-environment";
+import { krasnodar } from '@fluencelabs/fluence-network-environment';
-import {helloWorld} from "./compiled/examples/helloWorld";
+import { helloWorld, registerStringExtra } from './compiled/examples/helloWorld';
 
 const main = async () => {
     // each compiled aqua function require a connected client
-    const client = await createClient(krasnodar[0]);
+    await FluencePeer.default.init({ connectTo: krasnodar[0] });
 
     // example to how register a local service
     // it could be used in aqua code as follows
     // service StringExtra("service-id"):
     //     addNameToHello: string -> string
     // see more in helloWorld.aqua
-    registerServiceFunction(client, "service-id", "addNameToHello", (args: any[], _) => {
+    registerStringExtra({
-        return `Hello, ${args[0]}!`
+        addNameToHello: (arg0) => {
-    })
+            return `Hello, ${arg0}!`;
+        },
+    });
 
     // call an aqua function thet presented in ../aqua/helloWorld.aqua
-    const result = await helloWorld(client, "NAME");
+    const result = await helloWorld('NAME');
-    console.log(result)
+    console.log(result);
 
-    process.exit(0)
+    process.exit(0);
 };
 
 main().catch((err) => {
-    console.log(err)
+    console.log(err);
-    process.exit(1)
+    process.exit(1);
-})
+});

src/pubsub.ts

@@ -1,24 +1,25 @@
-import {findSubscribers, getNeighbours, initTopicAndSubscribe} from "@fluencelabs/aqua-dht-ts";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {createClient} from "@fluencelabs/fluence";
+import { krasnodar } from '@fluencelabs/fluence-network-environment';
-import {krasnodar} from "@fluencelabs/fluence-network-environment";
+import { getNeighbours, initTopicAndSubscribe, findSubscribers } from './compiled/dht/dht-example';
 
 const main = async () => {
-    const client = await createClient(krasnodar[0]);
+    await FluencePeer.default.init({ connectTo: krasnodar[0] });
-    const peer = krasnodar[0].peerId
+    const relayPeerId = krasnodar[0].peerId;
-    const nodes = await getNeighbours(client, peer, "random")
-    console.log(nodes)
 
-    const topic = "random"
+    const nodes = await getNeighbours(relayPeerId, 'random');
-    await initTopicAndSubscribe(client, peer, topic, "random value", null, null)
+    console.log(nodes);
 
-    const result = await findSubscribers(client, peer, topic)
+    const topic = 'random';
+    await initTopicAndSubscribe(relayPeerId, topic, 'random value', null, null);
 
-    console.log(result)
+    const result = await findSubscribers(relayPeerId, topic);
 
-    process.exit(0)
+    console.log(result);
-}
+
+    process.exit(0);
+};
 
 main().catch((err) => {
-    console.log(err)
+    console.log(err);
-    process.exit(1)
+    process.exit(1);
-})
+});

src/run-examples.ts

@@ -1,239 +1,233 @@
 #!/usr/bin/env node
 
-import {createClient, registerServiceFunction, setLogLevel} from "@fluencelabs/fluence";
+import { FluencePeer } from '@fluencelabs/fluence';
-import {krasnodar, testNet, stage} from "@fluencelabs/fluence-network-environment";
+import { krasnodar, testNet } from '@fluencelabs/fluence-network-environment';
-import {callArrowCall} from "./examples/callArrowCall";
+import { registerPrintln } from './compiled/examples/println';
-import {dataAliasCall} from "./examples/dataAliasCall";
+import { callArrowCall } from './examples/callArrowCall';
-import {onCall} from "./examples/onCall";
+import { dataAliasCall } from './examples/dataAliasCall';
-import {funcCall} from "./examples/funcCall";
+import { onCall } from './examples/onCall';
-import {helloWorldCall} from "./examples/helloWorldCall";
+import { funcCall } from './examples/funcCall';
-import {foldCall} from "./examples/foldCall";
+import { helloWorldCall } from './examples/helloWorldCall';
-import {ifCall} from "./examples/if";
+import { foldCall } from './examples/foldCall';
-import {parCall} from "./examples/parCall";
+import { ifCall } from './examples/if';
-import {complexCall} from "./examples/complex";
+import { parCall } from './examples/parCall';
-import {constantsCall} from "./examples/constantsCall";
+import { complexCall } from './examples/complex';
-import {streamCall} from "./examples/streamCall";
+import { constantsCall } from './examples/constantsCall';
-import {topologyCall} from "./examples/topologyCall";
+import { streamCall } from './examples/streamCall';
-import {foldJoinCall} from "./examples/foldJoinCall";
+import { topologyCall } from './examples/topologyCall';
-import {returnNull, returnOptionalCall, useOptionalCall} from "./examples/useOptionalCall";
+import { foldJoinCall } from './examples/foldJoinCall';
-import {viaCall} from "./examples/viaCall";
+import { registerHandlers, returnNull, returnOptionalCall, useOptionalCall } from './examples/useOptionalCall';
-import {nestedFuncsCall} from "./examples/nestedFuncsCall";
+import { viaCall } from './examples/viaCall';
-import {assignmentCall} from "./examples/assignment";
+import { nestedFuncsCall } from './examples/nestedFuncsCall';
-import {tryCatchCall} from "./examples/tryCatchCall";
+import { assignmentCall } from './examples/assignment';
-import {tryOtherwiseCall} from "./examples/tryOtherwiseCall";
+import { tryCatchCall } from './examples/tryCatchCall';
-import {coCall} from "./examples/coCall";
+import { tryOtherwiseCall } from './examples/tryOtherwiseCall';
-import {passArgsCall} from "./examples/passArgsCall";
+import { coCall } from './examples/coCall';
-import {streamArgsCall} from "./examples/streamArgsCall";
+import { passArgsCall } from './examples/passArgsCall';
-import {streamResultsCall} from "./examples/streamResultsCall";
+import { streamArgsCall } from './examples/streamArgsCall';
-import {pushToStreamCall} from "./examples/pushToStreamCall";
+import { streamResultsCall } from './examples/streamResultsCall';
-import {literalCall} from "./examples/returnLiteralCall";
+import { pushToStreamCall } from './examples/pushToStreamCall';
-import {multiReturnCall} from "./examples/multiReturnCall";
+import { literalCall } from './examples/returnLiteralCall';
-import {declareCall} from "./examples/declareCall";
+import { multiReturnCall } from './examples/multiReturnCall';
-import {subImportCall} from "./examples/subImportUsageCall";
+import { declareCall } from './examples/declareCall';
-import {import2Call} from "./examples/import2Call";
+let deepEqual = require('deep-equal');
-let deepEqual = require('deep-equal')
 
 function checkCall(name: string, actual: any, expected: any, callBackOnError: () => void) {
-  if (!deepEqual(expected, actual)) {
+    console.log('-- checking ' + name + ' --');
-    console.error(`${name} call has the wrong result`)
+    if (!deepEqual(expected, actual)) {
-    console.error("actual: ")
+        console.error(`${name} call has the wrong result`);
-    console.dir(actual)
+        console.error('actual: ');
-    console.error("expected: ")
+        console.dir(actual);
-    console.dir(expected)
+        console.error('expected: ');
-    callBackOnError()
+        console.dir(expected);
-  }
+        callBackOnError();
+    }
 }
 
 function checkCallBy(name: string, actual: any, by: (res: any) => boolean, callBackOnError: () => void) {
-  if (!by(actual)) {
+    console.log('-- checking ' + name + ' --');
-    console.error(`${name} call has the wrong result`)
+    if (!by(actual)) {
-    console.error("actual: " + actual)
+        console.error(`${name} call has the wrong result`);
-    callBackOnError()
+        console.error('actual: ' + actual);
-  }
+        callBackOnError();
+    }
 }
 
 const main = async () => {
-  // setLogLevel("trace")
+    // setLogLevel("trace")
-  const client = await createClient(stage[0]);
-  const client2 = await createClient(stage[1]);
 
-  // this could be called from `println.aqua`
+    await FluencePeer.default.init({ connectTo: krasnodar[0] });
-  registerServiceFunction(client, "println-service-id", "print", (args: any[], _) => {
+    const selfPeerId = FluencePeer.default.connectionInfo.selfPeerId;
-    console.log("println:   " + args[0])
-    return {}
-  })
 
-  // these is only list of calls. Take a look into functions to see what's going on
+    const peer2 = new FluencePeer();
+    await peer2.init({ connectTo: krasnodar[1] });
 
-  // these calls return void, so they could be executed at any time,
+    // this could be called from `println.aqua`
-  // because promise waits only a fact that particle was sent
+    registerPrintln({
+        print: (arg0) => {
+            console.log('println:   ' + arg0);
+        },
+    });
 
-  // callArrow.aqua
+    // these is only list of calls. Take a look into functions to see what's going on
-  let callArrowResult = await callArrowCall(client)
 
-  // fold.aqua
+    // these calls return void, so they could be executed at any time,
-  let foldCallResult = await foldCall(client)
+    // because promise waits only a fact that particle was sent
 
-  //if.aqua
+    let success = true;
-  await ifCall(client)
+    let cb: () => void = () => {
+        success = false;
+    };
 
-  // par.aqua
+    // callArrow.aqua
-  let parCallResult = await parCall(client)
+    let callArrowResult = await callArrowCall();
+    checkCall('callArrow', callArrowResult, 'Hello, callArrow call!', cb);
 
-  // these calls waiting for a result, so it will be called sequentially
+    // fold.aqua
-  // helloWorld.aqua
+    let foldCallResult = await foldCall();
-  let helloWorldResult = await helloWorldCall(client)
+    checkCall('foldCall', foldCallResult, ['/ip4/164.90.171.139/tcp/7770', '/ip4/164.90.171.139/tcp/9990/ws'], cb);
 
-  // func.aqua
+    //if.aqua
-  let funcCallResult = await funcCall(client)
+    await ifCall();
 
-  // on.aqua
+    // par.aqua
-  let onCallResult = await onCall(client)
+    let parCallResult = await parCall();
+    checkCall('parArrow', parCallResult, 'hello', cb);
 
-  // dataAlias.aqua
+    // these calls waiting for a result, so it will be called sequentially
-  let dataAliasResult = await dataAliasCall(client)
+    // helloWorld.aqua
+    let helloWorldResult = await helloWorldCall();
+    checkCall('helloWorldCall', helloWorldResult, 'Hello, NAME!', cb);
 
-  // complex.aqua
+    // func.aqua
-  let complexCallResult = await complexCall(client)
+    let funcCallResult = await funcCall();
+    checkCall('funcCall', funcCallResult, 'some str', cb);
 
-  // constants.aqua
+    // on.aqua
-  let constantCallResult = await constantsCall(client)
+    let onCallResult = await onCall();
+    checkCall('onCall', onCallResult, ['/ip4/164.90.171.139/tcp/7770', '/ip4/164.90.171.139/tcp/9990/ws'], cb);
 
-  // stream.aqua
+    // dataAlias.aqua
-  let streamResult = await streamCall(client)
+    let dataAliasResult = await dataAliasCall();
+    checkCall('dataAliasCall', dataAliasResult, 'peer id str', cb);
 
-  // topology.aqua
+    // complex.aqua
-  let topologyResult = await topologyCall(client, client2)
+    let complexCallResult = await complexCall();
+    checkCall(
+        'complexCall',
+        complexCallResult,
+        ['some str', '3', '1', '4', '1', '1', '3', '2', '4', '2', '2', selfPeerId],
+        cb,
+    );
 
-  // foldJoin.aqua
+    // constants.aqua
-  let foldJoinResult = await foldJoinCall(client)
+    let constantCallResult = await constantsCall();
+    checkCall('constantCall', constantCallResult, ['1', 'ab'], cb);
 
-  // option.aqua
+    // stream.aqua
-  let optionResult = await useOptionalCall(client)
+    let streamResult = await streamCall();
-  let optionalResult = await returnOptionalCall(client)
+    checkCall('streamCall', streamResult, ['first updated', 'second updated', 'third updated', 'fourth updated'], cb);
-  let noneResult = await returnNull(client)
 
-  // via.aqua
+    // topology.aqua
-  let viaResult = await viaCall(client)
+    let topologyResult = await topologyCall(peer2);
+    checkCall('topologyCall', topologyResult, 'finish', cb);
 
-  // nestedFuncs.aqua
+    // foldJoin.aqua
-  let nestedFuncsResult = await nestedFuncsCall(client)
+    let foldJoinResult = await foldJoinCall();
+    checkCallBy('foldJoinCall', foldJoinResult, (res) => res.length == 3, cb);
 
-  // assignment.aqua
+    // option.aqua
-  let assignmentResult = await assignmentCall(client)
+    registerHandlers();
+    let optionResult = await useOptionalCall();
+    let optionalResult = await returnOptionalCall();
+    let noneResult = await returnNull();
+    checkCall('useOptional', optionResult, 'hello', cb);
+    checkCall('returnOptional', optionalResult, 'optional', cb);
+    checkCall('returnNone', noneResult, null, cb);
 
-  // tryOtherwise.aqua
+    // via.aqua
-  let tryOtherwiseResult = await tryOtherwiseCall(client)
+    let viaResult = await viaCall();
+    checkCallBy('via', viaResult, (res) => res.every((val, i, arr) => deepEqual(val, arr[0])), cb);
 
-  // tryCatch.aqua
+    // nestedFuncs.aqua
-  let tryCatchResult = await tryCatchCall(client)
+    let nestedFuncsResult = await nestedFuncsCall();
+    checkCall('nestedFuncsCall', nestedFuncsResult, 'some-str', cb);
 
-  // coCall.aqua
+    // assignment.aqua
-  let coCallResult = await coCall(client)
+    let assignmentResult = await assignmentCall();
+    checkCall('assignmentCall', assignmentResult, ['abc', 'hello'], cb);
 
-  // passArgsCall.aqua
+    // tryOtherwise.aqua
-  let passArgsResult = await passArgsCall(client)
+    let tryOtherwiseResult = await tryOtherwiseCall();
+    checkCall('tryOtherwiseCall', tryOtherwiseResult, 'error', cb);
 
-  // streamArgs.aqua
+    // tryCatch.aqua
-  let streamArgsResult = await streamArgsCall(client)
+    let tryCatchResult = await tryCatchCall();
+    checkCallBy(
+        'tryCatchCall',
+        tryCatchResult,
+        (res) => {
+            return (
+                (res[0] as string).includes("Error: Service with id 'unex' not found") &&
+                res[1] === '/ip4/164.90.171.139/tcp/7770'
+            );
+        },
+        cb,
+    );
 
-  // streamResults.aqua
+    // coCall.aqua
-  let streamResultsResult = await streamResultsCall(client)
+    let coCallResult = await coCall();
+    checkCall('coCall', coCallResult, ['/ip4/164.90.171.139/tcp/7770', '/ip4/164.90.171.139/tcp/9990/ws'], cb);
 
-  // pushToStream.aqua
+    // passArgsCall.aqua
-  let pushToStreamResult = await pushToStreamCall(client)
+    let passArgsResult = await passArgsCall();
+    checkCall('passArgsCall', passArgsResult, 'client-utilsid', cb);
 
-  // literalCall.aqua
+    // streamArgs.aqua
-  let literalCallResult = await literalCall(client)
+    let streamArgsResult = await streamArgsCall();
+    checkCall('streamArgsCall', streamArgsResult, [['peer_id', 'peer_id']], cb);
 
-  // multiReturn.aqua
+    // streamResults.aqua
-  let multiReturnResult = await multiReturnCall(client)
+    let streamResultsResult = await streamResultsCall();
+    checkCall('streamResultsCall', streamResultsResult, ['new_name', 'new_name', 'new_name'], cb);
 
-  // declare.aqua
+    // pushToStream.aqua
-  let declareResult = await declareCall(client)
+    let pushToStreamResult = await pushToStreamCall();
+    checkCall('pushToStreamCall', pushToStreamResult, ['hello', 'get_string'], cb);
 
-  // subImport.aqua and subImportUsage.aqua
+    // literalCall.aqua
-  let subImportResult = await subImportCall(client)
+    let literalCallResult = await literalCall();
+    checkCall('literalCall', literalCallResult, 'some literal', cb);
 
-  // import2.aqua, export2.aqua, OneMore.aqua
+    // multiReturn.aqua
-  let import2Result = await import2Call(client)
+    let multiReturnResult = await multiReturnCall();
+    checkCall(
+        'multiReturnResult',
+        multiReturnResult,
+        [['some-str', 'random-str', 'some-str'], 5, 'some-str', [1, 2], null, 10],
+        cb,
+    );
 
-  await client.disconnect();
+    // declare.aqua
+    let declareResult = await declareCall();
+    checkCall(
+        'declareResult',
+        declareResult,
+        'small_foodeclare all barsmall_fooexport_constdeclare_constdeclare_const2',
+        cb,
+    );
 
-  let success = true;
+    await FluencePeer.default.uninit();
-  let cb: () => void = () => {
+    await peer2.uninit();
-    success = false;
-  }
-
-  checkCall("callArrow", callArrowResult, "Hello, callArrow call!", cb)
-
-  checkCall("foldCall", foldCallResult, ['/ip4/134.209.186.43/tcp/7001', '/ip4/134.209.186.43/tcp/9001/ws'], cb)
-
-  checkCall("onCall", onCallResult, ['/ip4/134.209.186.43/tcp/7001', '/ip4/134.209.186.43/tcp/9001/ws'], cb)
-
-  checkCall("parArrow", parCallResult, "hello", cb)
-
-  checkCall("helloWorldCall", helloWorldResult, "Hello, NAME!", cb)
-
-  checkCall("funcCall", funcCallResult, "some str", cb)
-
-  checkCall("dataAliasCall", dataAliasResult, "peer id str", cb)
-
-  checkCall("complexCall", complexCallResult, ["some str", "3", "1", "4", "1", "1", "3", "2", "4", "2", "2", client.selfPeerId], cb)
-
-  checkCall("constantCall", constantCallResult, ['1', 'ab'], cb)
-
-  checkCall("streamCall", streamResult, ["first updated", "second updated", "third updated", "fourth updated"], cb)
-
-  checkCall("topologyCall", topologyResult, "finish", cb)
-
-  checkCallBy("foldJoinCall", foldJoinResult, (res) => res.length == 3, cb)
-
-  checkCall("useOptional", optionResult, "hello", cb)
-  checkCall("returnOptional", optionalResult, "optional", cb)
-  checkCall("returnNone", noneResult, null, cb)
-
-  checkCallBy("via", viaResult, (res) => res.every( (val, i, arr) => deepEqual(val, arr[0]) ), cb)
-
-  checkCall("nestedFuncsCall", nestedFuncsResult, "some-str", cb)
-
-  checkCall("assignmentCall", assignmentResult, ["abc", "hello"], cb)
-
-  checkCall("tryOtherwiseCall", tryOtherwiseResult, "error", cb)
-
-  checkCall("coCall", coCallResult, [ '/ip4/134.209.186.43/tcp/7001', '/ip4/134.209.186.43/tcp/9001/ws' ], cb)
-
-  checkCall("passArgsCall", passArgsResult, "client-utilsid", cb)
-
-  checkCall("streamArgsCall", streamArgsResult, [["peer_id", "peer_id"]], cb)
-
-  checkCall("streamResultsCall", streamResultsResult, ["new_name", "new_name", "new_name"], cb)
-
-  checkCall("pushToStreamCall", pushToStreamResult, ["hello", "get_string"], cb)
-
-  checkCall("literalCall", literalCallResult, "some literal", cb)
-
-  checkCall("multiReturnResult", multiReturnResult, [ [ 'some-str', 'random-str', 'some-str' ], 5, 'some-str', [ 1, 2 ], null, 10], cb)
-
-  checkCall("declareResult", declareResult, 'small_foodeclare all barsmall_fooexport_constdeclare_constdeclare_const2', cb)
-
-  checkCall("subImportResult", subImportResult, { one: "random_string", two: 42 }, cb)
-
-  checkCall("import2Result", import2Result, { first: 'I am MyFooBar foo', second: [ 'I am MyFooBar foo', ' I am MyFooBar bar' ] }, cb)
-
-  checkCallBy("tryCatchCall", tryCatchResult, (res) => {
-    return (res[0] as string).includes("Error: Service with id 'unex' not found") && res[1] === '/ip4/134.209.186.43/tcp/7001'
-  }, cb)
-
-  if (success) {
-    process.exit(0)
-  } else {
-    process.exit(1)
-  }
 
+    if (success) {
+        process.exit(0);
+    } else {
+        process.exit(1);
+    }
 };
 
 main().catch((err) => {
-  console.log(err)
+    console.log(err);
-  process.exit(1)
+    process.exit(1);
-})
+});

tsconfig.json

@@ -13,7 +13,8 @@
     "moduleResolution": "node",
     "strict": true,
     "esModuleInterop": true,
-    "noImplicitAny": false
+    "noImplicitAny": false,
+    "strictNullChecks": false
   },
   "exclude": [
     "node_modules",