fluencelabs/aqua-playground
1
0
Fork 0
mirror of https://github.com/fluencelabs/aqua-playground synced 2025-06-20 20:26:33 +00:00
Code Issues Projects Releases Wiki Activity

move aqua into the root of the project

Browse Source
This commit is contained in:
Pavel Murygin
2021-04-15 18:19:24 +03:00
parent 4b7d8a827b
commit 1874b74769
23 changed files with 1264 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
src/aqua/builtin.aqua → aqua/builtin.aqua
View File

0
src/aqua/callArrow.aqua → aqua/callArrow.aqua
View File

0
src/aqua/complex.aqua → aqua/complex.aqua
View File

0
src/aqua/dataAlias.aqua → aqua/dataAlias.aqua
View File

0
src/aqua/fold.aqua → aqua/fold.aqua
View File

0
src/aqua/func.aqua → aqua/func.aqua
View File

0
src/aqua/helloWorld.aqua → aqua/helloWorld.aqua
View File

0
src/aqua/if.aqua → aqua/if.aqua
View File

0
src/aqua/on.aqua → aqua/on.aqua
View File

0
src/aqua/par.aqua → aqua/par.aqua
View File

0
src/aqua/println.aqua → aqua/println.aqua
View File

2
package.json
View File

@ -18,7 +18,7 @@
"scripts": { "scripts": {
"build": "tsc", "build": "tsc",
"cli": "node -r ts-node/register src/index.ts", "cli": "node -r ts-node/register src/index.ts",
"compile-aqua": "aqua-cli -i ./src/aqua/ -o ./src/compiled" "compile-aqua": "aqua-cli -i ./aqua/ -o ./src/compiled"
}, },
"devDependencies": { "devDependencies": {
"@fluencelabs/aqua-cli": "^0.1.1-76", "@fluencelabs/aqua-cli": "^0.1.1-76",

8
src/callArrowCall.ts
View File

@ -1,8 +1,8 @@
import {FluenceClient} from "@fluencelabs/fluence"; import { FluenceClient } from "@fluencelabs/fluence";
import {passFunctionAsArg} from "./compiled/callArrow"; import { passFunctionAsArg } from "./compiled/callArrow";
export async function callArrowCall(client: FluenceClient) { export async function callArrowCall(client: FluenceClient) {
await passFunctionAsArg(client, client.relayPeerId!, (a: string) => { await passFunctionAsArg(client, client.relayPeerId!, (a: string) => {
return "Hello, " + a + "!" return "Hello, " + a + "!";
}) });
} }

160
src/compiled/callArrow.ts Normal file
View File

@ -0,0 +1,160 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function print(client: FluenceClient, str: string): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "str") [] str)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(call %init_peer_id% ("println-service-id" "print") [str])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'str', () => {return str;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function id(client: FluenceClient): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("op" "identity") [])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function passFunctionAsArg(client: FluenceClient, node: string, c: (arg0: string) => string): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "node") [] node)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(seq
(seq
(seq
(call relay ("op" "identity") [])
(seq
(seq
(seq
(call node ("peer" "identify") [])
(seq
(call relay ("op" "identity") [])
(call %init_peer_id% ("callbackSrv" "c") ["hello"] init_call_res)
)
)
(call relay ("op" "identity") [])
)
(call node ("peer" "identify") [])
)
)
(call relay ("op" "identity") [])
)
(call %init_peer_id% ("println-service-id" "print") [init_call_res])
)
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'node', () => {return node;});
h.on('callbackSrv', 'c', (args) => {return c(args[0]);});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}

250
src/compiled/complex.ts Normal file
View File

