fluencelabs/marine
1
0
Fork 0
mirror of https://github.com/fluencelabs/marine.git synced 2025-06-22 19:21:38 +00:00
Code Issues Projects Releases Wiki Activity

Support references (#70)

Browse Source
This commit is contained in:
vms
2021-04-12 00:21:47 +03:00
committed by GitHub
parent 2aa3caee83
commit 1dcc9968bb
59 changed files with 401 additions and 459 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
Cargo.lock generated
View File

@ -69,7 +69,7 @@ dependencies = [
name = "arguments-passing-test"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"safe-transmute",
]
@ -83,7 +83,7 @@ checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
name = "arrays-passing-test"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"safe-transmute",
]
@ -132,11 +132,10 @@ checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
[[package]]
name = "bincode"
version = "1.3.1"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f30d3a39baa26f9651f17b375061f3233dde33424a8b72b0dbe93a68a0bc896d"
checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
dependencies = [
"byteorder",
"serde",
]
@ -206,7 +205,7 @@ checksum = "b700ce4376041dcd0a327fd0097c41095743c4c8af8887265942faf1100bd040"
name = "call_parameters"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
]
[[package]]
@ -379,9 +378,9 @@ dependencies = [
[[package]]
name = "crossbeam-channel"
version = "0.5.0"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dca26ee1f8d361640700bde38b2c37d8c22b3ce2d360e1fc1c74ea4b0aa7d775"
checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
dependencies = [
"cfg-if 1.0.0",
"crossbeam-utils",
@ -446,7 +445,7 @@ dependencies = [
name = "curl_adapter"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"log",
]
@ -651,7 +650,7 @@ name = "facade"
version = "0.1.0"
dependencies = [
"anyhow",
"fluence 0.5.0",
"fluence 0.6.0",
"log",
]
@ -712,7 +711,7 @@ version = "0.1.0"
dependencies = [
"anyhow",
"chrono",
"fluence-sdk-main 0.5.0",
"fluence-sdk-main 0.6.0",
"semver 0.11.0",
"serde",
"thiserror",
@ -722,11 +721,19 @@ dependencies = [
[[package]]
name = "fce-sqlite-connector"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c02ba19dff7f195418416b249423384761a964447dc40e7427f448687ac60b56"
version = "0.3.0"
source = "git+https://github.com/fluencelabs/sqlite-wasm-connector?branch=fluence_0_6_0#6cf624a62b27d35351aa390cfa20b3358655fe1f"
dependencies = [
"fluence 0.4.2",
"fluence 0.6.0",
]
[[package]]
name = "fce-timestamp-macro"
version = "0.6.0"
source = "git+https://github.com/fluencelabs/rust-sdk#e2a1e66e170abd992ee5b1a1bd21347494fcf91c"
dependencies = [
"chrono",
"quote",
]
[[package]]
@ -735,11 +742,11 @@ version = "0.1.29"
[[package]]
name = "fce-wit-generator"
version = "0.2.0"
version = "0.3.0"
dependencies = [
"cargo_toml",
"fce-wit-parser",
"fluence-sdk-wit 0.5.0",
"fluence-sdk-wit 0.6.0",
"once_cell",
"serde",
"serde_json",
@ -799,22 +806,13 @@ dependencies = [
[[package]]
name = "fluence"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "31068fe4873478f9c59f01230dc6f23d504d8c11a36d6b6c51693b20c6d2570e"
version = "0.6.0"
source = "git+https://github.com/fluencelabs/rust-sdk#e2a1e66e170abd992ee5b1a1bd21347494fcf91c"
dependencies = [
"fluence-sdk-macro 0.4.2",
"fluence-sdk-main 0.4.2",
]
[[package]]
name = "fluence"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "342831732a977f13220ecd6f25c7e6b6127af8d3794d42e3c880b05e457a0484"
dependencies = [
"fluence-sdk-macro 0.5.0",
"fluence-sdk-main 0.5.0",
"fce-timestamp-macro",
"fluence-sdk-macro 0.6.0",
"fluence-sdk-main 0.6.0",
"serde",
]
[[package]]
@ -839,7 +837,8 @@ dependencies = [
"env_logger 0.7.1",
"fce",
"fce-utils",
"fluence-sdk-main 0.5.0",
"fluence 0.6.0",
"fluence-sdk-main 0.6.0",
"itertools",
"log",
"once_cell",
@ -879,20 +878,10 @@ dependencies = [
[[package]]
name = "fluence-sdk-macro"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "76ce80dc2d7c3db828fb31b95e75c372fde7a9a25dfa2b0d9beac07379b890a6"
version = "0.6.0"
source = "git+https://github.com/fluencelabs/rust-sdk#e2a1e66e170abd992ee5b1a1bd21347494fcf91c"
dependencies = [
"fluence-sdk-wit 0.4.2",
]
[[package]]
name = "fluence-sdk-macro"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00c840552e5e58b62d4a272e3e4aabd548e1a4519df629a51d42157c7ecbe653"
dependencies = [
"fluence-sdk-wit 0.5.0",
"fluence-sdk-wit 0.6.0",
]
[[package]]
@ -908,22 +897,10 @@ dependencies = [
[[package]]
name = "fluence-sdk-main"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29cce53288e08ed86ebe36c64d8eb641a95e1d0f7f75da969b29e16ab0d7d406"
version = "0.6.0"
source = "git+https://github.com/fluencelabs/rust-sdk#e2a1e66e170abd992ee5b1a1bd21347494fcf91c"
dependencies = [
"fluence-sdk-macro 0.4.2",
"log",
"serde",
]
[[package]]
name = "fluence-sdk-main"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f1d126f05a798c8f812fbe47a42145478ce8029e00411b04d1c5194ab368313"
dependencies = [
"fluence-sdk-macro 0.5.0",
"fluence-sdk-macro 0.6.0",
"log",
"serde",
]
@ -944,23 +921,8 @@ dependencies = [
[[package]]
name = "fluence-sdk-wit"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56d835812bab8fb6f261b9e37355b9bf0a28a16123580145ce0fe44ef4363144"
dependencies = [
"proc-macro2",
"quote",
"serde",
"serde_json",
"syn",
"uuid",
]
[[package]]
name = "fluence-sdk-wit"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ac71e8d48a8e2bdaccf59572dc7a8e8a1ad0de512fc452107756e37ac0bf752"
version = "0.6.0"
source = "git+https://github.com/fluencelabs/rust-sdk#e2a1e66e170abd992ee5b1a1bd21347494fcf91c"
dependencies = [
"proc-macro2",
"quote",
@ -1010,7 +972,7 @@ dependencies = [
"clap",
"env_logger 0.7.1",
"fluence-app-service",
"fluence-sdk-main 0.5.0",
"fluence-sdk-main 0.6.0",
"itertools",
"log",
"rustop",
@ -1040,42 +1002,42 @@ checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
[[package]]
name = "futures-channel"
version = "0.3.13"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c2dd2df839b57db9ab69c2c9d8f3e8c81984781937fe2807dc6dcf3b2ad2939"
checksum = "ce79c6a52a299137a6013061e0cf0e688fce5d7f1bc60125f520912fdb29ec25"
dependencies = [
"futures-core",
]
[[package]]
name = "futures-core"
version = "0.3.13"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "15496a72fabf0e62bdc3df11a59a3787429221dd0710ba8ef163d6f7a9112c94"
checksum = "098cd1c6dda6ca01650f1a37a794245eb73181d0d4d4e955e2f3c37db7af1815"
[[package]]
name = "futures-io"
version = "0.3.13"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d71c2c65c57704c32f5241c1223167c2c3294fd34ac020c807ddbe6db287ba59"
checksum = "365a1a1fb30ea1c03a830fdb2158f5236833ac81fa0ad12fe35b29cddc35cb04"
[[package]]
name = "futures-sink"
version = "0.3.13"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85754d98985841b7d4f5e8e6fbfa4a4ac847916893ec511a2917ccd8525b8bb3"
checksum = "5c5629433c555de3d82861a7a4e3794a4c40040390907cfbfd7143a92a426c23"
[[package]]
name = "futures-task"
version = "0.3.13"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa189ef211c15ee602667a6fcfe1c1fd9e07d42250d2156382820fba33c9df80"
checksum = "ba7aa51095076f3ba6d9a1f702f74bd05ec65f555d70d2033d55ba8d69f581bc"
[[package]]
name = "futures-util"
version = "0.3.13"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1812c7ab8aedf8d6f2701a43e1243acdbcc2b36ab26e2ad421eb99ac963d96d1"
checksum = "3c144ad54d60f23927f0a6b6d816e4271278b64f005ad65e4e35291d2de9c025"
dependencies = [
"futures-core",
"futures-io",
@ -1413,7 +1375,7 @@ dependencies = [
name = "inner-records-test"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"safe-transmute",
]
@ -1461,7 +1423,7 @@ dependencies = [
name = "ipfs-effector"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"log",
]
@ -1469,7 +1431,7 @@ dependencies = [
name = "ipfs-pure"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"log",
]
@ -1554,7 +1516,7 @@ checksum = "9385f66bf6105b241aa65a61cb923ef20efc665cb9f9bb50ac2f0c4b7f378d41"
name = "local_storage"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"log",
]
@ -2143,7 +2105,7 @@ dependencies = [
name = "record-effector"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"test-record",
]
@ -2151,7 +2113,7 @@ dependencies = [
name = "record-pure"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
"test-record",
]
@ -2673,7 +2635,7 @@ dependencies = [
name = "test-record"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
]
[[package]]
@ -3174,7 +3136,7 @@ checksum = "d9a543ae66aa233d14bb765ed9af4a33e81b8b58d1584cf1b47ff8cd0b9e4489"
name = "wasm-greeting"
version = "0.1.0"
dependencies = [
"fluence 0.5.0",
"fluence 0.6.0",
]
[[package]]
@ -3182,7 +3144,7 @@ name = "wasm-sqlite-test"
version = "0.1.0"
dependencies = [
"fce-sqlite-connector",
"fluence 0.5.0",
"fluence 0.6.0",
]
[[package]]
@ -3239,9 +3201,9 @@ dependencies = [
[[package]]
name = "wasmer-interface-types-fl"
version = "0.18.3"
version = "0.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a0f9430f67621da4ace505a3e7b56c19e2ceff93db5507d2ca2f8e0b53feca6"
checksum = "be2004c1e24c8d51bd7732b8cbd968c6015b2d766fb31d19794c3ea3474cc297"
dependencies = [
"fluence-it-types",
"it-to-bytes",

2
crates/module-info-parser/Cargo.toml
View File

@ -11,7 +11,7 @@ name = "fce_module_info_parser"
path = "src/lib.rs"
[dependencies]
fluence-sdk-main = "0.5.0"
fluence-sdk-main = { git = "https://github.com/fluencelabs/rust-sdk" }
wasmer-core = { package = "wasmer-runtime-core-fl", version = "0.17.0" }

6
crates/wit-generator/Cargo.toml
View File

@ -1,7 +1,7 @@
[package]
name = "fce-wit-generator"
description = "Fluence FCE interface type helper crate"
version = "0.2.0"
version = "0.3.0"
authors = ["Fluence Labs"]
license = "Apache-2.0"
edition = "2018"
@ -12,10 +12,10 @@ path = "src/lib.rs"
[dependencies]
fce-wit-parser = { path = "../wit-parser", version = "0.4.0"}
fluence-sdk-wit = "=0.5.0"
fluence-sdk-wit = { git = "https://github.com/fluencelabs/rust-sdk" }
walrus = "0.18.0"
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.18.3" }
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.19.0" }
once_cell = "1.4.0"
serde = { version = "=1.0.118", features = ["derive"] }
serde_json = "1.0.56"

15
crates/wit-generator/src/default_export_api_config.rs
View File

@ -55,20 +55,11 @@ pub(crate) static ALLOCATE_FUNC: Lazy<ApiExportFuncDescriptor> =
output_types: vec![IType::I32],
});
pub(crate) static DEALLOCATE_FUNC: Lazy<ApiExportFuncDescriptor> =
pub(crate) static RELEASE_OBJECTS: Lazy<ApiExportFuncDescriptor> =
Lazy::new(|| ApiExportFuncDescriptor {
name: "deallocate",
name: "release_objects",
id: 1,
arguments: vec![
IFunctionArg {
name: String::from("pointer"),
ty: IType::I32,
},
IFunctionArg {
name: String::from("size"),
ty: IType::I32,
},
],
arguments: vec![],
output_types: vec![],
});

88
crates/wit-generator/src/instructions_generator/fn_instructions.rs
View File

@ -20,14 +20,14 @@ use super::utils::ptype_to_itype_checked;
use crate::default_export_api_config::*;
use crate::Result;
use fluence_sdk_wit::AstFunctionItem;
use fluence_sdk_wit::AstFnItem;
use fluence_sdk_wit::ParsedType;
use wasmer_wit::interpreter::Instruction;
use wasmer_wit::ast::FunctionArg as IFunctionArg;
use std::rc::Rc;
impl WITGenerator for AstFunctionItem {
impl WITGenerator for AstFnItem {
fn generate_wit<'a>(&'a self, wit_resolver: &mut WITResolver<'a>) -> Result<()> {
use wasmer_wit::ast::Type;
use wasmer_wit::ast::Adapter;
@ -36,10 +36,10 @@ impl WITGenerator for AstFunctionItem {
.signature
.arguments
.iter()
.map(|(arg_name, arg_type)| -> Result<IFunctionArg> {
.map(|arg| -> Result<IFunctionArg> {
Ok(IFunctionArg {
name: arg_name.clone(),
ty: ptype_to_itype_checked(arg_type, wit_resolver)?,
name: arg.name.clone(),
ty: ptype_to_itype_checked(&arg.ty, wit_resolver)?,
})
})
.collect::<Result<Vec<_>>>()?;
@ -77,16 +77,14 @@ impl WITGenerator for AstFunctionItem {
.arguments
.iter()
.enumerate()
.try_fold::<_, _, Result<_>>(
Vec::new(),
|mut instructions, (arg_id, (_, input_type))| {
let mut new_instructions = input_type
.generate_instructions_for_input_type(arg_id as _, wit_resolver)?;
.try_fold::<_, _, Result<_>>(Vec::new(), |mut instructions, (arg_id, arg)| {
let mut new_instructions = arg
.ty
.generate_instructions_for_input_type(arg_id as _, wit_resolver)?;
instructions.append(&mut new_instructions);
Ok(instructions)
},
)?;
instructions.append(&mut new_instructions);
Ok(instructions)
})?;
let export_function_index = (wit_resolver.interfaces.exports.len() - 1) as u32;
instructions.push(Instruction::CallCore {
@ -133,25 +131,25 @@ impl FnInstructionGenerator for ParsedType {
#[rustfmt::skip]
fn generate_instructions_for_input_type<'a>(&self, index: u32, wit_resolver: &mut WITResolver<'a>) -> Result<Vec<Instruction>> {
let instructions = match self {
ParsedType::Boolean => vec![Instruction::ArgumentGet { index }],
ParsedType::I8 => vec![Instruction::ArgumentGet { index }, Instruction::I32FromS8],
ParsedType::I16 => vec![Instruction::ArgumentGet { index }, Instruction::I32FromS16],
ParsedType::I32 => vec![Instruction::ArgumentGet { index }, Instruction::I32FromS32],
ParsedType::I64 => vec![Instruction::ArgumentGet { index }, Instruction::I64FromS64],
ParsedType::U8 => vec![Instruction::ArgumentGet { index }, Instruction::I32FromU8],
ParsedType::U16 => vec![Instruction::ArgumentGet { index }, Instruction::I32FromU16],
ParsedType::U32 => vec![Instruction::ArgumentGet { index }, Instruction::I32FromU32],
ParsedType::U64 => vec![Instruction::ArgumentGet { index }, Instruction::I64FromU64],
ParsedType::F32 => vec![Instruction::ArgumentGet { index }],
ParsedType::F64 => vec![Instruction::ArgumentGet { index }],
ParsedType::Utf8String => vec![
ParsedType::Boolean(_) => vec![Instruction::ArgumentGet { index }],
ParsedType::I8(_) => vec![Instruction::ArgumentGet { index }, Instruction::I32FromS8],
ParsedType::I16(_) => vec![Instruction::ArgumentGet { index }, Instruction::I32FromS16],
ParsedType::I32(_) => vec![Instruction::ArgumentGet { index }, Instruction::I32FromS32],
ParsedType::I64(_) => vec![Instruction::ArgumentGet { index }, Instruction::I64FromS64],
ParsedType::U8(_) => vec![Instruction::ArgumentGet { index }, Instruction::I32FromU8],
ParsedType::U16(_) => vec![Instruction::ArgumentGet { index }, Instruction::I32FromU16],
ParsedType::U32(_) => vec![Instruction::ArgumentGet { index }, Instruction::I32FromU32],
ParsedType::U64(_) => vec![Instruction::ArgumentGet { index }, Instruction::I64FromU64],
ParsedType::F32(_) => vec![Instruction::ArgumentGet { index }],
ParsedType::F64(_) => vec![Instruction::ArgumentGet { index }],
ParsedType::Utf8Str(_) | ParsedType::Utf8String(_) => vec![
Instruction::ArgumentGet { index },
Instruction::StringSize,
Instruction::CallCore { function_index: ALLOCATE_FUNC.id },
Instruction::ArgumentGet { index },
Instruction::StringLowerMemory,
],
ParsedType::Vector(value_type) => {
ParsedType::Vector(value_type, _) => {
let value_type = ptype_to_itype_checked(value_type, wit_resolver)?;
vec![
Instruction::ArgumentGet { index },
@ -160,7 +158,7 @@ impl FnInstructionGenerator for ParsedType {
},
]
},
ParsedType::Record(record_name) => {
ParsedType::Record(record_name, _) => {
let record_type_id = wit_resolver.get_record_type_id(record_name)? as u32;
vec! [
@ -176,40 +174,40 @@ impl FnInstructionGenerator for ParsedType {
#[rustfmt::skip]
fn generate_instructions_for_output_type<'a>(&self, wit_resolver: &mut WITResolver<'a>) -> Result<Vec<Instruction>> {
let instructions = match self {
ParsedType::Boolean => vec![],
ParsedType::I8 => vec![Instruction::S8FromI32],
ParsedType::I16 => vec![Instruction::S16FromI32],
ParsedType::I32 => vec![Instruction::S32FromI32],
ParsedType::I64 => vec![Instruction::S64FromI64],
ParsedType::U8 => vec![Instruction::U8FromI32],
ParsedType::U16 => vec![Instruction::U16FromI32],
ParsedType::U32 => vec![Instruction::U32FromI32],
ParsedType::U64 => vec![Instruction::U64FromI64],
ParsedType::F32 => vec![],
ParsedType::F64 => vec![],
ParsedType::Utf8String => vec![
ParsedType::Boolean(_) => vec![],
ParsedType::I8(_) => vec![Instruction::S8FromI32],
ParsedType::I16(_) => vec![Instruction::S16FromI32],
ParsedType::I32(_) => vec![Instruction::S32FromI32],
ParsedType::I64(_) => vec![Instruction::S64FromI64],
ParsedType::U8(_) => vec![Instruction::U8FromI32],
ParsedType::U16(_) => vec![Instruction::U16FromI32],
ParsedType::U32(_) => vec![Instruction::U32FromI32],
ParsedType::U64(_) => vec![Instruction::U64FromI64],
ParsedType::F32(_) => vec![],
ParsedType::F64(_) => vec![],
ParsedType::Utf8Str(_) | ParsedType::Utf8String(_) => vec![
Instruction::CallCore { function_index: GET_RESULT_PTR_FUNC.id },
Instruction::CallCore { function_index: GET_RESULT_SIZE_FUNC.id },
Instruction::StringLiftMemory,
Instruction::CallCore { function_index: GET_RESULT_PTR_FUNC.id },
Instruction::CallCore { function_index: GET_RESULT_SIZE_FUNC.id },
Instruction::CallCore { function_index: DEALLOCATE_FUNC.id },
Instruction::CallCore { function_index: RELEASE_OBJECTS.id },
],
ParsedType::Vector(value_type) => {
ParsedType::Vector(value_type, _) => {
let value_type = ptype_to_itype_checked(value_type, wit_resolver)?;
vec![
Instruction::CallCore { function_index: GET_RESULT_PTR_FUNC.id },
Instruction::CallCore { function_index: GET_RESULT_SIZE_FUNC.id },
Instruction::ArrayLiftMemory { value_type },
Instruction::CallCore { function_index: RELEASE_OBJECTS.id },
]
},
ParsedType::Record(record_name) => {
ParsedType::Record(record_name, _) => {
let record_type_id = wit_resolver.get_record_type_id(record_name)? as u32;
vec! [
Instruction::CallCore { function_index: GET_RESULT_PTR_FUNC.id },
Instruction::RecordLiftMemory { record_type_id },
Instruction::CallCore { function_index: RELEASE_OBJECTS.id },
]
},
};

144
crates/wit-generator/src/instructions_generator/foreign_mod_instructions.rs
View File

@ -23,6 +23,7 @@ use crate::Result;
use fluence_sdk_wit::AstExternModItem;
use fluence_sdk_wit::AstExternFnItem;
use fluence_sdk_wit::ParsedType;
use fluence_sdk_wit::AstFnArgument;
use wasmer_wit::ast::FunctionArg as IFunctionArg;
use wasmer_wit::interpreter::Instruction;
use crate::instructions_generator::utils::wtype_to_itype;
@ -58,10 +59,10 @@ fn generate_wit_for_import<'a>(
.signature
.arguments
.iter()
.map(|(arg_name, arg_type)| -> Result<IFunctionArg> {
.map(|arg| -> Result<IFunctionArg> {
Ok(IFunctionArg {
name: arg_name.clone(),
ty: ptype_to_itype_checked(arg_type, wit_resolver)?,
name: arg.name.clone(),
ty: ptype_to_itype_checked(&arg.ty, wit_resolver)?,
})
})
.collect::<Result<Vec<_>>>()?;
@ -132,16 +133,14 @@ fn generate_wit_for_import<'a>(
.signature
.arguments
.iter()
.try_fold::<_, _, Result<_>>(
(0, Vec::new()),
|(arg_id, mut instructions), (_, input_type)| {
let (mut new_instructions, shift) =
input_type.generate_instructions_for_input_type(arg_id as _, wit_resolver)?;
.try_fold::<_, _, Result<_>>((0, Vec::new()), |(arg_id, mut instructions), arg| {
let (mut new_instructions, shift) = arg
.ty
.generate_instructions_for_input_type(arg_id as _, wit_resolver)?;
instructions.append(&mut new_instructions);
Ok((arg_id + shift, instructions))
},
)?
instructions.append(&mut new_instructions);
Ok((arg_id + shift, instructions))
})?
.1;
// TODO: refactor
@ -194,23 +193,23 @@ impl ForeignModInstructionGenerator for ParsedType {
wit_resolver: &mut WITResolver<'a>,
) -> Result<(Vec<Instruction>, u32)> {
let instructions = match self {
ParsedType::Boolean => (vec![Instruction::ArgumentGet { index }], 1),
ParsedType::I8 => (vec![Instruction::ArgumentGet { index }, Instruction::S8FromI32], 1),
ParsedType::I16 => (vec![Instruction::ArgumentGet { index }, Instruction::S16FromI32], 1),
ParsedType::I32 => (vec![Instruction::ArgumentGet { index }, Instruction::S32FromI32], 1),
ParsedType::I64 => (vec![Instruction::ArgumentGet { index }, Instruction::S64FromI64], 1),
ParsedType::U8 => (vec![Instruction::ArgumentGet { index }, Instruction::U8FromI32], 1),
ParsedType::U16 => (vec![Instruction::ArgumentGet { index }, Instruction::U16FromI32], 1),
ParsedType::U32 => (vec![Instruction::ArgumentGet { index }, Instruction::U32FromI32], 1),
ParsedType::U64 => (vec![Instruction::ArgumentGet { index }, Instruction::U64FromI64], 1),
ParsedType::F32 => (vec![Instruction::ArgumentGet { index }], 1),
ParsedType::F64 => (vec![Instruction::ArgumentGet { index }], 1),
ParsedType::Utf8String => (vec![
ParsedType::Boolean(_) => (vec![Instruction::ArgumentGet { index }], 1),
ParsedType::I8(_) => (vec![Instruction::ArgumentGet { index }, Instruction::S8FromI32], 1),
ParsedType::I16(_) => (vec![Instruction::ArgumentGet { index }, Instruction::S16FromI32], 1),
ParsedType::I32(_) => (vec![Instruction::ArgumentGet { index }, Instruction::S32FromI32], 1),
ParsedType::I64(_) => (vec![Instruction::ArgumentGet { index }, Instruction::S64FromI64], 1),
ParsedType::U8(_) => (vec![Instruction::ArgumentGet { index }, Instruction::U8FromI32], 1),
ParsedType::U16(_) => (vec![Instruction::ArgumentGet { index }, Instruction::U16FromI32], 1),
ParsedType::U32(_) => (vec![Instruction::ArgumentGet { index }, Instruction::U32FromI32], 1),
ParsedType::U64(_) => (vec![Instruction::ArgumentGet { index }, Instruction::U64FromI64], 1),
ParsedType::F32(_) => (vec![Instruction::ArgumentGet { index }], 1),
ParsedType::F64(_) => (vec![Instruction::ArgumentGet { index }], 1),
ParsedType::Utf8Str(_) | ParsedType::Utf8String(_) => (vec![
Instruction::ArgumentGet { index },
Instruction::ArgumentGet { index: index + 1 },
Instruction::StringLiftMemory,
], 2),
ParsedType::Vector(value_type) => {
ParsedType::Vector(value_type, _) => {
let value_type = ptype_to_itype_checked(value_type, wit_resolver)?;
(vec![
@ -219,7 +218,7 @@ impl ForeignModInstructionGenerator for ParsedType {
Instruction::ArrayLiftMemory { value_type },
], 2)
},
ParsedType::Record(record_name) => {
ParsedType::Record(record_name, _) => {
let record_type_id = wit_resolver.get_record_type_id(record_name)? as u32;
(vec![
@ -235,18 +234,18 @@ impl ForeignModInstructionGenerator for ParsedType {
#[rustfmt::skip]
fn generate_instructions_for_output_type<'a>(&self, wit_resolver: &mut WITResolver<'a>) -> Result<Vec<Instruction>> {
let instructions = match self {
ParsedType::Boolean => vec![],
ParsedType::I8 => vec![Instruction::I32FromS8],
ParsedType::I16 => vec![Instruction::I32FromS16],
ParsedType::I32 => vec![Instruction::I32FromS32],
ParsedType::I64 => vec![Instruction::I64FromS64],
ParsedType::U8 => vec![Instruction::I32FromU8],
ParsedType::U16 => vec![Instruction::I32FromU16],
ParsedType::U32 => vec![Instruction::I32FromU32],
ParsedType::U64 => vec![Instruction::I64FromU64],
ParsedType::F32 => vec![],
ParsedType::F64 => vec![],
ParsedType::Utf8String => vec![
ParsedType::Boolean(_) => vec![],
ParsedType::I8(_) => vec![Instruction::I32FromS8],
ParsedType::I16(_) => vec![Instruction::I32FromS16],
ParsedType::I32(_) => vec![Instruction::I32FromS32],
ParsedType::I64(_) => vec![Instruction::I64FromS64],
ParsedType::U8(_) => vec![Instruction::I32FromU8],
ParsedType::U16(_) => vec![Instruction::I32FromU16],
ParsedType::U32(_) => vec![Instruction::I32FromU32],
ParsedType::U64(_) => vec![Instruction::I64FromU64],
ParsedType::F32(_) => vec![],
ParsedType::F64(_) => vec![],
ParsedType::Utf8Str(_) | ParsedType::Utf8String(_) => vec![
Instruction::Dup,
Instruction::StringSize,
Instruction::CallCore { function_index: ALLOCATE_FUNC.id },
@ -255,7 +254,7 @@ impl ForeignModInstructionGenerator for ParsedType {
Instruction::CallCore { function_index: SET_RESULT_SIZE_FUNC.id },
Instruction::CallCore { function_index: SET_RESULT_PTR_FUNC.id },
],
ParsedType::Vector(value_type) => {
ParsedType::Vector(value_type, _) => {
let value_type = ptype_to_itype_checked(value_type, wit_resolver)?;
vec![
@ -264,7 +263,7 @@ impl ForeignModInstructionGenerator for ParsedType {
Instruction::CallCore { function_index: SET_RESULT_PTR_FUNC.id },
]
},
ParsedType::Record(record_name) => {
ParsedType::Record(record_name, _) => {
let record_type_id = wit_resolver.get_record_type_id(record_name)? as u32;
vec![
@ -281,38 +280,38 @@ impl ForeignModInstructionGenerator for ParsedType {
use fluence_sdk_wit::RustType;
use wasmer_wit::IType;
pub fn to_raw_input_types(arg: &(String, ParsedType)) -> Vec<IFunctionArg> {
match arg.1 {
ParsedType::Boolean
| ParsedType::I8
| ParsedType::I16
| ParsedType::I32
| ParsedType::U8
| ParsedType::U16
| ParsedType::U32
| ParsedType::Record(_) => vec![IFunctionArg {
name: arg.0.clone(),
pub fn to_raw_input_types(arg: &AstFnArgument) -> Vec<IFunctionArg> {
match arg.ty {
ParsedType::Boolean(_)
| ParsedType::I8(_)
| ParsedType::I16(_)
| ParsedType::I32(_)
| ParsedType::U8(_)
| ParsedType::U16(_)
| ParsedType::U32(_)
| ParsedType::Record(..) => vec![IFunctionArg {
name: arg.name.clone(),
ty: IType::I32,
}],
ParsedType::I64 | ParsedType::U64 => vec![IFunctionArg {
name: arg.0.clone(),
ParsedType::I64(_) | ParsedType::U64(_) => vec![IFunctionArg {
name: arg.name.clone(),
ty: IType::I64,
}],
ParsedType::F32 => vec![IFunctionArg {
name: arg.0.clone(),
ParsedType::F32(_) => vec![IFunctionArg {
name: arg.name.clone(),
ty: IType::F32,
}],
ParsedType::F64 => vec![IFunctionArg {
name: arg.0.clone(),
ParsedType::F64(_) => vec![IFunctionArg {
name: arg.name.clone(),
ty: IType::F64,
}],
ParsedType::Utf8String | ParsedType::Vector(_) => vec![
ParsedType::Utf8Str(_) | ParsedType::Utf8String(_) | ParsedType::Vector(..) => vec![
IFunctionArg {
name: format!("{}_ptr", arg.0),
name: format!("{}_ptr", arg.name),
ty: IType::I32,
},
IFunctionArg {
name: format!("{}_ptr", arg.0),
name: format!("{}_ptr", arg.name),
ty: IType::I32,
},
],
@ -321,16 +320,19 @@ pub fn to_raw_input_types(arg: &(String, ParsedType)) -> Vec<IFunctionArg> {
pub fn to_raw_output_type(ty: &ParsedType) -> Vec<RustType> {
match ty {
ParsedType::Boolean
| ParsedType::I8
| ParsedType::I16
| ParsedType::I32
| ParsedType::U8
| ParsedType::U16
| ParsedType::U32 => vec![RustType::I32],
ParsedType::I64 | ParsedType::U64 => vec![RustType::I64],
ParsedType::F32 => vec![RustType::F32],
ParsedType::F64 => vec![RustType::F64],
ParsedType::Utf8String | ParsedType::Vector(_) | ParsedType::Record(_) => vec![],
ParsedType::Boolean(_)
| ParsedType::I8(_)
| ParsedType::I16(_)
| ParsedType::I32(_)
| ParsedType::U8(_)
| ParsedType::U16(_)
| ParsedType::U32(_) => vec![RustType::I32],
ParsedType::I64(_) | ParsedType::U64(_) => vec![RustType::I64],
ParsedType::F32(_) => vec![RustType::F32],
ParsedType::F64(_) => vec![RustType::F64],
ParsedType::Utf8Str(_)
| ParsedType::Utf8String(_)
| ParsedType::Vector(..)
| ParsedType::Record(..) => vec![],
}
}

58
crates/wit-generator/src/instructions_generator/utils.rs
View File

@ -27,23 +27,24 @@ pub(crate) fn ptype_to_itype_checked(
wit_resolver: &mut WITResolver<'_>,
) -> Result<IType> {
match pty {
ParsedType::I8 => Ok(IType::S8),
ParsedType::I16 => Ok(IType::S16),
ParsedType::I32 => Ok(IType::S32),
ParsedType::I64 => Ok(IType::S64),
ParsedType::U8 => Ok(IType::U8),
ParsedType::U16 => Ok(IType::U16),
ParsedType::U32 => Ok(IType::U32),
ParsedType::U64 => Ok(IType::U64),
ParsedType::F32 => Ok(IType::F32),
ParsedType::F64 => Ok(IType::F64),
ParsedType::Boolean => Ok(IType::I32),
ParsedType::Utf8String => Ok(IType::String),
ParsedType::Vector(ty) => {
ParsedType::I8(_) => Ok(IType::S8),
ParsedType::I16(_) => Ok(IType::S16),
ParsedType::I32(_) => Ok(IType::S32),
ParsedType::I64(_) => Ok(IType::S64),
ParsedType::U8(_) => Ok(IType::U8),
ParsedType::U16(_) => Ok(IType::U16),
ParsedType::U32(_) => Ok(IType::U32),
ParsedType::U64(_) => Ok(IType::U64),
ParsedType::F32(_) => Ok(IType::F32),
ParsedType::F64(_) => Ok(IType::F64),
ParsedType::Boolean(_) => Ok(IType::I32),
ParsedType::Utf8Str(_) => Ok(IType::String),
ParsedType::Utf8String(_) => Ok(IType::String),
ParsedType::Vector(ty, _) => {
let array_itype = ptype_to_itype_checked(ty, wit_resolver)?;
Ok(IType::Array(Box::new(array_itype)))
}
ParsedType::Record(record_name) => {
ParsedType::Record(record_name, _) => {
let record_type_id = wit_resolver.get_record_type_id(record_name)?;
Ok(IType::Record(record_type_id as _))
}
@ -55,23 +56,24 @@ pub(crate) fn ptype_to_itype_unchecked(
wit_resolver: &mut WITResolver<'_>,
) -> IType {
match pty {
ParsedType::I8 => IType::S8,
ParsedType::I16 => IType::S16,
ParsedType::I32 => IType::S32,
ParsedType::I64 => IType::S64,
ParsedType::U8 => IType::U8,
ParsedType::U16 => IType::U16,
ParsedType::U32 => IType::U32,
ParsedType::U64 => IType::U64,
ParsedType::F32 => IType::F32,
ParsedType::F64 => IType::F64,
ParsedType::Boolean => IType::I32,
ParsedType::Utf8String => IType::String,
ParsedType::Vector(ty) => {
ParsedType::I8(_) => IType::S8,
ParsedType::I16(_) => IType::S16,
ParsedType::I32(_) => IType::S32,
ParsedType::I64(_) => IType::S64,
ParsedType::U8(_) => IType::U8,
ParsedType::U16(_) => IType::U16,
ParsedType::U32(_) => IType::U32,
ParsedType::U64(_) => IType::U64,
ParsedType::F32(_) => IType::F32,
ParsedType::F64(_) => IType::F64,
ParsedType::Boolean(_) => IType::I32,
ParsedType::Utf8Str(_) => IType::String,
ParsedType::Utf8String(_) => IType::String,
ParsedType::Vector(ty, _) => {
let array_itype = ptype_to_itype_unchecked(ty, wit_resolver);
IType::Array(Box::new(array_itype))
}
ParsedType::Record(record_name) => {
ParsedType::Record(record_name, _) => {
let record_type_id = wit_resolver.get_record_type_id_unchecked(record_name);
IType::Record(record_type_id as _)
}

6
crates/wit-generator/src/interface_generator.rs
View File

@ -44,7 +44,7 @@ pub fn embed_wit(path: std::path::PathBuf) -> Result<()> {
pub(crate) struct ModuleAST {
pub(crate) records: Vec<fluence_sdk_wit::AstRecordItem>,
pub(crate) functions: Vec<fluence_sdk_wit::AstFunctionItem>,
pub(crate) functions: Vec<fluence_sdk_wit::AstFnItem>,
pub(crate) extern_mods: Vec<fluence_sdk_wit::AstExternModItem>,
}
@ -53,7 +53,7 @@ fn wasm_ast_extractor(wasm_module: &walrus::Module) -> Result<ModuleAST> {
use fluence_sdk_wit::*;
let mut records: Vec<AstRecordItem> = Vec::new();
let mut functions: Vec<AstFunctionItem> = Vec::new();
let mut functions: Vec<AstFnItem> = Vec::new();
let mut extern_mods: Vec<AstExternModItem> = Vec::new();
// consider only sections name of that starts with GENERATED_SECTION_PREFIX
@ -101,7 +101,7 @@ fn generate_interfaces(module_ast: &ModuleAST) -> Result<Interfaces<'_>> {
fn generate_default_export_api(interfaces: &mut Interfaces<'_>) {
// TODO: the order is matter
ALLOCATE_FUNC.update_interfaces(interfaces);
DEALLOCATE_FUNC.update_interfaces(interfaces);
RELEASE_OBJECTS.update_interfaces(interfaces);
GET_RESULT_SIZE_FUNC.update_interfaces(interfaces);
GET_RESULT_PTR_FUNC.update_interfaces(interfaces);
SET_RESULT_SIZE_FUNC.update_interfaces(interfaces);

2
crates/wit-interfaces/Cargo.toml
View File

@ -11,5 +11,5 @@ name = "fce_wit_interfaces"
path = "src/lib.rs"
[dependencies]
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.18.3" }
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.19.0" }
multimap = "0.8.1"

2
crates/wit-parser/Cargo.toml
View File

@ -16,7 +16,7 @@ fce-wit-interfaces = { path = "../wit-interfaces", version = "0.2.0" }
anyhow = "1.0.31"
walrus = "0.18.0"
wasmer-core = { package = "wasmer-runtime-core-fl", version = "0.17.0"}
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.18.3" }
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.19.0" }
semver = "0.11.0"
serde = "=1.0.118"

4
engine/Cargo.toml
View File

@ -14,13 +14,13 @@ path = "src/lib.rs"
fce-module-info-parser = { path = "../crates/module-info-parser", version = "0.1.0" }
fce-wit-interfaces = { path = "../crates/wit-interfaces", version = "0.2.0" }
fce-wit-parser = { path = "../crates/wit-parser", version = "0.4.0" }
fce-wit-generator = { path = "../crates/wit-generator", version = "0.2.0" }
fce-wit-generator = { path = "../crates/wit-generator", version = "0.3.0" }
fce-utils = { path = "../crates/utils", version = "0.1.29" }
wasmer-runtime = { package = "wasmer-runtime-fl", version = "0.17.0" }
# dynamicfunc-fat-closures allows using state inside DynamicFunc
wasmer-core = { package = "wasmer-runtime-core-fl", version = "0.17.0", features = ["dynamicfunc-fat-closures"] }
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.18.3" }
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.19.0" }
wasmer-wasi = { package = "wasmer-wasi-fl", version = "0.17.1" }
multimap = "0.8.1"

12
engine/src/engine.rs
View File

@ -58,31 +58,31 @@ impl FCE {
module_name.as_ref()
)))
},
|module| module.call(func_name.as_ref(), arguments),
|module| module.call(module_name.as_ref(), func_name.as_ref(), arguments),
)
}
/// Load a new module inside FCE.
pub fn load_module<S: Into<String>>(
&mut self,
import_name: S,
name: S,
wasm_bytes: &[u8],
config: FCEModuleConfig,
) -> FCEResult<()> {
self.load_module_(import_name.into(), wasm_bytes, config)
self.load_module_(name.into(), wasm_bytes, config)
}
fn load_module_(
&mut self,
import_name: String,
name: String,
wasm_bytes: &[u8],
config: FCEModuleConfig,
) -> FCEResult<()> {
let _prepared_wasm_bytes = crate::misc::prepare_module(wasm_bytes, config.mem_pages_count)?;
let module = FCEModule::new(&wasm_bytes, config, &self.modules)?;
let module = FCEModule::new(&name, &wasm_bytes, config, &self.modules)?;
match self.modules.entry(import_name) {
match self.modules.entry(name) {
Entry::Vacant(entry) => {
entry.insert(module);
Ok(())

181
engine/src/errors.rs
View File

@ -19,173 +19,128 @@ use fce_wit_interfaces::FCEWITInterfacesError;
use fce_wit_parser::WITParserError;
use fce_module_info_parser::ModuleInfoError;
use wasmer_wit::errors::InstructionError;
use wasmer_runtime::error::{
CallError, CompileError, CreationError, Error as WasmerError, ResolveError, RuntimeError,
};
use wasmer_runtime::error as wasmer_error;
use std::error::Error;
use thiserror::Error as ThisError;
// TODO: refactor errors
#[derive(Debug)]
#[derive(Debug, ThisError)]
pub enum FCEError {
/// This error type is produced by Wasmer during resolving a Wasm function.
WasmerResolveError(String),
#[error("WasmerResolveError: {0}")]
ResolveError(#[from] wasmer_error::ResolveError),
/// Error related to calling a main Wasm module.
#[error("WasmerInvokeError: {0}")]
WasmerInvokeError(String),
/// Error that raises during compilation Wasm code by Wasmer.
WasmerCreationError(String),
#[error("WasmerCreationError: {0}")]
WasmerCreationError(#[from] wasmer_error::CreationError),
/// Error that raises during creation of some Wasm objects (like table and memory) by Wasmer.
WasmerCompileError(String),
#[error("WasmerCompileError: {0}")]
WasmerCompileError(#[from] wasmer_error::CompileError),
/// Errors arisen during execution of a Wasm module.
#[error("WasmerCompileError: {0}")]
WasmerRuntimeError(String),
/// Errors arisen during linking Wasm modules with already loaded into FCE modules.
#[error("WasmerLinkError: {0}")]
WasmerLinkError(#[from] wasmer_error::LinkError),
/// Errors from the temporary class of amalgamation errors from the Wasmer side.
#[error("WasmerError: {0}")]
WasmerError(String),
/// Errors related to failed resolving of records.
#[error("{0}")]
RecordResolveError(String),
/// Errors arisen during creation of a WASI context.
#[error("{0}")]
WASIPrepareError(String),
/// Error arisen during execution of Wasm modules (especially, interface types).
#[error("Execution error: {0}")]
ITInstructionError(#[from] wasmer_wit::errors::InstructionError),
/// Error that raises on the preparation step.
PrepareError(String),
#[error("PrepareError: {0}, probably module is malformed")]
PrepareError(#[from] parity_wasm::elements::Error),
/// Indicates that there is already a module with such name.
#[error("Module with name {0} already loaded in FCE, please specify another name")]
NonUniqueModuleName(String),
/// Returns when there is no module with such name.
NoSuchFunction(String),
#[error("Module with name {0} doesn't have function with name {1}")]
NoSuchFunction(String, String),
/// Returns when there is no module with such name.
#[error("Module with name {0} doesn't loaded in FCE")]
NoSuchModule(String),
/// An error occurred when host functions tries to lift IValues from WValues and lowering back.
HostImportError(HostImportError),
#[error("{0}")]
HostImportError(#[from] HostImportError),
/// WIT section parse error.
WITParseError(WITParserError),
#[error("{0}")]
WITParseError(#[from] WITParserError),
/// Incorrect WIT section.
#[error("{0}")]
IncorrectWIT(String),
/// Error is encountered while parsing module version.
ModuleVersionParseError(ModuleInfoError),
#[error("{0}")]
ModuleVersionParseError(#[from] ModuleInfoError),
/// Provided module doesn't contain a sdk version that is necessary.
ModuleWithoutVersion,
#[error("module with name {0} doesn't contain a version of sdk, probably it's compiled with an old one")]
ModuleWithoutVersion(String),
/// Module sdk versions are incompatible.
#[error("module with name {module_name} compiled with {provided} sdk version, but at least {required} required")]
IncompatibleSDKVersions {
module_name: String,
required: semver::Version,
provided: semver::Version,
},
/// Module IT versions are incompatible.
#[error("module with name {module_name} compiled with {provided} IT version, but at least {required} required")]
IncompatibleITVersions {
module_name: String,
required: semver::Version,
provided: semver::Version,
},
}
impl Error for FCEError {}
impl std::fmt::Display for FCEError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
match self {
FCEError::WasmerResolveError(msg) => write!(f, "WasmerResolveError: {}", msg),
FCEError::WasmerInvokeError(msg) => write!(f, "WasmerInvokeError: {}", msg),
FCEError::WasmerCompileError(msg) => write!(f, "WasmerCompileError: {}", msg),
FCEError::WasmerCreationError(msg) => write!(f, "WasmerCreationError: {}", msg),
FCEError::PrepareError(msg) => {
write!(f, "Prepare error: {}, probably module is malformed", msg)
}
FCEError::NonUniqueModuleName(module_name) => {
write!(f, r#"FCE already has module with name "{}""#, module_name)
}
FCEError::NoSuchFunction(function_name) => write!(
f,
r#"FCE doesn't have a function with name: {}"#,
function_name
),
FCEError::NoSuchModule(err_msg) => write!(f, "{}", err_msg),
FCEError::HostImportError(host_import_error) => write!(f, "{}", host_import_error),
FCEError::WITParseError(err) => write!(f, "{}", err),
FCEError::IncorrectWIT(err_msg) => write!(f, "{}", err_msg),
FCEError::ModuleVersionParseError(err) => write!(f, "{}", err),
FCEError::ModuleWithoutVersion => write!(f, "provided modules doesn't contain a version of sdk, probably it's compiled with an old version of sdk"),
FCEError::IncompatibleSDKVersions {required, provided} => write!(f, "module compiled with {} sdk version, but at least {} required", provided, required),
FCEError::IncompatibleITVersions {required, provided} => write!(f, "module compiled with {} IT version, but at least {} required", provided, required),
}
}
}
impl From<HostImportError> for FCEError {
fn from(err: HostImportError) -> Self {
FCEError::HostImportError(err)
}
}
impl From<CreationError> for FCEError {
fn from(err: CreationError) -> Self {
FCEError::WasmerCreationError(format!("{}", err))
}
}
impl From<CompileError> for FCEError {
fn from(err: CompileError) -> Self {
FCEError::WasmerCompileError(format!("{}", err))
}
}
impl From<parity_wasm::elements::Error> for FCEError {
fn from(err: parity_wasm::elements::Error) -> Self {
FCEError::PrepareError(format!("{}", err))
}
}
impl From<CallError> for FCEError {
fn from(err: CallError) -> Self {
match err {
CallError::Resolve(err) => FCEError::WasmerResolveError(format!("{}", err)),
CallError::Runtime(err) => FCEError::WasmerInvokeError(format!("{}", err)),
}
}
}
impl From<ResolveError> for FCEError {
fn from(err: ResolveError) -> Self {
FCEError::WasmerResolveError(format!("{}", err))
}
}
impl From<RuntimeError> for FCEError {
fn from(err: RuntimeError) -> Self {
FCEError::WasmerInvokeError(format!("{}", err))
}
}
impl From<WasmerError> for FCEError {
fn from(err: WasmerError) -> Self {
FCEError::WasmerInvokeError(format!("{}", err))
}
}
impl From<InstructionError> for FCEError {
fn from(err: InstructionError) -> Self {
FCEError::WasmerInvokeError(format!("{}", err))
}
}
impl From<WITParserError> for FCEError {
fn from(err: WITParserError) -> Self {
FCEError::WITParseError(err)
}
}
impl From<FCEWITInterfacesError> for FCEError {
fn from(err: FCEWITInterfacesError) -> Self {
FCEError::IncorrectWIT(format!("{}", err))
}
}
impl From<ModuleInfoError> for FCEError {
fn from(err: ModuleInfoError) -> Self {
Self::ModuleVersionParseError(err)
impl From<wasmer_error::RuntimeError> for FCEError {
fn from(err: wasmer_error::RuntimeError) -> Self {
Self::WasmerRuntimeError(err.to_string())
}
}
impl From<wasmer_error::Error> for FCEError {
fn from(err: wasmer_error::Error) -> Self {
Self::WasmerError(err.to_string())
}
}
impl From<wasmer_error::InvokeError> for FCEError {
fn from(err: wasmer_error::InvokeError) -> Self {
Self::WasmerInvokeError(err.to_string())
}
}

1
engine/src/host_imports/errors.rs
View File

@ -18,7 +18,6 @@ use crate::IType;
use super::WType;
use super::WValue;
// use safe_transmute::Error as TransmuteError;
use thiserror::Error as ThisError;
#[derive(Debug, ThisError)]

2
engine/src/lib.rs
View File

@ -67,7 +67,7 @@ static MINIMAL_SUPPORTED_IT_VERSION: Lazy<semver::Version> = Lazy::new(|| {
semver::Version::from_str("0.17.0").expect("invalid minimal sdk version specified")
});
/// These locals intended for check that set versions are correct at the start of an application.
// These locals intended for check that set versions are correct at the start of an application.
thread_local!(static MINIMAL_SUPPORTED_SDK_VERSION_CHECK: &'static semver::Version = Lazy::force(&MINIMAL_SUPPORTED_SDK_VERSION));
thread_local!(static MINIMAL_SUPPORTED_IT_VERSION_CHECK: &'static semver::Version = Lazy::force(&MINIMAL_SUPPORTED_IT_VERSION));

11
engine/src/misc/version_checker.rs
View File

@ -21,16 +21,17 @@ use fce_module_info_parser::sdk_version;
use wasmer_core::Module;
pub(crate) fn check_sdk_version(wasmer_module: &Module) -> FCEResult<()> {
pub(crate) fn check_sdk_version(name: impl Into<String>, wasmer_module: &Module) -> FCEResult<()> {
let module_version = sdk_version::extract_from_wasmer_module(wasmer_module)?;
let module_version = match module_version {
Some(module_version) => module_version,
None => return Err(FCEError::ModuleWithoutVersion),
None => return Err(FCEError::ModuleWithoutVersion(name.into())),
};
let required_version = crate::min_sdk_version();
if module_version < *required_version {
return Err(FCEError::IncompatibleSDKVersions {
module_name: name.into(),
required: required_version.clone(),
provided: module_version,
});
@ -39,10 +40,14 @@ pub(crate) fn check_sdk_version(wasmer_module: &Module) -> FCEResult<()> {
Ok(())
}
pub(crate) fn check_it_version(it_version: &semver::Version) -> FCEResult<()> {
pub(crate) fn check_it_version(
name: impl Into<String>,
it_version: &semver::Version,
) -> FCEResult<()> {
let required_version = crate::min_it_version();
if it_version < required_version {
return Err(FCEError::IncompatibleITVersions {
module_name: name.into(),
required: required_version.clone(),
provided: it_version.clone(),
});

44
engine/src/module/fce_module.rs
View File

@ -110,15 +110,16 @@ pub(crate) struct FCEModule {
impl FCEModule {
pub(crate) fn new(
name: &str,
wasm_bytes: &[u8],
config: FCEModuleConfig,
modules: &HashMap<String, FCEModule>,
) -> FCEResult<Self> {
let wasmer_module = compile(&wasm_bytes)?;
crate::misc::check_sdk_version(&wasmer_module)?;
crate::misc::check_sdk_version(name, &wasmer_module)?;
let wit = extract_wit_from_module(&wasmer_module)?;
crate::misc::check_it_version(&wit.version)?;
crate::misc::check_it_version(name, &wit.version)?;
let fce_wit = FCEWITInterfaces::new(wit);
@ -133,7 +134,7 @@ impl FCEModule {
// get_mut_unchecked here is safe because currently only this modules have reference to
// it and the environment is single-threaded
*Arc::get_mut_unchecked(&mut wit_instance) =
MaybeUninit::new(WITInstance::new(&wasmer_instance, &fce_wit, modules)?);
MaybeUninit::new(WITInstance::new(&wasmer_instance, name, &fce_wit, modules)?);
std::mem::transmute::<_, Arc<WITInstance>>(wit_instance)
};
@ -156,13 +157,18 @@ impl FCEModule {
})
}
pub(crate) fn call(&mut self, function_name: &str, args: &[IValue]) -> FCEResult<Vec<IValue>> {
pub(crate) fn call(
&mut self,
module_name: &str,
function_name: &str,
args: &[IValue],
) -> FCEResult<Vec<IValue>> {
self.export_funcs.get_mut(function_name).map_or_else(
|| {
Err(FCEError::NoSuchFunction(format!(
"{} hasn't been found while calling",
function_name
)))
Err(FCEError::NoSuchFunction(
module_name.to_string(),
function_name.to_string(),
))
},
|func| Rc::make_mut(func).call(args),
)
@ -191,13 +197,17 @@ impl FCEModule {
}
// TODO: change the cloning Callable behaviour after changes of Wasmer API
pub(super) fn get_callable(&self, function_name: &str) -> FCEResult<Rc<Callable>> {
pub(super) fn get_callable(
&self,
module_name: &str,
function_name: &str,
) -> FCEResult<Rc<Callable>> {
match self.export_funcs.get(function_name) {
Some(func) => Ok(func.clone()),
None => Err(FCEError::NoSuchFunction(format!(
"{} hasn't been found while calling",
function_name
))),
None => Err(FCEError::NoSuchFunction(
module_name.to_string(),
function_name.to_string(),
)),
}
}
@ -227,7 +237,7 @@ impl FCEModule {
wasi_preopened_files,
wasi_mapped_dirs,
)
.map_err(|e| FCEError::PrepareError(e))?;
.map_err(FCEError::WASIPrepareError)?;
let mut host_closures_namespace = Namespace::new();
let record_types = fce_wit
@ -449,7 +459,7 @@ impl FCEModule {
wit_instance: &Arc<WITInstance>,
) -> FCEResult<RecordTypes> {
use fce_wit_generator::TYPE_RESOLVE_RECURSION_LIMIT;
use FCEError::WasmerResolveError;
use FCEError::RecordResolveError;
fn handle_itype(
itype: &IType,
@ -460,7 +470,7 @@ impl FCEModule {
use wasmer_wit::interpreter::wasm::structures::Instance;
if recursion_level > TYPE_RESOLVE_RECURSION_LIMIT {
return Err(WasmerResolveError(String::from(
return Err(RecordResolveError(String::from(
"mailformed module: a record contains more recursion level then allowed",
)));
}
@ -475,7 +485,7 @@ impl FCEModule {
wit_instance
.wit_record_by_id(record_type_id)
.ok_or_else(|| {
WasmerResolveError(format!(
RecordResolveError(format!(
"record type with type id {} not found",
record_type_id
))

3
engine/src/module/wit_function.rs
View File

@ -84,11 +84,12 @@ impl WITFunction {
/// Creates function from a module import.
pub(super) fn from_import(
wit_module: &FCEModule,
module_name: &str,
function_name: &str,
arguments: Rc<Vec<IFunctionArg>>,
outputs: Rc<Vec<IType>>,
) -> FCEResult<Self> {
let callable = wit_module.get_callable(function_name)?;
let callable = wit_module.get_callable(module_name, function_name)?;
let inner = WITFunctionInner::Import { callable };

13
engine/src/module/wit_instance.rs
View File

@ -46,11 +46,12 @@ pub(super) struct WITInstance {
impl WITInstance {
pub(super) fn new(
wasmer_instance: &WasmerInstance,
module_name: &str,
wit: &FCEWITInterfaces<'_>,
modules: &HashMap<String, FCEModule>,
) -> FCEResult<Self> {
let mut exports = Self::extract_raw_exports(&wasmer_instance, wit)?;
let imports = Self::extract_imports(modules, wit, exports.len())?;
let imports = Self::extract_imports(module_name, modules, wit, exports.len())?;
let memories = Self::extract_memories(&wasmer_instance);
exports.extend(imports);
@ -93,6 +94,7 @@ impl WITInstance {
/// Extracts only those imports that don't have implementations.
fn extract_imports(
module_name: &str,
modules: &HashMap<String, FCEModule>,
wit: &FCEWITInterfaces<'_>,
start_index: usize,
@ -119,8 +121,13 @@ impl WITInstance {
}
};
let func =
WITFunction::from_import(module, import.name, arguments, output_types)?;
let func = WITFunction::from_import(
module,
module_name,
import.name,
arguments,
output_types,
)?;
Ok((start_index + idx as usize, func))
}

8
engine/tests/greeting.rs
View File

@ -70,16 +70,18 @@ pub fn non_exist_module_func() {
fce.load_module("greeting", &*GREETING_WASM_BYTES, <_>::default())
.unwrap_or_else(|e| panic!("can't load a module into FCE: {:?}", e));
let module_name = "greeting";
let function_name = "greeting";
let non_exist_name = String::from("_");
let call_result1 = fce.call(
non_exist_name.as_str(),
"greeting",
function_name,
&[IValue::String(String::from("Fluence"))],
);
let call_result2 = fce.call(
"greeting",
module_name,
non_exist_name.as_str(),
&[IValue::String(String::from("Fluence"))],
);
@ -99,7 +101,7 @@ pub fn non_exist_module_func() {
assert!(call_result2.is_err());
assert!(matches!(
call_result2.err().unwrap(),
fce::FCEError::NoSuchFunction(non_exist_name)
fce::FCEError::NoSuchFunction(module_name, non_exist_name)
));
assert!(call_result3.is_err());

2
examples/call_parameters/Cargo.toml
View File

@ -10,4 +10,4 @@ name = "call_parameters"
path = "src/main.rs"
[dependencies]
fluence = "=0.5.0"
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }

BIN
examples/call_parameters/artifacts/call_parameters.wasm
View File

Binary file not shown.

2
examples/greeting/Cargo.toml
View File

@ -12,4 +12,4 @@ name = "greeting"
path = "src/main.rs"
[dependencies]
fluence = "0.5.0"
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }

BIN
examples/greeting/artifacts/greeting.wasm
View File

Binary file not shown.

BIN
examples/ipfs-node/artifacts/ipfs_effector.wasm
View File

Binary file not shown.

BIN
examples/ipfs-node/artifacts/ipfs_pure.wasm
View File

Binary file not shown.

2
examples/ipfs-node/effector/Cargo.toml
View File

@ -10,5 +10,5 @@ name = "ipfs_effector"
path = "src/main.rs"
[dependencies]
fluence = { version = "=0.5.0", features = ["logger"] }
fluence = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
log = "0.4.14"

2
examples/ipfs-node/pure/Cargo.toml
View File

@ -10,5 +10,5 @@ name = "ipfs_pure"
path = "src/main.rs"
[dependencies]
fluence = { version = "=0.5.0", features = ["logger"] }
fluence = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
log = "0.4.14"

BIN
examples/records/artifacts/records_effector.wasm
View File

Binary file not shown.

BIN
examples/records/artifacts/records_pure.wasm
View File

Binary file not shown.

2
examples/records/effector/Cargo.toml
View File

@ -10,5 +10,5 @@ name = "records_effector"
path = "src/main.rs"
[dependencies]
fluence = { version = "=0.5.0", features = ["logger"]}
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
test-record = { path = "../test-record" }

2
examples/records/pure/Cargo.toml
View File

@ -10,5 +10,5 @@ name = "records_pure"
path = "src/main.rs"
[dependencies]
fluence = { version = "=0.5.0", features = ["logger"]}
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
test-record = { path = "../test-record" }

2
examples/records/test-record/Cargo.toml
View File

@ -10,4 +10,4 @@ name = "test_record"
path = "src/test_record.rs"
[dependencies]
fluence = "=0.5.0"
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }

4
examples/sqlite/Cargo.toml
View File

@ -10,5 +10,5 @@ name = "sqlite_test"
path = "src/main.rs"
[dependencies]
fluence = "0.5.0"
fce-sqlite-connector = "0.2.0"
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
fce-sqlite-connector = { git = "https://github.com/fluencelabs/sqlite-wasm-connector", branch = "fluence_0_6_0" }

BIN
examples/sqlite/artifacts/sqlite_test.wasm
View File

Binary file not shown.

BIN
examples/url-downloader/artifacts/curl_adapter.wasm
View File

Binary file not shown.

BIN
examples/url-downloader/artifacts/facade.wasm
View File

Binary file not shown.

BIN
examples/url-downloader/artifacts/local_storage.wasm
View File

Binary file not shown.

2
examples/url-downloader/curl_adapter/Cargo.toml
View File

@ -10,5 +10,5 @@ path = "src/main.rs"
name = "curl_adapter"
[dependencies]
fluence = { version = "=0.5.0", features = ["logger"] }
fluence = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
log = "0.4.8"

2
examples/url-downloader/facade/Cargo.toml
View File

@ -10,6 +10,6 @@ name = "facade"
path = "src/main.rs"
[dependencies]
fluence = { version = "=0.5.0", features = ["logger"]}
fluence = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
anyhow = "1.0.31"
log = "0.4.8"

2
examples/url-downloader/local_storage/Cargo.toml
View File

@ -10,5 +10,5 @@ name = "local_storage"
path = "src/main.rs"
[dependencies]
fluence = { version = "=0.5.0", features = ["logger"]}
fluence = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
log = "0.4.8"

5
fluence-faas/Cargo.toml
View File

@ -9,13 +9,14 @@ edition = "2018"
[dependencies]
fce = { path = "../engine", version = "0.4.0" }
fce-utils = { path = "../crates/utils", version = "0.1.29" }
fluence-sdk-main = { version = "0.5.0", features = ["logger"] }
fluence-sdk-main = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
fluence = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
wasmer-runtime = { package = "wasmer-runtime-fl", version = "0.17.0" }
# dynamicfunc-fat-closures allows using state inside DynamicFunc
wasmer-core = { package = "wasmer-runtime-core-fl", version = "0.17.0", features = ["dynamicfunc-fat-closures"] }
wasmer-wasi = { package = "wasmer-wasi-fl", version = "0.17.1" }
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.18.3" }
wasmer-wit = { package = "wasmer-interface-types-fl", version = "=0.19.0" }
toml = "0.5.6"
serde = { version = "=1.0.118", features = ["derive"] }

2
fluence-faas/src/config/to_fce_config.rs
View File

@ -34,7 +34,7 @@ use std::rc::Rc;
pub(crate) fn make_fce_config(
module_name: String,
faas_module_config: Option<FaaSModuleConfig>,
call_parameters: Rc<RefCell<fluence_sdk_main::CallParameters>>,
call_parameters: Rc<RefCell<fluence::CallParameters>>,
logger_filter: &LoggerFilter<'_>,
) -> Result<FCEModuleConfig> {
let mut fce_module_config = FCEModuleConfig::default();

6
fluence-faas/src/faas.rs
View File

@ -29,7 +29,7 @@ use fce::FCE;
use fce::IFunctionArg;
use fce_utils::SharedString;
use fce::RecordTypes;
use fluence_sdk_main::CallParameters;
use fluence::CallParameters;
use serde_json::Value as JValue;
use std::cell::RefCell;
@ -136,7 +136,7 @@ impl FluenceFaaS {
module_name: MN,
func_name: FN,
args: &[IValue],
call_parameters: fluence_sdk_main::CallParameters,
call_parameters: fluence::CallParameters,
) -> Result<Vec<IValue>> {
self.call_parameters.replace(call_parameters);
@ -151,7 +151,7 @@ impl FluenceFaaS {
module_name: MN,
func_name: FN,
json_args: JValue,
call_parameters: fluence_sdk_main::CallParameters,
call_parameters: fluence::CallParameters,
) -> Result<JValue> {
use crate::json::json_to_ivalues;
use crate::json::ivalues_to_json;

2
fluence-faas/src/host_imports/call_parameters.rs
View File

@ -25,7 +25,7 @@ use std::ops::Deref;
/// Create the import intended for handling get_call_parameters SDK api.
pub(crate) fn create_call_parameters_import(
call_parameters: Rc<RefCell<fluence_sdk_main::CallParameters>>,
call_parameters: Rc<RefCell<fluence::CallParameters>>,
) -> HostImportDescriptor {
let call_parameters_closure = move |_ctx: &mut Ctx, _args: Vec<IValue>| {
let result = crate::to_interface_value(call_parameters.borrow().deref()).unwrap();

2
fluence-faas/src/host_imports/mounted_binaries.rs
View File

@ -15,7 +15,7 @@
*/
use fce::HostImportDescriptor;
use fluence_sdk_main::mounted_binary::Result as MountedBinaryResult;
use fluence::MountedBinaryResult;
use wasmer_core::vm::Ctx;
use wasmer_wit::IValue;

4
fluence-faas/src/lib.rs
View File

@ -67,7 +67,7 @@ pub use fce::ne_vec;
pub use fce::min_sdk_version;
pub use fce::min_it_version;
pub use fluence_sdk_main::CallParameters;
pub use fluence_sdk_main::SecurityTetraplet;
pub use fluence::CallParameters;
pub use fluence::SecurityTetraplet;
pub use wasmer_core::vm::Ctx;

4
fluence-faas/tests/call_parameters.rs
View File

@ -41,10 +41,10 @@ pub fn call_parameters() {
let host_id = "host_id";
let particle_id = "particle_id";
let tetraplet = fluence_sdk_main::SecurityTetraplet::default();
let tetraplet = fluence::SecurityTetraplet::default();
let tetraplets = vec![vec![tetraplet]];
let call_parameters = fluence_sdk_main::CallParameters {
let call_parameters = fluence::CallParameters {
init_peer_id: init_peer_id.to_string(),
service_id: service_id.to_string(),
service_creator_peer_id: service_creator_peer_id.to_string(),

3
fluence-faas/tests/wasm_tests/arguments_passing/Cargo.toml
View File

@ -14,5 +14,6 @@ name = "arguments_passing_effector"
path = "src/effector.rs"
[dependencies]
fluence = "=0.5.0"
#fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
safe-transmute = "0.11.0"

BIN
fluence-faas/tests/wasm_tests/arguments_passing/artifacts/arguments_passing_effector.wasm
View File

Binary file not shown.

BIN
fluence-faas/tests/wasm_tests/arguments_passing/artifacts/arguments_passing_pure.wasm
View File

Binary file not shown.

3
fluence-faas/tests/wasm_tests/arrays_passing/Cargo.toml
View File

@ -14,5 +14,6 @@ name = "arrays_passing_effector"
path = "src/effector.rs"
[dependencies]
fluence = "=0.5.0"
# fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
safe-transmute = "0.11.0"

BIN
fluence-faas/tests/wasm_tests/arrays_passing/artifacts/arrays_passing_effector.wasm
View File

Binary file not shown.

BIN
fluence-faas/tests/wasm_tests/arrays_passing/artifacts/arrays_passing_pure.wasm
View File

Binary file not shown.

31
fluence-faas/tests/wasm_tests/build.sh
View File

@ -1,22 +1,27 @@
#!/bin/sh
# This script builds all tests
cd arguments_passing
cargo update
fce build --release
rm artifacts/*
(
cd arguments_passing || exit;
cargo update;
fce build --release;
rm artifacts/*;
)
cd ../arrays_passing
cargo update
fce build --release
rm artifacts/*
(
cd arrays_passing || exit;
cargo update;
fce build --release;
rm artifacts/*;
)
cd ../inner_records
cargo update
fce build --release
rm artifacts/*
(
cd inner_records || exit;
cargo update;
fce build --release;
rm artifacts/*;
)
cd ..
cp ../../../target/wasm32-wasi/release/arguments_passing_effector.wasm arguments_passing/artifacts/
cp ../../../target/wasm32-wasi/release/arguments_passing_pure.wasm arguments_passing/artifacts/
cp ../../../target/wasm32-wasi/release/arrays_passing_effector.wasm arrays_passing/artifacts/

2
fluence-faas/tests/wasm_tests/inner_records/Cargo.toml
View File

@ -10,5 +10,5 @@ name = "inner_records_pure"
path = "src/pure.rs"
[dependencies]
fluence = "=0.5.0"
fluence = { git = "https://github.com/fluencelabs/rust-sdk" }
safe-transmute = "0.11.0"

BIN
fluence-faas/tests/wasm_tests/inner_records/artifacts/inner_records_pure.wasm
View File

Binary file not shown.

2
tools/cli/Cargo.toml
View File

@ -12,7 +12,7 @@ name = "fce"
path = "src/main.rs"
[dependencies]
fce-wit-generator = { path = "../../crates/wit-generator", version = "0.2.0" }
fce-wit-generator = { path = "../../crates/wit-generator", version = "0.3.0" }
fce-wit-parser = { path = "../../crates/wit-parser", version = "0.4.0" }
fce-module-info-parser = { path = "../../crates/module-info-parser", version = "0.1.0" }

2
tools/repl/Cargo.toml
View File

@ -13,7 +13,7 @@ path = "src/main.rs"
[dependencies]
fluence-app-service = { path = "../../fluence-app-service", version = "0.6.0", features = ["raw-module-api"] }
fluence-sdk-main = { version = "0.5.0", features = ["logger"] }
fluence-sdk-main = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }
anyhow = "1.0.31"
clap = "2.33.1"