fluencelabs/fluence-js
1
0
Fork 0
mirror of https://github.com/fluencelabs/fluence-js.git synced 2025-06-12 07:31:21 +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

24
packages/core/js-client/.gitignore vendored Normal file
View File

@ -0,0 +1,24 @@
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*
# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release
bundle/
dist
esm
types
# Dependency directories
node_modules/
jspm_packages/
.idea
# workaround to make integration tests work
src/marine/worker-script/index.js

12
packages/core/js-client/.npmignore Normal file
View File

@ -0,0 +1,12 @@
.idea
.gitignore
node_modules
types
src/
tsconfig.json
webpack.config.js
bundle
pkg

1
packages/core/js-client/.prettierignore Normal file
View File

@ -0,0 +1 @@
/dist/

177
packages/core/js-client/CHANGELOG.md Normal file
View File

@ -0,0 +1,177 @@
# Changelog
## [0.9.1](https://github.com/fluencelabs/js-client/compare/js-peer-v0.9.0...js-peer-v0.9.1) (2023-08-08)
### Bug Fixes
* **deps:** update dependency @fluencelabs/avm to v0.43.1 ([#322](https://github.com/fluencelabs/js-client/issues/322)) ([c1d1fa6](https://github.com/fluencelabs/js-client/commit/c1d1fa6659b6dc2c6707786748b3410fab7f1bcd))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.8.0 to 0.8.1
## [0.9.0](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.10...js-peer-v0.9.0) (2023-06-29)
### ⚠ BREAKING CHANGES
* **avm:** avm 0.40.0 (https://github.com/fluencelabs/js-client/pull/315)
### Features
* **avm:** avm 0.40.0 (https://github.com/fluencelabs/js-client/pull/315) ([8bae6e2](https://github.com/fluencelabs/js-client/commit/8bae6e24e62153b567f320ccecc7bce76bc826d1))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.7.6 to 0.8.0
## [0.8.10](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.9...js-peer-v0.8.10) (2023-06-20)
### Features
* support signatures [fixes DXJ-389] ([#310](https://github.com/fluencelabs/js-client/issues/310)) ([a60dfe0](https://github.com/fluencelabs/js-client/commit/a60dfe0d680b4d9ac5092dec64e2ebf478bf80eb))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.7.5 to 0.7.6
## [0.8.9](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.8...js-peer-v0.8.9) (2023-06-14)
### Features
* Add tracing service [fixes DXJ-388] ([#307](https://github.com/fluencelabs/js-client/issues/307)) ([771086f](https://github.com/fluencelabs/js-client/commit/771086fddf52b7a5a1280894c7238e409cdf6a64))
* improve ttl error message ([#300](https://github.com/fluencelabs/js-client/issues/300)) ([9821183](https://github.com/fluencelabs/js-client/commit/9821183d53870240cb5700be67cb8d57533b954b))
## [0.8.8](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.7...js-peer-v0.8.8) (2023-05-30)
### Features
* add run-console ([#305](https://github.com/fluencelabs/js-client/issues/305)) ([cf1f029](https://github.com/fluencelabs/js-client/commit/cf1f02963c1d7e1a17866f5798901a0f61b8bc31))
## [0.8.7](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.6...js-peer-v0.8.7) (2023-04-04)
### Features
* Cleaning up technical debts ([#295](https://github.com/fluencelabs/js-client/issues/295)) ([0b2f12d](https://github.com/fluencelabs/js-client/commit/0b2f12d8ac223db341d6c30ff403166b3eae2e56))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.7.4 to 0.7.5
## [0.8.6](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.5...js-peer-v0.8.6) (2023-03-31)
### Features
* **logs:** Use `debug.js` library for logging [DXJ-327] ([#285](https://github.com/fluencelabs/js-client/issues/285)) ([e95c34a](https://github.com/fluencelabs/js-client/commit/e95c34a79220bd8ecdcee806802ac3d69a2af0cb))
* **test:** Automate smoke tests for JS Client [DXJ-293] ([#282](https://github.com/fluencelabs/js-client/issues/282)) ([10d7eae](https://github.com/fluencelabs/js-client/commit/10d7eaed809dde721b582d4b3228a48bbec50884))
### Bug Fixes
* **test:** All tests are working with vitest [DXJ-306] ([#291](https://github.com/fluencelabs/js-client/issues/291)) ([58ad3ca](https://github.com/fluencelabs/js-client/commit/58ad3ca6f666e8580997bb47609947645903436d))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.7.3 to 0.7.4
## [0.8.5](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.4...js-peer-v0.8.5) (2023-03-03)
### Bug Fixes
* Increase number of inbound and outbound streams to 1024 ([#280](https://github.com/fluencelabs/js-client/issues/280)) ([1ccc483](https://github.com/fluencelabs/js-client/commit/1ccc4835328426b546f31e1646d3a49ed042fdf9))
## [0.8.4](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.3...js-peer-v0.8.4) (2023-02-22)
### Bug Fixes
* `nodenext` moduleResolution for js peer ([#271](https://github.com/fluencelabs/js-client/issues/271)) ([78d98f1](https://github.com/fluencelabs/js-client/commit/78d98f15c12431dee9fdd7b9869d57760503f8c7))
## [0.8.3](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.2...js-peer-v0.8.3) (2023-02-16)
### Bug Fixes
* Trigger release to publish packages that were built ([#262](https://github.com/fluencelabs/js-client/issues/262)) ([47abf38](https://github.com/fluencelabs/js-client/commit/47abf3882956ffbdc52df372db26ba6252e8306b))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.7.2 to 0.7.3
## [0.8.2](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.1...js-peer-v0.8.2) (2023-02-16)
### Features
* Add `getRelayPeerId` method for `IFluenceClient` ([#260](https://github.com/fluencelabs/js-client/issues/260)) ([a10278a](https://github.com/fluencelabs/js-client/commit/a10278afaa782a307feb10c4eac060094c101230))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.7.1 to 0.7.2
## [0.8.1](https://github.com/fluencelabs/js-client/compare/js-peer-v0.8.0...js-peer-v0.8.1) (2023-02-16)
### Features
* Simplify JS Client public API ([#257](https://github.com/fluencelabs/js-client/issues/257)) ([9daaf41](https://github.com/fluencelabs/js-client/commit/9daaf410964d43228192c829c7ff785db6e88081))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.7.0 to 0.7.1
## [0.8.0](https://github.com/fluencelabs/fluence-js/compare/js-peer-v0.7.0...js-peer-v0.8.0) (2023-02-15)
### ⚠ BREAKING CHANGES
* Expose updated JS Client API via `js-client.api` package ([#246](https://github.com/fluencelabs/fluence-js/issues/246))
* Standalone web JS Client ([#243](https://github.com/fluencelabs/fluence-js/issues/243))
### Features
* Expose updated JS Client API via `js-client.api` package ([#246](https://github.com/fluencelabs/fluence-js/issues/246)) ([d4bb8fb](https://github.com/fluencelabs/fluence-js/commit/d4bb8fb42964b3ba25154232980b9ae82c21e627))
* Standalone web JS Client ([#243](https://github.com/fluencelabs/fluence-js/issues/243)) ([9667c4f](https://github.com/fluencelabs/fluence-js/commit/9667c4fec6868f984bba13249f3c47d293396406))
### Bug Fixes
* NodeJS package building ([#248](https://github.com/fluencelabs/fluence-js/issues/248)) ([0d05e51](https://github.com/fluencelabs/fluence-js/commit/0d05e517d89529af513fcb96cfa6c722ccc357a7))
### Dependencies
* The following workspace dependencies were updated
* dependencies
* @fluencelabs/interfaces bumped from 0.6.0 to 0.7.0

13
packages/core/js-client/CONTRIBUTING.md Normal file
View File

@ -0,0 +1,13 @@
## Contribute Code
You are welcome to contribute to Fluence.
Things you need to know:
1. You need to **agree to the Contributors License Agreement**. This is a common practice in all major Open Source projects. At the current moment we are unable to accept contributions made on behalf of a company. Only individual contributions will be accepted.
2. **Not all proposed contributions can be accepted**. Some features may e.g. just fit a third-party add-on better. The contribution must fit the overall direction of Fluence and really improve it. The more effort you invest, the better you should clarify in advance whether the contribution fits: the best way would be to just open an issue to discuss the contribution you plan to make.
### Contributor License Agreement
When you contribute, you have to be aware that your contribution is covered by **Apache License 2.0**, but might relicensed under few other software licenses mentioned in the **Contributor License Agreement**.
In particular you need to agree to the [Contributor License Agreement](https://gist.github.com/fluencelabs-org/3f4cbb3cc14c1c0fb9ad99d8f7316ed7). If you agree to its content, you simply have to click on the link posted by the CLA assistant as a comment to the pull request. Click it to check the CLA, then accept it on the following screen if you agree to it. CLA assistant will save this decision for upcoming contributions and will notify you if there is any change to the CLA in the meantime.

11
packages/core/js-client/README.md Normal file
View File

@ -0,0 +1,11 @@
# JS Peer
TDB
## Contributing
While the project is still in the early stages of development, you are welcome to track progress and contribute. As the project is undergoing rapid changes, interested contributors should contact the team before embarking on larger pieces of work. All contributors should consult with and agree to our [basic contributing rules](CONTRIBUTING.md).
## License
[Apache 2.0](LICENSE)

12
packages/core/js-client/aqua/node-utils.aqua Normal file
View File

@ -0,0 +1,12 @@
data ReadFileResult:
-- Was the call successful or not
success: bool
-- File content in base64 if the call was successful
content: ?string
-- Error message if the call was unsuccessful
error: ?string
service NodeUtils("node_utils"):
-- Read file from file system.
-- returns file content in base64 format
read_file(path: string) -> ReadFileResult

35
packages/core/js-client/aqua/services.aqua Normal file
View File

@ -0,0 +1,35 @@
-- import SignResult, Sig from "@fluencelabs/aqua-lib/builtin.aqua"
-- export SignResult, Sig
-- TODO:: fix this issue: https://github.com/fluencelabs/aqua-lib/issues/12
-- and remove copy-paste
data SignResult:
-- Was call successful or not
success: bool
-- Error message. Will be null if the call is successful
error: ?string
-- Signature as byte array. Will be null if the call is not successful
signature: ?[]u8
-- Available only on FluenceJS peers
-- The service can also be resolved by it's host peer id
service Sig("sig"):
-- Signs data with the service's private key.
-- Depending on implementation the service might check call params to restrict usage for security reasons.
-- By default it is only allowed to be used on the same peer the particle was initiated
-- and accepts data only from the following sources:
-- trust-graph.get_trust_bytes
-- trust-graph.get_revocation_bytes
-- registry.get_route_bytes
-- registry.get_record_bytes
-- registry.get_host_record_bytes
-- Argument: data - byte array to sign
-- Returns: signature as SignResult structure
sign(data: []u8) -> SignResult
-- Given the data and signature both as byte arrays, returns true if the signature is correct, false otherwise.
verify(signature: []u8, data: []u8) -> bool
-- Gets service's public key.
get_peer_id() -> string

32
packages/core/js-client/aqua/single-module-srv.aqua Normal file
View File

@ -0,0 +1,32 @@
alias Bytes : []u8
data ServiceCreationResult:
success: bool
service_id: ?string
error: ?string
data ReadFileResult:
success: bool
content: ?string
error: ?string
data RemoveResult:
success: bool
error: ?string
alias ListServiceResult: []string
service Srv("single_module_srv"):
-- Used to create a service on a certain node
-- Arguments:
-- bytes – a base64 string containing the .wasm module to add.
-- Returns: service_id – the service ID of the created service.
create(wasm_b64_content: string) -> ServiceCreationResult
-- Used to remove a service from a certain node
-- Arguments:
-- service_id – ID of the service to remove
remove(service_id: string) -> RemoveResult
-- Returns a list of services ids running on a peer
list() -> ListServiceResult

2
packages/core/js-client/aqua/tracing.aqua Normal file
View File

@ -0,0 +1,2 @@
service Tracing("tracingSrv"):
tracingEvent(arrowName: string, event: string)

26
packages/core/js-client/aqua_test/marine-js.aqua Normal file
View File

@ -0,0 +1,26 @@
data GreetingRecord:
str: string
num: i32
service Greeting("greeting"):
greeting(name: string) -> string
greeting_record() -> GreetingRecord
func call(arg: string) -> string:
res1 <- Greeting.greeting(arg)
res2 <- Greeting.greeting(res1)
res3 <- Greeting.greeting(res2)
<- res3
service GreetingRecord:
greeting_record() -> GreetingRecord
log_debug()
log_error()
log_info()
log_trace()
log_warn()
void_fn()
func call_info(srvId: string):
GreetingRecord srvId
GreetingRecord.log_info()

13
packages/core/js-client/aqua_test/sigService.aqua Normal file
View File

@ -0,0 +1,13 @@
module Export
import SignResult, Sig from "../aqua/services.aqua"
export Sig, DataProvider, callSig
service DataProvider("data"):
provide_data() -> []u8
func callSig(sigId: string) -> SignResult:
data <- DataProvider.provide_data()
Sig sigId
signature <- Sig.sign(data)
<- signature

44
packages/core/js-client/aqua_test/srv.aqua Normal file
View File

@ -0,0 +1,44 @@
module Export
import Srv from "../aqua/single-module-srv.aqua"
import NodeUtils from "../aqua/node-utils.aqua"
export happy_path, list_services, file_not_found, service_removed, removing_non_exiting
service Greeting("greeting"):
greeting(name: string) -> string
func happy_path(file_path: string) -> string:
file <- NodeUtils.read_file(file_path)
created_service <- Srv.create(file.content!)
Greeting created_service.service_id!
<- Greeting.greeting("test")
func list_services(file_path: string) -> []string:
file <- NodeUtils.read_file(file_path)
Srv.create(file.content!)
Srv.create(file.content!)
Srv.create(file.content!)
<- Srv.list()
func file_not_found() -> string:
e <- NodeUtils.read_file("/random/incorrect/file")
<- e.error!
func service_removed(file_path: string) -> string:
result: *string
file <- NodeUtils.read_file(file_path)
created_service <- Srv.create(file.content!)
Greeting created_service.service_id!
Srv.remove(created_service.service_id!)
try:
dontcare <- Greeting.greeting("test")
result <<- "ok"
catch e:
result <<- e.message
<- result!
func removing_non_exiting() -> string:
e <- Srv.remove("random_id")
<- e.error!

102
packages/core/js-client/build.ts Normal file
View File

@ -0,0 +1,102 @@
import path, { dirname } from 'path';
import type { InlineConfig, PluginOption } from 'vite';
import { build } from 'vite';
import { builtinModules, createRequire } from 'module';
import tsconfigPaths from 'vite-tsconfig-paths';
import inject from '@rollup/plugin-inject';
import stdLibBrowser from 'node-stdlib-browser';
import { fileURLToPath } from 'url';
import { rm, rename } from 'fs/promises';
import { replaceCodePlugin } from 'vite-plugin-replace';
import pkg from './package.json' assert { type: 'json' };
import libAssetsPlugin from '@laynezh/vite-plugin-lib-assets';
const require = createRequire(import.meta.url);
const commonConfig = (isNode: boolean): InlineConfig & Required<Pick<InlineConfig, 'build'>> => {
const esbuildShim = require.resolve('node-stdlib-browser/helpers/esbuild/shim');
return {
build: {
target: 'modules',
minify: 'esbuild',
lib: {
entry: './src/index.ts',
name: 'js-client',
fileName: `${isNode ? 'node' : 'browser'}/index`,
},
outDir: './dist',
emptyOutDir: false,
...(isNode ? {
rollupOptions: {
external: [...builtinModules, ...builtinModules.map(bm => `node:${bm}`)],
plugins: [
// @ts-ignore
inject({
self: 'global',
'WorkerScope': ['worker_threads', '*'],
'Worker': ['worker_threads', 'Worker'],
'isMainThread': ['worker_threads', 'isMainThread'],
})
]
}
} : {
rollupOptions: {
plugins: [
{
// @ts-ignore
...inject({
global: [esbuildShim, 'global'],
process: [esbuildShim, 'process'],
Buffer: [esbuildShim, 'Buffer']
}), enforce: 'post'
}
],
}
})
},
plugins: [tsconfigPaths(), libAssetsPlugin({
include: ['**/*.wasm*', '**/marine-worker.umd.cjs*'],
publicUrl: '/',
}), ...(isNode ? [replaceCodePlugin({
replacements: [
// After 'threads' package is built, it produces wrong output, which throws runtime errors.
// This code aims to fix such places.
// Should remove this after we move from threads to other package.
{ from: 'eval("require")("worker_threads")', to: 'WorkerScope' },
{ from: 'eval("require")("worker_threads")', to: 'WorkerScope' },
]
})] : [])] as PluginOption[],
optimizeDeps: {
esbuildOptions: {
define: {
global: 'globalThis',
},
},
},
resolve: {
browserField: !isNode,
conditions: isNode ? ['node'] : ['browser']
},
// Used only by browser
define: {
__JS_CLIENT_VERSION__: pkg.version,
__ENV__: isNode ? 'node' : 'browser'
},
};
};
const buildClient = async () => {
const nodeConfig = commonConfig(true);
const browserConfig = commonConfig(false);
try {
await rm('./dist', { recursive: true });
} catch {}
await build(nodeConfig);
await build(browserConfig);
};
buildClient()
.then(() => console.log('Built successfully'))
.catch((err) => console.error('failed', err));

BIN
packages/core/js-client/data_for_test/greeting-record.wasm Executable file
View File

Binary file not shown.

BIN
packages/core/js-client/data_for_test/greeting.wasm Executable file
View File

Binary file not shown.

70
packages/core/js-client/package.json Normal file
View File

@ -0,0 +1,70 @@
{
"name": "@fluencelabs/js-client",
"version": "0.0.10",
"description": "Client for interacting with Fluence network",
"engines": {
"node": ">=10",
"pnpm": ">=8"
},
"files": [
"dist"
],
"main": "./dist/browser/index.js",
"unpkg": "./dist/browser/index.js",
"types": "./dist/types/index.d.ts",
"exports": {
"types": "./dist/types/index.d.ts",
"node": "./dist/node/index.js",
"default": "./dist/browser/index.js"
},
"type": "module",
"scripts": {
"build": "node --loader ts-node/esm build.ts && tsc --emitDeclarationOnly",
"test": "vitest --threads false run"
},
"repository": "https://github.com/fluencelabs/fluence-js",
"author": "Fluence Labs",
"license": "Apache-2.0",
"dependencies": {
"@chainsafe/libp2p-noise": "13.0.0",
"@fluencelabs/interfaces": "0.8.1",
"@libp2p/crypto": "2.0.3",
"@libp2p/interface": "0.1.2",
"@libp2p/mplex": "9.0.4",
"@libp2p/peer-id": "3.0.2",
"@libp2p/peer-id-factory": "3.0.3",
"@libp2p/websockets": "7.0.4",
"@multiformats/multiaddr": "11.3.0",
"async": "3.2.4",
"bs58": "5.0.0",
"buffer": "6.0.3",
"debug": "4.3.4",
"it-length-prefixed": "8.0.4",
"it-map": "2.0.0",
"it-pipe": "2.0.5",
"js-base64": "3.7.5",
"libp2p": "0.46.6",
"multiformats": "11.0.1",
"rxjs": "7.5.5",
"threads": "1.7.0",
"ts-pattern": "3.3.3",
"uint8arrays": "4.0.3",
"uuid": "8.3.2"
},
"devDependencies": {
"@fluencelabs/aqua-api": "0.9.3",
"@fluencelabs/avm": "0.43.1",
"@fluencelabs/marine-js": "0.7.2",
"@fluencelabs/marine-worker": "workspace:*",
"@laynezh/vite-plugin-lib-assets": "0.5.2",
"@rollup/plugin-inject": "5.0.3",
"@types/bs58": "4.0.1",
"@types/debug": "4.1.7",
"@types/uuid": "8.3.2",
"node-stdlib-browser": "1.2.0",
"vite": "4.0.4",
"vite-plugin-replace": "0.1.1",
"vite-tsconfig-paths": "4.0.3",
"vitest": "0.29.7"
}
}

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';
};

11
packages/core/js-client/tsconfig.json Normal file
View File

@ -0,0 +1,11 @@
{
"extends": "../../../tsconfig.json",
"compilerOptions": {
"types": ["vite/client"],
"outDir": "dist/types",
"esModuleInterop": true,
"resolveJsonModule": true
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist"],
}