@ -0,0 +1,250 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function helloWorld(client: FluenceClient, name: string): Promise<string> {
let request;
const promise = new Promise<string>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(seq
(call %init_peer_id% ("getDataSrv" "name") [] name)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(call %init_peer_id% ("service-id" "addNameToHello") [name] res)
)
(call %init_peer_id% ("callbackSrv" "response") [res])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'name', () => {return name;});
h.on('callbackSrv', 'response', (args) => {
const [res] = args;
resolve(res);
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return promise;
}
export async function print(client: FluenceClient, str: string): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "str") [] str)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(call %init_peer_id% ("println-service-id" "print") [str])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'str', () => {return str;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function id(client: FluenceClient): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("op" "identity") [])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function testFunc(client: FluenceClient): Promise<string> {
let request;
const promise = new Promise<string>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("test-service-id" "str") [] res)
)
(call %init_peer_id% ("callbackSrv" "response") [res])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('callbackSrv', 'response', (args) => {
const [res] = args;
resolve(res);
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return promise;
}
export async function doStuff(client: FluenceClient, a: string): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "a") [] a)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(par
(par
(call %init_peer_id% ("test-service-id" "str") [] str)
(call %init_peer_id% ("println-service-id" "print") [str])
)
(seq
(call relay ("op" "identity") [])
(call a ("peer" "identify") [])
)
)
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'a', () => {return a;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}

53
src/compiled/dataAlias.ts Normal file
View File

@ -0,0 +1,53 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function getAliasedData(client: FluenceClient): Promise<string> {
let request;
const promise = new Promise<string>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("somesrv" "get") [] res)
)
(call %init_peer_id% ("callbackSrv" "response") [res.$.peerId!])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('callbackSrv', 'response', (args) => {
const [res] = args;
resolve(res);
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return promise;
}

204
src/compiled/fold.ts Normal file
View File

@ -0,0 +1,204 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function print(client: FluenceClient, str: string): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "str") [] str)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(call %init_peer_id% ("println-service-id" "print") [str])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'str', () => {return str;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function id(client: FluenceClient): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("op" "identity") [])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function iterateAndPrint(client: FluenceClient, strings: string[]): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "strings") [] strings)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(fold strings s
(seq
(call %init_peer_id% ("println-service-id" "print") [s])
(next s)
)
)
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'strings', () => {return strings;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function iterateAndPrintParallel(client: FluenceClient, nodes: string[], c: (arg0: {external_addresses:string[]}) => void): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "nodes") [] nodes)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(fold nodes s
(par
(seq
(call relay ("op" "identity") [])
(seq
(call s ("peer" "identify") [] ads)
(seq
(call relay ("op" "identity") [])
(call %init_peer_id% ("callbackSrv" "c") [ads])
)
)
)
(next s)
)
)
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'nodes', () => {return nodes;});
h.on('callbackSrv', 'c', (args) => {return c(args[0]);});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}

53
src/compiled/func.ts Normal file
View File

@ -0,0 +1,53 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function testFunc(client: FluenceClient): Promise<string> {
let request;
const promise = new Promise<string>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("test-service-id" "str") [] res)
)
(call %init_peer_id% ("callbackSrv" "response") [res])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('callbackSrv', 'response', (args) => {
const [res] = args;
resolve(res);
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return promise;
}

56
src/compiled/helloWorld.ts Normal file
View File

@ -0,0 +1,56 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function helloWorld(client: FluenceClient, name: string): Promise<string> {
let request;
const promise = new Promise<string>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(seq
(call %init_peer_id% ("getDataSrv" "name") [] name)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(call %init_peer_id% ("service-id" "addNameToHello") [name] res)
)
(call %init_peer_id% ("callbackSrv" "response") [res])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'name', () => {return name;});
h.on('callbackSrv', 'response', (args) => {
const [res] = args;
resolve(res);
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return promise;
}

151
src/compiled/if.ts Normal file
View File

@ -0,0 +1,151 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function print(client: FluenceClient, str: string): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "str") [] str)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(call %init_peer_id% ("println-service-id" "print") [str])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'str', () => {return str;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function ifElseCall(client: FluenceClient, condition: boolean): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "condition") [] condition)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(xor
(match condition true
(call %init_peer_id% ("println-service-id" "print") ["it is true"])
)
(call %init_peer_id% ("println-service-id" "print") ["it is false"])
)
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'condition', () => {return condition;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function ifElseNumCall(client: FluenceClient, condition: number): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "condition") [] condition)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(xor
(match condition 1
(call %init_peer_id% ("println-service-id" "print") ["it is 1"])
)
(call %init_peer_id% ("println-service-id" "print") ["it is not 1"])
)
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'condition', () => {return condition;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}

