diff --git a/crates/codec/src/api/json/deploy.rs b/crates/codec/src/api/json/deploy.rs index 7ddf342b1..14fedaf3c 100644 --- a/crates/codec/src/api/json/deploy.rs +++ b/crates/codec/src/api/json/deploy.rs @@ -4,7 +4,7 @@ use crate::api::builder::TemplateBuilder; use crate::api::json::{self, JsonError}; use crate::template; -use svm_layout::{Id, Layout, LayoutBuilder}; +use svm_layout::{FixedLayoutBuilder, Id, Layout}; use svm_types::{CodeSection, CtorsSection, DataSection, HeaderSection}; /// @@ -71,7 +71,7 @@ fn to_data_layout(blob: Vec) -> Result { .collect(); // Note: `LayoutBuilder` assume that the `first var id` is zero - let mut builder = LayoutBuilder::with_capacity(data.len()); + let mut builder = FixedLayoutBuilder::with_capacity(data.len()); builder.set_first(Id(0)); builder.extend_from_slice(&data); diff --git a/crates/codec/src/section/sections/data.rs b/crates/codec/src/section/sections/data.rs index e43c6bffa..10af7766a 100644 --- a/crates/codec/src/section/sections/data.rs +++ b/crates/codec/src/section/sections/data.rs @@ -45,7 +45,7 @@ use std::io::Cursor; -use svm_layout::{Id, Layout, LayoutBuilder, LayoutKind, RawVar}; +use svm_layout::{FixedLayoutBuilder, Id, Layout, LayoutKind, RawVar}; use svm_types::DataSection; use crate::section::{SectionDecoder, SectionEncoder}; @@ -124,7 +124,7 @@ fn decode_layout(cursor: &mut Cursor<&[u8]>) -> Result { Ok(var_count) => { let var_count = var_count as usize; - let mut builder = LayoutBuilder::with_capacity(var_count); + let mut builder = FixedLayoutBuilder::with_capacity(var_count); if var_count > 0 { // `First Var Id` diff --git a/crates/layout/src/builder.rs b/crates/layout/src/builder.rs index 884ea9d13..010b8166b 100644 --- a/crates/layout/src/builder.rs +++ b/crates/layout/src/builder.rs @@ -1,22 +1,20 @@ use crate::{FixedLayout, Id, RawVar}; /// Specifies the fixed-sized variables -pub struct LayoutBuilder { +pub struct FixedLayoutBuilder { first: Option, - vars: Vec<(u32, u32)>, - next_offset: u32, } -impl Default for LayoutBuilder { +impl Default for FixedLayoutBuilder { fn default() -> Self { Self::new() } } -/// `LayoutBuilder` represents the fixed-sized variables (storage) of an application. -impl LayoutBuilder { +/// Builds [`FixedLayout`]. +impl FixedLayoutBuilder { /// New builder pub fn new() -> Self { Self::with_capacity(0) @@ -61,9 +59,7 @@ impl LayoutBuilder { /// The starting offset is right after where the previous variable ended. pub fn push(&mut self, len: u32) { let offset = self.next_offset; - self.vars.push((offset, len)); - self.next_offset += len; } diff --git a/crates/layout/src/fixed.rs b/crates/layout/src/fixed.rs index 82f080fd2..b1c39d50d 100644 --- a/crates/layout/src/fixed.rs +++ b/crates/layout/src/fixed.rs @@ -1,4 +1,4 @@ -use crate::{Id, LayoutBuilder, RawVar}; +use crate::{FixedLayoutBuilder, Id, RawVar}; /// In-memory representation of a program's fixed-sized storage variables. #[derive(Debug, PartialEq, Clone)] @@ -97,7 +97,7 @@ impl From<&[u32]> for FixedLayout { fn from(slice: &[u32]) -> Self { let len = slice.len(); - let mut builder = LayoutBuilder::with_capacity(len); + let mut builder = FixedLayoutBuilder::with_capacity(len); if len > 0 { builder.set_first(Id(0)); @@ -161,7 +161,7 @@ mod tests { #[test] fn layout_new() { - let mut builder = LayoutBuilder::with_capacity(2); + let mut builder = FixedLayoutBuilder::with_capacity(2); builder.set_first(Id(3)); builder.push(10); @@ -185,7 +185,7 @@ mod tests { #[test] fn layout_extend_from_slice() { - let mut builder = LayoutBuilder::with_capacity(2); + let mut builder = FixedLayoutBuilder::with_capacity(2); builder.set_first(Id(4)); builder.push(10); @@ -203,7 +203,7 @@ mod tests { #[test] fn layout_iter() { - let mut builder = LayoutBuilder::with_capacity(2); + let mut builder = FixedLayoutBuilder::with_capacity(2); builder.set_first(Id(1)); builder.push(10); diff --git a/crates/layout/src/lib.rs b/crates/layout/src/lib.rs index e3b194532..c2bddcc4a 100644 --- a/crates/layout/src/lib.rs +++ b/crates/layout/src/lib.rs @@ -9,7 +9,7 @@ mod builder; mod fixed; mod var; -pub use builder::LayoutBuilder; +pub use builder::FixedLayoutBuilder; pub use fixed::FixedLayout; pub use var::{Id, Primitive, RawVar, SymbolicVar, Type}; diff --git a/crates/runtime-ffi/src/api.rs b/crates/runtime-ffi/src/api.rs index cd32099f7..4488d53bb 100644 --- a/crates/runtime-ffi/src/api.rs +++ b/crates/runtime-ffi/src/api.rs @@ -19,11 +19,11 @@ use crate::raw_utf8_error; use crate::{raw_error, raw_validate_error, svm_result_t}; -static KV_TYPE: Type = Type::Str("key-value store"); -static VALIDATE_TX_APP_ADDR_TYPE: Type = Type::Str("svm_validate_tx app_addr"); -static DEPLOY_TEMPLATE_RECEIPT_TYPE: Type = Type::Str("deploy-template receipt"); -static SPAWN_APP_RECEIPT_TYPE: Type = Type::Str("spawn-app receipt"); -static EXEC_APP_RECEIPT_TYPE: Type = Type::Str("exec-app receipt"); +static KV_TYPE: Type = Type::Str("Key-Value Store"); +static VALIDATE_CALL_TARGET_TYPE: Type = Type::Str("validate_call Target"); +static DEPLOY_RECEIPT_TYPE: Type = Type::Str("Deploy Receipt"); +static SPAWN_RECEIPT_TYPE: Type = Type::Str("Spawn Receipt"); +static CALL_RECEIPT_TYPE: Type = Type::Str("Call Receipt"); #[inline(always)] fn maybe_gas(gas_enabled: bool, gas_limit: u64) -> Gas { @@ -65,7 +65,7 @@ unsafe fn data_to_svm_byte_array( /// use svm_ffi::svm_byte_array; /// use svm_types::Address; /// -/// // create runtime +/// // Create runtime /// /// let mut kv = std::ptr::null_mut(); /// let res = unsafe { svm_memory_state_kv_create(&mut kv) }; @@ -78,12 +78,12 @@ unsafe fn data_to_svm_byte_array( /// assert!(res.is_ok()); /// /// let bytes = svm_byte_array::default(); -/// let _res = unsafe { svm_validate_template(runtime, bytes, &mut error) }; +/// let _res = unsafe { svm_validate_deploy(runtime, bytes, &mut error) }; /// ``` /// #[must_use] #[no_mangle] -pub unsafe extern "C" fn svm_validate_template( +pub unsafe extern "C" fn svm_validate_deploy( runtime: *mut c_void, bytes: svm_byte_array, error: *mut svm_byte_array, @@ -100,7 +100,7 @@ pub unsafe extern "C" fn svm_validate_template( } } -/// Validates syntactically a raw `spawn app` transaction. +/// Validates syntactically a binary `Spawn Account` transaction. /// /// Should be called while the transaction is in the `mempool` of the Host. /// In case the transaction isn't valid - the transaction should be discarded. @@ -126,12 +126,12 @@ pub unsafe extern "C" fn svm_validate_template( /// assert!(res.is_ok()); /// /// let bytes = svm_byte_array::default(); -/// let _res = unsafe { svm_validate_app(runtime, bytes, &mut error) }; +/// let _res = unsafe { svm_validate_spawn(runtime, bytes, &mut error) }; /// ``` /// #[must_use] #[no_mangle] -pub unsafe extern "C" fn svm_validate_app( +pub unsafe extern "C" fn svm_validate_spawn( runtime: *mut c_void, bytes: svm_byte_array, error: *mut svm_byte_array, @@ -141,15 +141,15 @@ pub unsafe extern "C" fn svm_validate_app( match runtime.validate_spawn(bytes.into()) { Ok(()) => svm_result_t::SVM_SUCCESS, Err(e) => { - error!("`svm_validate_app` returns `SVM_FAILURE`"); + error!("`svm_validate_spawn` returns `SVM_FAILURE`"); raw_validate_error(&e, error); svm_result_t::SVM_FAILURE } } } -/// Validates syntactically a raw `execute app` transaction. -/// Returns the `App` address that appears in the transaction. +/// Validates syntactically a binary `Call Account` transaction. +/// Returns the `Target Address` that appears in the transaction. /// /// # Examples /// @@ -171,38 +171,41 @@ pub unsafe extern "C" fn svm_validate_app( /// let res = unsafe { svm_memory_runtime_create(&mut runtime, kv, &mut error) }; /// assert!(res.is_ok()); /// -/// let mut app_addr = svm_byte_array::default(); +/// let mut target_addr = svm_byte_array::default(); /// let bytes = svm_byte_array::default(); -/// let _res = unsafe { svm_validate_tx(&mut app_addr, runtime, bytes, &mut error) }; +/// let _res = unsafe { svm_validate_call(&mut target_addr, runtime, bytes, &mut error) }; /// ``` /// #[must_use] #[no_mangle] -pub unsafe extern "C" fn svm_validate_tx( - app_addr: *mut svm_byte_array, +pub unsafe extern "C" fn svm_validate_call( + target_addr: *mut svm_byte_array, runtime: *mut c_void, bytes: svm_byte_array, error: *mut svm_byte_array, ) -> svm_result_t { - debug!("`svm_validate_tx` start"); + debug!("`svm_validate_call` start"); let runtime: &mut Box = runtime.into(); match runtime.validate_call(bytes.into()) { Ok(tx) => { - // returning encoded `AppReceipt` as `svm_byte_array`. + // Returns `target Address` that appears in `bytes`. + // + // # Notes + // // should call later `svm_receipt_destroy` data_to_svm_byte_array( - VALIDATE_TX_APP_ADDR_TYPE, - app_addr, + VALIDATE_CALL_TARGET_TYPE, + target_addr, tx.target.unwrap().as_slice().to_vec(), ); - debug!("`svm_validate_tx` returns `SVM_SUCCESS`"); + debug!("`svm_validate_call` returns `SVM_SUCCESS`"); svm_result_t::SVM_SUCCESS } Err(e) => { - error!("`svm_validate_tx` returns `SVM_FAILURE`"); + error!("`svm_validate_call` returns `SVM_FAILURE`"); raw_validate_error(&e, error); svm_result_t::SVM_FAILURE } @@ -363,7 +366,7 @@ pub unsafe extern "C" fn svm_runtime_create( res } -/// Deploys a new app-template +/// Deploys a `Template` /// /// # Examples /// @@ -388,16 +391,16 @@ pub unsafe extern "C" fn svm_runtime_create( /// let ty = Type::Str("deployer"); /// let deployer: svm_byte_array = (ty, Address::of("@deployer")).into(); /// let template_bytes = svm_byte_array::default(); -/// let gas_metering = false; +/// let gas_enabled = false; /// let gas_limit = 0; /// /// let res = unsafe { -/// svm_deploy_template( +/// svm_deploy( /// &mut receipt, /// runtime, /// template_bytes, /// deployer, -/// gas_metering, +/// gas_enabled, /// gas_limit, /// &mut error) /// }; @@ -407,12 +410,12 @@ pub unsafe extern "C" fn svm_runtime_create( /// #[must_use] #[no_mangle] -pub unsafe extern "C" fn svm_deploy_template( +pub unsafe extern "C" fn svm_deploy( receipt: *mut svm_byte_array, runtime: *mut c_void, bytes: svm_byte_array, deployer: svm_byte_array, - gas_metering: bool, + gas_enabled: bool, gas_limit: u64, error: *mut svm_byte_array, ) -> svm_result_t { @@ -427,13 +430,13 @@ pub unsafe extern "C" fn svm_deploy_template( return svm_result_t::SVM_FAILURE; } - let gas_limit = maybe_gas(gas_metering, gas_limit); + let gas_limit = maybe_gas(gas_enabled, gas_limit); let rust_receipt = runtime.deploy(bytes.into(), &deployer.unwrap().into(), gas_limit); let receipt_bytes = receipt::encode_deploy(&rust_receipt); // returning encoded `TemplateReceipt` as `svm_byte_array`. // should call later `svm_receipt_destroy` - data_to_svm_byte_array(DEPLOY_TEMPLATE_RECEIPT_TYPE, receipt, receipt_bytes); + data_to_svm_byte_array(DEPLOY_RECEIPT_TYPE, receipt, receipt_bytes); debug!("`svm_deploy_template` returns `SVM_SUCCESS`"); @@ -462,22 +465,22 @@ pub unsafe extern "C" fn svm_deploy_template( /// let res = unsafe { svm_memory_runtime_create(&mut runtime, state_kv, &mut error) }; /// assert!(res.is_ok()); /// -/// let mut app_receipt = svm_byte_array::default(); +/// let mut receipt = svm_byte_array::default(); /// let mut init_state = svm_byte_array::default(); /// /// let spawner_ty = Type::Str("spawner"); /// let spawner: svm_byte_array = (spawner_ty, Address::of("@spawner")).into(); -/// let app_bytes = svm_byte_array::default(); -/// let gas_metering = false; +/// let bytes = svm_byte_array::default(); +/// let gas_enabled = false; /// let gas_limit = 0; /// /// let _res = unsafe { -/// svm_spawn_app( -/// &mut app_receipt, +/// svm_spawn( +/// &mut receipt, /// runtime, -/// app_bytes, +/// bytes, /// spawner, -/// gas_metering, +/// gas_enabled, /// gas_limit, /// &mut error) /// }; @@ -485,16 +488,16 @@ pub unsafe extern "C" fn svm_deploy_template( /// #[must_use] #[no_mangle] -pub unsafe extern "C" fn svm_spawn_app( +pub unsafe extern "C" fn svm_spawn( receipt: *mut svm_byte_array, runtime: *mut c_void, bytes: svm_byte_array, spawner: svm_byte_array, - gas_metering: bool, + gas_enabled: bool, gas_limit: u64, error: *mut svm_byte_array, ) -> svm_result_t { - debug!("`svm_spawn_app` start"); + debug!("`svm_spawn_account` start"); let runtime: &mut Box = runtime.into(); let spawner: Result = Address::try_from(spawner); @@ -504,21 +507,24 @@ pub unsafe extern "C" fn svm_spawn_app( return svm_result_t::SVM_FAILURE; } - let gas_limit = maybe_gas(gas_metering, gas_limit); + let gas_limit = maybe_gas(gas_enabled, gas_limit); let rust_receipt = runtime.spawn(bytes.into(), &spawner.unwrap().into(), gas_limit); let receipt_bytes = receipt::encode_spawn(&rust_receipt); - // returning encoded `AppReceipt` as `svm_byte_array`. - // should call later `svm_receipt_destroy` - data_to_svm_byte_array(SPAWN_APP_RECEIPT_TYPE, receipt, receipt_bytes); + // Returns the encoded `SpawnReceipt` as `svm_byte_array`. + // + // # Notes: + // + // Should call later `svm_receipt_destroy` + data_to_svm_byte_array(SPAWN_RECEIPT_TYPE, receipt, receipt_bytes); - debug!("`svm_spawn_app` returns `SVM_SUCCESS`"); + debug!("`svm_spawn_account` returns `SVM_SUCCESS`"); svm_result_t::SVM_SUCCESS } -/// Triggers an app-transaction execution of an already deployed app. -/// Returns the receipt of the execution via the `receipt` parameter. +/// Triggers a `Call App` transaction. +/// Returns the Receipt of the execution via the `receipt` parameter. /// /// # Examples /// @@ -542,20 +548,20 @@ pub unsafe extern "C" fn svm_spawn_app( /// let res = unsafe { svm_memory_runtime_create(&mut runtime, state_kv, &mut error) }; /// assert!(res.is_ok()); /// -/// let mut exec_receipt = svm_byte_array::default(); +/// let mut receipt = svm_byte_array::default(); /// let bytes = svm_byte_array::default(); /// let ty = Type::of::(); /// let state = (ty, State::zeros()).into(); -/// let gas_metering = false; +/// let gas_enabled = false; /// let gas_limit = 0; /// /// let _res = unsafe { -/// svm_exec_app( -/// &mut exec_receipt, +/// svm_call( +/// &mut receipt, /// runtime, /// bytes, /// state, -/// gas_metering, +/// gas_enabled, /// gas_limit, /// &mut error) /// }; @@ -563,16 +569,16 @@ pub unsafe extern "C" fn svm_spawn_app( /// #[must_use] #[no_mangle] -pub unsafe extern "C" fn svm_exec_app( +pub unsafe extern "C" fn svm_call( receipt: *mut svm_byte_array, runtime: *mut c_void, bytes: svm_byte_array, state: svm_byte_array, - gas_metering: bool, + gas_enabled: bool, gas_limit: u64, error: *mut svm_byte_array, ) -> svm_result_t { - debug!("`svm_exec_app` start"); + debug!("`svm_call` start"); let runtime: &mut Box = runtime.into(); let state: Result = State::try_from(state); @@ -582,17 +588,20 @@ pub unsafe extern "C" fn svm_exec_app( return svm_result_t::SVM_FAILURE; } - let gas_limit = maybe_gas(gas_metering, gas_limit); + let gas_limit = maybe_gas(gas_enabled, gas_limit); let tx = runtime.validate_call(bytes.into()).unwrap(); let rust_receipt = runtime.call(&tx, &state.unwrap(), gas_limit); let receipt_bytes = receipt::encode_call(&rust_receipt); - // returning encoded `ExecReceipt` as `svm_byte_array`. - // should call later `svm_receipt_destroy` - data_to_svm_byte_array(EXEC_APP_RECEIPT_TYPE, receipt, receipt_bytes); + // Returns encoded `CallReceipt` as `svm_byte_array`. + // + // # Notes: + // + // Should call later `svm_receipt_destroy` + data_to_svm_byte_array(CALL_RECEIPT_TYPE, receipt, receipt_bytes); - debug!("`svm_exec_app` returns `SVM_SUCCESS`"); + debug!("`svm_call` returns `SVM_SUCCESS`"); svm_result_t::SVM_SUCCESS } diff --git a/crates/runtime-ffi/src/lib.rs b/crates/runtime-ffi/src/lib.rs index ca695f7b3..0651bb59b 100644 --- a/crates/runtime-ffi/src/lib.rs +++ b/crates/runtime-ffi/src/lib.rs @@ -25,14 +25,14 @@ pub use api::{svm_memory_runtime_create, svm_memory_state_kv_create}; #[rustfmt::skip] pub use api::{ // Runtime - svm_exec_app, - svm_deploy_template, - svm_spawn_app, + svm_call, + svm_deploy, + svm_spawn, // Validations - svm_validate_template, - svm_validate_app, - svm_validate_tx, + svm_validate_deploy, + svm_validate_spawn, + svm_validate_call, // Destroy svm_runtime_destroy, diff --git a/crates/runtime-ffi/tests/api_tests.rs b/crates/runtime-ffi/tests/api_tests.rs index 3421c1fa5..ed6d8ce29 100644 --- a/crates/runtime-ffi/tests/api_tests.rs +++ b/crates/runtime-ffi/tests/api_tests.rs @@ -14,17 +14,17 @@ use svm_sdk::ReturnData; use svm_types::{Address, Type}; static TEST_STRING_TY: Type = Type::Str("test String"); -static DEPLOYER: Type = Type::Str("deployer"); -static SPAWNER: Type = Type::Str("spawner"); -static SENDER: Type = Type::Str("sender"); -static TEMPLATE_ADDR: Type = Type::Str("template address"); -static APP_ADDR: Type = Type::Str("app address"); -static INIT_STATE: Type = Type::Str("init state"); -static DEPLOY_TEMPLATE_TX: Type = Type::Str("deploy template tx"); -static SPAWN_APP_TX: Type = Type::Str("spawn app tx"); -static EXEC_APP_TX: Type = Type::Str("exec app tx"); -static PARAMS_TYPES: Type = Type::Str("import params types"); -static RETURNS_TYPES: Type = Type::Str("import returns types"); +static DEPLOYER: Type = Type::Str("Deployer"); +static SPAWNER: Type = Type::Str("Spawner"); +static PRINCIPAL: Type = Type::Str("Principal"); +static TEMPLATE_ADDR: Type = Type::Str("Template Address"); +static ACCOUNT_ADDR: Type = Type::Str("Account Address"); +static INIT_STATE: Type = Type::Str("Initial State"); +static DEPLOY_TX: Type = Type::Str("Deploy tx"); +static SPAWN_TX: Type = Type::Str("Spawn Tx"); +static CALL_TX: Type = Type::Str("Call Tx"); +static PARAMS_TYPES: Type = Type::Str("Import Params Types"); +static RETURNS_TYPES: Type = Type::Str("Import Returns Types"); unsafe fn wasm_error(msg: String) -> *mut svm_byte_array { let msg: svm_byte_array = (TEST_STRING_TY, msg).into(); @@ -35,13 +35,13 @@ unsafe fn wasm_error(msg: String) -> *mut svm_byte_array { err } -fn deploy_template_bytes(code_version: u32, name: &str, ctors: &[String], wasm: &[u8]) -> Vec { +fn deploy_bytes(code_version: u32, name: &str, ctors: &[String], wasm: &[u8]) -> Vec { let data: FixedLayout = vec![4].into(); svm_runtime::testing::build_template(code_version, name, data, ctors, WasmFile::Binary(wasm)) } -fn spawn_app_bytes( +fn spawn_bytes( template_addr: &svm_byte_array, name: &str, ctor_name: &str, @@ -51,11 +51,11 @@ fn spawn_app_bytes( svm_runtime::testing::build_spawn(&template_addr, name, ctor_name, calldata) } -fn exec_app_bytes(app_addr: &svm_byte_array, func_name: &str, calldata: &[u8]) -> Vec { - let app_addr: &[u8] = app_addr.into(); - let app_addr = Address::from(app_addr).into(); +fn call_bytes(target_addr: &svm_byte_array, func_name: &str, calldata: &[u8]) -> Vec { + let target_addr: &[u8] = target_addr.into(); + let target_addr = Address::from(target_addr).into(); - svm_runtime::testing::build_transaction(&app_addr, func_name, calldata) + svm_runtime::testing::build_transaction(&target_addr, func_name, calldata) } #[test] @@ -127,10 +127,10 @@ fn svm_runtime_failure() { assert_eq!(tracking::total_live(), 0); let code_version = 1; - let gas_metering = false; + let gas_enabled = false; let gas_limit = 0; - // 1) init Runtime + // 1) `Init Runtime` let mut state_kv = std::ptr::null_mut(); let mut runtime = std::ptr::null_mut(); let mut error = svm_byte_array::default(); @@ -142,113 +142,106 @@ fn svm_runtime_failure() { assert!(res.is_ok()); // 2) `Deploy Template` - let deployer: svm_byte_array = (DEPLOYER, Address::of("deployer")).into(); + let deployer: svm_byte_array = (DEPLOYER, Address::of("@Deployer")).into(); let wasm = include_bytes!("wasm/failure.wasm"); - // raw `Deploy Template` let ctors = vec!["initialize".to_string()]; - let msg = deploy_template_bytes(code_version, "My Template", &ctors, wasm); - let msg: svm_byte_array = (DEPLOY_TEMPLATE_TX, msg).into(); + let msg = deploy_bytes(code_version, "My Template", &ctors, wasm); + let msg: svm_byte_array = (DEPLOY_TX, msg).into(); - let mut template_receipt = svm_byte_array::default(); - let res = api::svm_deploy_template( - &mut template_receipt, + let mut deploy_receipt = svm_byte_array::default(); + let res = api::svm_deploy( + &mut deploy_receipt, runtime, msg.clone(), deployer.clone(), - gas_metering, + gas_enabled, gas_limit, &mut error, ); assert!(res.is_ok()); - // extract the `Template Address` out of the `Receipt` - let receipt = receipt::decode_receipt(template_receipt.clone().into()).into_deploy(); + // Extracts the deployed `Template Address` + let receipt = receipt::decode_receipt(deploy_receipt.clone().into()).into_deploy(); let template_addr: &Address = receipt.template_addr().inner(); let template_addr: svm_byte_array = (TEMPLATE_ADDR, template_addr).into(); - // 3) `Spawn App` - let name = "My App"; - let spawner: svm_byte_array = (SPAWNER, Address::of("spawner")).into(); + // 3) `Spawn Account` + let name = "My Account"; + let spawner: svm_byte_array = (SPAWNER, Address::of("@Spawner")).into(); let ctor_name = "initialize"; let calldata = vec![]; - // raw `Spawn App` let version = 0; - let app_bytes = spawn_app_bytes(&template_addr, name, ctor_name, &calldata); - let app_bytes: svm_byte_array = (SPAWN_APP_TX, app_bytes).into(); + let spawn_bytes = spawn_bytes(&template_addr, name, ctor_name, &calldata); + let spawn_bytes: svm_byte_array = (SPAWN_TX, spawn_bytes).into(); let mut spawn_receipt = svm_byte_array::default(); - let res = api::svm_spawn_app( + let res = api::svm_spawn( &mut spawn_receipt, runtime, - app_bytes.clone(), + spawn_bytes.clone(), spawner.clone(), - gas_metering, + gas_enabled, gas_limit, &mut error, ); assert!(res.is_ok()); - // extracts the spawned-app `Address` and initial `State`. let receipt = receipt::decode_receipt(spawn_receipt.clone().into()).into_spawn(); assert_eq!(receipt.success, true); - let app_addr = receipt.account_addr().inner(); - let app_addr: svm_byte_array = (APP_ADDR, app_addr).into(); + // Extracts the Spawned `Account Address` and its initial `State`. + let account_addr = receipt.account_addr().inner(); + let account_addr: svm_byte_array = (ACCOUNT_ADDR, account_addr).into(); let init_state = receipt.init_state(); let init_state: svm_byte_array = (INIT_STATE, init_state).into(); - // 4) execute app + // 4) `Call Account` let func_name = "fail"; let mut calldata = vec![]; - let exec_bytes = exec_app_bytes(&app_addr, func_name, &calldata); - let exec_bytes: svm_byte_array = (EXEC_APP_TX, exec_bytes).into(); + let call_bytes = call_bytes(&account_addr, func_name, &calldata); + let exec_bytes: svm_byte_array = (CALL_TX, call_bytes).into(); - // 4.1) validates tx and extracts its `App`'s `Address` - let mut derived_app_addr = svm_byte_array::default(); - let res = api::svm_validate_tx( - &mut derived_app_addr, - runtime, - exec_bytes.clone(), - &mut error, - ); + // 4.1) Validates tx and extracts its `Target`'s `Address` + let mut target_addr = svm_byte_array::default(); + let res = api::svm_validate_call(&mut target_addr, runtime, exec_bytes.clone(), &mut error); assert!(res.is_ok()); - // 4.2) execute the app-transaction - let mut exec_receipt = svm_byte_array::default(); + // 4.2) Executes the `Call Account` transaction. + let mut call_receipt = svm_byte_array::default(); - let res = api::svm_exec_app( - &mut exec_receipt, + let res = api::svm_call( + &mut call_receipt, runtime, exec_bytes.clone(), init_state.clone(), - gas_metering, + gas_enabled, gas_limit, &mut error, ); assert!(res.is_ok()); - let receipt = receipt::decode_receipt(exec_receipt.clone().into()).into_call(); + let receipt = receipt::decode_receipt(call_receipt.clone().into()).into_call(); assert_eq!(receipt.success, false); assert_ne!(tracking::total_live(), 0); let _ = api::svm_byte_array_destroy(msg); - let _ = api::svm_byte_array_destroy(app_bytes); + let _ = api::svm_byte_array_destroy(spawn_bytes); let _ = api::svm_byte_array_destroy(exec_bytes); let _ = api::svm_byte_array_destroy(deployer); let _ = api::svm_byte_array_destroy(spawner); let _ = api::svm_byte_array_destroy(template_addr); - let _ = api::svm_byte_array_destroy(app_addr); - let _ = api::svm_byte_array_destroy(derived_app_addr); + let _ = api::svm_byte_array_destroy(account_addr); + let _ = api::svm_byte_array_destroy(target_addr); let _ = api::svm_byte_array_destroy(init_state); - let _ = api::svm_byte_array_destroy(template_receipt); + let _ = api::svm_byte_array_destroy(deploy_receipt); let _ = api::svm_byte_array_destroy(spawn_receipt); - let _ = api::svm_byte_array_destroy(exec_receipt); + let _ = api::svm_byte_array_destroy(call_receipt); let _ = api::svm_runtime_destroy(runtime); let _ = api::svm_state_kv_destroy(state_kv); @@ -267,10 +260,10 @@ fn svm_runtime_success() { assert_eq!(tracking::total_live(), 0); let code_version = 0; - let gas_metering = false; + let gas_enabled = false; let gas_limit = 0; - // 1) init runtime + // 1) `Init Runtime` let mut state_kv = std::ptr::null_mut(); let mut runtime = std::ptr::null_mut(); let mut error = svm_byte_array::default(); @@ -281,34 +274,33 @@ fn svm_runtime_success() { let res = api::svm_memory_runtime_create(&mut runtime, state_kv, &mut error); assert!(res.is_ok()); - // 2) deploy Template - let deployer: svm_byte_array = (DEPLOYER, Address::of("deployer")).into(); + // 2) `Deploy Template` + let deployer: svm_byte_array = (DEPLOYER, Address::of("@Deployer")).into(); let ctors = vec!["initialize".to_string()]; let wasm = include_bytes!("wasm/counter.wasm"); - // raw template - let msg = deploy_template_bytes(code_version, "My Template", &ctors, wasm); - let msg: svm_byte_array = (DEPLOY_TEMPLATE_TX, msg).into(); + let msg = deploy_bytes(code_version, "My Template", &ctors, wasm); + let msg: svm_byte_array = (DEPLOY_TX, msg).into(); - let mut template_receipt = svm_byte_array::default(); - let res = api::svm_deploy_template( - &mut template_receipt, + let mut deploy_receipt = svm_byte_array::default(); + let res = api::svm_deploy( + &mut deploy_receipt, runtime, msg.clone(), deployer.clone(), - gas_metering, + gas_enabled, gas_limit, &mut error, ); assert!(res.is_ok()); - // extract the `template-address` out of the receipt - let receipt = receipt::decode_receipt(template_receipt.clone().into()).into_deploy(); + // Extracts the deployed `Template Address` + let receipt = receipt::decode_receipt(deploy_receipt.clone().into()).into_deploy(); let template_addr: &Address = receipt.template_addr().inner(); let template_addr: svm_byte_array = (TEMPLATE_ADDR, template_addr).into(); - // 3) spawn app - let name = "My App"; + // 3) `Spawn Account` + let name = "My Account"; let spawner: svm_byte_array = (SPAWNER, Address::of("spawner")).into(); let ctor_name = "initialize"; let counter_init: u32 = 10; @@ -316,33 +308,33 @@ fn svm_runtime_success() { let mut calldata = svm_sdk::Vec::with_capacity(1000); counter_init.encode(&mut calldata); - // raw `spawn-app` - let app_bytes = spawn_app_bytes(&template_addr, name, ctor_name, calldata.as_slice()); - let app_bytes: svm_byte_array = (SPAWN_APP_TX, app_bytes).into(); + let spawn_bytes = spawn_bytes(&template_addr, name, ctor_name, calldata.as_slice()); + let spawn_bytes: svm_byte_array = (SPAWN_TX, spawn_bytes).into(); let mut spawn_receipt = svm_byte_array::default(); - let res = api::svm_spawn_app( + let res = api::svm_spawn( &mut spawn_receipt, runtime, - app_bytes.clone(), + spawn_bytes.clone(), spawner.clone(), - gas_metering, + gas_enabled, gas_limit, &mut error, ); assert!(res.is_ok()); - // extracts the spawned-app `Address` and initial `State`. let receipt = receipt::decode_receipt(spawn_receipt.clone().into()).into_spawn(); assert_eq!(receipt.success, true); - let app_addr = receipt.account_addr().inner(); - let app_addr: svm_byte_array = (APP_ADDR, app_addr).into(); + + // Extracts the Spawned `Account Address` and its initial `State`. + let account_addr = receipt.account_addr().inner(); + let account_addr: svm_byte_array = (ACCOUNT_ADDR, account_addr).into(); let init_state = receipt.init_state(); let init_state: svm_byte_array = (INIT_STATE, init_state).into(); - // 4) execute app + // 4) `Call Account` let func_name = "add_and_mul"; let add = 5u32; let mul = 3u32; @@ -352,34 +344,29 @@ fn svm_runtime_success() { add.encode(&mut calldata); mul.encode(&mut calldata); - let exec_bytes = exec_app_bytes(&app_addr, func_name, &calldata); - let exec_bytes: svm_byte_array = (EXEC_APP_TX, exec_bytes).into(); + let call_bytes = call_bytes(&account_addr, func_name, &calldata); + let exec_bytes: svm_byte_array = (CALL_TX, call_bytes).into(); - // 4.1) validates tx and extracts its `App`'s `Address` - let mut derived_app_addr = svm_byte_array::default(); - let res = api::svm_validate_tx( - &mut derived_app_addr, - runtime, - exec_bytes.clone(), - &mut error, - ); + // 4.1) Validates tx and extracts its `Target`'s `Address` + let mut target_addr = svm_byte_array::default(); + let res = api::svm_validate_call(&mut target_addr, runtime, exec_bytes.clone(), &mut error); assert!(res.is_ok()); - // 4.2) execute the app-transaction - let mut exec_receipt = svm_byte_array::default(); + // 4.2) Executes the `Call Account` transaction. + let mut call_receipt = svm_byte_array::default(); - let res = api::svm_exec_app( - &mut exec_receipt, + let res = api::svm_call( + &mut call_receipt, runtime, exec_bytes.clone(), init_state.clone(), - gas_metering, + gas_enabled, gas_limit, &mut error, ); assert!(res.is_ok()); - let receipt = receipt::decode_receipt(exec_receipt.clone().into()).into_call(); + let receipt = receipt::decode_receipt(call_receipt.clone().into()).into_call(); assert_eq!(receipt.success, true); let bytes = receipt.returndata(); @@ -395,17 +382,17 @@ fn svm_runtime_success() { assert_ne!(tracking::total_live(), 0); let _ = api::svm_byte_array_destroy(msg); - let _ = api::svm_byte_array_destroy(app_bytes); + let _ = api::svm_byte_array_destroy(spawn_bytes); let _ = api::svm_byte_array_destroy(exec_bytes); let _ = api::svm_byte_array_destroy(deployer); let _ = api::svm_byte_array_destroy(spawner); let _ = api::svm_byte_array_destroy(template_addr); - let _ = api::svm_byte_array_destroy(app_addr); - let _ = api::svm_byte_array_destroy(derived_app_addr); + let _ = api::svm_byte_array_destroy(account_addr); + let _ = api::svm_byte_array_destroy(target_addr); let _ = api::svm_byte_array_destroy(init_state); - let _ = api::svm_byte_array_destroy(template_receipt); + let _ = api::svm_byte_array_destroy(deploy_receipt); let _ = api::svm_byte_array_destroy(spawn_receipt); - let _ = api::svm_byte_array_destroy(exec_receipt); + let _ = api::svm_byte_array_destroy(call_receipt); let _ = api::svm_runtime_destroy(runtime); let _ = api::svm_state_kv_destroy(state_kv); diff --git a/crates/sdk-tests/tests/ctor.rs b/crates/sdk-tests/tests/ctor.rs index 86bd96f30..4afc48cc8 100644 --- a/crates/sdk-tests/tests/ctor.rs +++ b/crates/sdk-tests/tests/ctor.rs @@ -34,7 +34,7 @@ fn ctor_tests() { // This restriction should be enforced by the `SVM` Runtime: // // * When trying to spawn a new `Account` with a public function not defined as `ctor`, - /// the validation phase should fail the transaction. + // the validation phase should fail the transaction. // // * When trying to execute a function of an existing `Account` defined as a `ctor`, // the validation phase should fail the transaction.