diff --git a/.github/workflows/iroha2-dev-pr-wasm.yml b/.github/workflows/iroha2-dev-pr-wasm.yml index ab682d7f65..1f12926c2d 100644 --- a/.github/workflows/iroha2-dev-pr-wasm.yml +++ b/.github/workflows/iroha2-dev-pr-wasm.yml @@ -47,7 +47,7 @@ jobs: steps: - uses: actions/checkout@v4 - name: Build wasm libs - run: mold --run cargo run --bin iroha_wasm_builder -- build ./wasm/libs/default_executor --optimize --out-file ${{ env.DEFAULTS_DIR }}/executor.wasm + run: mold --run cargo run --package iroha_wasm_builder --bin iroha_wasm_builder -- build ./wasm/libs/default_executor --optimize --out-file ${{ env.DEFAULTS_DIR }}/executor.wasm - name: Upload executor to reuse in other jobs uses: actions/upload-artifact@v4 with: @@ -71,4 +71,4 @@ jobs: run: which iroha_wasm_test_runner || cargo install --path crates/iroha_wasm_test_runner - name: Run smart contract tests on WebAssembly VM working-directory: crates/iroha_smart_contract - run: mold --run cargo test -p iroha_smart_contract -p iroha_smart_contract_utils --release --tests --target wasm32-unknown-unknown --no-fail-fast --quiet + run: mold --run cargo test --package iroha_smart_contract --package iroha_smart_contract_utils --tests --target wasm32-unknown-unknown --no-fail-fast --quiet diff --git a/crates/iroha/src/secrecy.rs b/crates/iroha/src/secrecy.rs index 19b4db79dc..cdba906f47 100644 --- a/crates/iroha/src/secrecy.rs +++ b/crates/iroha/src/secrecy.rs @@ -12,7 +12,7 @@ impl SecretString { } } -const REDACTED: &'static str = "[REDACTED]"; +const REDACTED: &str = "[REDACTED]"; impl Serialize for SecretString { fn serialize(&self, serializer: S) -> Result { diff --git a/crates/iroha_core/src/smartcontracts/wasm.rs b/crates/iroha_core/src/smartcontracts/wasm.rs index 450621f5fd..d9c532a7f9 100644 --- a/crates/iroha_core/src/smartcontracts/wasm.rs +++ b/crates/iroha_core/src/smartcontracts/wasm.rs @@ -47,8 +47,6 @@ const WASM_MODULE: &str = "iroha"; mod export { pub const EXECUTE_ISI: &str = "execute_instruction"; pub const EXECUTE_QUERY: &str = "execute_query"; - pub const GET_SMART_CONTRACT_CONTEXT: &str = "get_smart_contract_context"; - pub const GET_TRIGGER_CONTEXT: &str = "get_trigger_context"; pub const SET_DATA_MODEL: &str = "set_data_model"; pub const DBG: &str = "dbg"; @@ -771,11 +769,11 @@ where let instance = self.instantiate_module(module, &mut store)?; let validate_fn = Self::get_typed_func(&instance, &mut store, validate_fn_name)?; - let payload = Self::get_validate_payload(&instance, &mut store); + let context = Self::get_validate_context(&instance, &mut store); // NOTE: This function takes ownership of the pointer let offset = validate_fn - .call(&mut store, payload) + .call(&mut store, context) .map_err(ExportFnCallError::from)?; let memory = @@ -797,19 +795,19 @@ where Ok(validation_res) } - fn get_validate_payload( + fn get_validate_context( instance: &Instance, store: &mut Store>>, ) -> WasmUsize { let state = store.data(); - let payload = payloads::Validate { + let context = payloads::Validate { context: payloads::ExecutorContext { authority: state.authority.clone(), curr_block: state.specific_state.curr_block, }, target: state.specific_state.to_validate.clone(), }; - Runtime::encode_payload(instance, store, payload) + Self::encode_payload(instance, store, context) } } @@ -940,14 +938,15 @@ impl<'wrld, 'block: 'wrld, 'state: 'block> Runtime, ) -> Result<()> { let mut store = self.create_store(state); - let smart_contract = self.create_smart_contract(&mut store, bytes)?; + let instance = self.create_smart_contract(&mut store, bytes)?; let main_fn: TypedFunc<_, ()> = - Self::get_typed_func(&smart_contract, &mut store, import::SMART_CONTRACT_MAIN)?; + Self::get_typed_func(&instance, &mut store, import::SMART_CONTRACT_MAIN)?; + let context = Self::get_smart_contract_context(&instance, &mut store); // NOTE: This function takes ownership of the pointer main_fn - .call(&mut store, ()) + .call(&mut store, context) .map_err(ExportFnCallError::from)?; let mut state = store.into_data(); let executed_queries = state.take_executed_queries(); @@ -956,12 +955,16 @@ impl<'wrld, 'block: 'wrld, 'state: 'block> Runtime payloads::SmartContractContext { - payloads::SmartContractContext { + fn get_smart_contract_context( + instance: &Instance, + store: &mut Store>, + ) -> WasmUsize { + let state = store.data(); + let payload = payloads::SmartContractContext { authority: state.authority.clone(), curr_block: state.state.0.curr_block, - } + }; + Runtime::encode_payload(instance, store, payload) } } @@ -1019,10 +1022,11 @@ impl<'wrld, 'block: 'wrld, 'state: 'block> Runtime = Self::get_typed_func(&instance, &mut store, import::TRIGGER_MAIN)?; + let context = Self::get_trigger_context(&instance, &mut store); // NOTE: This function takes ownership of the pointer main_fn - .call(&mut store, ()) + .call(&mut store, context) .map_err(ExportFnCallError::from)?; let mut state = store.into_data(); @@ -1032,14 +1036,18 @@ impl<'wrld, 'block: 'wrld, 'state: 'block> Runtime payloads::TriggerContext { - payloads::TriggerContext { + fn get_trigger_context( + instance: &Instance, + store: &mut Store>, + ) -> WasmUsize { + let state = store.data(); + let payload = payloads::TriggerContext { id: state.specific_state.id.clone(), authority: state.authority.clone(), curr_block: state.state.0.curr_block, event: state.specific_state.triggering_event.clone(), - } + }; + Runtime::encode_payload(instance, store, payload) } } @@ -1302,24 +1310,24 @@ impl<'wrld, 'block, 'state> Runtime = Self::get_typed_func(&instance, &mut store, import::EXECUTOR_MIGRATE)?; - let payload = Self::get_migrate_payload(&instance, &mut store); + let context = Self::get_migrate_context(&instance, &mut store); migrate_fn - .call(&mut store, payload) + .call(&mut store, context) .map_err(ExportFnCallError::from)?; Ok(()) } - fn get_migrate_payload( + fn get_migrate_context( instance: &Instance, store: &mut Store, Migrate>>, ) -> WasmUsize { - let payload = payloads::ExecutorContext { + let context = payloads::ExecutorContext { authority: store.data().authority.clone(), curr_block: store.data().state.0.curr_block, }; - Self::encode_payload(instance, store, payload) + Self::encode_payload(instance, store, context) } } @@ -1436,7 +1444,6 @@ impl<'wrld, 'block, 'state> RuntimeBuilder, export::EXECUTE_ISI => |caller: ::wasmtime::Caller>, offset, len| Runtime::execute_instruction(caller, offset, len), export::EXECUTE_QUERY => |caller: ::wasmtime::Caller>, offset, len| Runtime::execute_query(caller, offset, len), - export::GET_SMART_CONTRACT_CONTEXT => |caller: ::wasmtime::Caller>| Runtime::get_smart_contract_context(caller), )?; Ok(linker) }) @@ -1456,7 +1463,6 @@ impl<'wrld, 'block, 'state> RuntimeBuilder create_imports!(linker, state::Trigger<'wrld, 'block, 'state>, export::EXECUTE_ISI => |caller: ::wasmtime::Caller>, offset, len| Runtime::execute_instruction(caller, offset, len), export::EXECUTE_QUERY => |caller: ::wasmtime::Caller>, offset, len| Runtime::execute_query(caller, offset, len), - export::GET_TRIGGER_CONTEXT => |caller: ::wasmtime::Caller>| Runtime::get_trigger_context(caller), )?; Ok(linker) }) @@ -1895,53 +1901,4 @@ mod tests { Ok(()) } - - #[test] - async fn trigger_related_func_is_not_linked_for_smart_contract() -> Result<(), Error> { - let (authority, _authority_keypair) = gen_account_in("wonderland"); - let kura = Kura::blank_kura_for_testing(); - let query_handle = LiveQueryStore::start_test(); - let state = State::new(world_with_test_account(&authority), kura, query_handle); - - let wat = format!( - r#" - (module - ;; Import host function to execute - (import "iroha" "{get_trigger_payload_fn_name}" - (func $exec_fn (param) (result i32))) - - {memory_and_alloc} - - ;; Function which starts the smartcontract execution - (func (export "{main_fn_name}") (param) - (call $exec_fn) - - ;; No use of return values - drop)) - "#, - main_fn_name = import::SMART_CONTRACT_MAIN, - get_trigger_payload_fn_name = export::GET_TRIGGER_CONTEXT, - // this test doesn't use the memory - memory_and_alloc = memory_and_alloc(""), - ); - - let mut runtime = RuntimeBuilder::::new().build()?; - let block_header = ValidBlock::new_dummy(&KeyPair::random().into_parts().1) - .as_ref() - .header(); - let mut state_block = state.block(block_header); - let mut state_transaction = state_block.transaction(); - let err = runtime - .execute(&mut state_transaction, authority, wat) - .expect_err("Execution should fail"); - state_transaction.apply(); - state_block.commit(); - - assert!(matches!( - err, - Error::Instantiation(InstantiationError::Linker(_)) - )); - - Ok(()) - } } diff --git a/crates/iroha_crypto/src/hash.rs b/crates/iroha_crypto/src/hash.rs index 2c390b68e9..cb446a175e 100644 --- a/crates/iroha_crypto/src/hash.rs +++ b/crates/iroha_crypto/src/hash.rs @@ -278,7 +278,7 @@ impl FromStr for HashOf { type Err = ParseError; fn from_str(s: &str) -> Result { - Ok(s.parse::().map(Self::from_untyped_unchecked)?) + s.parse::().map(Self::from_untyped_unchecked) } } diff --git a/crates/iroha_executor/src/lib.rs b/crates/iroha_executor/src/lib.rs index a35f01f0ec..f7998cea09 100644 --- a/crates/iroha_executor/src/lib.rs +++ b/crates/iroha_executor/src/lib.rs @@ -31,35 +31,51 @@ pub mod log { } /// Get context for `validate_transaction()` entrypoint. +/// +/// # Safety +/// +/// It's safe to call this function as long as it's safe to construct, from the given +/// pointer, byte array of prefix length and `Box<[u8]>` containing the encoded object #[cfg(not(test))] -pub fn decode_execute_transaction_context( +pub unsafe fn decode_execute_transaction_context( context: *const u8, ) -> payloads::Validate { - // Safety: ownership of the provided context is transferred into `_decode_from_raw` - unsafe { decode_with_length_prefix_from_raw(context) } + decode_with_length_prefix_from_raw(context) } /// Get context for `validate_instruction()` entrypoint. +/// +/// # Safety +/// +/// It's safe to call this function as long as it's safe to construct, from the given +/// pointer, byte array of prefix length and `Box<[u8]>` containing the encoded object #[cfg(not(test))] -pub fn decode_execute_instruction_context( +pub unsafe fn decode_execute_instruction_context( context: *const u8, ) -> payloads::Validate { - // Safety: ownership of the provided context is transferred into `_decode_from_raw` - unsafe { decode_with_length_prefix_from_raw(context) } + decode_with_length_prefix_from_raw(context) } /// Get context for `validate_query()` entrypoint. +/// +/// # Safety +/// +/// It's safe to call this function as long as it's safe to construct, from the given +/// pointer, byte array of prefix length and `Box<[u8]>` containing the encoded object #[cfg(not(test))] -pub fn decode_validate_query_context(context: *const u8) -> payloads::Validate { - // Safety: ownership of the provided context is transferred into `_decode_from_raw` - unsafe { decode_with_length_prefix_from_raw(context) } +pub unsafe fn decode_validate_query_context(context: *const u8) -> payloads::Validate { + decode_with_length_prefix_from_raw(context) } /// Get context for `migrate()` entrypoint. +/// +/// # Safety +/// +/// It's safe to call this function as long as it's safe to construct, from the given +/// pointer, byte array of prefix length and `Box<[u8]>` containing the encoded object #[cfg(not(test))] -pub fn decode_migrate_context(context: *const u8) -> payloads::ExecutorContext { - // Safety: ownership of the provided context is transferred into `_decode_from_raw` - unsafe { decode_with_length_prefix_from_raw(context) } +pub unsafe fn decode_migrate_context(context: *const u8) -> payloads::ExecutorContext { + decode_with_length_prefix_from_raw(context) } /// Set new [`ExecutorDataModel`]. @@ -227,8 +243,7 @@ impl DataModelBuilder { let account_permissions = host .query(FindPermissionsByAccountId::new(account.id().clone())) .execute() - .unwrap() - .into_iter(); + .unwrap(); for permission in account_permissions.map(|permission| permission.unwrap()) { if !self.permissions.contains(permission.name()) { diff --git a/crates/iroha_smart_contract/src/lib.rs b/crates/iroha_smart_contract/src/lib.rs index 08131cde85..003f6af6d2 100644 --- a/crates/iroha_smart_contract/src/lib.rs +++ b/crates/iroha_smart_contract/src/lib.rs @@ -226,10 +226,17 @@ pub fn stub_getrandom(_dest: &mut [u8]) -> Result<(), getrandom::Error> { } /// Get context for smart contract `main()` entrypoint. +/// +/// # Safety +/// +/// It's safe to call this function as long as it's safe to construct, from the given +/// pointer, byte array of prefix length and `Box<[u8]>` containing the encoded object #[cfg(not(test))] -pub fn get_smart_contract_context() -> data_model::smart_contract::payloads::SmartContractContext { +pub unsafe fn decode_smart_contract_context( + context: *const u8, +) -> data_model::smart_contract::payloads::SmartContractContext { // Safety: ownership of the returned result is transferred into `_decode_from_raw` - unsafe { decode_with_length_prefix_from_raw(host::get_smart_contract_context()) } + decode_with_length_prefix_from_raw(context) } #[cfg(not(test))] @@ -253,12 +260,6 @@ mod host { /// This function doesn't take ownership of the provided allocation /// but it does transfer ownership of the result to the caller pub(super) fn execute_instruction(ptr: *const u8, len: usize) -> *const u8; - - /// Get context for smart contract `main()` entrypoint. - /// # Warning - /// - /// This function transfers ownership of the result to the caller - pub(super) fn get_smart_contract_context() -> *const u8; } } diff --git a/crates/iroha_smart_contract_derive/src/entrypoint.rs b/crates/iroha_smart_contract_derive/src/entrypoint.rs index 4184c4b2c3..659abf7f4c 100644 --- a/crates/iroha_smart_contract_derive/src/entrypoint.rs +++ b/crates/iroha_smart_contract_derive/src/entrypoint.rs @@ -34,9 +34,9 @@ pub fn impl_entrypoint(emitter: &mut Emitter, item: syn::ItemFn) -> TokenStream /// Smart contract entrypoint #[no_mangle] #[doc(hidden)] - unsafe extern "C" fn #main_fn_name() { + unsafe extern "C" fn #main_fn_name(context: *const u8) { let host = ::iroha_smart_contract::Iroha; - let context = ::iroha_smart_contract::get_smart_contract_context(); + let context = ::iroha_trigger::decode_trigger_context(context); #fn_name(host, context) } diff --git a/crates/iroha_trigger/src/lib.rs b/crates/iroha_trigger/src/lib.rs index ffa36a4918..bea08890ea 100644 --- a/crates/iroha_trigger/src/lib.rs +++ b/crates/iroha_trigger/src/lib.rs @@ -12,26 +12,18 @@ pub mod log { pub use iroha_smart_contract_utils::{debug, error, event, info, log::*, trace, warn}; } +/// Get context for smart contract `main()` entrypoint. +/// +/// # Safety +/// +/// It's safe to call this function as long as it's safe to construct, from the given +/// pointer, byte array of prefix length and `Box<[u8]>` containing the encoded object #[cfg(not(test))] -mod host { - #[link(wasm_import_module = "iroha")] - extern "C" { - /// Get context for trigger `main()` entrypoint. - /// - /// # Warning - /// - /// This function does transfer ownership of the result to the caller - pub(super) fn get_trigger_context() -> *const u8; - } -} - -/// Get context for trigger `main()` entrypoint. -#[cfg(not(test))] -pub fn get_trigger_context() -> data_model::smart_contract::payloads::TriggerContext { +pub unsafe fn decode_trigger_context( + context: *const u8, +) -> data_model::smart_contract::payloads::TriggerContext { // Safety: ownership of the returned result is transferred into `_decode_from_raw` - unsafe { - iroha_smart_contract_utils::decode_with_length_prefix_from_raw(host::get_trigger_context()) - } + iroha_smart_contract_utils::decode_with_length_prefix_from_raw(context) } pub mod prelude { diff --git a/crates/iroha_trigger_derive/src/entrypoint.rs b/crates/iroha_trigger_derive/src/entrypoint.rs index 2337268151..a2b4e6dbe4 100644 --- a/crates/iroha_trigger_derive/src/entrypoint.rs +++ b/crates/iroha_trigger_derive/src/entrypoint.rs @@ -34,9 +34,9 @@ pub fn impl_entrypoint(emitter: &mut Emitter, item: syn::ItemFn) -> TokenStream /// Smart contract entrypoint #[no_mangle] #[doc(hidden)] - unsafe extern "C" fn #main_fn_name() { + unsafe extern "C" fn #main_fn_name(context: *const u8) { let host = ::iroha_trigger::smart_contract::Iroha; - let context = ::iroha_trigger::get_trigger_context(); + let context = ::iroha_trigger::decode_trigger_context(context); #fn_name(host, context) } diff --git a/scripts/tests/consistency.sh b/scripts/tests/consistency.sh index 36c5520418..ca23bc9c0d 100755 --- a/scripts/tests/consistency.sh +++ b/scripts/tests/consistency.sh @@ -3,14 +3,14 @@ set -e case $1 in "genesis") - cargo run --release --bin kagami -- genesis generate --executor executor.wasm --wasm-dir libs --genesis-public-key ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 | diff - defaults/genesis.json || { - echo 'Please re-generate the default genesis with `cargo run --package iroha_kagami --release --bin kagami -- genesis --executor executor.wasm --wasm-dir libs --genesis-public-key ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 > ./defaults/genesis.json`' + cargo run --package iroha_kagami --bin kagami --release -- genesis generate --executor executor.wasm --wasm-dir libs --genesis-public-key ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 | diff - defaults/genesis.json || { + echo 'Please re-generate the default genesis with `cargo run --package iroha_kagami --bin kagami --release -- genesis --executor executor.wasm --wasm-dir libs --genesis-public-key ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 > ./defaults/genesis.json`' echo 'The assumption here is that the authority of the default genesis transaction is `iroha_test_samples::SAMPLE_GENESIS_ACCOUNT_ID`' exit 1 };; "schema") - cargo run --release --bin kagami -- schema | diff - docs/source/references/schema.json || { - echo 'Please re-generate schema with `cargo run --package iroha_kagami --release --bin kagami -- schema > docs/source/references/schema.json`' + cargo run --package iroha_kagami --bin kagami --release -- schema | diff - docs/source/references/schema.json || { + echo 'Please re-generate schema with `cargo run --package iroha_kagami --bin kagami --release -- schema > docs/source/references/schema.json`' exit 1 };; "docker-compose") @@ -25,15 +25,15 @@ case $1 in } command_base_for_single() { - echo "cargo run --package iroha_swarm --release --bin iroha_swarm -- -p 1 -s Iroha -H -c ./defaults -i hyperledger/iroha:local -b ." + echo "cargo run --package iroha_swarm --bin iroha_swarm --release -- -p 1 -s Iroha -H -c ./defaults -i hyperledger/iroha:local -b ." } command_base_for_multiple_local() { - echo "cargo run --package iroha_swarm --release --bin iroha_swarm -- -p 4 -s Iroha -H -c ./defaults -i hyperledger/iroha:local -b ." + echo "cargo run --package iroha_swarm --bin iroha_swarm --release -- -p 4 -s Iroha -H -c ./defaults -i hyperledger/iroha:local -b ." } command_base_for_default() { - echo "cargo run --package iroha_swarm --release --bin iroha_swarm -- -p 4 -s Iroha -H -c ./defaults -i hyperledger/iroha:dev" + echo "cargo run --package iroha_swarm --bin iroha_swarm --release -- -p 4 -s Iroha -H -c ./defaults -i hyperledger/iroha:dev" } diff --git a/tests/status_response.rs b/tests/status_response.rs deleted file mode 100644 index fcf9d8db78..0000000000 --- a/tests/status_response.rs +++ /dev/null @@ -1,54 +0,0 @@ -//use eyre::Result; -//use iroha::{client, data_model::prelude::*}; -//use iroha_telemetry::metrics::Status; -//use iroha_test_network::*; -//use tokio::task::spawn_blocking; -// -//fn status_eq_excluding_uptime_and_queue(lhs: &Status, rhs: &Status) -> bool { -// lhs.peers == rhs.peers -// && lhs.blocks == rhs.blocks -// && lhs.txs_accepted == rhs.txs_accepted -// && lhs.txs_rejected == rhs.txs_rejected -// && lhs.view_changes == rhs.view_changes -//} -// -//async fn check(client: &client::Client, blocks: u64) -> Result<()> { -// let status_json = reqwest::get(client.torii_url.join("/status").unwrap()) -// .await? -// .json() -// .await?; -// -// let status_scale = { -// let client = client.clone(); -// spawn_blocking(move || client.get_status()).await?? -// }; -// -// assert!(status_eq_excluding_uptime_and_queue( -// &status_json, -// &status_scale -// )); -// assert_eq!(status_json.blocks, blocks); -// -// Ok(()) -//} -// -//#[tokio::test] -//async fn json_and_scale_statuses_equality() -> Result<()> { -// let network = NetworkBuilder::new().start().await?; -// let client = network.client(); -// -// check(&client, 1).await?; -// -// { -// let client = client.clone(); -// spawn_blocking(move || { -// client.submit_blocking(Register::domain(Domain::new("looking_glass".parse()?))) -// }) -// } -// .await??; -// network.ensure_blocks(2).await?; -// -// check(&client, 2).await?; -// -// Ok(()) -//}