174
src/compiled/on.ts Normal file
View File

@ -0,0 +1,174 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function id(client: FluenceClient): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("op" "identity") [])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function getPeerExternalAddresses(client: FluenceClient, otherNodePeerId: string): Promise<string[]> {
let request;
const promise = new Promise<string[]>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(seq
(seq
(call %init_peer_id% ("getDataSrv" "otherNodePeerId") [] otherNodePeerId)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(seq
(call relay ("op" "identity") [])
(call otherNodePeerId ("peer" "identify") [] res)
)
)
(call relay ("op" "identity") [])
)
(call %init_peer_id% ("callbackSrv" "response") [res.$.external_addresses!])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'otherNodePeerId', () => {return otherNodePeerId;});
h.on('callbackSrv', 'response', (args) => {
const [res] = args;
resolve(res);
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return promise;
}
export async function getDistantAddresses(client: FluenceClient, target: string, viaNode: string): Promise<string[]> {
let request;
const promise = new Promise<string[]>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(seq
(seq
(seq
(seq
(call %init_peer_id% ("getDataSrv" "target") [] target)
(call %init_peer_id% ("getDataSrv" "viaNode") [] viaNode)
)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(seq
(seq
(call relay ("op" "identity") [])
(call viaNode ("op" "identity") [])
)
(call target ("peer" "identify") [] res)
)
)
(call viaNode ("op" "identity") [])
)
(call relay ("op" "identity") [])
)
(call %init_peer_id% ("callbackSrv" "response") [res.$.external_addresses!])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'target', () => {return target;});
h.on('getDataSrv', 'viaNode', () => {return viaNode;});
h.on('callbackSrv', 'response', (args) => {
const [res] = args;
resolve(res);
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return promise;
}

108
src/compiled/par.ts Normal file
View File

@ -0,0 +1,108 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function id(client: FluenceClient): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
(call %init_peer_id% ("op" "identity") [])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}
export async function parFunc(client: FluenceClient, node: string, c: (arg0: {external_addresses:string[]}) => void): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "node") [] node)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(par
(par
(call %init_peer_id% ("parservice-id" "call") [] y)
(seq
(call relay ("op" "identity") [])
(seq
(call node ("peer" "identify") [] t)
(seq
(call relay ("op" "identity") [])
(call %init_peer_id% ("callbackSrv" "c") [t])
)
)
)
)
(call %init_peer_id% ("parservice-id" "call") [] x)
)
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'node', () => {return node;});
h.on('callbackSrv', 'c', (args) => {return c(args[0]);});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}

49
src/compiled/println.ts Normal file
View File

@ -0,0 +1,49 @@
import { FluenceClient, PeerIdB58 } from '@fluencelabs/fluence';
import { RequestFlowBuilder } from '@fluencelabs/fluence/dist/api.unstable';
export async function print(client: FluenceClient, str: string): Promise<void> {
let request;
const promise = new Promise<void>((resolve, reject) => {
request = new RequestFlowBuilder()
.withRawScript(
`
(xor
(seq
(seq
(call %init_peer_id% ("getDataSrv" "str") [] str)
(call %init_peer_id% ("getDataSrv" "relay") [] relay)
)
(call %init_peer_id% ("println-service-id" "print") [str])
)
(call %init_peer_id% ("errorHandlingSrv" "error") [%last_error%])
)
`,
)
.configHandler((h) => {
h.on('getDataSrv', 'relay', () => {
return client.relayPeerId;
});
h.on('getRelayService', 'hasReleay', () => {// Not Used
return client.relayPeerId !== undefined;
});
h.on('getDataSrv', 'str', () => {return str;});
h.on('errorHandlingSrv', 'error', (args) => {
// assuming error is the single argument
const [err] = args;
reject(err);
});
})
.handleScriptError(reject)
.handleTimeout(() => {
reject('Request timed out');
})
.build();
});
await client.initiateFlow(request);
return Promise.race([promise, Promise.resolve()]);
}