fluencelabs/fluence-js
1
0
Fork 0
mirror of https://github.com/fluencelabs/fluence-js.git synced 2025-06-16 09:31:20 +00:00
Code Issues Projects Releases Wiki Activity

feat!: Unify all packages (#327)

Browse Source 
* * Separate marine worker as a package
* Trying to fix tests

* Finalizing test fixes

* fix: rename back to Fluence CLI (#320)

chore: rename back to Fluence CLI

* fix(deps): update dependency @fluencelabs/avm to v0.43.1 (#322)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

* chore: release master (#324)

* chore: release master

* chore: Regenerate pnpm lock file

* feat: use marine-js 0.7.2 (#321)

* use marine-js 0.5.0

* increace some timeouts

* increace some timeouts

* use latest marine + remove larger timeouts

* propagate CallParameters type

* use marine 0.7.2

* Temp use node 18 and 20

* Comment out node 20.x

---------

Co-authored-by: Anatoly Laskaris <github_me@nahsi.dev>

* chore: Fix test with node 18/20 error message (#323)

* Fix test with node 18/20 error message

* Run tests on node 18 and 20

* Enhance description

* Fix type and obj property

---------

Co-authored-by: Anatoly Laskaris <github_me@nahsi.dev>

* * Separate marine worker as a package
* Trying to fix tests

* Finalizing test fixes

* * Refactoring packages.
* Using CDN to load .wasm deps.
* Setting up tests for new architecture

* Fix almost all tests

* Fix last strange test

* Remove package specific packages

* Remove avm class as it looks excessive

* marine worker new version

* misc refactoring/remove console.log's

* Rename package js-peer to js-client

* Move service info to marine worker

* Change CDN path

* Fix worker race confition

* Remove buffer type

* Remove turned off headless mode in platform tests

* Remove async keyword to make tests pass

* Remove util package

* Make js-client.api package just reexport interface from js-client main package

* Update package info in CI

* Fix review comments

* Remove test entry from marine-worker package

* Misc fixes

* Fix worker type

* Add fetchers

* Specify correct versions for js-client package

* Set first ver for js-client

* Update libp2p and related dep versions to the latest

* Build all deps into package itself

* Fix review

* Refine package

* Fix comment

* Update packages/core/js-client/src/fetchers/browser.ts

* Update packages/core/js-client/src/fetchers/index.ts

* Update packages/core/js-client/src/fetchers/node.ts

* Update packages/core/js-client/src/jsPeer/FluencePeer.ts

* Update packages/core/js-client/src/keypair/__test__/KeyPair.spec.ts

* Update packages/core/js-client/src/jsPeer/FluencePeer.ts

Co-authored-by: shamsartem <shamsartem@gmail.com>

* Delete outdated file

* Need types for build to work

* Inline func call

* Add comments to replacement lines.
P.S. we can remove some of them after update libp2p

---------

Co-authored-by: shamsartem <shamsartem@gmail.com>
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: fluencebot <116741523+fluencebot@users.noreply.github.com>
Co-authored-by: Valery Antopol <valery.antopol@gmail.com>
Co-authored-by: Anatoly Laskaris <github_me@nahsi.dev>
This commit is contained in:
Akim
2023-08-25 00:15:49 +07:00
committed by GitHub
parent 2d2f5591cf
commit 97c24918d8
130 changed files with 3350 additions and 3119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
packages/core/js-client/src/api.ts Normal file
View File

@ -0,0 +1,173 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { FnConfig, FunctionCallDef, ServiceDef } from '@fluencelabs/interfaces';
import type { IFluenceClient } from '@fluencelabs/interfaces';
import { getArgumentTypes } from '@fluencelabs/interfaces';
import { isFluencePeer } from '@fluencelabs/interfaces';
import { callAquaFunction, Fluence, registerService } from './index.js';
/**
* Convenience function to support Aqua `func` generation backend
* The compiler only need to generate a call the function and provide the corresponding definitions and the air script
*
* @param rawFnArgs - raw arguments passed by user to the generated function
* @param def - function definition generated by the Aqua compiler
* @param script - air script with function execution logic generated by the Aqua compiler
*/
export const v5_callFunction = async (
rawFnArgs: Array<any>,
def: FunctionCallDef,
script: string,
): Promise<unknown> => {
const { args, client: peer, config } = await extractFunctionArgs(rawFnArgs, def);
return callAquaFunction({
args,
def,
script,
config: config || {},
peer: peer,
});
};
/**
* Convenience function to support Aqua `service` generation backend
* The compiler only need to generate a call the function and provide the corresponding definitions and the air script
* @param args - raw arguments passed by user to the generated function
* @param def - service definition generated by the Aqua compiler
*/
export const v5_registerService = async (args: any[], def: ServiceDef): Promise<unknown> => {
const { peer, service, serviceId } = await extractServiceArgs(args, def.defaultServiceId);
return registerService({
def,
service,
serviceId,
peer,
});
};
/**
* Arguments could be passed in one these configurations:
* [...actualArgs]
* [peer, ...actualArgs]
* [...actualArgs, config]
* [peer, ...actualArgs, config]
*
* This function select the appropriate configuration and returns
* arguments in a structured way of: { peer, config, args }
*/
const extractFunctionArgs = async (
args: any[],
def: FunctionCallDef,
): Promise<{
client: IFluenceClient;
config?: FnConfig;
args: { [key: string]: any };
}> => {
const argumentTypes = getArgumentTypes(def);
const argumentNames = Object.keys(argumentTypes);
const numberOfExpectedArgs = argumentNames.length;
let peer: IFluenceClient;
let structuredArgs: any[];
let config: FnConfig;
if (isFluencePeer(args[0])) {
peer = args[0];
structuredArgs = args.slice(1, numberOfExpectedArgs + 1);
config = args[numberOfExpectedArgs + 1];
} else {
if (!Fluence.defaultClient) {
throw new Error(
'Could not register Aqua service because the client is not initialized. Did you forget to call Fluence.connect()?',
);
}
peer = Fluence.defaultClient;
structuredArgs = args.slice(0, numberOfExpectedArgs);
config = args[numberOfExpectedArgs];
}
if (structuredArgs.length !== numberOfExpectedArgs) {
throw new Error(`Incorrect number of arguments. Expecting ${numberOfExpectedArgs}`);
}
const argsRes = argumentNames.reduce((acc, name, index) => ({ ...acc, [name]: structuredArgs[index] }), {});
return {
client: peer,
config: config,
args: argsRes,
};
};
/**
* Arguments could be passed in one these configurations:
* [serviceObject]
* [peer, serviceObject]
* [defaultId, serviceObject]
* [peer, defaultId, serviceObject]
*
* Where serviceObject is the raw object with function definitions passed by user
*
* This function select the appropriate configuration and returns
* arguments in a structured way of: { peer, serviceId, service }
*/
const extractServiceArgs = async (
args: any[],
defaultServiceId?: string,
): Promise<{ peer: IFluenceClient; serviceId: string; service: any }> => {
let peer: IFluenceClient;
let serviceId: any;
let service: any;
if (isFluencePeer(args[0])) {
peer = args[0];
} else {
if (!Fluence.defaultClient) {
throw new Error(
'Could not register Aqua service because the client is not initialized. Did you forget to call Fluence.connect()?',
);
}
peer = Fluence.defaultClient;
}
if (typeof args[0] === 'string') {
serviceId = args[0];
} else if (typeof args[1] === 'string') {
serviceId = args[1];
} else {
serviceId = defaultServiceId;
}
// Figuring out which overload is the service.
// If the first argument is not Fluence Peer and it is an object, then it can only be the service def
// If the first argument is peer, we are checking further. The second argument might either be
// an object, that it must be the service object
// or a string, which is the service id. In that case the service is the third argument
if (!isFluencePeer(args[0]) && typeof args[0] === 'object') {
service = args[0];
} else if (typeof args[1] === 'object') {
service = args[1];
} else {
service = args[2];
}
return {
peer: peer,
serviceId: serviceId,
service: service,
};
};

132
packages/core/js-client/src/clientPeer/ClientPeer.ts Normal file
View File

@ -0,0 +1,132 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { ClientConfig, ConnectionState, IFluenceClient, PeerIdB58, RelayOptions } from '@fluencelabs/interfaces';
import { RelayConnection, RelayConnectionConfig } from '../connection/RelayConnection.js';
import { fromOpts, KeyPair } from '../keypair/index.js';
import { FluencePeer, PeerConfig } from '../jsPeer/FluencePeer.js';
import { relayOptionToMultiaddr } from '../util/libp2pUtils.js';
import { IAvmRunner, IMarineHost } from '../marine/interfaces.js';
import { JsServiceHost } from '../jsServiceHost/JsServiceHost.js';
import { logger } from '../util/logger.js';
const log = logger('client');
const DEFAULT_TTL_MS = 7000;
const MAX_OUTBOUND_STREAMS = 1024;
const MAX_INBOUND_STREAMS = 1024;
export const makeClientPeerConfig = async (
relay: RelayOptions,
config: ClientConfig,
): Promise<{ peerConfig: PeerConfig; relayConfig: RelayConnectionConfig; keyPair: KeyPair }> => {
const opts = config?.keyPair || { type: 'Ed25519', source: 'random' };
const keyPair = await fromOpts(opts);
const relayAddress = relayOptionToMultiaddr(relay);
return {
peerConfig: {
debug: {
printParticleId: config?.debug?.printParticleId || false,
},
defaultTtlMs: config?.defaultTtlMs || DEFAULT_TTL_MS,
},
relayConfig: {
peerId: keyPair.getLibp2pPeerId(),
relayAddress: relayAddress,
dialTimeoutMs: config?.connectionOptions?.dialTimeoutMs,
maxInboundStreams: config?.connectionOptions?.maxInboundStreams || MAX_OUTBOUND_STREAMS,
maxOutboundStreams: config?.connectionOptions?.maxOutboundStreams || MAX_INBOUND_STREAMS,
},
keyPair: keyPair,
};
};
export class ClientPeer extends FluencePeer implements IFluenceClient {
private relayPeerId: PeerIdB58;
private relayConnection: RelayConnection;
constructor(
peerConfig: PeerConfig,
relayConfig: RelayConnectionConfig,
keyPair: KeyPair,
marine: IMarineHost,
) {
const relayConnection = new RelayConnection(relayConfig);
super(peerConfig, keyPair, marine, new JsServiceHost(), relayConnection);
this.relayPeerId = relayConnection.getRelayPeerId();
this.relayConnection = relayConnection;
}
getPeerId(): string {
return this.keyPair.getPeerId();
}
getPeerSecretKey(): Uint8Array {
return this.keyPair.toEd25519PrivateKey();
}
connectionState: ConnectionState = 'disconnected';
connectionStateChangeHandler: (state: ConnectionState) => void = () => {};
getRelayPeerId(): string {
return this.relayPeerId;
}
onConnectionStateChange(handler: (state: ConnectionState) => void): ConnectionState {
this.connectionStateChangeHandler = handler;
return this.connectionState;
}
private changeConnectionState(state: ConnectionState) {
this.connectionState = state;
this.connectionStateChangeHandler(state);
}
/**
* Connect to the Fluence network
*/
async connect(): Promise<void> {
return this.start();
}
// /**
// * Disconnect from the Fluence network
// */
async disconnect(): Promise<void> {
return this.stop();
}
async start(): Promise<void> {
log.trace('connecting to Fluence network');
this.changeConnectionState('connecting');
await super.start();
await this.relayConnection.start();
// TODO: check connection (`checkConnection` function) here
this.changeConnectionState('connected');
log.trace('connected');
}
async stop(): Promise<void> {
log.trace('disconnecting from Fluence network');
this.changeConnectionState('disconnecting');
await this.relayConnection.stop();
await super.stop();
this.changeConnectionState('disconnected');
log.trace('disconnected');
}
}

187
packages/core/js-client/src/clientPeer/__test__/client.spec.ts Normal file
View File

@ -0,0 +1,187 @@
import { it, describe, expect } from 'vitest';
import { handleTimeout } from '../../particle/Particle.js';
import { doNothing } from '../../jsServiceHost/serviceUtils.js';
import { registerHandlersHelper, withClient } from '../../util/testUtils.js';
import { checkConnection } from '../checkConnection.js';
import { nodes, RELAY } from './connection.js';
import { CallServiceData } from '../../jsServiceHost/interfaces.js';
describe('FluenceClient usage test suite', () => {
it('should make a call through network', async () => {
await withClient(RELAY, {}, async (peer) => {
// arrange
const result = await new Promise<string[]>((resolve, reject) => {
const script = `
(xor
(seq
(call %init_peer_id% ("load" "relay") [] init_relay)
(seq
(call init_relay ("op" "identity") ["hello world!"] result)
(call %init_peer_id% ("callback" "callback") [result])
)
)
(seq
(call init_relay ("op" "identity") [])
(call %init_peer_id% ("callback" "error") [%last_error%])
)
)`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
load: {
relay: () => {
return peer.getRelayPeerId();
},
},
callback: {
callback: (args: any) => {
const [val] = args;
resolve(val);
},
error: (args: any) => {
const [error] = args;
reject(error);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
expect(result).toBe('hello world!');
});
});
it('check connection should work', async function () {
await withClient(RELAY, {}, async (peer) => {
const isConnected = await checkConnection(peer);
expect(isConnected).toEqual(true);
});
});
it('check connection should work with ttl', async function () {
await withClient(RELAY, {}, async (peer) => {
const isConnected = await checkConnection(peer, 10000);
expect(isConnected).toEqual(true);
});
});
it('two clients should work inside the same time javascript process', async () => {
await withClient(RELAY, {}, async (peer1) => {
await withClient(RELAY, {}, async (peer2) => {
const res = new Promise((resolve) => {
peer2.internals.regHandler.common('test', 'test', (req: CallServiceData) => {
resolve(req.args[0]);
return {
result: {},
retCode: 0,
};
});
});
const script = `
(seq
(call "${peer1.getRelayPeerId()}" ("op" "identity") [])
(call "${peer2.getPeerId()}" ("test" "test") ["test"])
)
`;
const particle = peer1.internals.createNewParticle(script);
if (particle instanceof Error) {
throw particle;
}
peer1.internals.initiateParticle(particle, doNothing);
expect(await res).toEqual('test');
});
});
});
describe('should make connection to network', () => {
it('address as string', async () => {
await withClient(nodes[0].multiaddr, {}, async (peer) => {
const isConnected = await checkConnection(peer);
expect(isConnected).toBeTruthy();
});
});
it('address as node', async () => {
await withClient(nodes[0], {}, async (peer) => {
const isConnected = await checkConnection(peer);
expect(isConnected).toBeTruthy();
});
});
it('With connection options: dialTimeout', async () => {
await withClient(RELAY, { connectionOptions: { dialTimeoutMs: 100000 } }, async (peer) => {
const isConnected = await checkConnection(peer);
expect(isConnected).toBeTruthy();
});
});
it('With connection options: skipCheckConnection', async () => {
await withClient(RELAY, { connectionOptions: { skipCheckConnection: true } }, async (peer) => {
const isConnected = await checkConnection(peer);
expect(isConnected).toBeTruthy();
});
});
it('With connection options: defaultTTL', async () => {
await withClient(RELAY, { defaultTtlMs: 1 }, async (peer) => {
const isConnected = await checkConnection(peer);
expect(isConnected).toBeFalsy();
});
});
});
it.skip('Should throw correct error when the client tries to send a particle not to the relay', async () => {
await withClient(RELAY, {}, async (peer) => {
const promise = new Promise((resolve, reject) => {
const script = `
(xor
(call "incorrect_peer_id" ("any" "service") [])
(call %init_peer_id% ("callback" "error") [%last_error%])
)`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
callback: {
error: (args: any) => {
const [error] = args;
reject(error);
},
},
});
peer.internals.initiateParticle(particle, (stage) => {
if (stage.stage === 'sendingError') {
reject(stage.errorMessage);
}
});
});
await promise;
await expect(promise).rejects.toMatch(
'Particle is expected to be sent to only the single peer (relay which client is connected to)',
);
});
});
});

8
packages/core/js-client/src/clientPeer/__test__/connection.ts Normal file
View File

@ -0,0 +1,8 @@
export const nodes = [
{
multiaddr: '/ip4/127.0.0.1/tcp/9991/ws/p2p/12D3KooWBM3SdXWqGaawQDGQ6JprtwswEg3FWGvGhmgmMez1vRbR',
peerId: '12D3KooWBM3SdXWqGaawQDGQ6JprtwswEg3FWGvGhmgmMez1vRbR',
},
];
export const RELAY = nodes[0].multiaddr;

117
packages/core/js-client/src/clientPeer/checkConnection.ts Normal file
View File

@ -0,0 +1,117 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { ClientPeer } from './ClientPeer.js';
import { logger } from '../util/logger.js';
import { WrapFnIntoServiceCall } from '../jsServiceHost/serviceUtils.js';
import { handleTimeout } from '../particle/Particle.js';
const log = logger('connection');
/**
* Checks the network connection by sending a ping-like request to relay node
* @param { ClientPeer } peer - The Fluence Client instance.
*/
export const checkConnection = async (peer: ClientPeer, ttl?: number): Promise<boolean> => {
const msg = Math.random().toString(36).substring(7);
const promise = new Promise<string>((resolve, reject) => {
const script = `
(xor
(seq
(call %init_peer_id% ("load" "relay") [] init_relay)
(seq
(call %init_peer_id% ("load" "msg") [] msg)
(seq
(call init_relay ("op" "identity") [msg] result)
(call %init_peer_id% ("callback" "callback") [result])
)
)
)
(seq
(call init_relay ("op" "identity") [])
(call %init_peer_id% ("callback" "error") [%last_error%])
)
)`;
const particle = peer.internals.createNewParticle(script, ttl);
if (particle instanceof Error) {
return reject(particle.message);
}
peer.internals.regHandler.forParticle(
particle.id,
'load',
'relay',
WrapFnIntoServiceCall(() => {
return peer.getRelayPeerId();
}),
);
peer.internals.regHandler.forParticle(
particle.id,
'load',
'msg',
WrapFnIntoServiceCall(() => {
return msg;
}),
);
peer.internals.regHandler.forParticle(
particle.id,
'callback',
'callback',
WrapFnIntoServiceCall((args) => {
const [val] = args;
setTimeout(() => {
resolve(val);
}, 0);
return {};
}),
);
peer.internals.regHandler.forParticle(
particle.id,
'callback',
'error',
WrapFnIntoServiceCall((args) => {
const [error] = args;
setTimeout(() => {
reject(error);
}, 0);
return {};
}),
);
peer.internals.initiateParticle(
particle,
handleTimeout(() => {
reject('particle timed out');
}),
);
});
try {
const result = await promise;
if (result != msg) {
log.error("unexpected behavior. 'identity' must return the passed arguments.");
}
return true;
} catch (e) {
log.error('error on establishing connection. Relay: %s error: %j', peer.getRelayPeerId(), e);
return false;
}
};

223
packages/core/js-client/src/compilerSupport/__test__/v3.spec.ts Normal file
View File

@ -0,0 +1,223 @@
import { it, describe, expect, test } from 'vitest';
import { aqua2ts, ts2aqua } from '../conversions.js';
const i32 = { tag: 'scalar', name: 'i32' } as const;
const opt_i32 = {
tag: 'option',
type: i32,
} as const;
const array_i32 = { tag: 'array', type: i32 };
const array_opt_i32 = { tag: 'array', type: opt_i32 };
const labeledProduct = {
tag: 'labeledProduct',
fields: {
a: i32,
b: opt_i32,
c: array_opt_i32,
},
};
const struct = {
tag: 'struct',
name: 'someStruct',
fields: {
a: i32,
b: opt_i32,
c: array_opt_i32,
},
};
const structs = [
{
aqua: {
a: 1,
b: [2],
c: [[1], [2]],
},
ts: {
a: 1,
b: 2,
c: [1, 2],
},
},
{
aqua: {
a: 1,
b: [],
c: [[], [2]],
},
ts: {
a: 1,
b: null,
c: [null, 2],
},
},
];
const labeledProduct2 = {
tag: 'labeledProduct',
fields: {
x: i32,
y: i32,
},
};
const nestedLabeledProductType = {
tag: 'labeledProduct',
fields: {
a: labeledProduct2,
b: {
tag: 'option',
type: labeledProduct2,
},
c: {
tag: 'array',
type: labeledProduct2,
},
},
};
const nestedStructs = [
{
aqua: {
a: {
x: 1,
y: 2,
},
b: [
{
x: 1,
y: 2,
},
],
c: [
{
x: 1,
y: 2,
},
{
x: 3,
y: 4,
},
],
},
ts: {
a: {
x: 1,
y: 2,
},
b: {
x: 1,
y: 2,
},
c: [
{
x: 1,
y: 2,
},
{
x: 3,
y: 4,
},
],
},
},
{
aqua: {
a: {
x: 1,
y: 2,
},
b: [],
c: [],
},
ts: {
a: {
x: 1,
y: 2,
},
b: null,
c: [],
},
},
];
describe('Conversion from aqua to typescript', () => {
test.each`
aqua | ts | type
${1} | ${1} | ${i32}
${[]} | ${null} | ${opt_i32}
${[1]} | ${1} | ${opt_i32}
${[1, 2, 3]} | ${[1, 2, 3]} | ${array_i32}
${[]} | ${[]} | ${array_i32}
${[[1]]} | ${[1]} | ${array_opt_i32}
${[[]]} | ${[null]} | ${array_opt_i32}
${[[1], [2]]} | ${[1, 2]} | ${array_opt_i32}
${[[], [2]]} | ${[null, 2]} | ${array_opt_i32}
${structs[0].aqua} | ${structs[0].ts} | ${labeledProduct}
${structs[1].aqua} | ${structs[1].ts} | ${labeledProduct}
${structs[0].aqua} | ${structs[0].ts} | ${struct}
${structs[1].aqua} | ${structs[1].ts} | ${struct}
${nestedStructs[0].aqua} | ${nestedStructs[0].ts} | ${nestedLabeledProductType}
${nestedStructs[1].aqua} | ${nestedStructs[1].ts} | ${nestedLabeledProductType}
`(
//
'aqua: $aqua. ts: $ts. type: $type',
async ({ aqua, ts, type }) => {
// arrange
// act
const tsFromAqua = aqua2ts(aqua, type);
const aquaFromTs = ts2aqua(ts, type);
// assert
expect(tsFromAqua).toStrictEqual(ts);
expect(aquaFromTs).toStrictEqual(aqua);
},
);
});
describe('Conversion corner cases', () => {
it('Should accept undefined in object entry', () => {
// arrange
const type = {
tag: 'labeledProduct',
fields: {
x: opt_i32,
y: opt_i32,
},
} as const;
const valueInTs = {
x: 1,
};
const valueInAqua = {
x: [1],
y: [],
};
// act
const aqua = ts2aqua(valueInTs, type);
const ts = aqua2ts(valueInAqua, type);
// assert
expect(aqua).toStrictEqual({
x: [1],
y: [],
});
expect(ts).toStrictEqual({
x: 1,
y: null,
});
});
});

98
packages/core/js-client/src/compilerSupport/callFunction.ts Normal file
View File

@ -0,0 +1,98 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { getArgumentTypes, isReturnTypeVoid, CallAquaFunctionType } from '@fluencelabs/interfaces';
import {
injectRelayService,
registerParticleScopeService,
responseService,
errorHandlingService,
ServiceDescription,
userHandlerService,
injectValueService,
} from './services.js';
import { logger } from '../util/logger.js';
const log = logger('aqua');
/**
* Convenience function which does all the internal work of creating particles
* and making necessary service registrations in order to support Aqua function calls
*
* @param def - function definition generated by the Aqua compiler
* @param script - air script with function execution logic generated by the Aqua compiler
* @param config - options to configure Aqua function execution
* @param peer - Fluence Peer to invoke the function at
* @param args - args in the form of JSON where each key corresponds to the name of the argument
* @returns
*/
export const callAquaFunction: CallAquaFunctionType = ({ def, script, config, peer, args }) => {
log.trace('calling aqua function %j', { def, script, config, args });
const argumentTypes = getArgumentTypes(def);
const promise = new Promise((resolve, reject) => {
const particle = peer.internals.createNewParticle(script, config?.ttl);
if (particle instanceof Error) {
return reject(particle.message);
}
for (let [name, argVal] of Object.entries(args)) {
const type = argumentTypes[name];
let service: ServiceDescription;
if (type.tag === 'arrow') {
service = userHandlerService(def.names.callbackSrv, [name, type], argVal);
} else {
service = injectValueService(def.names.getDataSrv, name, type, argVal);
}
registerParticleScopeService(peer, particle, service);
}
registerParticleScopeService(peer, particle, responseService(def, resolve));
registerParticleScopeService(peer, particle, injectRelayService(def, peer));
registerParticleScopeService(peer, particle, errorHandlingService(def, reject));
peer.internals.initiateParticle(particle, (stage: any) => {
// If function is void, then it's completed when one of the two conditions is met:
// 1. The particle is sent to the network (state 'sent')
// 2. All CallRequests are executed, e.g., all variable loading and local function calls are completed (state 'localWorkDone')
if (isReturnTypeVoid(def) && (stage.stage === 'sent' || stage.stage === 'localWorkDone')) {
resolve(undefined);
}
if (stage.stage === 'sendingError') {
reject(`Could not send particle for ${def.functionName}: not connected (particle id: ${particle.id})`);
}
if (stage.stage === 'expired') {
reject(
`Particle expired after ttl of ${particle.ttl}ms for function ${def.functionName} (particle id: ${particle.id})`,
);
}
if (stage.stage === 'interpreterError') {
reject(
`Script interpretation failed for ${def.functionName}: ${stage.errorMessage} (particle id: ${particle.id})`,
);
}
});
});
return promise;
};

201
packages/core/js-client/src/compilerSupport/conversions.ts Normal file
View File

@ -0,0 +1,201 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { jsonify } from '../util/utils.js';
import { match } from 'ts-pattern';
import type { ArrowType, ArrowWithoutCallbacks, NonArrowType } from '@fluencelabs/interfaces';
import { CallServiceData } from '../jsServiceHost/interfaces.js';
/**
* Convert value from its representation in aqua language to representation in typescript
* @param value - value as represented in aqua
* @param type - definition of the aqua type
* @returns value represented in typescript
*/
export const aqua2ts = (value: any, type: NonArrowType): any => {
const res = match(type)
.with({ tag: 'nil' }, () => {
return null;
})
.with({ tag: 'option' }, (opt) => {
if (value.length === 0) {
return null;
} else {
return aqua2ts(value[0], opt.type);
}
})
// @ts-ignore
.with({ tag: 'scalar' }, { tag: 'bottomType' }, { tag: 'topType' }, () => {
return value;
})
.with({ tag: 'array' }, (arr) => {
return value.map((y: any) => aqua2ts(y, arr.type));
})
.with({ tag: 'struct' }, (x) => {
return Object.entries(x.fields).reduce((agg, [key, type]) => {
const val = aqua2ts(value[key], type);
return { ...agg, [key]: val };
}, {});
})
.with({ tag: 'labeledProduct' }, (x) => {
return Object.entries(x.fields).reduce((agg, [key, type]) => {
const val = aqua2ts(value[key], type);
return { ...agg, [key]: val };
}, {});
})
.with({ tag: 'unlabeledProduct' }, (x) => {
return x.items.map((type, index) => {
return aqua2ts(value[index], type);
});
})
// uncomment to check that every pattern in matched
// .exhaustive();
.otherwise(() => {
throw new Error('Unexpected tag: ' + jsonify(type));
});
return res;
};
/**
* Convert call service arguments list from their aqua representation to representation in typescript
* @param req - call service data
* @param arrow - aqua type definition
* @returns arguments in typescript representation
*/
export const aquaArgs2Ts = (req: CallServiceData, arrow: ArrowWithoutCallbacks) => {
const argTypes = match(arrow.domain)
.with({ tag: 'labeledProduct' }, (x) => {
return Object.values(x.fields);
})
.with({ tag: 'unlabeledProduct' }, (x) => {
return x.items;
})
.with({ tag: 'nil' }, (x) => {
return [];
})
// uncomment to check that every pattern in matched
// .exhaustive()
.otherwise(() => {
throw new Error('Unexpected tag: ' + jsonify(arrow.domain));
});
if (req.args.length !== argTypes.length) {
throw new Error(`incorrect number of arguments, expected: ${argTypes.length}, got: ${req.args.length}`);
}
return req.args.map((arg, index) => {
return aqua2ts(arg, argTypes[index]);
});
};
/**
* Convert value from its typescript representation to representation in aqua
* @param value - the value as represented in typescript
* @param type - definition of the aqua type
* @returns value represented in aqua
*/
export const ts2aqua = (value: any, type: NonArrowType): any => {
const res = match(type)
.with({ tag: 'nil' }, () => {
return null;
})
.with({ tag: 'option' }, (opt) => {
if (value === null || value === undefined) {
return [];
} else {
return [ts2aqua(value, opt.type)];
}
})
// @ts-ignore
.with({ tag: 'scalar' }, { tag: 'bottomType' }, { tag: 'topType' }, () => {
return value;
})
.with({ tag: 'array' }, (arr) => {
return value.map((y: any) => ts2aqua(y, arr.type));
})
.with({ tag: 'struct' }, (x) => {
return Object.entries(x.fields).reduce((agg, [key, type]) => {
const val = ts2aqua(value[key], type);
return { ...agg, [key]: val };
}, {});
})
.with({ tag: 'labeledProduct' }, (x) => {
return Object.entries(x.fields).reduce((agg, [key, type]) => {
const val = ts2aqua(value[key], type);
return { ...agg, [key]: val };
}, {});
})
.with({ tag: 'unlabeledProduct' }, (x) => {
return x.items.map((type, index) => {
return ts2aqua(value[index], type);
});
})
// uncomment to check that every pattern in matched
// .exhaustive()
.otherwise(() => {
throw new Error('Unexpected tag: ' + jsonify(type));
});
return res;
};
/**
* Convert return type of the service from it's typescript representation to representation in aqua
* @param returnValue - the value as represented in typescript
* @param arrowType - the arrow type which describes the service
* @returns - value represented in aqua
*/
export const returnType2Aqua = (returnValue: any, arrowType: ArrowType<NonArrowType>) => {
if (arrowType.codomain.tag === 'nil') {
return {};
}
if (arrowType.codomain.items.length === 0) {
return {};
}
if (arrowType.codomain.items.length === 1) {
return ts2aqua(returnValue, arrowType.codomain.items[0]);
}
return arrowType.codomain.items.map((type, index) => {
return ts2aqua(returnValue[index], type);
});
};
/**
* Converts response value from aqua its representation to representation in typescript
* @param req - call service data
* @param arrow - aqua type definition
* @returns response value in typescript representation
*/
export const responseServiceValue2ts = (req: CallServiceData, arrow: ArrowType<any>) => {
return match(arrow.codomain)
.with({ tag: 'nil' }, () => {
return undefined;
})
.with({ tag: 'unlabeledProduct' }, (x) => {
if (x.items.length === 0) {
return undefined;
}
if (x.items.length === 1) {
return aqua2ts(req.args[0], x.items[0]);
}
return req.args.map((y, index) => aqua2ts(y, x.items[index]));
})
.exhaustive();
};

55
packages/core/js-client/src/compilerSupport/registerService.ts Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { RegisterServiceType } from '@fluencelabs/interfaces';
import { registerGlobalService, userHandlerService } from './services.js';
import { logger } from '../util/logger.js';
const log = logger('aqua');
export const registerService: RegisterServiceType = ({ peer, def, serviceId, service }) => {
log.trace('registering aqua service %o', { def, serviceId, service });
// Checking for missing keys
const requiredKeys = def.functions.tag === 'nil' ? [] : Object.keys(def.functions.fields);
const incorrectServiceDefinitions = requiredKeys.filter((f) => !(f in service));
if (!!incorrectServiceDefinitions.length) {
throw new Error(
`Error registering service ${serviceId}: missing functions: ` +
incorrectServiceDefinitions.map((d) => "'" + d + "'").join(', '),
);
}
if (!serviceId) {
serviceId = def.defaultServiceId;
}
if (!serviceId) {
throw new Error('Service ID must be specified');
}
const singleFunctions = def.functions.tag === 'nil' ? [] : Object.entries(def.functions.fields);
for (let singleFunction of singleFunctions) {
let [name, type] = singleFunction;
// The function has type of (arg1, arg2, arg3, ... , callParams) => CallServiceResultType | void
// Account for the fact that user service might be defined as a class - .bind(...)
const userDefinedHandler = service[name].bind(service);
const serviceDescription = userHandlerService(serviceId, singleFunction, userDefinedHandler);
registerGlobalService(peer, serviceDescription);
}
log.trace('aqua service registered %s', serviceId);
};

196
packages/core/js-client/src/compilerSupport/services.ts Normal file
View File

@ -0,0 +1,196 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { SecurityTetraplet } from '@fluencelabs/avm';
import { match } from 'ts-pattern';
import { Particle } from '../particle/Particle.js';
import { aquaArgs2Ts, responseServiceValue2ts, returnType2Aqua, ts2aqua } from './conversions.js';
import {
CallParams,
ArrowWithoutCallbacks,
FunctionCallConstants,
FunctionCallDef,
NonArrowType,
IFluenceInternalApi,
} from '@fluencelabs/interfaces';
import { CallServiceData, GenericCallServiceHandler, ResultCodes } from '../jsServiceHost/interfaces.js';
export interface ServiceDescription {
serviceId: string;
fnName: string;
handler: GenericCallServiceHandler;
}
/**
* Creates a service which injects relay's peer id into aqua space
*/
export const injectRelayService = (def: FunctionCallDef, peer: IFluenceInternalApi) => {
return {
serviceId: def.names.getDataSrv,
fnName: def.names.relay,
handler: () => {
return {
retCode: ResultCodes.success,
result: peer.internals.getRelayPeerId(),
};
},
};
};
/**
* Creates a service which injects plain value into aqua space
*/
export const injectValueService = (serviceId: string, fnName: string, valueType: NonArrowType, value: any) => {
return {
serviceId: serviceId,
fnName: fnName,
handler: () => {
return {
retCode: ResultCodes.success,
result: ts2aqua(value, valueType),
};
},
};
};
/**
* Creates a service which is used to return value from aqua function into typescript space
*/
export const responseService = (def: FunctionCallDef, resolveCallback: Function) => {
return {
serviceId: def.names.responseSrv,
fnName: def.names.responseFnName,
handler: (req: CallServiceData) => {
const userFunctionReturn = responseServiceValue2ts(req, def.arrow);
setTimeout(() => {
resolveCallback(userFunctionReturn);
}, 0);
return {
retCode: ResultCodes.success,
result: {},
};
},
};
};
/**
* Creates a service which is used to return errors from aqua function into typescript space
*/
export const errorHandlingService = (def: FunctionCallDef, rejectCallback: Function) => {
return {
serviceId: def.names.errorHandlingSrv,
fnName: def.names.errorFnName,
handler: (req: CallServiceData) => {
const [err, _] = req.args;
setTimeout(() => {
rejectCallback(err);
}, 0);
return {
retCode: ResultCodes.success,
result: {},
};
},
};
};
/**
* Creates a service for user-defined service function handler
*/
export const userHandlerService = (
serviceId: string,
arrowType: [string, ArrowWithoutCallbacks],
userHandler: (...args: Array<unknown>) => Promise<unknown>,
) => {
const [fnName, type] = arrowType;
return {
serviceId,
fnName,
handler: async (req: CallServiceData) => {
const args = [...aquaArgs2Ts(req, type), extractCallParams(req, type)];
const rawResult = await userHandler.apply(null, args);
const result = returnType2Aqua(rawResult, type);
return {
retCode: ResultCodes.success,
result: result,
};
},
};
};
/**
* Converts argument of aqua function to a corresponding service.
* For arguments of non-arrow types the resulting service injects the argument into aqua space.
* For arguments of arrow types the resulting service calls the corresponding function.
*/
export const argToServiceDef = (
arg: any,
argName: string,
argType: NonArrowType | ArrowWithoutCallbacks,
names: FunctionCallConstants,
): ServiceDescription => {
if (argType.tag === 'arrow') {
return userHandlerService(names.callbackSrv, [argName, argType], arg);
} else {
return injectValueService(names.getDataSrv, argName, arg, argType);
}
};
/**
* Extracts call params from from call service data according to aqua type definition
*/
const extractCallParams = (req: CallServiceData, arrow: ArrowWithoutCallbacks): CallParams<any> => {
const names = match(arrow.domain)
.with({ tag: 'nil' }, () => {
return [] as string[];
})
.with({ tag: 'labeledProduct' }, (x) => {
return Object.keys(x.fields);
})
.with({ tag: 'unlabeledProduct' }, (x) => {
return x.items.map((_, index) => 'arg' + index);
})
.exhaustive();
const tetraplets: Record<string, SecurityTetraplet[]> = {};
for (let i = 0; i < req.args.length; i++) {
if (names[i]) {
tetraplets[names[i]] = req.tetraplets[i];
}
}
const callParams = {
...req.particleContext,
tetraplets,
};
return callParams;
};
export const registerParticleScopeService = (
peer: IFluenceInternalApi,
particle: Particle,
service: ServiceDescription,
) => {
peer.internals.regHandler.forParticle(particle.id, service.serviceId, service.fnName, service.handler);
};
export const registerGlobalService = (peer: IFluenceInternalApi, service: ServiceDescription) => {
peer.internals.regHandler.common(service.serviceId, service.fnName, service.handler);
};

221
packages/core/js-client/src/connection/RelayConnection.ts Normal file
View File

@ -0,0 +1,221 @@
/*
* Copyright 2020 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { PeerIdB58 } from '@fluencelabs/interfaces';
import { pipe } from 'it-pipe';
import { encode, decode } from 'it-length-prefixed';
import type { PeerId } from '@libp2p/interface/peer-id';
import { createLibp2p, Libp2p } from 'libp2p';
import { noise } from '@chainsafe/libp2p-noise';
import { mplex } from '@libp2p/mplex';
import { webSockets } from '@libp2p/websockets';
import { all } from '@libp2p/websockets/filters';
import { multiaddr } from '@multiformats/multiaddr';
import type { Multiaddr } from '@multiformats/multiaddr';
import map from 'it-map';
import { fromString } from 'uint8arrays/from-string';
import { toString } from 'uint8arrays/to-string';
import { logger } from '../util/logger.js';
import { Subject } from 'rxjs';
import { throwIfHasNoPeerId } from '../util/libp2pUtils.js';
import { IConnection } from './interfaces.js';
import { IParticle } from '../particle/interfaces.js';
import { Particle, serializeToString } from '../particle/Particle.js';
import { IStartable } from '../util/commonTypes.js';
const log = logger('connection');
export const PROTOCOL_NAME = '/fluence/particle/2.0.0';
/**
* Options to configure fluence relay connection
*/
export interface RelayConnectionConfig {
/**
* Peer id of the Fluence Peer
*/
peerId: PeerId;
/**
* Multiaddress of the relay to make connection to
*/
relayAddress: Multiaddr;
/**
* The dialing timeout in milliseconds
*/
dialTimeoutMs?: number;
/**
* The maximum number of inbound streams for the libp2p node.
* Default: 1024
*/
maxInboundStreams: number;
/**
* The maximum number of outbound streams for the libp2p node.
* Default: 1024
*/
maxOutboundStreams: number;
}
/**
* Implementation for JS peers which connects to Fluence through relay node
*/
export class RelayConnection implements IStartable, IConnection {
private relayAddress: Multiaddr;
private lib2p2Peer: Libp2p | null = null;
constructor(private config: RelayConnectionConfig) {
this.relayAddress = multiaddr(this.config.relayAddress);
throwIfHasNoPeerId(this.relayAddress);
}
getRelayPeerId(): string {
// since we check for peer id in constructor, we can safely use ! here
return this.relayAddress.getPeerId()!;
}
supportsRelay(): boolean {
return true;
}
particleSource = new Subject<IParticle>();
async start(): Promise<void> {
// check if already started
if (this.lib2p2Peer !== null) {
return;
}
const lib2p2Peer = await createLibp2p({
peerId: this.config.peerId,
transports: [
webSockets({
filter: all,
}),
],
streamMuxers: [mplex()],
connectionEncryption: [noise()],
connectionManager: {
dialTimeout: this.config.dialTimeoutMs,
},
connectionGater: {
// By default, this function forbids connections to private peers. For example multiaddr with ip 127.0.0.1 isn't allowed
denyDialMultiaddr: () => Promise.resolve(false)
}
});
this.lib2p2Peer = lib2p2Peer;
this.lib2p2Peer.start();
await this.connect();
}
async stop(): Promise<void> {
// check if already stopped
if (this.lib2p2Peer === null) {
return;
}
await this.lib2p2Peer.unhandle(PROTOCOL_NAME);
await this.lib2p2Peer.stop();
}
async sendParticle(nextPeerIds: PeerIdB58[], particle: IParticle): Promise<void> {
if (this.lib2p2Peer === null) {
throw new Error('Relay connection is not started');
}
if (nextPeerIds.length !== 1 && nextPeerIds[0] !== this.getRelayPeerId()) {
throw new Error(
`Relay connection only accepts peer id of the connected relay. Got: ${JSON.stringify(
nextPeerIds,
)} instead.`,
);
}
/*
TODO:: find out why this doesn't work and a new connection has to be established each time
if (this._connection.streams.length !== 1) {
throw new Error('Incorrect number of streams in FluenceConnection');
}
const sink = this._connection.streams[0].sink;
*/
const stream = await this.lib2p2Peer.dialProtocol(this.relayAddress, PROTOCOL_NAME);
const sink = stream.sink;
pipe(
[fromString(serializeToString(particle))],
// @ts-ignore
encode(),
sink,
);
}
private async connect() {
if (this.lib2p2Peer === null) {
throw new Error('Relay connection is not started');
}
this.lib2p2Peer.handle(
[PROTOCOL_NAME],
async ({ connection, stream }) => {
pipe(
stream.source,
// @ts-ignore
decode(),
// @ts-ignore
(source) => map(source, (buf) => toString(buf.subarray())),
async (source) => {
try {
for await (const msg of source) {
try {
const particle = Particle.fromString(msg);
this.particleSource.next(particle);
} catch (e) {
log.error('error on handling a new incoming message: %j', e);
}
}
} catch (e) {
log.error('connection closed: %j', e);
}
},
);
},
{
maxInboundStreams: this.config.maxInboundStreams,
maxOutboundStreams: this.config.maxOutboundStreams,
},
);
log.debug("dialing to the node with client's address: %s", this.lib2p2Peer.peerId.toString());
try {
await this.lib2p2Peer.dial(this.relayAddress);
} catch (e: any) {
if (e.name === 'AggregateError' && e._errors?.length === 1) {
const error = e._errors[0];
throw new Error(`Error dialing node ${this.relayAddress}:\n${error.code}\n${error.message}`);
} else {
throw e;
}
}
}
}

45
packages/core/js-client/src/connection/interfaces.ts Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { PeerIdB58 } from '@fluencelabs/interfaces';
import type { Subscribable } from 'rxjs';
import { IParticle } from '../particle/interfaces.js';
/**
* Interface for connection used in Fluence Peer.
*/
export interface IConnection {
/**
* Observable that emits particles received from the connection.
*/
particleSource: Subscribable<IParticle>;
/**
* Send particle to the network using the connection.
* @param nextPeerIds - list of peer ids to send the particle to
* @param particle - particle to send
*/
sendParticle(nextPeerIds: PeerIdB58[], particle: IParticle): Promise<void>;
/**
* Get peer id of the relay peer. Throws an error if the connection doesn't support relay.
*/
getRelayPeerId(): PeerIdB58;
/**
* Check if the connection supports relay.
*/
supportsRelay(): boolean;
}

80
packages/core/js-client/src/ephemeral/__test__/ephemeral.spec.ts Normal file
View File

@ -0,0 +1,80 @@
import { it, describe, expect, beforeEach, afterEach } from 'vitest';
import { DEFAULT_CONFIG, FluencePeer } from '../../jsPeer/FluencePeer.js';
import { CallServiceData, ResultCodes } from '../../jsServiceHost/interfaces.js';
import { KeyPair } from '../../keypair/index.js';
import { EphemeralNetworkClient } from '../client.js';
import { EphemeralNetwork, defaultConfig } from '../network.js';
let en: EphemeralNetwork;
let client: FluencePeer;
const relay = defaultConfig.peers[0].peerId;
// TODO: race condition here. Needs to be fixed
describe.skip('Ephemeral networks tests', () => {
beforeEach(async () => {
en = new EphemeralNetwork(defaultConfig);
await en.up();
const kp = await KeyPair.randomEd25519();
client = new EphemeralNetworkClient(DEFAULT_CONFIG, kp, en, relay);
await client.start();
});
afterEach(async () => {
if (client) {
await client.stop();
}
if (en) {
await en.down();
}
});
it('smoke test', async function () {
// arrange
const peers = defaultConfig.peers.map((x) => x.peerId);
const script = `
(seq
(call "${relay}" ("op" "noop") [])
(seq
(call "${peers[1]}" ("op" "noop") [])
(seq
(call "${peers[2]}" ("op" "noop") [])
(seq
(call "${peers[3]}" ("op" "noop") [])
(seq
(call "${peers[4]}" ("op" "noop") [])
(seq
(call "${peers[5]}" ("op" "noop") [])
(seq
(call "${relay}" ("op" "noop") [])
(call %init_peer_id% ("test" "test") [])
)
)
)
)
)
)
)
`;
const particle = client.internals.createNewParticle(script);
const promise = new Promise<string>((resolve) => {
client.internals.regHandler.forParticle(particle.id, 'test', 'test', (req: CallServiceData) => {
resolve('success');
return {
result: 'test',
retCode: ResultCodes.success,
};
});
});
// act
client.internals.initiateParticle(particle, () => {});
// assert
await expect(promise).resolves.toBe('success');
});
});

37
packages/core/js-client/src/ephemeral/client.ts Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { PeerIdB58 } from '@fluencelabs/interfaces';
import { FluencePeer, PeerConfig } from '../jsPeer/FluencePeer.js';
import { KeyPair } from '../keypair/index.js';
import { WasmLoaderFromNpm } from '../marine/deps-loader/node.js';
import { WorkerLoader } from '../marine/worker-script/workerLoader.js';
import { MarineBackgroundRunner } from '../marine/worker/index.js';
import { EphemeralNetwork } from './network.js';
import { JsServiceHost } from '../jsServiceHost/JsServiceHost.js';
/**
* Ephemeral network client is a FluencePeer that connects to a relay peer in an ephemeral network.
*/
export class EphemeralNetworkClient extends FluencePeer {
constructor(config: PeerConfig, keyPair: KeyPair, network: EphemeralNetwork, relay: PeerIdB58) {
const workerLoader = new WorkerLoader();
const controlModuleLoader = new WasmLoaderFromNpm('@fluencelabs/marine-js', 'marine-js.wasm');
const avmModuleLoader = new WasmLoaderFromNpm('@fluencelabs/avm', 'avm.wasm');
const marine = new MarineBackgroundRunner(workerLoader, controlModuleLoader, avmModuleLoader);
const conn = network.getRelayConnection(keyPair.getPeerId(), relay);
super(config, keyPair, marine, new JsServiceHost(), conn);
}
}

288
packages/core/js-client/src/ephemeral/network.ts Normal file
View File

@ -0,0 +1,288 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { PeerIdB58 } from '@fluencelabs/interfaces';
import { fromBase64Sk, KeyPair } from '../keypair/index.js';
import { MarineBackgroundRunner } from '../marine/worker/index.js';
import { WorkerLoaderFromFs } from '../marine/deps-loader/node.js';
import { logger } from '../util/logger.js';
import { Subject } from 'rxjs';
import { Particle } from '../particle/Particle.js';
import { WasmLoaderFromNpm } from '../marine/deps-loader/node.js';
import { DEFAULT_CONFIG, FluencePeer } from '../jsPeer/FluencePeer.js';
import { IConnection } from '../connection/interfaces.js';
import { IAvmRunner, IMarineHost } from '../marine/interfaces.js';
import { JsServiceHost } from '../jsServiceHost/JsServiceHost.js';
const log = logger('ephemeral');
interface EphemeralConfig {
peers: Array<{
peerId: PeerIdB58;
sk: string;
}>;
}
export const defaultConfig = {
peers: [
{
peerId: '12D3KooWJankP2PcEDYCZDdJ26JsU8BMRfdGWyGqbtFiWyoKVtmx',
sk: 'dWNAHhDVuFj9bEieILMu6TcCFRxBJdOPIvAWmf4sZQI=',
},
{
peerId: '12D3KooWSBTB5sYxdwayUyTnqopBwABsnGFY3p4dTx5hABYDtJjV',
sk: 'dOmaxAeu4Th+MJ22vRDLMFTNbiDgKNXar9fW9ofAMgQ=',
},
{
peerId: '12D3KooWQjwf781DJ41moW5RrZXypLdnTbo6aMsoA8QLctGGX8RB',
sk: 'TgzaLlxXuOMDNuuuTKEHUKsW0jM4AmX0gahFvkB1KgE=',
},
{
peerId: '12D3KooWCXWTLFyY1mqKnNAhLQTsjW1zqDzCMbUs8M4a8zdz28HK',
sk: 'hiO2Ta8g2ibMQ7iu5yj9CfN+qQCwE8oRShjr7ortKww=',
},
{
peerId: '12D3KooWPmZpf4ng6GMS39HLagxsXbjiTPLH5CFJpFAHyN6amw6V',
sk: 'LzJtOHTqxfrlHDW40BKiLfjai8JU4yW6/s2zrXLCcQE=',
},
{
peerId: '12D3KooWKrx8PZxM1R9A8tp2jmrFf6c6q1ZQiWfD4QkNgh7fWSoF',
sk: 'XMhlk/xr1FPcp7sKQhS18doXlq1x16EMhBC2NGW2LQ4=',
},
{
peerId: '12D3KooWCbJHvnzSZEXjR1UJmtSUozuJK13iRiCYHLN1gjvm4TZZ',
sk: 'KXPAIqxrSHr7v0ngv3qagcqivFvnQ0xd3s1/rKmi8QU=',
},
{
peerId: '12D3KooWEvKe7WQHp42W4xhHRgTAWQjtDWyH38uJbLHAsMuTtYvD',
sk: 'GCYMAshGnsrNtrHhuT7ayzh5uCzX99J03PmAXoOcCgw=',
},
{
peerId: '12D3KooWSznSHN3BGrSykBXkLkFsqo9SYB73wVauVdqeuRt562cC',
sk: 'UP+SEuznS0h259VbFquzyOJAQ4W5iIwhP+hd1PmUQQ0=',
},
{
peerId: '12D3KooWF57jwbShfnT3c4dNfRDdGjr6SQ3B71m87UVpEpSWHFwi',
sk: '8dl+Crm5RSh0eh+LqLKwX8/Eo4QLpvIjfD8L0wzX4A4=',
},
{
peerId: '12D3KooWBWrzpSg9nwMLBCa2cJubUjTv63Mfy6PYg9rHGbetaV5C',
sk: 'qolc1FcpJ+vHDon0HeXdUYnstjV1wiVx2p0mjblrfAg=',
},
{
peerId: '12D3KooWNkLVU6juM8oyN2SVq5nBd2kp7Rf4uzJH1hET6vj6G5j6',
sk: 'vN6QzWILTM7hSHp+iGkKxiXcqs8bzlnH3FPaRaDGSQY=',
},
{
peerId: '12D3KooWKo1YwGL5vivPiKJMJS7wjtB6B2nJNdSXPkSABT4NKBUU',
sk: 'YbDQ++bsor2kei7rYAsu2SbyoiOYPRzFRZWnNRUpBgQ=',
},
{
peerId: '12D3KooWLUyBKmmNCyxaPkXoWcUFPcy5qrZsUo2E1tyM6CJmGJvC',
sk: 'ptB9eSFMKudAtHaFgDrRK/1oIMrhBujxbMw2Pzwx/wA=',
},
{
peerId: '12D3KooWAEZXME4KMu9FvLezsJWDbYFe2zyujyMnDT1AgcAxgcCk',
sk: 'xtwTOKgAbDIgkuPf7RKiR7gYyZ1HY4mOgFMv3sOUcAQ=',
},
{
peerId: '12D3KooWEhXetsFVAD9h2dRz9XgFpfidho1TCZVhFrczX8h8qgzY',
sk: '1I2MGuiKG1F4FDMiRihVOcOP2mxzOLWJ99MeexK27A4=',
},
{
peerId: '12D3KooWDBfVNdMyV3hPEF4WLBmx9DwD2t2SYuqZ2mztYmDzZWM1',
sk: 'eqJ4Bp7iN4aBXgPH0ezwSg+nVsatkYtfrXv9obI0YQ0=',
},
{
peerId: '12D3KooWSyY7wiSiR4vbXa1WtZawi3ackMTqcQhEPrvqtagoWPny',
sk: 'UVM3SBJhPYIY/gafpnd9/q/Fn9V4BE9zkgrvF1T7Pgc=',
},
{
peerId: '12D3KooWFZmBMGG9PxTs9s6ASzkLGKJWMyPheA5ruaYc2FDkDTmv',
sk: '8RbZfEVpQhPVuhv64uqxENDuSoyJrslQoSQJznxsTQ0=',
},
{
peerId: '12D3KooWBbhUaqqur6KHPunnKxXjY1daCtqJdy4wRji89LmAkVB4',
sk: 'RbgKmG6soWW9uOi7yRedm+0Qck3f3rw6MSnDP7AcBQs=',
},
],
};
export interface IEphemeralConnection extends IConnection {
readonly selfPeerId: PeerIdB58;
readonly connections: Map<PeerIdB58, IEphemeralConnection>;
receiveParticle(particle: Particle): void;
}
export class EphemeralConnection implements IConnection, IEphemeralConnection {
readonly selfPeerId: PeerIdB58;
readonly connections: Map<PeerIdB58, IEphemeralConnection> = new Map();
constructor(selfPeerId: PeerIdB58) {
this.selfPeerId = selfPeerId;
}
connectToOther(other: IEphemeralConnection) {
if (other.selfPeerId === this.selfPeerId) {
return;
}
this.connections.set(other.selfPeerId, other);
other.connections.set(this.selfPeerId, this);
}
disconnectFromOther(other: IEphemeralConnection) {
this.connections.delete(other.selfPeerId);
other.connections.delete(this.selfPeerId);
}
disconnectFromAll() {
for (let other of this.connections.values()) {
this.disconnectFromOther(other);
}
}
particleSource = new Subject<Particle>();
receiveParticle(particle: Particle): void {
this.particleSource.next(Particle.fromString(particle.toString()));
}
async sendParticle(nextPeerIds: string[], particle: Particle): Promise<void> {
const from = this.selfPeerId;
for (let to of nextPeerIds) {
const destConnection = this.connections.get(to);
if (destConnection === undefined) {
log.error('peer %s has no connection with %s', from, to);
continue;
}
// log.trace(`Sending particle from %s, to %j, particleId %s`, from, to, particle.id);
destConnection.receiveParticle(particle);
}
}
getRelayPeerId(): string {
if (this.connections.size === 1) {
return this.connections.keys().next().value;
}
throw new Error('relay is not supported in this Ephemeral network peer');
}
supportsRelay(): boolean {
return this.connections.size === 1;
}
}
class EphemeralPeer extends FluencePeer {
ephemeralConnection: EphemeralConnection;
constructor(keyPair: KeyPair, marine: IMarineHost) {
const conn = new EphemeralConnection(keyPair.getPeerId());
super(DEFAULT_CONFIG, keyPair, marine, new JsServiceHost(), conn);
this.ephemeralConnection = conn;
}
}
/**
* Ephemeral network implementation.
* Ephemeral network is a virtual network which runs locally and focuses on p2p interaction by removing connectivity layer out of the equation.
*/
export class EphemeralNetwork {
private peers: Map<PeerIdB58, EphemeralPeer> = new Map();
workerLoader: WorkerLoaderFromFs;
controlModuleLoader: WasmLoaderFromNpm;
avmModuleLoader: WasmLoaderFromNpm;
constructor(public readonly config: EphemeralConfig) {
// shared worker for all the peers
this.workerLoader = new WorkerLoaderFromFs('../../marine/worker-script');
this.controlModuleLoader = new WasmLoaderFromNpm('@fluencelabs/marine-js', 'marine-js.wasm');
this.avmModuleLoader = new WasmLoaderFromNpm('@fluencelabs/avm', 'avm.wasm');
}
/**
* Starts the Ephemeral network up
*/
async up(): Promise<void> {
log.trace('starting ephemeral network up...');
const promises = this.config.peers.map(async (x) => {
const kp = await fromBase64Sk(x.sk);
const marine = new MarineBackgroundRunner(this.workerLoader, this.controlModuleLoader, this.avmModuleLoader);
const peerId = kp.getPeerId();
if (peerId !== x.peerId) {
throw new Error(`Invalid config: peer id ${x.peerId} does not match the secret key ${x.sk}`);
}
return new EphemeralPeer(kp, marine);
});
const peers = await Promise.all(promises);
for (let i = 0; i < peers.length; i++) {
for (let j = 0; j < i; j++) {
if (i === j) {
continue;
}
peers[i].ephemeralConnection.connectToOther(peers[j].ephemeralConnection);
}
}
const startPromises = peers.map((x) => x.start());
await Promise.all(startPromises);
for (let p of peers) {
this.peers.set(p.keyPair.getPeerId(), p);
}
}
/**
* Shuts the ephemeral network down. Will disconnect all connected peers.
*/
async down(): Promise<void> {
log.trace('shutting down ephemeral network...');
const peers = Array.from(this.peers.entries());
const promises = peers.map(async ([k, p]) => {
await p.ephemeralConnection.disconnectFromAll();
await p.stop();
});
await Promise.all(promises);
this.peers.clear();
log.trace('ephemeral network shut down');
}
/**
* Gets a relay connection to the specified peer.
*/
getRelayConnection(peerId: PeerIdB58, relayPeerId: PeerIdB58): IConnection {
const relay = this.peers.get(relayPeerId);
if (relay === undefined) {
throw new Error(`Peer ${relayPeerId} is not found`);
}
const res = new EphemeralConnection(peerId);
res.connectToOther(relay.ephemeralConnection);
return res;
}
}

19
packages/core/js-client/src/fetchers/browser.ts Normal file
View File

@ -0,0 +1,19 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export async function fetchResource(assetPath: string, version: string) {
return fetch(new globalThis.URL(`@fluencelabs/js-client@${version}/dist` + assetPath, `https://unpkg.com/`));
}

30
packages/core/js-client/src/fetchers/index.ts Normal file
View File

@ -0,0 +1,30 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { fetchResource as fetchResourceBrowser } from './browser.js';
import { fetchResource as fetchResourceNode } from './node.js';
import process from 'process';
const isNode = typeof process !== 'undefined' && process?.release?.name === 'node';
export async function fetchResource(assetPath: string, version: string) {
switch (true) {
case isNode:
return fetchResourceNode(assetPath, version);
default:
return fetchResourceBrowser(assetPath, version);
}
}

44
packages/core/js-client/src/fetchers/node.ts Normal file
View File

@ -0,0 +1,44 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import fs from 'fs';
import url from 'url';
import path from 'path';
export async function fetchResource(assetPath: string, version: string) {
const file = await new Promise<ArrayBuffer>((resolve, reject) => {
// Cannot use 'fs/promises' with current vite config. This module is not polyfilled by default.
const root = path.dirname(url.fileURLToPath(import.meta.url));
const workerFilePath = path.join(root, '..', assetPath);
fs.readFile(workerFilePath, (err, data) => {
if (err) {
reject(err);
return;
}
resolve(data);
});
});
return new Response(file, {
headers: {
'Content-type':
assetPath.endsWith('.wasm')
? 'application/wasm'
: assetPath.endsWith('.js')
? 'application/javascript'
: 'application/text'
}
});
}

165
packages/core/js-client/src/index.ts Normal file
View File

@ -0,0 +1,165 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { ClientConfig, IFluenceClient, RelayOptions, ConnectionState, CallAquaFunctionType, RegisterServiceType } from '@fluencelabs/interfaces';
import { ClientPeer, makeClientPeerConfig } from './clientPeer/ClientPeer.js';
import { callAquaFunction } from './compilerSupport/callFunction.js';
import { registerService } from './compilerSupport/registerService.js';
import { MarineBackgroundRunner } from './marine/worker/index.js';
// @ts-ignore
import { BlobWorker, Worker } from 'threads';
import { doRegisterNodeUtils } from './services/NodeUtils.js';
import { fetchResource } from './fetchers/index.js';
import process from 'process';
import avmWasmUrl from '../node_modules/@fluencelabs/avm/dist/avm.wasm?url';
import marineJsWasmUrl from '../node_modules/@fluencelabs/marine-js/dist/marine-js.wasm?url';
import workerCodeUrl from '../node_modules/@fluencelabs/marine-worker/dist/__ENV__/marine-worker.umd.cjs?url';
const JS_CLIENT_VERSION = '__JS_CLIENT_VERSION__';
const isNode = typeof process !== 'undefined' && process?.release?.name === 'node';
const fetchWorkerCode = () => fetchResource(workerCodeUrl, JS_CLIENT_VERSION).then(res => res.text());
const fetchMarineJsWasm = () => fetchResource(marineJsWasmUrl, JS_CLIENT_VERSION).then(res => res.arrayBuffer());
const fetchAvmWasm = () => fetchResource(avmWasmUrl, JS_CLIENT_VERSION).then(res => res.arrayBuffer());
const createClient = async (relay: RelayOptions, config: ClientConfig): Promise<IFluenceClient> => {
const workerCode = await fetchWorkerCode();
const marineJsWasm = await fetchMarineJsWasm();
const avmWasm = await fetchAvmWasm();
const marine = new MarineBackgroundRunner({
getValue() {
return BlobWorker.fromText(workerCode)
},
start() {
return Promise.resolve(undefined);
},
stop() {
return Promise.resolve(undefined);
},
}, {
getValue() {
return marineJsWasm;
}, start(): Promise<void> {
return Promise.resolve(undefined);
}, stop(): Promise<void> {
return Promise.resolve(undefined);
}
}, {
getValue() {
return avmWasm;
}, start(): Promise<void> {
return Promise.resolve(undefined);
}, stop(): Promise<void> {
return Promise.resolve(undefined);
}
});
const { keyPair, peerConfig, relayConfig } = await makeClientPeerConfig(relay, config);
const client: IFluenceClient = new ClientPeer(peerConfig, relayConfig, keyPair, marine);
if (isNode) {
doRegisterNodeUtils(client);
}
await client.connect();
return client;
};
/**
* Public interface to Fluence Network
*/
export const Fluence = {
defaultClient: undefined as (IFluenceClient | undefined),
/**
* Connect to the Fluence network
* @param relay - relay node to connect to
* @param config - client configuration
*/
connect: async function(relay: RelayOptions, config: ClientConfig): Promise<void> {
const client = await createClient(relay, config);
this.defaultClient = client;
},
/**
* Disconnect from the Fluence network
*/
disconnect: async function(): Promise<void> {
await this.defaultClient?.disconnect();
this.defaultClient = undefined;
},
/**
* Handle connection state changes. Immediately returns the current connection state
*/
onConnectionStateChange(handler: (state: ConnectionState) => void): ConnectionState {
return this.defaultClient?.onConnectionStateChange(handler) || 'disconnected';
},
/**
* Low level API. Get the underlying client instance which holds the connection to the network
* @returns IFluenceClient instance
*/
getClient: async function(): Promise<IFluenceClient> {
if (!this.defaultClient) {
throw new Error('Fluence client is not initialized. Call Fluence.connect() first');
}
return this.defaultClient;
},
};
export type { IFluenceClient, ClientConfig, CallParams } from '@fluencelabs/interfaces';
export type {
ArrayType,
ArrowType,
ArrowWithCallbacks,
ArrowWithoutCallbacks,
BottomType,
FunctionCallConstants,
FunctionCallDef,
LabeledProductType,
NilType,
NonArrowType,
OptionType,
ProductType,
ScalarNames,
ScalarType,
ServiceDef,
StructType,
TopType,
UnlabeledProductType,
CallAquaFunctionType,
CallAquaFunctionArgs,
PassedArgs,
FnConfig,
RegisterServiceType,
RegisterServiceArgs,
} from '@fluencelabs/interfaces';
export { v5_callFunction, v5_registerService } from './api.js';
// @ts-ignore
globalThis.new_fluence = Fluence;
// @ts-ignore
globalThis.fluence = {
clientFactory: createClient,
callAquaFunction,
registerService,
};
export { createClient, callAquaFunction, registerService };
export { getFluenceInterface, getFluenceInterfaceFromGlobalThis } from './util/loadClient.js';

572
packages/core/js-client/src/jsPeer/FluencePeer.ts Normal file
View File

@ -0,0 +1,572 @@
/*
* Copyright 2021 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { KeyPair } from '../keypair/index.js';
import type { PeerIdB58 } from '@fluencelabs/interfaces';
import { deserializeAvmResult, InterpreterResult, KeyPairFormat, serializeAvmArgs } from '@fluencelabs/avm';
import {
cloneWithNewData,
getActualTTL,
hasExpired,
Particle,
ParticleExecutionStage,
ParticleQueueItem,
} from '../particle/Particle.js';
import { defaultCallParameters } from "@fluencelabs/marine-js/dist/types"
import { jsonify, isString } from '../util/utils.js';
import { concatMap, filter, pipe, Subject, tap, Unsubscribable } from 'rxjs';
import { defaultSigGuard, Sig } from '../services/Sig.js';
import { registerSig } from '../services/_aqua/services.js';
import { registerSrv } from '../services/_aqua/single-module-srv.js';
import { registerTracing } from '../services/_aqua/tracing.js';
import { Buffer } from 'buffer';
import { Srv } from '../services/SingleModuleSrv.js';
import { Tracing } from '../services/Tracing.js';
import { logger } from '../util/logger.js';
import { getParticleContext, registerDefaultServices, ServiceError } from '../jsServiceHost/serviceUtils.js';
import { IParticle } from '../particle/interfaces.js';
import { IConnection } from '../connection/interfaces.js';
import { IAvmRunner, IMarineHost } from '../marine/interfaces.js';
import {
CallServiceData,
CallServiceResult,
GenericCallServiceHandler,
IJsServiceHost,
ResultCodes,
} from '../jsServiceHost/interfaces.js';
import { JSONValue } from '../util/commonTypes.js';
const log_particle = logger('particle');
const log_peer = logger('peer');
export type PeerConfig = {
/**
* Sets the default TTL for all particles originating from the peer with no TTL specified.
* If the originating particle's TTL is defined then that value will be used
* If the option is not set default TTL will be 7000
*/
defaultTtlMs: number;
/**
* Enables\disabled various debugging features
*/
debug: {
/**
* If set to true, newly initiated particle ids will be printed to console.
* Useful to see what particle id is responsible for aqua function
*/
printParticleId: boolean;
};
};
export const DEFAULT_CONFIG: PeerConfig = {
debug: {
printParticleId: false,
},
defaultTtlMs: 7000,
};
/**
* This class implements the Fluence protocol for javascript-based environments.
* It provides all the necessary features to communicate with Fluence network
*/
export abstract class FluencePeer {
constructor(
protected readonly config: PeerConfig,
public readonly keyPair: KeyPair,
protected readonly marineHost: IMarineHost,
protected readonly jsServiceHost: IJsServiceHost,
protected readonly connection: IConnection,
) {
this._initServices();
}
/**
* Internal contract to cast unknown objects to IFluenceClient.
* If an unknown object has this property then we assume it is in fact a Peer and it implements IFluenceClient
* Check against this variable MUST NOT be coupled with any `FluencePeer` because otherwise it might get bundled
* brining a lot of unnecessary stuff alongside with it
*/
__isFluenceAwesome = true;
async start(): Promise<void> {
log_peer.trace('starting Fluence peer');
if (this.config?.debug?.printParticleId) {
this.printParticleId = true;
}
await this.marineHost.start();
this._startParticleProcessing();
this.isInitialized = true;
log_peer.trace('started Fluence peer');
}
/**
* Un-initializes the peer: stops all the underlying workflows, stops the Aqua VM
* and disconnects from the Fluence network
*/
async stop() {
log_peer.trace('stopping Fluence peer');
this._particleSourceSubscription?.unsubscribe();
this._stopParticleProcessing();
await this.marineHost.stop();
this.isInitialized = false;
log_peer.trace('stopped Fluence peer');
}
/**
* Registers marine service within the Fluence peer from wasm file.
* Following helper functions can be used to load wasm files:
* * loadWasmFromFileSystem
* * loadWasmFromNpmPackage
* * loadWasmFromServer
* @param wasm - buffer with the wasm file for service
* @param serviceId - the service id by which the service can be accessed in aqua
*/
async registerMarineService(wasm: SharedArrayBuffer | Buffer, serviceId: string): Promise<void> {
if (!this.marineHost) {
throw new Error("Can't register marine service: peer is not initialized");
}
if (this.jsServiceHost.hasService(serviceId)) {
throw new Error(`Service with '${serviceId}' id already exists`);
}
await this.marineHost.createService(wasm, serviceId);
}
/**
* Removes the specified marine service from the Fluence peer
* @param serviceId - the service id to remove
*/
async removeMarineService(serviceId: string): Promise<void> {
await this.marineHost.removeService(serviceId);
}
// internal api
/**
* @private Is not intended to be used manually. Subject to change
*/
get internals() {
return {
getServices: () => this._classServices,
getRelayPeerId: () => {
if (this.connection.supportsRelay()) {
return this.connection.getRelayPeerId();
}
throw new Error('Relay is not supported by the current connection');
},
parseAst: async (air: string): Promise<{ success: boolean; data: any }> => {
if (!this.isInitialized) {
new Error("Can't use avm: peer is not initialized");
}
const res = await this.marineHost.callService('avm', 'ast', [air], defaultCallParameters);
if (!isString(res)) {
throw new Error(`Call to avm:ast expected to return string. Actual return: ${res}`);
}
try {
if (res.startsWith('error')) {
return {
success: false,
data: res,
};
} else {
return {
success: true,
data: JSON.parse(res),
};
}
} catch (err) {
throw new Error('Failed to call avm. Result: ' + res + '. Error: ' + err);
}
},
createNewParticle: (script: string, ttl: number = this.config.defaultTtlMs): IParticle => {
return Particle.createNew(script, this.keyPair.getPeerId(), ttl);
},
/**
* Initiates a new particle execution starting from local peer
* @param particle - particle to start execution of
*/
initiateParticle: (particle: IParticle, onStageChange: (stage: ParticleExecutionStage) => void): void => {
if (!this.isInitialized) {
throw new Error('Cannot initiate new particle: peer is not initialized');
}
if (this.printParticleId) {
console.log('Particle id: ', particle.id);
}
this._incomingParticles.next({
particle: particle,
callResults: [],
onStageChange: onStageChange,
});
},
/**
* Register Call Service handler functions
*/
regHandler: {
/**
* Register handler for all particles
*/
common: this.jsServiceHost.registerGlobalHandler.bind(this.jsServiceHost),
/**
* Register handler which will be called only for particle with the specific id
*/
forParticle: this.jsServiceHost.registerParticleScopeHandler.bind(this.jsServiceHost),
},
};
}
// Queues for incoming and outgoing particles
private _incomingParticles = new Subject<ParticleQueueItem>();
private _outgoingParticles = new Subject<ParticleQueueItem & { nextPeerIds: PeerIdB58[] }>();
private _timeouts: Array<NodeJS.Timeout> = [];
private _particleSourceSubscription?: Unsubscribable;
private _particleQueues = new Map<string, Subject<ParticleQueueItem>>();
// Internal peer state
// @ts-expect-error - initialized in constructor through `_initServices` call
private _classServices: {
sig: Sig;
srv: Srv;
tracing: Tracing;
};
private isInitialized = false;
private printParticleId = false;
private _initServices() {
this._classServices = {
sig: new Sig(this.keyPair),
srv: new Srv(this),
tracing: new Tracing(),
};
const peerId = this.keyPair.getPeerId();
registerDefaultServices(this);
this._classServices.sig.securityGuard = defaultSigGuard(peerId);
registerSig(this, 'sig', this._classServices.sig);
registerSig(this, peerId, this._classServices.sig);
registerSrv(this, 'single_module_srv', this._classServices.srv);
registerTracing(this, 'tracingSrv', this._classServices.tracing);
}
private _startParticleProcessing() {
this._particleSourceSubscription = this.connection.particleSource.subscribe({
next: (p) => {
this._incomingParticles.next({ particle: p, callResults: [], onStageChange: () => {} });
},
});
this._incomingParticles
.pipe(
tap((item) => {
log_particle.debug('id %s. received:', item.particle.id);
log_particle.trace('id %s. data: %j', item.particle.id, {
initPeerId: item.particle.initPeerId,
timestamp: item.particle.timestamp,
ttl: item.particle.ttl,
signature: item.particle.signature,
});
log_particle.trace('id %s. script: %s', item.particle.id, item.particle.script);
log_particle.trace('id %s. call results: %j', item.particle.id, item.callResults);
}),
filterExpiredParticles(this._expireParticle.bind(this)),
)
.subscribe((item) => {
const p = item.particle;
let particlesQueue = this._particleQueues.get(p.id);
if (!particlesQueue) {
particlesQueue = this._createParticlesProcessingQueue();
this._particleQueues.set(p.id, particlesQueue);
const timeout = setTimeout(() => {
this._expireParticle(item);
}, getActualTTL(p));
this._timeouts.push(timeout);
}
particlesQueue.next(item);
});
this._outgoingParticles.subscribe((item) => {
// Do not send particle after the peer has been stopped
if (!this.isInitialized) {
return;
}
log_particle.debug(
'id %s. sending particle into network. Next peer ids: %s',
item.particle.id,
item.nextPeerIds.toString(),
);
this.connection
?.sendParticle(item.nextPeerIds, item.particle)
.then(() => {
item.onStageChange({ stage: 'sent' });
})
.catch((e: any) => {
log_particle.error('id %s. send failed %j', item.particle.id, e);
item.onStageChange({ stage: 'sendingError', errorMessage: e.toString() });
});
});
}
private _expireParticle(item: ParticleQueueItem) {
const particleId = item.particle.id;
log_particle.debug(
'id %s. particle has expired after %d. Deleting particle-related queues and handlers',
item.particle.id,
item.particle.ttl,
);
this._particleQueues.delete(particleId);
this.jsServiceHost.removeParticleScopeHandlers(particleId);
item.onStageChange({ stage: 'expired' });
}
private _createParticlesProcessingQueue() {
const particlesQueue = new Subject<ParticleQueueItem>();
let prevData: Uint8Array = Buffer.from([]);
particlesQueue
.pipe(
filterExpiredParticles(this._expireParticle.bind(this)),
concatMap(async (item) => {
if (!this.isInitialized || this.marineHost === undefined) {
// If `.stop()` was called return null to stop particle processing immediately
return null;
}
// IMPORTANT!
// AVM runner execution and prevData <-> newData swapping
// MUST happen sequentially (in a critical section).
// Otherwise the race might occur corrupting the prevData
log_particle.debug('id %s. sending particle to interpreter', item.particle.id);
log_particle.trace('id %s. prevData: %a', item.particle.id, prevData);
const args = serializeAvmArgs(
{
initPeerId: item.particle.initPeerId,
currentPeerId: this.keyPair.getPeerId(),
timestamp: item.particle.timestamp,
ttl: item.particle.ttl,
keyFormat: KeyPairFormat.Ed25519,
particleId: item.particle.id,
secretKeyBytes: this.keyPair.toEd25519PrivateKey(),
},
item.particle.script,
prevData,
item.particle.data,
item.callResults,
);
let avmCallResult: InterpreterResult | Error;
try {
const res = await this.marineHost.callService('avm', 'invoke', args, defaultCallParameters);
avmCallResult = deserializeAvmResult(res);
} catch (e) {
avmCallResult = e instanceof Error ? e : new Error(String(e));
}
if (!(avmCallResult instanceof Error) && avmCallResult.retCode === 0) {
const newData = Buffer.from(avmCallResult.data);
prevData = newData;
}
return {
...item,
result: avmCallResult,
};
}),
)
.subscribe((item) => {
// If peer was stopped, do not proceed further
if (item === null || !this.isInitialized) {
return;
}
// Do not proceed further if the particle is expired
if (hasExpired(item.particle)) {
return;
}
// Do not continue if there was an error in particle interpretation
if (item.result instanceof Error) {
log_particle.error('id %s. interpreter failed: %s', item.particle.id, item.result.message);
item.onStageChange({ stage: 'interpreterError', errorMessage: item.result.message });
return;
}
if (item.result.retCode !== 0) {
log_particle.error(
'id %s. interpreter failed: retCode: %d, message: %s',
item.particle.id,
item.result.retCode,
item.result.errorMessage,
);
log_particle.trace('id %s. avm data: %a', item.particle.id, item.result.data);
item.onStageChange({ stage: 'interpreterError', errorMessage: item.result.errorMessage });
return;
}
log_particle.trace(
'id %s. interpreter result: retCode: %d, avm data: %a',
item.particle.id,
item.result.retCode,
item.result.data,
);
setTimeout(() => {
item.onStageChange({ stage: 'interpreted' });
}, 0);
// send particle further if requested
if (item.result.nextPeerPks.length > 0) {
const newParticle = cloneWithNewData(item.particle, Buffer.from(item.result.data));
this._outgoingParticles.next({
...item,
particle: newParticle,
nextPeerIds: item.result.nextPeerPks,
});
}
// execute call requests if needed
// and put particle with the results back to queue
if (item.result.callRequests.length > 0) {
for (const [key, cr] of item.result.callRequests) {
const req = {
fnName: cr.functionName,
args: cr.arguments,
serviceId: cr.serviceId,
tetraplets: cr.tetraplets,
particleContext: getParticleContext(item.particle),
};
if (hasExpired(item.particle)) {
// just in case do not call any services if the particle is already expired
return;
}
this._execSingleCallRequest(req)
.catch((err): CallServiceResult => {
if (err instanceof ServiceError) {
return {
retCode: ResultCodes.error,
result: err.message,
};
}
return {
retCode: ResultCodes.error,
result: `Service call failed. fnName="${req.fnName}" serviceId="${
req.serviceId
}" error: ${err.toString()}`,
};
})
.then((res) => {
const serviceResult = {
result: jsonify(res.result),
retCode: res.retCode,
};
const newParticle = cloneWithNewData(item.particle, Buffer.from([]));
particlesQueue.next({
...item,
particle: newParticle,
callResults: [[key, serviceResult]],
});
});
}
} else {
item.onStageChange({ stage: 'localWorkDone' });
}
});
return particlesQueue;
}
private async _execSingleCallRequest(req: CallServiceData): Promise<CallServiceResult> {
const particleId = req.particleContext.particleId;
log_particle.trace('id %s. executing call service handler %j', particleId, req);
if (this.marineHost && await this.marineHost.hasService(req.serviceId)) {
// TODO build correct CallParameters instead of default ones
const result = await this.marineHost.callService(req.serviceId, req.fnName, req.args, defaultCallParameters);
return {
retCode: ResultCodes.success,
result: result as JSONValue,
};
}
let res = await this.jsServiceHost.callService(req);
if (res === null) {
res = {
retCode: ResultCodes.error,
result: `No service found for service call: serviceId='${req.serviceId}', fnName='${
req.fnName
}' args='${jsonify(req.args)}'`,
};
}
log_particle.trace('id %s. executed call service handler, req: %j, res: %j ', particleId, req, res);
return res;
}
private _stopParticleProcessing() {
// do not hang if the peer has been stopped while some of the timeouts are still being executed
this._timeouts.forEach((timeout) => {
clearTimeout(timeout);
});
this._particleQueues.clear();
}
}
function filterExpiredParticles(onParticleExpiration: (item: ParticleQueueItem) => void) {
return pipe(
tap((item: ParticleQueueItem) => {
if (hasExpired(item.particle)) {
onParticleExpiration(item);
}
}),
filter((x: ParticleQueueItem) => !hasExpired(x.particle)),
);
}

159
packages/core/js-client/src/jsPeer/__test__/avm.spec.ts Normal file
View File

@ -0,0 +1,159 @@
import { it, describe, expect } from 'vitest';
import { registerHandlersHelper, withPeer } from '../../util/testUtils.js';
import { handleTimeout } from '../../particle/Particle.js';
describe('Basic AVM functionality in Fluence Peer tests', () => {
it('Simple call', async () => {
await withPeer(async (peer) => {
const res = await new Promise<string[]>((resolve, reject) => {
const script = `
(call %init_peer_id% ("print" "print") ["1"])
`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
print: {
print: (args: Array<Array<string>>) => {
const [res] = args;
resolve(res);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
expect(res).toBe('1');
});
});
it('Par call', async () => {
await withPeer(async (peer) => {
const res = await new Promise<string[]>((resolve, reject) => {
const res: any[] = [];
const script = `
(seq
(par
(call %init_peer_id% ("print" "print") ["1"])
(null)
)
(call %init_peer_id% ("print" "print") ["2"])
)
`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
print: {
print: (args: any) => {
res.push(args[0]);
if (res.length == 2) {
resolve(res);
}
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
expect(res).toStrictEqual(['1', '2']);
});
});
it('Timeout in par call: race', async () => {
await withPeer(async (peer) => {
const res = await new Promise((resolve, reject) => {
const script = `
(seq
(call %init_peer_id% ("op" "identity") ["slow_result"] arg)
(seq
(par
(call %init_peer_id% ("peer" "timeout") [1000 arg] $result)
(call %init_peer_id% ("op" "identity") ["fast_result"] $result)
)
(seq
(canon %init_peer_id% $result #result)
(call %init_peer_id% ("return" "return") [#result.$[0]])
)
)
)
`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
return: {
return: (args: any) => {
resolve(args[0]);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
expect(res).toBe('fast_result');
});
});
it('Timeout in par call: wait', async () => {
await withPeer(async (peer) => {
const res = await new Promise((resolve, reject) => {
const script = `
(seq
(call %init_peer_id% ("op" "identity") ["timeout_msg"] arg)
(seq
(seq
(par
(call %init_peer_id% ("peer" "timeout") [1000 arg] $ok_or_err)
(call "invalid_peer" ("op" "identity") ["never"] $ok_or_err)
)
(xor
(seq
(canon %init_peer_id% $ok_or_err #ok_or_err)
(match #ok_or_err.$[0] "timeout_msg"
(ap "failed_with_timeout" $result)
)
)
(ap "impossible happened" $result)
)
)
(seq
(canon %init_peer_id% $result #result)
(call %init_peer_id% ("return" "return") [#result.$[0]])
)
)
)
`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
return: {
return: (args: any) => {
resolve(args[0]);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
expect(res).toBe('failed_with_timeout');
});
});
});

29
packages/core/js-client/src/jsPeer/__test__/parseAst.spec.ts Normal file
View File

@ -0,0 +1,29 @@
import { it, describe, expect } from 'vitest';
import { withPeer } from '../../util/testUtils.js';
describe('Parse ast tests', () => {
it('Correct ast should be parsed correctly', async () => {
withPeer(async (peer) => {
const air = `(null)`;
const res = await peer.internals.parseAst(air);
expect(res).toStrictEqual({
success: true,
data: { Null: null },
});
});
});
it('Incorrect ast should result in corresponding error', async () => {
withPeer(async (peer) => {
const air = `(null`;
const res = await peer.internals.parseAst(air);
expect(res).toStrictEqual({
success: false,
data: expect.stringContaining('error'),
});
});
});
});

178
packages/core/js-client/src/jsPeer/__test__/peer.spec.ts Normal file
View File

@ -0,0 +1,178 @@
import { it, describe, expect } from 'vitest';
import { isFluencePeer } from '@fluencelabs/interfaces';
import { mkTestPeer, registerHandlersHelper, withPeer } from '../../util/testUtils.js';
import { handleTimeout } from '../../particle/Particle.js';
import { FluencePeer } from '../FluencePeer.js';
describe('FluencePeer usage test suite', () => {
it('should perform test for FluencePeer class correctly', async () => {
// arrange
const peer = await mkTestPeer();
const number = 1;
const object = { str: 'Hello!' };
const undefinedVal = undefined;
// act
const isPeerPeer = isFluencePeer(peer);
const isNumberPeer = isFluencePeer(number);
const isObjectPeer = isFluencePeer(object);
const isUndefinedPeer = isFluencePeer(undefinedVal);
// act
expect(isPeerPeer).toBe(true);
expect(isNumberPeer).toBe(false);
expect(isObjectPeer).toBe(false);
expect(isUndefinedPeer).toBe(false);
});
it('Should successfully call identity on local peer', async function () {
await withPeer(async (peer) => {
const res = await new Promise<string>((resolve, reject) => {
const script = `
(seq
(call %init_peer_id% ("op" "identity") ["test"] res)
(call %init_peer_id% ("callback" "callback") [res])
)
`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
callback: {
callback: async (args: any) => {
const [res] = args;
resolve(res);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
expect(res).toBe('test');
});
});
it('Should throw correct message when calling non existing local service', async function () {
await withPeer(async (peer) => {
const res = callIncorrectService(peer);
await expect(res).rejects.toMatchObject({
message: expect.stringContaining(
`"No service found for service call: serviceId='incorrect', fnName='incorrect' args='[]'"`,
),
instruction: 'call %init_peer_id% ("incorrect" "incorrect") [] res',
});
});
});
it('Should not crash if undefined is passed as a variable', async () => {
await withPeer(async (peer) => {
const res = await new Promise<any>((resolve, reject) => {
const script = `
(seq
(call %init_peer_id% ("load" "arg") [] arg)
(seq
(call %init_peer_id% ("op" "identity") [arg] res)
(call %init_peer_id% ("callback" "callback") [res])
)
)`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
load: {
arg: () => undefined,
},
callback: {
callback: (args: any) => {
const [val] = args;
resolve(val);
},
error: (args: any) => {
const [error] = args;
reject(error);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
expect(res).toBe(null);
});
});
it('Should not crash if an error ocurred in user-defined handler', async () => {
await withPeer(async (peer) => {
const promise = new Promise<any>((_resolve, reject) => {
const script = `
(xor
(call %init_peer_id% ("load" "arg") [] arg)
(call %init_peer_id% ("callback" "error") [%last_error%])
)`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
load: {
arg: () => {
throw new Error('my super custom error message');
},
},
callback: {
error: (args: any) => {
const [error] = args;
reject(error);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
await expect(promise).rejects.toMatchObject({
message: expect.stringContaining('my super custom error message'),
});
});
});
});
async function callIncorrectService(peer: FluencePeer): Promise<string[]> {
return new Promise<any[]>((resolve, reject) => {
const script = `
(xor
(call %init_peer_id% ("incorrect" "incorrect") [] res)
(call %init_peer_id% ("callback" "error") [%last_error%])
)`;
const particle = peer.internals.createNewParticle(script);
if (particle instanceof Error) {
return reject(particle.message);
}
registerHandlersHelper(peer, particle, {
callback: {
callback: (args: any) => {
resolve(args);
},
error: (args: any) => {
const [error] = args;
reject(error);
},
},
});
peer.internals.initiateParticle(particle, handleTimeout(reject));
});
}

111
packages/core/js-client/src/jsServiceHost/JsServiceHost.ts Normal file
View File

@ -0,0 +1,111 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { CallServiceData, CallServiceResult, GenericCallServiceHandler, IJsServiceHost } from './interfaces.js';
export class JsServiceHost implements IJsServiceHost {
private particleScopeHandlers = new Map<string, Map<string, GenericCallServiceHandler>>();
private commonHandlers = new Map<string, GenericCallServiceHandler>();
/**
* Returns true if any handler for the specified serviceId is registered
*/
hasService(serviceId: string): boolean {
return this.commonHandlers.has(serviceId) || this.particleScopeHandlers.has(serviceId);
}
/**
* Removes all handlers associated with the specified particle scope
* @param particleId Particle ID to remove handlers for
*/
removeParticleScopeHandlers(particleId: string): void {
this.particleScopeHandlers.delete(particleId);
}
/**
* Find call service handler for specified particle
* @param serviceId Service ID as specified in `call` air instruction
* @param fnName Function name as specified in `call` air instruction
* @param particleId Particle ID
*/
getHandler(serviceId: string, fnName: string, particleId: string): GenericCallServiceHandler | null {
const key = serviceFnKey(serviceId, fnName);
const psh = this.particleScopeHandlers.get(particleId);
let handler: GenericCallServiceHandler | undefined = undefined;
// we should prioritize handler for this particle if there is one
// if particle-scoped handler exist for this particle try getting handler there
if (psh !== undefined) {
handler = psh.get(key);
}
// then try to find a common handler for all particles with this service-fn key
// if there is no particle-specific handler, get one from common map
if (handler === undefined) {
handler = this.commonHandlers.get(key);
}
return handler || null;
}
/**
* Execute service call for specified call service data. Return null if no handler was found
*/
async callService(req: CallServiceData): Promise<CallServiceResult | null> {
const handler = this.getHandler(req.serviceId, req.fnName, req.particleContext.particleId);
if (handler === null) {
return null;
}
const result = await handler(req);
// Otherwise AVM might break
if (result.result === undefined) {
result.result = null;
}
return result;
}
/**
* Register handler for all particles
*/
registerGlobalHandler(serviceId: string, fnName: string, handler: GenericCallServiceHandler): void {
this.commonHandlers.set(serviceFnKey(serviceId, fnName), handler);
}
/**
* Register handler which will be called only for particle with the specific id
*/
registerParticleScopeHandler(
particleId: string,
serviceId: string,
fnName: string,
handler: GenericCallServiceHandler,
): void {
let psh = this.particleScopeHandlers.get(particleId);
if (psh === undefined) {
psh = new Map<string, GenericCallServiceHandler>();
this.particleScopeHandlers.set(particleId, psh);
}
psh.set(serviceFnKey(serviceId, fnName), handler);
}
}
function serviceFnKey(serviceId: string, fnName: string) {
return `${serviceId}/${fnName}`;
}

153
packages/core/js-client/src/jsServiceHost/interfaces.ts Normal file
View File

@ -0,0 +1,153 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { PeerIdB58 } from '@fluencelabs/interfaces';
import type { SecurityTetraplet } from '@fluencelabs/avm';
import { JSONValue } from '../util/commonTypes.js';
/**
* JS Service host a low level interface for managing pure javascript services.
* It operates on a notion of Call Service Handlers - functions which are called when a `call` air instruction is executed on the local peer.
*/
export interface IJsServiceHost {
/**
* Returns true if any handler for the specified serviceId is registered
*/
hasService(serviceId: string): boolean;
/**
* Find call service handler for specified particle
* @param serviceId Service ID as specified in `call` air instruction
* @param fnName Function name as specified in `call` air instruction
* @param particleId Particle ID
*/
getHandler(serviceId: string, fnName: string, particleId: string): GenericCallServiceHandler | null;
/**
* Execute service call for specified call service data
*/
callService(req: CallServiceData): Promise<CallServiceResult | null>;
/**
* Register handler for all particles
*/
registerGlobalHandler(serviceId: string, fnName: string, handler: GenericCallServiceHandler): void;
/**
* Register handler which will be called only for particle with the specific id
*/
registerParticleScopeHandler(
particleId: string,
serviceId: string,
fnName: string,
handler: GenericCallServiceHandler,
): void;
/**
* Removes all handlers associated with the specified particle scope
* @param particleId Particle ID to remove handlers for
*/
removeParticleScopeHandlers(particleId: string): void;
}
export enum ResultCodes {
success = 0,
error = 1,
}
/**
* Particle context. Contains additional information about particle which triggered `call` air instruction from AVM
*/
export interface ParticleContext {
/**
* The identifier of particle which triggered the call
*/
particleId: string;
/**
* The peer id which created the particle
*/
initPeerId: PeerIdB58;
/**
* Particle's timestamp when it was created
*/
timestamp: number;
/**
* Time to live in milliseconds. The time after the particle should be expired
*/
ttl: number;
/**
* Particle's signature
*/
signature?: string;
}
/**
* Represents the information passed from AVM when a `call` air instruction is executed on the local peer
*/
export interface CallServiceData {
/**
* Service ID as specified in `call` air instruction
*/
serviceId: string;
/**
* Function name as specified in `call` air instruction
*/
fnName: string;
/**
* Arguments as specified in `call` air instruction
*/
args: any[];
/**
* Security Tetraplets received from AVM
*/
tetraplets: SecurityTetraplet[][];
/**
* Particle context, @see {@link ParticleContext}
*/
particleContext: ParticleContext;
}
/**
* Type for all the possible objects that can be returned to the AVM
*/
export type CallServiceResultType = JSONValue;
/**
* Generic call service handler
*/
export type GenericCallServiceHandler = (req: CallServiceData) => CallServiceResult | Promise<CallServiceResult>;
/**
* Represents the result of the `call` air instruction to be returned into AVM
*/
export interface CallServiceResult {
/**
* Return code to be returned to AVM
*/
retCode: ResultCodes;
/**
* Result object to be returned to AVM
*/
result: CallServiceResultType;
}

60
packages/core/js-client/src/jsServiceHost/serviceUtils.ts Normal file
View File

@ -0,0 +1,60 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { FluencePeer } from '../jsPeer/FluencePeer.js';
import { IParticle } from '../particle/interfaces.js';
import { builtInServices } from '../services/builtins.js';
import {
CallServiceData,
CallServiceResult,
CallServiceResultType,
ParticleContext,
ResultCodes,
} from './interfaces.js';
export const doNothing = (..._args: Array<unknown>) => undefined;
export const WrapFnIntoServiceCall =
(fn: (args: any[]) => CallServiceResultType) =>
(req: CallServiceData): CallServiceResult => ({
retCode: ResultCodes.success,
result: fn(req.args),
});
export class ServiceError extends Error {
constructor(message: string) {
super(message);
Object.setPrototypeOf(this, ServiceError.prototype);
}
}
export const getParticleContext = (particle: IParticle): ParticleContext => {
return {
particleId: particle.id,
initPeerId: particle.initPeerId,
timestamp: particle.timestamp,
ttl: particle.ttl,
signature: particle.signature,
};
};
export function registerDefaultServices(peer: FluencePeer) {
Object.entries(builtInServices).forEach(([serviceId, service]) => {
Object.entries(service).forEach(([fnName, fn]) => {
peer.internals.regHandler.common(serviceId, fnName, fn);
});
});
}

94
packages/core/js-client/src/keypair/__test__/KeyPair.spec.ts Normal file
View File

@ -0,0 +1,94 @@
import { it, describe, expect } from 'vitest';
import { toUint8Array } from 'js-base64';
import * as bs58 from 'bs58';
import { KeyPair } from '../index.js';
// @ts-ignore
const { decode } = bs58.default;
const key = '+cmeYlZKj+MfSa9dpHV+BmLPm6wq4inGlsPlQ1GvtPk=';
const keyBytes = toUint8Array(key);
const testData = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 9, 10]);
const testDataSig = Uint8Array.from([
224, 104, 245, 206, 140, 248, 27, 72, 68, 133, 111, 10, 164, 197, 242, 132, 107, 77, 224, 67, 99, 106, 76, 29, 144,
121, 122, 169, 36, 173, 58, 80, 170, 102, 137, 253, 157, 247, 168, 87, 162, 223, 188, 214, 203, 220, 52, 246, 29,
86, 77, 71, 224, 248, 16, 213, 254, 75, 78, 239, 243, 222, 241, 15,
]);
// signature produced by KeyPair created from some random KeyPair
describe('KeyPair tests', () => {
it('generate keypair from seed', async function () {
// arrange
const random = await KeyPair.randomEd25519();
const privateKey = random.toEd25519PrivateKey();
// act
const keyPair = await KeyPair.fromEd25519SK(privateKey);
const privateKey2 = keyPair.toEd25519PrivateKey();
// assert
expect(privateKey).toStrictEqual(privateKey2);
});
it('create keypair from ed25519 private key', async function () {
// arrange
const rustSK = 'jDaxLJzYtzgwTMrELJCAqavtmx85ktQNfB2rLcK7MhH';
const sk = decode(rustSK);
// act
const keyPair = await KeyPair.fromEd25519SK(sk);
// assert
const expectedPeerId = '12D3KooWH1W3VznVZ87JH4FwABK4mkntcspTVWJDta6c2xg9Pzbp';
expect(keyPair.getPeerId()).toStrictEqual(expectedPeerId);
});
it('create keypair from a seed phrase', async function () {
// arrange
const seedArray = new Uint8Array(32).fill(1);
// act
const keyPair = await KeyPair.fromEd25519SK(seedArray);
// assert
const expectedPeerId = '12D3KooWK99VoVxNE7XzyBwXEzW7xhK7Gpv85r9F3V3fyKSUKPH5';
expect(keyPair.getPeerId()).toStrictEqual(expectedPeerId);
});
it('sign', async function () {
// arrange
const keyPair = await KeyPair.fromEd25519SK(keyBytes);
// act
const res = await keyPair.signBytes(testData);
// assert
expect(new Uint8Array(res)).toStrictEqual(testDataSig);
});
it('verify', async function () {
// arrange
const keyPair = await KeyPair.fromEd25519SK(keyBytes);
// act
const res = await keyPair.verify(testData, testDataSig);
// assert
expect(res).toBe(true);
});
it('sign-verify', async function () {
// arrange
const keyPair = await KeyPair.fromEd25519SK(keyBytes);
// act
const data = new Uint8Array(32).fill(1);
const sig = await keyPair.signBytes(data);
const res = await keyPair.verify(data, sig);
// assert
expect(res).toBe(true);
});
});

95
packages/core/js-client/src/keypair/index.ts Normal file
View File

@ -0,0 +1,95 @@
/*
* Copyright 2020 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { PeerId } from '@libp2p/interface/peer-id';
import { generateKeyPairFromSeed, generateKeyPair } from '@libp2p/crypto/keys';
import { createFromPrivKey } from '@libp2p/peer-id-factory';
import type { PrivateKey } from '@libp2p/interface/keys';
import { toUint8Array } from 'js-base64';
import * as bs58 from 'bs58';
import { KeyPairOptions } from '@fluencelabs/interfaces';
// @ts-ignore
const { decode } = bs58.default;
export class KeyPair {
/**
* Key pair in libp2p format. Used for backward compatibility with the current FluencePeer implementation
*/
getLibp2pPeerId() {
return this.libp2pPeerId;
}
constructor(private key: PrivateKey, private libp2pPeerId: PeerId) {}
/**
* Generates new KeyPair from ed25519 private key represented as a 32 byte array
* @param seed - Any sequence of 32 bytes
* @returns - Promise with the created KeyPair
*/
static async fromEd25519SK(seed: Uint8Array): Promise<KeyPair> {
const key = await generateKeyPairFromSeed('Ed25519', seed, 256);
const lib2p2Pid = await createFromPrivKey(key);
return new KeyPair(key, lib2p2Pid);
}
/**
* Generates new KeyPair with a random secret key
* @returns - Promise with the created KeyPair
*/
static async randomEd25519(): Promise<KeyPair> {
const key = await generateKeyPair('Ed25519');
const lib2p2Pid = await createFromPrivKey(key);
return new KeyPair(key, lib2p2Pid);
}
getPeerId(): string {
return this.libp2pPeerId.toString();
}
/**
* @returns 32 byte private key
*/
toEd25519PrivateKey(): Uint8Array {
return this.key.marshal().subarray(0, 32);
}
signBytes(data: Uint8Array): Promise<Uint8Array> {
return this.key.sign(data);
}
verify(data: Uint8Array, signature: Uint8Array): Promise<boolean> {
return this.key.public.verify(data, signature);
}
}
export const fromBase64Sk = (sk: string): Promise<KeyPair> => {
const skArr = toUint8Array(sk);
return KeyPair.fromEd25519SK(skArr);
};
export const fromBase58Sk = (sk: string): Promise<KeyPair> => {
const skArr = decode(sk);
return KeyPair.fromEd25519SK(skArr);
};
export const fromOpts = (opts: KeyPairOptions): Promise<KeyPair> => {
if (opts.source === 'random') {
return KeyPair.randomEd25519();
}
return KeyPair.fromEd25519SK(opts.source);
};

31
packages/core/js-client/src/marine/__test__/marine-js.spec.ts Normal file
View File

@ -0,0 +1,31 @@
import { it, describe, expect, beforeAll } from 'vitest';
import * as fs from 'fs';
import * as url from 'url';
import * as path from 'path';
import { compileAqua, withPeer } from '../../util/testUtils.js';
let aqua: any;
const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
describe('Marine js tests', () => {
beforeAll(async () => {
const pathToAquaFiles = path.join(__dirname, '../../../aqua_test/marine-js.aqua');
const { services, functions } = await compileAqua(pathToAquaFiles);
aqua = functions;
});
it('should call marine service correctly', async () => {
await withPeer(async (peer) => {
// arrange
const wasm = await fs.promises.readFile(path.join(__dirname, '../../../data_for_test/greeting.wasm'));
await peer.registerMarineService(wasm, 'greeting');
// act
const res = await aqua.call(peer, { arg: 'test' });
// assert
expect(res).toBe('Hi, Hi, Hi, test');
});
});
});

40
packages/core/js-client/src/marine/deps-loader/common.ts Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// @ts-ignore
import { BlobWorker } from 'threads';
import { fromBase64, toUint8Array } from 'js-base64';
// @ts-ignore
import type { WorkerImplementation } from 'threads/dist/types/master';
import { Buffer } from 'buffer';
import { LazyLoader } from '../interfaces.js';
export class InlinedWorkerLoader extends LazyLoader<WorkerImplementation> {
constructor(b64script: string) {
super(() => {
const script = fromBase64(b64script);
return BlobWorker.fromText(script);
});
}
}
export class InlinedWasmLoader extends LazyLoader<Buffer> {
constructor(b64wasm: string) {
super(() => {
const wasm = toUint8Array(b64wasm);
return Buffer.from(wasm);
});
}
}

85
packages/core/js-client/src/marine/deps-loader/node.ts Normal file
View File

@ -0,0 +1,85 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { createRequire } from 'module';
// @ts-ignore
import type { WorkerImplementation } from 'threads/dist/types/master';
// @ts-ignore
import { Worker } from 'threads';
import { Buffer } from 'buffer';
import * as fs from 'fs';
import * as path from 'path';
import { LazyLoader } from '../interfaces.js';
const require = createRequire(import.meta.url);
const bufferToSharedArrayBuffer = (buffer: Buffer): SharedArrayBuffer => {
const sab = new SharedArrayBuffer(buffer.length);
const tmp = new Uint8Array(sab);
tmp.set(buffer, 0);
return sab;
};
/**
* Load wasm file from npm package. Only works in nodejs environment.
* The function returns SharedArrayBuffer compatible with FluenceAppService methods.
* @param source - object specifying the source of the file. Consist two fields: package name and file path.
* @returns SharedArrayBuffer with the wasm file
*/
export const loadWasmFromNpmPackage = async (source: { package: string; file: string }): Promise<SharedArrayBuffer> => {
const packagePath = require.resolve(source.package);
const filePath = path.join(path.dirname(packagePath), source.file);
return loadWasmFromFileSystem(filePath);
};
/**
* Load wasm file from the file system. Only works in nodejs environment.
* The functions returns SharedArrayBuffer compatible with FluenceAppService methods.
* @param filePath - path to the wasm file
* @returns SharedArrayBuffer with the wasm fileWorker
*/
export const loadWasmFromFileSystem = async (filePath: string): Promise<SharedArrayBuffer> => {
const buffer = await fs.promises.readFile(filePath);
return bufferToSharedArrayBuffer(buffer);
};
export class WasmLoaderFromFs extends LazyLoader<SharedArrayBuffer> {
constructor(filePath: string) {
super(() => loadWasmFromFileSystem(filePath));
}
}
export class WasmLoaderFromNpm extends LazyLoader<SharedArrayBuffer> {
constructor(pkg: string, file: string) {
super(() => loadWasmFromNpmPackage({ package: pkg, file: file }));
}
}
export class WorkerLoaderFromFs extends LazyLoader<WorkerImplementation> {
constructor(scriptPath: string) {
super(() => new Worker(scriptPath));
}
}
export class WorkerLoaderFromNpm extends LazyLoader<WorkerImplementation> {
constructor(pkg: string, file: string) {
super(() => {
const packagePath = require.resolve(pkg);
const scriptPath = path.join(path.dirname(packagePath), file);
return new Worker(scriptPath);
});
}
}

63
packages/core/js-client/src/marine/deps-loader/web.ts Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { Buffer } from 'buffer';
import { LazyLoader } from '../interfaces.js';
// @ts-ignore
import type { WorkerImplementation } from 'threads/dist/types/master';
const bufferToSharedArrayBuffer = (buffer: Buffer): SharedArrayBuffer => {
const sab = new SharedArrayBuffer(buffer.length);
const tmp = new Uint8Array(sab);
tmp.set(buffer, 0);
return sab;
};
/**
* Load wasm file from the server. Only works in browsers.
* The function will try load file into SharedArrayBuffer if the site is cross-origin isolated.
* Otherwise the return value fallbacks to Buffer which is less performant but is still compatible with FluenceAppService methods.
* We strongly recommend to set-up cross-origin headers. For more details see: See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements
* Filename is relative to current origin.
* @param filePath - path to the wasm file relative to current origin
* @returns Either SharedArrayBuffer or Buffer with the wasm file
*/
export const loadWasmFromUrl = async (filePath: string): Promise<SharedArrayBuffer | Buffer> => {
const fullUrl = window.location.origin + '/' + filePath;
const res = await fetch(fullUrl);
const ab = await res.arrayBuffer();
new Uint8Array(ab);
const buffer = Buffer.from(ab);
// only convert to shared buffers if necessary CORS headers have been set:
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements
if (crossOriginIsolated) {
return bufferToSharedArrayBuffer(buffer);
}
return buffer;
};
export class WasmLoaderFromUrl extends LazyLoader<SharedArrayBuffer | Buffer> {
constructor(filePath: string) {
super(() => loadWasmFromUrl(filePath));
}
}
export class WorkerLoaderFromUrl extends LazyLoader<WorkerImplementation> {
constructor(scriptPath: string) {
super(() => new Worker(scriptPath));
}
}

109
packages/core/js-client/src/marine/interfaces.ts Normal file
View File

@ -0,0 +1,109 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { CallResultsArray, InterpreterResult, RunParameters } from '@fluencelabs/avm';
import { IStartable, JSONArray, JSONObject, CallParameters } from '../util/commonTypes.js';
// @ts-ignore
import type { WorkerImplementation } from 'threads/dist/types/master';
/**
* Contract for marine host implementations. Marine host is responsible for creating calling and removing marine services
*/
export interface IMarineHost extends IStartable {
/**
* Creates marine service from the given module and service id
*/
createService(serviceModule: ArrayBuffer | SharedArrayBuffer, serviceId: string): Promise<void>;
/**
* Removes marine service with the given service id
*/
removeService(serviceId: string): Promise<void>;
/**
* Returns true if any service with the specified service id is registered
*/
hasService(serviceId: string): Promise<boolean>;
/**
* Calls the specified function of the specified service with the given arguments
*/
callService(
serviceId: string,
functionName: string,
args: JSONArray | JSONObject,
callParams: CallParameters,
): Promise<unknown>;
}
/**
* Interface for different implementations of AVM runner
*/
export interface IAvmRunner extends IStartable {
/**
* Run AVM interpreter with the specified parameters
*/
run(
runParams: RunParameters,
air: string,
prevData: Uint8Array,
data: Uint8Array,
callResults: CallResultsArray,
): Promise<InterpreterResult | Error>;
}
/**
* Interface for something which can hold a value
*/
export interface IValueLoader<T> {
getValue(): T;
}
/**
* Interface for something which can load wasm files
*/
export interface IWasmLoader extends IValueLoader<ArrayBuffer | SharedArrayBuffer>, IStartable {}
/**
* Interface for something which can thread.js based worker
*/
export interface IWorkerLoader extends IValueLoader<WorkerImplementation>, IStartable {}
/**
* Lazy loader for some value. Value is loaded only when `start` method is called
*/
export class LazyLoader<T> implements IStartable, IValueLoader<T> {
private value: T | null = null;
constructor(private loadValue: () => Promise<T> | T) {}
getValue(): T {
if (this.value == null) {
throw new Error('Value has not been loaded. Call `start` method to load the value.');
}
return this.value;
}
async start() {
if (this.value !== null) {
return;
}
this.value = await this.loadValue();
}
async stop() {}
}

26
packages/core/js-client/src/marine/worker-script/workerLoader.ts Normal file
View File

@ -0,0 +1,26 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// @ts-ignore
import type { WorkerImplementation } from 'threads/dist/types/master';
// @ts-ignore
import { Worker } from 'threads';
import { LazyLoader } from '../interfaces.js';
export class WorkerLoader extends LazyLoader<WorkerImplementation> {
constructor() {
super(() => new Worker('../../../node_modules/@fluencelabs/marine-worker/dist/node/marine-worker.umd.cjs'));
}
}

109
packages/core/js-client/src/marine/worker/index.ts Normal file
View File

@ -0,0 +1,109 @@
/*
* Copyright 2022 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type { JSONArray, JSONObject, CallParameters } from '@fluencelabs/marine-js/dist/types';
import { LogFunction, logLevelToEnv } from '@fluencelabs/marine-js/dist/types';
import type { MarineBackgroundInterface } from '@fluencelabs/marine-worker';
// @ts-ignore
import { ModuleThread, spawn, Thread } from 'threads';
import { MarineLogger, marineLogger } from '../../util/logger.js';
import { IMarineHost, IWasmLoader, IWorkerLoader } from '../interfaces.js';
export class MarineBackgroundRunner implements IMarineHost {
private workerThread?: MarineBackgroundInterface;
private loggers = new Map<string, MarineLogger>();
constructor(private workerLoader: IWorkerLoader, private controlModuleLoader: IWasmLoader, private avmWasmLoader: IWasmLoader) {}
async hasService(serviceId: string) {
if (!this.workerThread) {
throw new Error('Worker is not initialized');
}
return this.workerThread.hasService(serviceId);
}
async removeService(serviceId: string) {
if (!this.workerThread) {
throw new Error('Worker is not initialized');
}
await this.workerThread.removeService(serviceId);
}
async start(): Promise<void> {
if (this.workerThread) {
throw new Error('Worker thread already initialized');
}
await this.controlModuleLoader.start();
const wasm = this.controlModuleLoader.getValue();
await this.avmWasmLoader.start();
await this.workerLoader.start();
const worker = this.workerLoader.getValue();
const workerThread = await spawn<MarineBackgroundInterface>(worker);
const logfn: LogFunction = (message) => {
const serviceLogger = this.loggers.get(message.service);
if (!serviceLogger) {
return;
}
serviceLogger[message.level](message.message);
};
workerThread.onLogMessage().subscribe(logfn);
await workerThread.init(wasm);
this.workerThread = workerThread;
await this.createService(this.avmWasmLoader.getValue(), 'avm');
}
async createService(serviceModule: ArrayBuffer | SharedArrayBuffer, serviceId: string): Promise<void> {
if (!this.workerThread) {
throw new Error('Worker is not initialized');
}
// The logging level is controlled by the environment variable passed to enable debug logs.
// We enable all possible log levels passing the control for exact printouts to the logger
const env = logLevelToEnv('trace');
this.loggers.set(serviceId, marineLogger(serviceId));
await this.workerThread.createService(serviceModule, serviceId, env);
}
async callService(
serviceId: string,
functionName: string,
args: JSONArray | JSONObject,
callParams: CallParameters,
): Promise<unknown> {
if (!this.workerThread) {
throw 'Worker is not initialized';
}
return this.workerThread.callService(serviceId, functionName, args, callParams);
}
async stop(): Promise<void> {
if (!this.workerThread) {
return;
}
await this.workerThread.terminate();
await Thread.terminate(this.workerThread);
}
}

129
packages/core/js-client/src/particle/Particle.ts Normal file
View File

@ -0,0 +1,129 @@
/*
* Copyright 2020 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { fromUint8Array, toUint8Array } from 'js-base64';
import { CallResultsArray } from '@fluencelabs/avm';
import { v4 as uuidv4 } from 'uuid';
import { Buffer } from 'buffer';
import { IParticle } from './interfaces.js';
export class Particle implements IParticle {
readonly signature: undefined;
constructor(
public readonly id: string,
public readonly timestamp: number,
public readonly script: string,
public readonly data: Uint8Array,
public readonly ttl: number,
public readonly initPeerId: string,
) {
this.signature = undefined;
}
static createNew(script: string, initPeerId: string, ttl: number): Particle {
return new Particle(uuidv4(), Date.now(), script, Buffer.from([]), ttl, initPeerId);
}
static fromString(str: string): Particle {
const json = JSON.parse(str);
const res = new Particle(
json.id,
json.timestamp,
json.script,
toUint8Array(json.data),
json.ttl,
json.init_peer_id,
);
return res;
}
}
/**
* Returns actual ttl of a particle, i.e. ttl - time passed since particle creation
*/
export const getActualTTL = (particle: IParticle): number => {
return particle.timestamp + particle.ttl - Date.now();
};
/**
* Returns true if particle has expired
*/
export const hasExpired = (particle: IParticle): boolean => {
return getActualTTL(particle) <= 0;
};
/**
* Creates a particle clone with new data
*/
export const cloneWithNewData = (particle: IParticle, newData: Uint8Array): IParticle => {
return new Particle(particle.id, particle.timestamp, particle.script, newData, particle.ttl, particle.initPeerId);
};
/**
* Creates a deep copy of a particle
*/
export const fullClone = (particle: IParticle): IParticle => {
return JSON.parse(JSON.stringify(particle));
};
/**
* Serializes particle into string suitable for sending through network
*/
export const serializeToString = (particle: IParticle): string => {
return JSON.stringify({
action: 'Particle',
id: particle.id,
init_peer_id: particle.initPeerId,
timestamp: particle.timestamp,
ttl: particle.ttl,
script: particle.script,
// TODO: copy signature from a particle after signatures will be implemented on nodes
signature: [],
data: particle.data && fromUint8Array(particle.data),
});
};
/**
* When particle is executed, it goes through different stages. The type describes all possible stages and their parameters
*/
export type ParticleExecutionStage =
| { stage: 'received' }
| { stage: 'interpreted' }
| { stage: 'interpreterError'; errorMessage: string }
| { stage: 'localWorkDone' }
| { stage: 'sent' }
| { stage: 'sendingError'; errorMessage: string }
| { stage: 'expired' };
/**
* Particle queue item is a wrapper around particle, which contains additional information about particle execution
*/
export interface ParticleQueueItem {
particle: IParticle;
callResults: CallResultsArray;
onStageChange: (state: ParticleExecutionStage) => void;
}
/**
* Helper function to handle particle at expired stage
*/
export const handleTimeout = (fn: () => void) => (stage: ParticleExecutionStage) => {
if (stage.stage === 'expired') {
fn();
}
};

59
packages/core/js-client/src/particle/interfaces.ts Normal file
View File

@ -0,0 +1,59 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { PeerIdB58 } from '@fluencelabs/interfaces';
/**
* Immutable part of the particle.
*/
export interface IImmutableParticlePart {
/**
* Particle id
*/
readonly id: string;
/**
* Particle timestamp. Specifies when the particle was created.
*/
readonly timestamp: number;
/**
* Particle's air script
*/
readonly script: string;
/**
* Particle's ttl. Specifies how long the particle is valid in milliseconds.
*/
readonly ttl: number;
/**
* Peer id where the particle was initiated.
*/
readonly initPeerId: PeerIdB58;
// TODO: implement particle signatures
readonly signature: undefined;
}
/**
* Particle is a data structure that is used to transfer data between peers in Fluence network.
*/
export interface IParticle extends IImmutableParticlePart {
/**
* Mutable particle data
*/
data: Uint8Array;
}

70
packages/core/js-client/src/services/NodeUtils.ts Normal file
View File

@ -0,0 +1,70 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { CallParams, IFluenceInternalApi } from '@fluencelabs/interfaces';
import { defaultGuard } from './SingleModuleSrv.js';
import { NodeUtilsDef, registerNodeUtils } from './_aqua/node-utils.js';
import { SecurityGuard } from './securityGuard.js';
import * as fs from 'fs';
import { FluencePeer } from '../jsPeer/FluencePeer.js';
import { Buffer } from 'buffer';
export class NodeUtils implements NodeUtilsDef {
constructor(private peer: FluencePeer) {
this.securityGuard_readFile = defaultGuard(this.peer);
}
securityGuard_readFile: SecurityGuard<'path'>;
async read_file(path: string, callParams: CallParams<'path'>) {
if (!this.securityGuard_readFile(callParams)) {
return {
success: false,
error: 'Security guard validation failed',
content: null,
};
}
try {
// Strange enough, but Buffer type works here, while reading with encoding 'utf-8' doesn't
const data = await new Promise<Buffer>((resolve, reject) => {
fs.readFile(path, (err, data) => {
if (err) {
reject(err);
return;
}
resolve(data);
})
});
return {
success: true,
content: data as unknown as string,
error: null,
};
} catch (err: any) {
return {
success: false,
error: err.message,
content: null,
};
}
}
}
// HACK:: security guard functions must be ported to user API
export const doRegisterNodeUtils = (peer: any) => {
registerNodeUtils(peer, 'node_utils', new NodeUtils(peer));
};

88
packages/core/js-client/src/services/Sig.ts Normal file
View File

@ -0,0 +1,88 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { CallParams, PeerIdB58 } from '@fluencelabs/interfaces';
import { KeyPair } from '../keypair/index.js';
import { FluencePeer } from '../jsPeer/FluencePeer.js';
import { SigDef } from './_aqua/services.js';
import { allowOnlyParticleOriginatedAt, allowServiceFn, and, or, SecurityGuard } from './securityGuard.js';
export const defaultSigGuard = (peerId: PeerIdB58) => {
return and<'data'>(
allowOnlyParticleOriginatedAt(peerId),
or(
allowServiceFn('trust-graph', 'get_trust_bytes'),
allowServiceFn('trust-graph', 'get_revocation_bytes'),
allowServiceFn('registry', 'get_key_bytes'),
allowServiceFn('registry', 'get_record_bytes'),
allowServiceFn('registry', 'get_record_metadata_bytes'),
allowServiceFn('registry', 'get_tombstone_bytes'),
),
);
};
export class Sig implements SigDef {
constructor(private keyPair: KeyPair) {}
/**
* Configurable security guard for sign method
*/
securityGuard: SecurityGuard<'data'> = (params) => {
return true;
};
/**
* Gets the public key of KeyPair. Required by aqua
*/
get_peer_id() {
return this.keyPair.getPeerId();
}
/**
* Signs the data using key pair's private key. Required by aqua
*/
async sign(
data: number[],
callParams: CallParams<'data'>,
): Promise<{ error: string | null; signature: number[] | null; success: boolean }> {
if (!this.securityGuard(callParams)) {
return {
success: false,
error: 'Security guard validation failed',
signature: null,
};
}
const signedData = await this.keyPair.signBytes(Uint8Array.from(data));
return {
success: true,
error: null,
signature: Array.from(signedData),
};
}
/**
* Verifies the signature. Required by aqua
*/
verify(signature: number[], data: number[]): Promise<boolean> {
return this.keyPair.verify(Uint8Array.from(data), Uint8Array.from(signature));
}
}
export const getDefaultSig = (peer: FluencePeer) => {
peer.registerMarineService;
};

101
packages/core/js-client/src/services/SingleModuleSrv.ts Normal file
View File

@ -0,0 +1,101 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { v4 as uuidv4 } from 'uuid';
import { SrvDef } from './_aqua/single-module-srv.js';
import { FluencePeer } from '../jsPeer/FluencePeer.js';
import { CallParams } from '@fluencelabs/interfaces';
import { Buffer } from 'buffer';
import { allowOnlyParticleOriginatedAt, SecurityGuard } from './securityGuard.js';
export const defaultGuard = (peer: FluencePeer) => {
return allowOnlyParticleOriginatedAt<any>(peer.keyPair.getPeerId());
};
export class Srv implements SrvDef {
private services: Set<string> = new Set();
constructor(private peer: FluencePeer) {
this.securityGuard_create = defaultGuard(this.peer);
this.securityGuard_remove = defaultGuard(this.peer);
}
securityGuard_create: SecurityGuard<'wasm_b64_content'>;
async create(wasm_b64_content: string, callParams: CallParams<'wasm_b64_content'>) {
if (!this.securityGuard_create(callParams)) {
return {
success: false,
error: 'Security guard validation failed',
service_id: null,
};
}
try {
const newServiceId = uuidv4();
const buffer = Buffer.from(wasm_b64_content, 'base64');
// TODO:: figure out why SharedArrayBuffer is not working here
// const sab = new SharedArrayBuffer(buffer.length);
// const tmp = new Uint8Array(sab);
// tmp.set(buffer, 0);
await this.peer.registerMarineService(buffer, newServiceId);
this.services.add(newServiceId);
return {
success: true,
service_id: newServiceId,
error: null,
};
} catch (err: any) {
return {
success: true,
service_id: null,
error: err.message,
};
}
}
securityGuard_remove: SecurityGuard<'service_id'>;
async remove(service_id: string, callParams: CallParams<'service_id'>) {
if (!this.securityGuard_remove(callParams)) {
return {
success: false,
error: 'Security guard validation failed',
service_id: null,
};
}
if (!this.services.has(service_id)) {
return {
success: false,
error: `Service with id ${service_id} not found`,
};
}
await this.peer.removeMarineService(service_id);
this.services.delete(service_id);
return {
success: true,
error: null,
};
}
list() {
return Array.from(this.services.values());
}
}

24
packages/core/js-client/src/services/Tracing.ts Normal file
View File

@ -0,0 +1,24 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { CallParams } from '@fluencelabs/interfaces';
import { TracingDef } from './_aqua/tracing.js';
export class Tracing implements TracingDef {
tracingEvent(arrowName: string, event: string, callParams: CallParams<'arrowName' | 'event'>): void {
console.log('[%s] (%s) %s', callParams.particleId, arrowName, event);
}
}

313
packages/core/js-client/src/services/__test__/builtInHandler.spec.ts Normal file
View File

@ -0,0 +1,313 @@
import { it, describe, expect, test } from 'vitest';
import { CallParams } from '@fluencelabs/interfaces';
import { toUint8Array } from 'js-base64';
import { KeyPair } from '../../keypair/index.js';
import { Sig, defaultSigGuard } from '../Sig.js';
import { allowServiceFn } from '../securityGuard.js';
import { builtInServices } from '../builtins.js';
import { CallServiceData } from '../../jsServiceHost/interfaces.js';
const a10b20 = `{
"a": 10,
"b": 20
}`;
const oneTwoThreeFour = `[
1,
2,
3,
4
]`;
describe('Tests for default handler', () => {
test.each`
serviceId | fnName | args | retCode | result
${'op'} | ${'identity'} | ${[]} | ${0} | ${{}}
${'op'} | ${'identity'} | ${[1]} | ${0} | ${1}
${'op'} | ${'identity'} | ${[1, 2]} | ${1} | ${'identity accepts up to 1 arguments, received 2 arguments'}
${'op'} | ${'noop'} | ${[1, 2]} | ${0} | ${{}}
${'op'} | ${'array'} | ${[1, 2, 3]} | ${0} | ${[1, 2, 3]}
${'op'} | ${'array_length'} | ${[[1, 2, 3]]} | ${0} | ${3}
${'op'} | ${'array_length'} | ${[]} | ${1} | ${'array_length accepts exactly one argument, found: 0'}
${'op'} | ${'concat'} | ${[[1, 2], [3, 4], [5, 6]]} | ${0} | ${[1, 2, 3, 4, 5, 6]}
${'op'} | ${'concat'} | ${[[1, 2]]} | ${0} | ${[1, 2]}
${'op'} | ${'concat'} | ${[]} | ${0} | ${[]}
${'op'} | ${'concat'} | ${[1, [1, 2], 1]} | ${1} | ${"All arguments of 'concat' must be arrays: arguments 0, 2 are not"}
${'op'} | ${'string_to_b58'} | ${['test']} | ${0} | ${'3yZe7d'}
${'op'} | ${'string_to_b58'} | ${['test', 1]} | ${1} | ${'string_to_b58 accepts only one string argument'}
${'op'} | ${'string_from_b58'} | ${['3yZe7d']} | ${0} | ${'test'}
${'op'} | ${'string_from_b58'} | ${['3yZe7d', 1]} | ${1} | ${'string_from_b58 accepts only one string argument'}
${'op'} | ${'bytes_to_b58'} | ${[[116, 101, 115, 116]]} | ${0} | ${'3yZe7d'}
${'op'} | ${'bytes_to_b58'} | ${[[116, 101, 115, 116], 1]} | ${1} | ${'bytes_to_b58 accepts only single argument: array of numbers'}
${'op'} | ${'bytes_from_b58'} | ${['3yZe7d']} | ${0} | ${[116, 101, 115, 116]}
${'op'} | ${'bytes_from_b58'} | ${['3yZe7d', 1]} | ${1} | ${'bytes_from_b58 accepts only one string argument'}
${'op'} | ${'sha256_string'} | ${['hello, world!']} | ${0} | ${'QmVQ8pg6L1tpoWYeq6dpoWqnzZoSLCh7E96fCFXKvfKD3u'}
${'op'} | ${'sha256_string'} | ${['hello, world!', true]} | ${0} | ${'84V7ZxLW7qKsx1Qvbd63BdGaHxUc3TfT2MBPqAXM7Wyu'}
${'op'} | ${'sha256_string'} | ${[]} | ${1} | ${'sha256_string accepts 1-3 arguments, found: 0'}
${'op'} | ${'concat_strings'} | ${[]} | ${0} | ${''}
${'op'} | ${'concat_strings'} | ${['a', 'b', 'c']} | ${0} | ${'abc'}
${'peer'} | ${'timeout'} | ${[200, []]} | ${0} | ${[]}
${'peer'} | ${'timeout'} | ${[200, ['test']]} | ${0} | ${['test']}
${'peer'} | ${'timeout'} | ${[]} | ${1} | ${'timeout accepts exactly two arguments: timeout duration in ms and a message string'}
${'peer'} | ${'timeout'} | ${[200, 'test', 1]} | ${1} | ${'timeout accepts exactly two arguments: timeout duration in ms and a message string'}
${'debug'} | ${'stringify'} | ${[]} | ${0} | ${'"<empty argument list>"'}
${'debug'} | ${'stringify'} | ${[{ a: 10, b: 20 }]} | ${0} | ${a10b20}
${'debug'} | ${'stringify'} | ${[1, 2, 3, 4]} | ${0} | ${oneTwoThreeFour}
${'math'} | ${'add'} | ${[2, 2]} | ${0} | ${4}
${'math'} | ${'add'} | ${[2]} | ${1} | ${'Expected 2 argument(s). Got 1'}
${'math'} | ${'sub'} | ${[2, 2]} | ${0} | ${0}
${'math'} | ${'sub'} | ${[2, 3]} | ${0} | ${-1}
${'math'} | ${'mul'} | ${[2, 2]} | ${0} | ${4}
${'math'} | ${'mul'} | ${[2, 0]} | ${0} | ${0}
${'math'} | ${'mul'} | ${[2, -1]} | ${0} | ${-2}
${'math'} | ${'fmul'} | ${[10, 0.66]} | ${0} | ${6}
${'math'} | ${'fmul'} | ${[0.5, 0.5]} | ${0} | ${0}
${'math'} | ${'fmul'} | ${[100.5, 0.5]} | ${0} | ${50}
${'math'} | ${'div'} | ${[2, 2]} | ${0} | ${1}
${'math'} | ${'div'} | ${[2, 3]} | ${0} | ${0}
${'math'} | ${'div'} | ${[10, 5]} | ${0} | ${2}
${'math'} | ${'rem'} | ${[10, 3]} | ${0} | ${1}
${'math'} | ${'pow'} | ${[2, 2]} | ${0} | ${4}
${'math'} | ${'pow'} | ${[2, 0]} | ${0} | ${1}
${'math'} | ${'log'} | ${[2, 2]} | ${0} | ${1}
${'math'} | ${'log'} | ${[2, 4]} | ${0} | ${2}
${'cmp'} | ${'gt'} | ${[2, 4]} | ${0} | ${false}
${'cmp'} | ${'gte'} | ${[2, 4]} | ${0} | ${false}
${'cmp'} | ${'gte'} | ${[4, 2]} | ${0} | ${true}
${'cmp'} | ${'gte'} | ${[2, 2]} | ${0} | ${true}
${'cmp'} | ${'lt'} | ${[2, 4]} | ${0} | ${true}
${'cmp'} | ${'lte'} | ${[2, 4]} | ${0} | ${true}
${'cmp'} | ${'lte'} | ${[4, 2]} | ${0} | ${false}
${'cmp'} | ${'lte'} | ${[2, 2]} | ${0} | ${true}
${'cmp'} | ${'cmp'} | ${[2, 4]} | ${0} | ${-1}
${'cmp'} | ${'cmp'} | ${[2, -4]} | ${0} | ${1}
${'cmp'} | ${'cmp'} | ${[2, 2]} | ${0} | ${0}
${'array'} | ${'sum'} | ${[[1, 2, 3]]} | ${0} | ${6}
${'array'} | ${'dedup'} | ${[['a', 'a', 'b', 'c', 'a', 'b', 'c']]} | ${0} | ${['a', 'b', 'c']}
${'array'} | ${'intersect'} | ${[['a', 'b', 'c'], ['c', 'b', 'd']]} | ${0} | ${['b', 'c']}
${'array'} | ${'diff'} | ${[['a', 'b', 'c'], ['c', 'b', 'd']]} | ${0} | ${['a']}
${'array'} | ${'sdiff'} | ${[['a', 'b', 'c'], ['c', 'b', 'd']]} | ${0} | ${['a', 'd']}
${'json'} | ${'obj'} | ${['a', 10, 'b', 'string', 'c', null]} | ${0} | ${{ a: 10, b: 'string', c: null }}
${'json'} | ${'obj'} | ${['a', 10, 'b', 'string', 'c']} | ${1} | ${'Expected even number of argument(s). Got 5'}
${'json'} | ${'obj'} | ${[]} | ${0} | ${{}}
${'json'} | ${'put'} | ${[{}, 'a', 10]} | ${0} | ${{ a: 10 }}
${'json'} | ${'put'} | ${[{ b: 11 }, 'a', 10]} | ${0} | ${{ a: 10, b: 11 }}
${'json'} | ${'put'} | ${['a', 'a', 11]} | ${1} | ${'Argument 0 expected to be of type object, Got string'}
${'json'} | ${'put'} | ${[{}, 'a', 10, 'b', 20]} | ${1} | ${'Expected 3 argument(s). Got 5'}
${'json'} | ${'put'} | ${[{}]} | ${1} | ${'Expected 3 argument(s). Got 1'}
${'json'} | ${'puts'} | ${[{}, 'a', 10]} | ${0} | ${{ a: 10 }}
${'json'} | ${'puts'} | ${[{ b: 11 }, 'a', 10]} | ${0} | ${{ a: 10, b: 11 }}
${'json'} | ${'puts'} | ${[{}, 'a', 10, 'b', 'string', 'c', null]} | ${0} | ${{ a: 10, b: 'string', c: null }}
${'json'} | ${'puts'} | ${[{ x: 'text' }, 'a', 10, 'b', 'string']} | ${0} | ${{ a: 10, b: 'string', x: 'text' }}
${'json'} | ${'puts'} | ${[{}]} | ${1} | ${'Expected more than 3 argument(s). Got 1'}
${'json'} | ${'puts'} | ${['a', 'a', 11]} | ${1} | ${'Argument 0 expected to be of type object, Got string'}
${'json'} | ${'stringify'} | ${[{ a: 10, b: 'string', c: null }]} | ${0} | ${'{"a":10,"b":"string","c":null}'}
${'json'} | ${'stringify'} | ${[1]} | ${1} | ${'Argument 0 expected to be of type object, Got number'}
${'json'} | ${'parse'} | ${['{"a":10,"b":"string","c":null}']} | ${0} | ${{ a: 10, b: 'string', c: null }}
${'json'} | ${'parse'} | ${['incorrect']} | ${1} | ${'Unexpected token i in JSON at position 0'}
${'json'} | ${'parse'} | ${[10]} | ${1} | ${'Argument 0 expected to be of type string, Got number'}
`(
//
'$fnName with $args expected retcode: $retCode and result: $result',
async ({ serviceId, fnName, args, retCode, result }) => {
// arrange
const req: CallServiceData = {
serviceId: serviceId,
fnName: fnName,
args: args,
tetraplets: [],
particleContext: {
particleId: 'some',
initPeerId: 'init peer id',
timestamp: 595951200,
ttl: 595961200,
signature: 'sig',
},
};
// act
const fn = builtInServices[req.serviceId][req.fnName];
const res = await fn(req);
// Our test cases above depend on node error message. In node 20 error message for JSON.parse has changed.
// Simple and fast solution for this specific case is to unify both variations into node 18 version error format.
if (res.result === 'Unexpected token \'i\', "incorrect" is not valid JSON') {
res.result = 'Unexpected token i in JSON at position 0';
}
// assert
expect(res).toMatchObject({
retCode: retCode,
result: result,
});
},
);
it('should return correct error message for identiy service', async () => {
// arrange
const req: CallServiceData = {
serviceId: 'peer',
fnName: 'identify',
args: [],
tetraplets: [],
particleContext: {
particleId: 'some',
initPeerId: 'init peer id',
timestamp: 595951200,
ttl: 595961200,
signature: 'sig',
},
};
// act
const fn = builtInServices[req.serviceId][req.fnName];
const res = await fn(req);
// assert
expect(res).toMatchObject({
retCode: 0,
result: {
external_addresses: [],
node_version: expect.stringContaining('js'),
air_version: expect.stringContaining('js'),
},
});
});
});
const key = '+cmeYlZKj+MfSa9dpHV+BmLPm6wq4inGlsPlQ1GvtPk=';
const context = (async () => {
const keyBytes = toUint8Array(key);
const kp = await KeyPair.fromEd25519SK(keyBytes);
const res = {
peerKeyPair: kp,
peerId: kp.getPeerId(),
};
return res;
})();
const testData = [1, 2, 3, 4, 5, 6, 7, 9, 10];
// signature produced by KeyPair created from key above (`key` variable)
const testDataSig = [
224, 104, 245, 206, 140, 248, 27, 72, 68, 133, 111, 10, 164, 197, 242, 132, 107, 77, 224, 67, 99, 106, 76, 29, 144,
121, 122, 169, 36, 173, 58, 80, 170, 102, 137, 253, 157, 247, 168, 87, 162, 223, 188, 214, 203, 220, 52, 246, 29,
86, 77, 71, 224, 248, 16, 213, 254, 75, 78, 239, 243, 222, 241, 15,
];
// signature produced by KeyPair created from some random KeyPair
const testDataWrongSig = [
116, 247, 189, 118, 236, 53, 147, 123, 219, 75, 176, 105, 101, 108, 233, 137, 97, 14, 146, 132, 252, 70, 51, 153,
237, 167, 156, 150, 36, 90, 229, 108, 166, 231, 255, 137, 8, 246, 125, 0, 213, 150, 83, 196, 237, 221, 131, 159,
157, 159, 25, 109, 95, 160, 181, 65, 254, 238, 47, 156, 240, 151, 58, 14,
];
const makeTetraplet = (initPeerId: string, serviceId?: string, fnName?: string): CallParams<'data'> => {
return {
initPeerId: initPeerId,
tetraplets: {
data: [
{
function_name: fnName,
service_id: serviceId,
},
],
},
} as any;
};
describe('Sig service tests', () => {
it('sig.sign should create the correct signature', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
const res = await sig.sign(testData, makeTetraplet(ctx.peerId));
expect(res.success).toBe(true);
expect(res.signature).toStrictEqual(testDataSig);
});
it('sig.verify should return true for the correct signature', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
const res = await sig.verify(testDataSig, testData);
expect(res).toBe(true);
});
it('sig.verify should return false for the incorrect signature', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
const res = await sig.verify(testDataWrongSig, testData);
expect(res).toBe(false);
});
it('sign-verify call chain should work', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
const signature = await sig.sign(testData, makeTetraplet(ctx.peerId));
const res = await sig.verify(signature.signature as number[], testData);
expect(res).toBe(true);
});
it('sig.sign with defaultSigGuard should work for correct callParams', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
sig.securityGuard = defaultSigGuard(ctx.peerId);
const signature = await sig.sign(testData, makeTetraplet(ctx.peerId, 'registry', 'get_route_bytes'));
await expect(signature).toBeDefined();
});
it('sig.sign with defaultSigGuard should not allow particles initiated from incorrect service', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
sig.securityGuard = defaultSigGuard(ctx.peerId);
const res = await sig.sign(testData, makeTetraplet(ctx.peerId, 'other_service', 'other_fn'));
await expect(res.success).toBe(false);
await expect(res.error).toBe('Security guard validation failed');
});
it('sig.sign with defaultSigGuard should not allow particles initiated from other peers', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
sig.securityGuard = defaultSigGuard(ctx.peerId);
const res = await sig.sign(
testData,
makeTetraplet((await KeyPair.randomEd25519()).getPeerId(), 'registry', 'get_key_bytes'),
);
await expect(res.success).toBe(false);
await expect(res.error).toBe('Security guard validation failed');
});
it('changing securityGuard should work', async () => {
const ctx = await context;
const sig = new Sig(ctx.peerKeyPair);
sig.securityGuard = allowServiceFn('test', 'test');
const successful1 = await sig.sign(testData, makeTetraplet(ctx.peerId, 'test', 'test'));
const unSuccessful1 = await sig.sign(testData, makeTetraplet(ctx.peerId, 'wrong', 'wrong'));
sig.securityGuard = allowServiceFn('wrong', 'wrong');
const successful2 = await sig.sign(testData, makeTetraplet(ctx.peerId, 'wrong', 'wrong'));
const unSuccessful2 = await sig.sign(testData, makeTetraplet(ctx.peerId, 'test', 'test'));
expect(successful1.success).toBe(true);
expect(successful2.success).toBe(true);
expect(unSuccessful1.success).toBe(false);
expect(unSuccessful2.success).toBe(false);
});
});

78
packages/core/js-client/src/services/__test__/jsonBuiltin.spec.ts Normal file
View File

@ -0,0 +1,78 @@
import { it, describe, expect, beforeEach, afterEach } from 'vitest';
import { Particle } from '../../particle/Particle.js';
import { FluencePeer } from '../../jsPeer/FluencePeer.js';
import { mkTestPeer } from '../../util/testUtils.js';
import { doNothing } from '../../jsServiceHost/serviceUtils.js';
let peer: FluencePeer;
describe('Sig service test suite', () => {
afterEach(async () => {
if (peer) {
await peer.stop();
}
});
beforeEach(async () => {
peer = await mkTestPeer();
await peer.start();
});
it('JSON builtin spec', async () => {
const script = `
(seq
(seq
(seq
;; create
(seq
(call %init_peer_id% ("json" "obj") ["name" "nested_first" "num" 1] nested_first)
(call %init_peer_id% ("json" "obj") ["name" "nested_second" "num" 2] nested_second)
)
(call %init_peer_id% ("json" "obj") ["name" "outer_first" "num" 0 "nested" nested_first] outer_first)
)
(seq
;; modify
(seq
(call %init_peer_id% ("json" "put") [outer_first "nested" nested_second] outer_tmp_second)
(call %init_peer_id% ("json" "puts") [outer_tmp_second "name" "outer_second" "num" 3] outer_second)
)
;; stringify and parse
(seq
(call %init_peer_id% ("json" "stringify") [outer_first] outer_first_string)
(call %init_peer_id% ("json" "parse") [outer_first_string] outer_first_parsed)
)
)
)
(call %init_peer_id% ("res" "res") [nested_first nested_second outer_first outer_second outer_first_string outer_first_parsed])
)
`;
const promise = new Promise<any>((resolve) => {
peer.internals.regHandler.common('res', 'res', (req) => {
resolve(req.args);
return {
result: {},
retCode: 0,
};
});
});
const p = peer.internals.createNewParticle(script);
await peer.internals.initiateParticle(p, doNothing);
const [nestedFirst, nestedSecond, outerFirst, outerSecond, outerFirstString, outerFirstParsed] = await promise;
const nfExpected = { name: 'nested_first', num: 1 };
const nsExpected = { name: 'nested_second', num: 2 };
const ofExpected = { name: 'outer_first', nested: nfExpected, num: 0 };
const ofString = JSON.stringify(ofExpected);
const osExpected = { name: 'outer_second', num: 3, nested: nsExpected };
expect(nestedFirst).toMatchObject(nfExpected);
expect(nestedSecond).toMatchObject(nsExpected);
expect(outerFirst).toMatchObject(ofExpected);
expect(outerSecond).toMatchObject(osExpected);
expect(outerFirstParsed).toMatchObject(ofExpected);
expect(outerFirstString).toBe(ofString);
});
});

119
packages/core/js-client/src/services/__test__/sigService.spec.ts Normal file
View File

@ -0,0 +1,119 @@
import { it, describe, expect, beforeAll } from 'vitest';
import * as path from 'path';
import * as url from 'url';
import { KeyPair } from '../../keypair/index.js';
import { allowServiceFn } from '../securityGuard.js';
import { Sig } from '../Sig.js';
import { registerService } from '../../compilerSupport/registerService.js';
import { compileAqua, withPeer } from '../../util/testUtils.js';
const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
let aqua: any;
let sigDef: any;
let dataProviderDef: any;
describe('Sig service test suite', () => {
beforeAll(async () => {
const pathToAquaFiles = path.join(__dirname, '../../../aqua_test/sigService.aqua');
const { services, functions } = await compileAqua(pathToAquaFiles);
aqua = functions;
sigDef = services.Sig;
dataProviderDef = services.DataProvider;
});
it('Use custom sig service, success path', async () => {
await withPeer(async (peer) => {
const customKeyPair = await KeyPair.randomEd25519();
const customSig = new Sig(customKeyPair);
const data = [1, 2, 3, 4, 5];
registerService({ peer, def: sigDef, serviceId: 'CustomSig', service: customSig });
registerService({
peer,
def: dataProviderDef,
serviceId: 'data',
service: {
provide_data: () => {
return data;
},
},
});
customSig.securityGuard = allowServiceFn('data', 'provide_data');
const result = await aqua.callSig(peer, { sigId: 'CustomSig' });
expect(result.success).toBe(true);
const isSigCorrect = await customSig.verify(result.signature as number[], data);
expect(isSigCorrect).toBe(true);
});
});
it('Use custom sig service, fail path', async () => {
await withPeer(async (peer) => {
const customKeyPair = await KeyPair.randomEd25519();
const customSig = new Sig(customKeyPair);
const data = [1, 2, 3, 4, 5];
registerService({ peer, def: sigDef, serviceId: 'CustomSig', service: customSig });
registerService({
peer,
def: dataProviderDef,
serviceId: 'data',
service: {
provide_data: () => {
return data;
},
},
});
customSig.securityGuard = allowServiceFn('wrong', 'wrong');
const result = await aqua.callSig(peer, { sigId: 'CustomSig' });
expect(result.success).toBe(false);
});
});
it('Default sig service should be resolvable by peer id', async () => {
await withPeer(async (peer) => {
const sig = peer.internals.getServices().sig;
const data = [1, 2, 3, 4, 5];
registerService({
peer: peer,
def: dataProviderDef,
serviceId: 'data',
service: {
provide_data: () => {
return data;
},
},
});
const callAsSigRes = await aqua.callSig(peer, { sigId: 'sig' });
const callAsPeerIdRes = await aqua.callSig(peer, { sigId: peer.keyPair.getPeerId() });
expect(callAsSigRes.success).toBe(false);
expect(callAsPeerIdRes.success).toBe(false);
sig.securityGuard = () => true;
const callAsSigResAfterGuardChange = await aqua.callSig(peer, { sigId: 'sig' });
const callAsPeerIdResAfterGuardChange = await aqua.callSig(peer, {
sigId: peer.keyPair.getPeerId(),
});
expect(callAsSigResAfterGuardChange.success).toBe(true);
expect(callAsPeerIdResAfterGuardChange.success).toBe(true);
const isValid = await sig.verify(callAsSigResAfterGuardChange.signature as number[], data);
expect(isValid).toBe(true);
});
});
});

85
packages/core/js-client/src/services/__test__/srv.spec.ts Normal file
View File

@ -0,0 +1,85 @@
import { it, describe, expect, beforeAll } from 'vitest';
import * as path from 'path';
import * as url from 'url';
import { compileAqua, withPeer } from '../../util/testUtils.js';
import { registerNodeUtils } from '../_aqua/node-utils.js';
import { NodeUtils } from '../NodeUtils.js';
const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
let aqua: any;
describe('Srv service test suite', () => {
beforeAll(async () => {
const pathToAquaFiles = path.join(__dirname, '../../../aqua_test/srv.aqua');
const { services, functions } = await compileAqua(pathToAquaFiles);
aqua = functions;
});
it('Use custom srv service, success path', async () => {
await withPeer(async (peer) => {
// arrange
registerNodeUtils(peer, 'node_utils', new NodeUtils(peer));
const wasm = path.join(__dirname, '../../../data_for_test/greeting.wasm');
// act
const res = await aqua.happy_path(peer, { file_path: wasm });
// assert
expect(res).toBe('Hi, test');
});
});
it('List deployed services', async () => {
await withPeer(async (peer) => {
// arrange
registerNodeUtils(peer, 'node_utils', new NodeUtils(peer));
const wasm = path.join(__dirname, '../../../data_for_test/greeting.wasm');
// act
const res = await aqua.list_services(peer, { file_path: wasm });
// assert
expect(res).toHaveLength(3);
});
});
it('Correct error for removed services', async () => {
await withPeer(async (peer) => {
// arrange
registerNodeUtils(peer, 'node_utils', new NodeUtils(peer));
const wasm = path.join(__dirname, '../../../data_for_test/greeting.wasm');
// act
const res = await aqua.service_removed(peer, { file_path: wasm });
// assert
expect(res).toMatch('No service found for service call');
});
});
it('Correct error for file not found', async () => {
await withPeer(async (peer) => {
// arrange
registerNodeUtils(peer, 'node_utils', new NodeUtils(peer));
// act
const res = await aqua.file_not_found(peer, {});
// assert
expect(res).toMatch("ENOENT: no such file or directory, open '/random/incorrect/file'");
});
});
it('Correct error for removing non existing service', async () => {
await withPeer(async (peer) => {
// arrange
registerNodeUtils(peer, 'node_utils', new NodeUtils(peer));
// act
const res = await aqua.removing_non_exiting(peer, {});
// assert
expect(res).toMatch('Service with id random_id not found');
});
});
});

75
packages/core/js-client/src/services/_aqua/node-utils.ts Normal file
View File

@ -0,0 +1,75 @@
/**
* This compiled aqua file was modified to make it work in monorepo
*/
import { CallParams, IFluenceInternalApi } from '@fluencelabs/interfaces';
import { registerService } from '../../compilerSupport/registerService.js';
// Services
export interface NodeUtilsDef {
read_file: (
path: string,
callParams: CallParams<'path'>,
) =>
| { content: string | null; error: string | null; success: boolean }
| Promise<{ content: string | null; error: string | null; success: boolean }>;
}
export function registerNodeUtils(peer: IFluenceInternalApi, serviceId: string, service: any) {
registerService({
peer,
service,
serviceId,
def: {
defaultServiceId: 'node_utils',
functions: {
tag: 'labeledProduct',
fields: {
read_file: {
tag: 'arrow',
domain: {
tag: 'labeledProduct',
fields: {
path: {
tag: 'scalar',
name: 'string',
},
},
},
codomain: {
tag: 'unlabeledProduct',
items: [
{
tag: 'struct',
name: 'ReadFileResult',
fields: {
content: {
tag: 'option',
type: {
tag: 'scalar',
name: 'string',
},
},
error: {
tag: 'option',
type: {
tag: 'scalar',
name: 'string',
},
},
success: {
tag: 'scalar',
name: 'bool',
},
},
},
],
},
},
},
},
},
});
}
// Functions

133
packages/core/js-client/src/services/_aqua/services.ts Normal file
View File

@ -0,0 +1,133 @@
/**
* This compiled aqua file was modified to make it work in monorepo
*/
import { CallParams, IFluenceInternalApi } from '@fluencelabs/interfaces';
import { registerService } from '../../compilerSupport/registerService.js';
// Services
export interface SigDef {
get_peer_id: (callParams: CallParams<null>) => string | Promise<string>;
sign: (
data: number[],
callParams: CallParams<'data'>,
) =>
| { error: string | null; signature: number[] | null; success: boolean }
| Promise<{ error: string | null; signature: number[] | null; success: boolean }>;
verify: (
signature: number[],
data: number[],
callParams: CallParams<'signature' | 'data'>,
) => boolean | Promise<boolean>;
}
export function registerSig(peer: IFluenceInternalApi, serviceId: string, service: any) {
registerService({
peer,
service,
serviceId,
def: {
defaultServiceId: 'sig',
functions: {
tag: 'labeledProduct',
fields: {
get_peer_id: {
tag: 'arrow',
domain: {
tag: 'nil',
},
codomain: {
tag: 'unlabeledProduct',
items: [
{
tag: 'scalar',
name: 'string',
},
],
},
},
sign: {
tag: 'arrow',
domain: {
tag: 'labeledProduct',
fields: {
data: {
tag: 'array',
type: {
tag: 'scalar',
name: 'u8',
},
},
},
},
codomain: {
tag: 'unlabeledProduct',
items: [
{
tag: 'struct',
name: 'SignResult',
fields: {
error: {
tag: 'option',
type: {
tag: 'scalar',
name: 'string',
},
},
signature: {
tag: 'option',
type: {
tag: 'array',
type: {
tag: 'scalar',
name: 'u8',
},
},
},
success: {
tag: 'scalar',
name: 'bool',
},
},
},
],
},
},
verify: {
tag: 'arrow',
domain: {
tag: 'labeledProduct',
fields: {
signature: {
tag: 'array',
type: {
tag: 'scalar',
name: 'u8',
},
},
data: {
tag: 'array',
type: {
tag: 'scalar',
name: 'u8',
},
},
},
},
codomain: {
tag: 'unlabeledProduct',
items: [
{
tag: 'scalar',
name: 'bool',
},
],
},
},
},
},
},
});
}
// Functions

132
packages/core/js-client/src/services/_aqua/single-module-srv.ts Normal file
View File

@ -0,0 +1,132 @@
/**
* This compiled aqua file was modified to make it work in monorepo
*/
import { CallParams, IFluenceInternalApi } from '@fluencelabs/interfaces';
import { registerService } from '../../compilerSupport/registerService.js';
// Services
export interface SrvDef {
create: (
wasm_b64_content: string,
callParams: CallParams<'wasm_b64_content'>,
) =>
| { error: string | null; service_id: string | null; success: boolean }
| Promise<{ error: string | null; service_id: string | null; success: boolean }>;
list: (callParams: CallParams<null>) => string[] | Promise<string[]>;
remove: (
service_id: string,
callParams: CallParams<'service_id'>,
) => { error: string | null; success: boolean } | Promise<{ error: string | null; success: boolean }>;
}
export function registerSrv(peer: IFluenceInternalApi, serviceId: string, service: any) {
registerService({
peer,
serviceId,
service,
def: {
defaultServiceId: 'single_module_srv',
functions: {
tag: 'labeledProduct',
fields: {
create: {
tag: 'arrow',
domain: {
tag: 'labeledProduct',
fields: {
wasm_b64_content: {
tag: 'scalar',
name: 'string',
},
},
},
codomain: {
tag: 'unlabeledProduct',
items: [
{
tag: 'struct',
name: 'ServiceCreationResult',
fields: {
error: {
tag: 'option',
type: {
tag: 'scalar',
name: 'string',
},
},
service_id: {
tag: 'option',
type: {
tag: 'scalar',
name: 'string',
},
},
success: {
tag: 'scalar',
name: 'bool',
},
},
},
],
},
},
list: {
tag: 'arrow',
domain: {
tag: 'nil',
},
codomain: {
tag: 'unlabeledProduct',
items: [
{
tag: 'array',
type: {
tag: 'scalar',
name: 'string',
},
},
],
},
},
remove: {
tag: 'arrow',
domain: {
tag: 'labeledProduct',
fields: {
service_id: {
tag: 'scalar',
name: 'string',
},
},
},
codomain: {
tag: 'unlabeledProduct',
items: [
{
tag: 'struct',
name: 'RemoveResult',
fields: {
error: {
tag: 'option',
type: {
tag: 'scalar',
name: 'string',
},
},
success: {
tag: 'scalar',
name: 'bool',
},
},
},
],
},
},
},
},
},
});
}
// Functions

52
packages/core/js-client/src/services/_aqua/tracing.ts Normal file
View File

@ -0,0 +1,52 @@
/**
* This compiled aqua file was modified to make it work in monorepo
*/
import { CallParams, IFluenceInternalApi } from '@fluencelabs/interfaces';
import { registerService } from '../../compilerSupport/registerService.js';
// Services
export interface TracingDef {
tracingEvent: (
arrowName: string,
event: string,
callParams: CallParams<'arrowName' | 'event'>,
) => void | Promise<void>;
}
export function registerTracing(peer: IFluenceInternalApi, serviceId: string, service: any) {
registerService({
peer,
serviceId,
service,
def: {
defaultServiceId: 'tracingSrv',
functions: {
tag: 'labeledProduct',
fields: {
tracingEvent: {
tag: 'arrow',
domain: {
tag: 'labeledProduct',
fields: {
arrowName: {
tag: 'scalar',
name: 'string',
},
event: {
tag: 'scalar',
name: 'string',
},
},
},
codomain: {
tag: 'nil',
},
},
},
},
},
});
}
// Functions

604
packages/core/js-client/src/services/builtins.ts Normal file
View File

@ -0,0 +1,604 @@
/*
* Copyright 2021 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import * as bs58 from 'bs58';
import { sha256 } from 'multiformats/hashes/sha2';
import { CallServiceResult } from '@fluencelabs/avm';
import { isString, jsonify } from '../util/utils.js';
import { Buffer } from 'buffer';
import { GenericCallServiceHandler, ResultCodes } from '../jsServiceHost/interfaces.js';
//@ts-ignore
const { encode, decode } = bs58.default;
const success = (result: any): CallServiceResult => {
return {
result: result,
retCode: ResultCodes.success,
};
};
const error = (error: string): CallServiceResult => {
return {
result: error,
retCode: ResultCodes.error,
};
};
const errorNotImpl = (methodName: string) => {
return error(`The JS implementation of Peer does not support "${methodName}"`);
};
const makeJsonImpl = (args: Array<any>) => {
const [obj, ...kvs] = args;
const toMerge: Record<string, any> = {};
for (let i = 0; i < kvs.length / 2; i++) {
const k = kvs[i * 2];
if (!isString(k)) {
return error(`Argument ${k} is expected to be string`);
}
const v = kvs[i * 2 + 1];
toMerge[k] = v;
}
const res = { ...obj, ...toMerge };
return success(res);
};
export const builtInServices: Record<string, Record<string, GenericCallServiceHandler>> = {
peer: {
identify: () => {
return success({
external_addresses: [],
// TODO: remove hardcoded values
node_version: 'js-0.23.0',
air_version: 'js-0.24.2',
});
},
timestamp_ms: () => {
return success(Date.now());
},
timestamp_sec: () => {
return success(Math.floor(Date.now() / 1000));
},
is_connected: () => {
return errorNotImpl('peer.is_connected');
},
connect: () => {
return errorNotImpl('peer.connect');
},
get_contact: () => {
return errorNotImpl('peer.get_contact');
},
timeout: (req) => {
if (req.args.length !== 2) {
return error('timeout accepts exactly two arguments: timeout duration in ms and a message string');
}
const durationMs = req.args[0];
const message = req.args[1];
return new Promise((resolve) => {
setTimeout(() => {
const res = success(message);
resolve(res);
}, durationMs);
});
},
},
kad: {
neighborhood: () => {
return errorNotImpl('kad.neighborhood');
},
merge: () => {
return errorNotImpl('kad.merge');
},
},
srv: {
list: () => {
return errorNotImpl('srv.list');
},
create: () => {
return errorNotImpl('srv.create');
},
get_interface: () => {
return errorNotImpl('srv.get_interface');
},
resolve_alias: () => {
return errorNotImpl('srv.resolve_alias');
},
add_alias: () => {
return errorNotImpl('srv.add_alias');
},
remove: () => {
return errorNotImpl('srv.remove');
},
},
dist: {
add_module_from_vault: () => {
return errorNotImpl('dist.add_module_from_vault');
},
add_module: () => {
return errorNotImpl('dist.add_module');
},
add_blueprint: () => {
return errorNotImpl('dist.add_blueprint');
},
make_module_config: () => {
return errorNotImpl('dist.make_module_config');
},
load_module_config: () => {
return errorNotImpl('dist.load_module_config');
},
default_module_config: () => {
return errorNotImpl('dist.default_module_config');
},
make_blueprint: () => {
return errorNotImpl('dist.make_blueprint');
},
load_blueprint: () => {
return errorNotImpl('dist.load_blueprint');
},
list_modules: () => {
return errorNotImpl('dist.list_modules');
},
get_module_interface: () => {
return errorNotImpl('dist.get_module_interface');
},
list_blueprints: () => {
return errorNotImpl('dist.list_blueprints');
},
},
script: {
add: () => {
return errorNotImpl('script.add');
},
remove: () => {
return errorNotImpl('script.remove');
},
list: () => {
return errorNotImpl('script.list');
},
},
op: {
noop: () => {
return success({});
},
array: (req) => {
return success(req.args);
},
array_length: (req) => {
if (req.args.length !== 1) {
return error('array_length accepts exactly one argument, found: ' + req.args.length);
} else {
return success(req.args[0].length);
}
},
identity: (req) => {
if (req.args.length > 1) {
return error(`identity accepts up to 1 arguments, received ${req.args.length} arguments`);
} else {
return success(req.args.length === 0 ? {} : req.args[0]);
}
},
concat: (req) => {
const incorrectArgIndices = req.args //
.map((x, i) => [Array.isArray(x), i])
.filter(([isArray, _]) => !isArray)
.map(([_, index]) => index);
if (incorrectArgIndices.length > 0) {
const str = incorrectArgIndices.join(', ');
return error(`All arguments of 'concat' must be arrays: arguments ${str} are not`);
} else {
return success([].concat.apply([], req.args));
}
},
string_to_b58: (req) => {
if (req.args.length !== 1) {
return error('string_to_b58 accepts only one string argument');
} else {
return success(encode(new TextEncoder().encode(req.args[0])));
}
},
string_from_b58: (req) => {
if (req.args.length !== 1) {
return error('string_from_b58 accepts only one string argument');
} else {
return success(new TextDecoder().decode(decode(req.args[0])));
}
},
bytes_to_b58: (req) => {
if (req.args.length !== 1 || !Array.isArray(req.args[0])) {
return error('bytes_to_b58 accepts only single argument: array of numbers');
} else {
const argumentArray = req.args[0] as number[];
return success(encode(new Uint8Array(argumentArray)));
}
},
bytes_from_b58: (req) => {
if (req.args.length !== 1) {
return error('bytes_from_b58 accepts only one string argument');
} else {
return success(Array.from(decode(req.args[0])));
}
},
sha256_string: async (req) => {
if (req.args.length < 1 || req.args.length > 3) {
return error(`sha256_string accepts 1-3 arguments, found: ${req.args.length}`);
} else {
const [input, digestOnly, asBytes] = req.args;
const inBuffer = Buffer.from(input);
const multihash = await sha256.digest(inBuffer);
const outBytes = digestOnly ? multihash.digest : multihash.bytes;
const res = asBytes ? Array.from(outBytes) : encode(outBytes);
return success(res);
}
},
concat_strings: (req) => {
const res = ''.concat(...req.args);
return success(res);
},
},
debug: {
stringify: (req) => {
let out;
if (req.args.length === 0) {
out = '<empty argument list>';
} else if (req.args.length === 1) {
out = req.args[0];
} else {
out = req.args;
}
return success(jsonify(out));
},
},
math: {
add: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x + y);
},
sub: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x - y);
},
mul: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x * y);
},
fmul: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(Math.floor(x * y));
},
div: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(Math.floor(x / y));
},
rem: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x % y);
},
pow: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(Math.pow(x, y));
},
log: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(Math.log(y) / Math.log(x));
},
},
cmp: {
gt: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x > y);
},
gte: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x >= y);
},
lt: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x < y);
},
lte: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x <= y);
},
cmp: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [x, y] = req.args;
return success(x === y ? 0 : x > y ? 1 : -1);
},
},
array: {
sum: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 1))) {
return err;
}
const [xs] = req.args;
return success(xs.reduce((agg: any, cur: any) => agg + cur, 0));
},
dedup: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 1))) {
return err;
}
const [xs] = req.args;
const set = new Set(xs);
return success(Array.from(set));
},
intersect: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [xs, ys] = req.args;
const intersection = xs.filter((x: any) => ys.includes(x));
return success(intersection);
},
diff: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [xs, ys] = req.args;
const diff = xs.filter((x: unknown) => !ys.includes(x));
return success(diff);
},
sdiff: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 2))) {
return err;
}
const [xs, ys] = req.args;
const sdiff = [
// force new line
...xs.filter((y: unknown) => !ys.includes(y)),
...ys.filter((x: unknown) => !xs.includes(x)),
];
return success(sdiff);
},
},
json: {
obj: (req) => {
let err;
if ((err = checkForArgumentsCountEven(req, 1))) {
return err;
}
return makeJsonImpl([{}, ...req.args]);
},
put: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 3))) {
return err;
}
if ((err = checkForArgumentType(req, 0, 'object'))) {
return err;
}
return makeJsonImpl(req.args);
},
puts: (req) => {
let err;
if ((err = checkForArgumentsCountOdd(req, 1))) {
return err;
}
if ((err = checkForArgumentsCountMoreThan(req, 3))) {
return err;
}
if ((err = checkForArgumentType(req, 0, 'object'))) {
return err;
}
return makeJsonImpl(req.args);
},
stringify: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 1))) {
return err;
}
if ((err = checkForArgumentType(req, 0, 'object'))) {
return err;
}
const [json] = req.args;
const res = JSON.stringify(json);
return success(res);
},
parse: (req) => {
let err;
if ((err = checkForArgumentsCount(req, 1))) {
return err;
}
if ((err = checkForArgumentType(req, 0, 'string'))) {
return err;
}
const [raw] = req.args;
try {
const json = JSON.parse(raw);
return success(json);
} catch (err: any) {
return error(err.message);
}
},
},
'run-console': {
print: (req) => {
console.log(...req.args);
return success({});
},
},
} as const;
const checkForArgumentsCount = (req: { args: Array<unknown> }, count: number) => {
if (req.args.length !== count) {
return error(`Expected ${count} argument(s). Got ${req.args.length}`);
}
};
const checkForArgumentsCountMoreThan = (req: { args: Array<unknown> }, count: number) => {
if (req.args.length < count) {
return error(`Expected more than ${count} argument(s). Got ${req.args.length}`);
}
};
const checkForArgumentsCountEven = (req: { args: Array<unknown> }, count: number) => {
if (req.args.length % 2 === 1) {
return error(`Expected even number of argument(s). Got ${req.args.length}`);
}
};
const checkForArgumentsCountOdd = (req: { args: Array<unknown> }, count: number) => {
if (req.args.length % 2 === 0) {
return error(`Expected odd number of argument(s). Got ${req.args.length}`);
}
};
const checkForArgumentType = (req: { args: Array<unknown> }, index: number, type: string) => {
const actual = typeof req.args[index];
if (actual !== type) {
return error(`Argument ${index} expected to be of type ${type}, Got ${actual}`);
}
};

80
packages/core/js-client/src/services/securityGuard.ts Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { SecurityTetraplet } from '@fluencelabs/avm';
import { CallParams, PeerIdB58 } from '@fluencelabs/interfaces';
type ArgName = string | null;
/**
* A predicate of call params for sig service's sign method which determines whether signing operation is allowed or not
*/
export type SecurityGuard<T extends ArgName> = (params: CallParams<T>) => boolean;
/**
* Only allow calls when tetraplet for 'data' argument satisfies the predicate
*/
export const allowTetraplet = <T extends ArgName>(
pred: (tetraplet: SecurityTetraplet) => boolean,
): SecurityGuard<T> => {
return (params) => {
const t = params.tetraplets.data[0];
return pred(t);
};
};
/**
* Only allow data which comes from the specified serviceId and fnName
*/
export const allowServiceFn = <T extends ArgName>(serviceId: string, fnName: string): SecurityGuard<T> => {
return allowTetraplet((t) => {
return t.service_id === serviceId && t.function_name === fnName;
});
};
/**
* Only allow data originated from the specified json_path
*/
export const allowExactJsonPath = <T extends ArgName>(jsonPath: string): SecurityGuard<T> => {
return allowTetraplet((t) => {
return t.json_path === jsonPath;
});
};
/**
* Only allow signing when particle is initiated at the specified peer
*/
export const allowOnlyParticleOriginatedAt = <T extends ArgName>(peerId: PeerIdB58): SecurityGuard<T> => {
return (params) => {
return params.initPeerId === peerId;
};
};
/**
* Only allow signing when all of the predicates are satisfied.
* Useful for predicates reuse
*/
export const and = <T extends ArgName>(...predicates: SecurityGuard<T>[]): SecurityGuard<T> => {
return (params) => predicates.every((x) => x(params));
};
/**
* Only allow signing when any of the predicates are satisfied.
* Useful for predicates reuse
*/
export const or = <T extends ArgName>(...predicates: SecurityGuard<T>[]): SecurityGuard<T> => {
return (params) => predicates.some((x) => x(params));
};

26
packages/core/js-client/src/util/commonTypes.ts Normal file
View File

@ -0,0 +1,26 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export { CallParameters} from "@fluencelabs/marine-js/dist/types";
export interface IStartable {
start(): Promise<void>;
stop(): Promise<void>;
}
export type JSONValue = string | number | boolean | null | { [x: string]: JSONValue } | Array<JSONValue>;
export type JSONArray = Array<JSONValue>;
export type JSONObject = { [x: string]: JSONValue };

35
packages/core/js-client/src/util/libp2pUtils.ts Normal file
View File

@ -0,0 +1,35 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { RelayOptions } from '@fluencelabs/interfaces';
import { multiaddr, Multiaddr } from '@multiformats/multiaddr';
import { isString } from './utils.js';
export function relayOptionToMultiaddr(relay: RelayOptions): Multiaddr {
const multiaddrString = isString(relay) ? relay : relay.multiaddr;
const ma = multiaddr(multiaddrString);
throwIfHasNoPeerId(ma);
return ma;
}
export function throwIfHasNoPeerId(ma: Multiaddr): void {
const peerId = ma.getPeerId();
if (!peerId) {
throw new Error('Specified multiaddr is invalid or missing peer id: ' + ma.toString());
}
}

80
packages/core/js-client/src/util/loadClient.ts Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import type {
CallAquaFunctionType,
ClientConfig,
IFluenceClient,
RegisterServiceType,
RelayOptions,
} from '@fluencelabs/interfaces';
type PublicFluenceInterface = {
defaultClient: IFluenceClient | undefined;
clientFactory: (relay: RelayOptions, config?: ClientConfig) => Promise<IFluenceClient>;
callAquaFunction: CallAquaFunctionType;
registerService: RegisterServiceType;
};
export const getFluenceInterfaceFromGlobalThis = (): PublicFluenceInterface | undefined => {
// @ts-ignore
return globalThis.fluence;
};
// TODO: fix link DXJ-271
const REJECT_MESSAGE = `Could not load Fluence JS Client library.
If you are using Node.js that probably means that you forgot in install or import the @fluencelabs/js-client.node package.
If you are using a browser, then you probably forgot to add the <script> tag to your HTML.
Please refer to the documentation page for more details: https://fluence.dev/docs/build/js-client/installation
`;
// Let's assume that if the library has not been loaded in 5 seconds, then the user has forgotten to add the script tag
const POLL_PEER_TIMEOUT = 5000;
// The script might be cached so need to try loading it ASAP, thus short interval
const POLL_PEER_INTERVAL = 100;
/**
* Wait until the js client script it loaded and return the default peer from globalThis
*/
export const getFluenceInterface = (): Promise<PublicFluenceInterface> => {
// If the script is already loaded, then return the value immediately
const optimisticResult = getFluenceInterfaceFromGlobalThis();
if (optimisticResult) {
return Promise.resolve(optimisticResult);
}
return new Promise((resolve, reject) => {
// This function is internal
// Make it sure that would be zero way for unnecessary types
// to break out into the public API
let interval: any;
let hits = POLL_PEER_TIMEOUT / POLL_PEER_INTERVAL;
interval = setInterval(() => {
if (hits === 0) {
clearInterval(interval);
reject(REJECT_MESSAGE);
}
let res = getFluenceInterfaceFromGlobalThis();
if (res) {
clearInterval(interval);
resolve(res);
}
hits--;
}, POLL_PEER_INTERVAL);
});
};

70
packages/core/js-client/src/util/logger.ts Normal file
View File

@ -0,0 +1,70 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import debug from 'debug';
import { Buffer } from 'buffer';
// Format avm data as a string
debug.formatters.a = (avmData: Uint8Array) => {
return new TextDecoder().decode(Buffer.from(avmData));
};
type Logger = (formatter: any, ...args: any[]) => void;
export interface CommonLogger {
error: Logger;
trace: Logger;
debug: Logger;
}
export interface MarineLogger {
warn: Logger;
error: Logger;
debug: Logger;
trace: Logger;
info: Logger;
}
export function logger(name: string): CommonLogger {
return {
error: debug(`fluence:${name}:error`),
trace: debug(`fluence:${name}:trace`),
debug: debug(`fluence:${name}:debug`),
};
}
export function marineLogger(serviceId: string): MarineLogger {
const name = `fluence:marine:${serviceId}`;
return {
warn: debug(`${name}:warn`),
error: debug(`${name}:error`),
debug: debug(`${name}:debug`),
trace: debug(`${name}:trace`),
info: debug(`${name}:info`),
};
}
export function disable() {
debug.disable();
}
export function enable(namespaces: string) {
debug.enable(namespaces);
}
export function enabled(namespaces: string) {
return debug.enabled(namespaces);
}

140
packages/core/js-client/src/util/testUtils.ts Normal file
View File

@ -0,0 +1,140 @@
/*
* Copyright 2023 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import * as api from '@fluencelabs/aqua-api/aqua-api.js';
import { promises as fs } from 'fs';
import { DEFAULT_CONFIG, FluencePeer, PeerConfig } from '../jsPeer/FluencePeer.js';
import { Particle } from '../particle/Particle.js';
import { ClientConfig, IFluenceClient, RelayOptions, ServiceDef } from '@fluencelabs/interfaces';
import { callAquaFunction } from '../compilerSupport/callFunction.js';
import { MarineBackgroundRunner } from '../marine/worker/index.js';
import { WorkerLoader } from '../marine/worker-script/workerLoader.js';
import { KeyPair } from '../keypair/index.js';
import { Subject, Subscribable } from 'rxjs';
import { WrapFnIntoServiceCall } from '../jsServiceHost/serviceUtils.js';
import { JsServiceHost } from '../jsServiceHost/JsServiceHost.js';
import { ClientPeer, makeClientPeerConfig } from '../clientPeer/ClientPeer.js';
import { WasmLoaderFromNpm, WorkerLoaderFromNpm } from '../marine/deps-loader/node.js';
import { IConnection } from '../connection/interfaces.js';
export const registerHandlersHelper = (
peer: FluencePeer,
particle: Particle,
handlers: Record<string, Record<string, any>>,
) => {
Object.entries(handlers).forEach(([serviceId, service]) => {
Object.entries(service).forEach(([fnName, fn]) => {
peer.internals.regHandler.forParticle(particle.id, serviceId, fnName, WrapFnIntoServiceCall(fn));
});
});
};
export type CompiledFnCall = (peer: IFluenceClient, args: { [key: string]: any }) => Promise<unknown>;
export type CompiledFile = {
functions: { [key: string]: CompiledFnCall };
services: { [key: string]: ServiceDef };
};
export const compileAqua = async (aquaFile: string): Promise<CompiledFile> => {
await fs.access(aquaFile);
const compilationResult = await api.Aqua.compile(new api.Path(aquaFile), [], undefined);
if (compilationResult.errors.length > 0) {
throw new Error('Aqua compilation failed. Error: ' + compilationResult.errors.join('/n'));
}
const functions = Object.entries(compilationResult.functions)
.map(([name, fnInfo]) => {
const callFn = (peer: IFluenceClient, args: { [key: string]: any }) => {
return callAquaFunction({
def: fnInfo.funcDef,
script: fnInfo.script,
config: {},
peer: peer,
args,
});
};
return { [name]: callFn };
})
.reduce((agg, obj) => {
return { ...agg, ...obj };
}, {});
return { functions, services: compilationResult.services };
};
class NoopConnection implements IConnection {
getRelayPeerId(): string {
return 'nothing_here';
}
supportsRelay(): boolean {
return true;
}
particleSource: Subscribable<Particle> = new Subject<Particle>();
sendParticle(nextPeerIds: string[], particle: Particle): Promise<void> {
return Promise.resolve();
}
}
export class TestPeer extends FluencePeer {
constructor(keyPair: KeyPair, connection: IConnection) {
const workerLoader = new WorkerLoader();
const controlModuleLoader = new WasmLoaderFromNpm('@fluencelabs/marine-js', 'marine-js.wasm');
const avmModuleLoader = new WasmLoaderFromNpm('@fluencelabs/avm', 'avm.wasm');
const marine = new MarineBackgroundRunner(workerLoader, controlModuleLoader, avmModuleLoader);
const jsHost = new JsServiceHost();
super(DEFAULT_CONFIG, keyPair, marine, jsHost, connection);
}
}
export const mkTestPeer = async () => {
const kp = await KeyPair.randomEd25519();
const conn = new NoopConnection();
return new TestPeer(kp, conn);
};
export const withPeer = async (action: (p: FluencePeer) => Promise<void>) => {
const p = await mkTestPeer();
try {
await p.start();
await action(p);
} finally {
await p.stop();
}
};
export const withClient = async (
relay: RelayOptions,
config: ClientConfig,
action: (client: ClientPeer) => Promise<void>,
) => {
const workerLoader = new WorkerLoader();
const controlModuleLoader = new WasmLoaderFromNpm('@fluencelabs/marine-js', 'marine-js.wasm');
const avmModuleLoader = new WasmLoaderFromNpm('@fluencelabs/avm', 'avm.wasm');
const marine = new MarineBackgroundRunner(workerLoader, controlModuleLoader, avmModuleLoader);
const { keyPair, peerConfig, relayConfig } = await makeClientPeerConfig(relay, config);
const client = new ClientPeer(peerConfig, relayConfig, keyPair, marine);
try {
await client.connect();
await action(client);
} finally {
await client.disconnect();
}
};

27
packages/core/js-client/src/util/utils.ts Normal file
View File

@ -0,0 +1,27 @@
/*
* Copyright 2021 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export function jsonify(obj: unknown) {
return JSON.stringify(obj, null, 4);
}
export const isString = (unknown: unknown): unknown is string => {
return unknown !== null && typeof unknown === 'string';
};
export const isObject = (unknown: unknown): unknown is object => {
return unknown !== null && typeof unknown === 'object';
};