implment call_invoke and call_evaluate

Author: taskooh

core/src/env/srml/mod.rs

@@ -24,7 +24,6 @@ pub use self::types::DefaultSrmlTypes;
 #[cfg(not(feature = "test-env"))]
 pub use self::srml_only::{
     sys,
-    SrmlReturnData,
     SrmlEnv,
     SrmlEnvStorage,
 };

core/src/env/srml/srml_only/impls.rs

@@ -20,7 +20,6 @@ use crate::{
         Env,
         EnvStorage,
         EnvTypes,
-        EnvReturnData,
     },
     memory::vec::Vec,
     storage::Key,
@@ -73,27 +72,12 @@ impl EnvStorage for SrmlEnvStorage {
     }
 }
 
-/// Wrapped access to return data.
-/// get() or get_raw Must be used right after ReturnData is returned.
-pub struct SrmlReturnData;
-
-impl EnvReturnData for SrmlReturnData
-{
-    fn get<U : Decode>(self) -> U {
-        U::decode(&mut &read_scratch_buffer()[..]).unwrap()
-    }
-
-    fn get_raw(self) -> Vec<u8> {
-        read_scratch_buffer()
-    }
-}
-
 /// The SRML contracts environment.
 pub struct SrmlEnv<T>
 where
     T: EnvTypes,
 {
-    marker: PhantomData<fn () -> T>,
+    marker: PhantomData<fn() -> T>,
 }
 
 impl<T> EnvTypes for SrmlEnv<T>
@@ -129,8 +113,6 @@ where
     T: EnvTypes,
 {
 
-    type ReturnData = SrmlReturnData;
-
     fn input() -> Vec<u8> {
         read_scratch_buffer()
     }
@@ -165,13 +147,33 @@ where
             )
         }
     }
+    fn call_invoke(
+        callee: <Self as EnvTypes>::AccountId,
+        gas: u64,
+        value: <Self as EnvTypes>::Balance,
+        input_data: &[u8],
+    ) {
+        let callee = callee.encode();
+        let value = value.encode();
+        unsafe {
+            sys::ext_call(
+                callee.as_ptr() as u32,
+                callee.len() as u32,
+                gas,
+                value.as_ptr() as u32,
+                value.len() as u32,
+                input_data.as_ptr() as u32,
+                input_data.len() as u32
+            );
+        }
+    }
 
-    fn call(
+    fn call_evaluate<U: Decode>(
         callee: <Self as EnvTypes>::AccountId,
         gas: u64,
         value: <Self as EnvTypes>::Balance,
         input_data: &[u8],
-    ) -> Option<Self::ReturnData> {
+    ) -> Option<U> {
         let callee = callee.encode();
         let value = value.encode();
         unsafe {
@@ -185,7 +187,7 @@ where
                 input_data.len() as u32
             );
             if success == 0 {
-                Some(Self::ReturnData{})
+                Some(U::decode(&mut &read_scratch_buffer()[..]).unwrap())
             } else {
                 None
             }

core/src/env/srml/srml_only/mod.rs

@@ -18,7 +18,6 @@ mod impls;
 pub mod sys;
 
 pub use self::impls::{
-    SrmlReturnData,
     SrmlEnv,
     SrmlEnvStorage,
 };

core/src/env/test_env.rs

@@ -16,10 +16,7 @@
 
 use super::*;
 use crate::{
-    env::{
-        EnvReturnData,
-        EnvTypes,
-    },
+    env::EnvTypes,
     memory::collections::hash_map::{
         Entry,
         HashMap,
@@ -404,13 +401,13 @@ impl TestEnvData {
     }
 
     #[allow(unused_variables)]
-    pub fn call(
+    pub fn call<T: Decode>(
         &mut self,
         callee: &[u8],
         gas: u64,
         value: &[u8],
         input_data: &[u8],
-    ) -> Option<TestReturnData> {
+    ) -> Option<T> {
         unimplemented!();
     }
 }
@@ -425,17 +422,6 @@ thread_local! {
     };
 }
 
-pub struct TestReturnData;
-
-impl EnvReturnData for TestReturnData {
-    fn get<U: Decode>(self) -> U {
-        unimplemented!();
-    }
-    fn get_raw(self) -> Vec<u8> {
-        unimplemented!();
-    }
-}
-
 /// Test environment for testing SRML contract off-chain.
 pub struct TestEnv<T> {
     marker: PhantomData<fn() -> T>,
@@ -530,8 +516,6 @@ impl<T> Env for TestEnv<T>
 where
     T: EnvTypes,
 {
-    type ReturnData = TestReturnData;
-
     impl_env_getters_for_test_env!(
         (address, T::AccountId),
         (balance, T::Balance),
@@ -560,12 +544,24 @@ where
         })
     }
 
-    fn call(
+    fn call_invoke(
+        callee: T::AccountId,
+        gas: u64,
+        value: T::Balance,
+        input_data: &[u8],
+    ) {
+        let callee = &(callee.encode())[..];
+        let value = &(value.encode())[..];
+        TEST_ENV_DATA
+            .with(|test_env| test_env.borrow_mut().call(callee, gas, value, input_data));
+    }
+
+    fn call_evaluate<U : Decode>(
         callee: T::AccountId,
         gas: u64,
         value: T::Balance,
         input_data: &[u8],
-    ) -> Option<Self::ReturnData> {
+    ) -> Option<U> {
         let callee = &(callee.encode())[..];
         let value = &(value.encode())[..];
         TEST_ENV_DATA

core/src/env/traits.rs

@@ -80,18 +80,8 @@ pub trait EnvStorage {
     unsafe fn load(key: Key) -> Option<Vec<u8>>;
 }
 
-pub trait EnvReturnData
-{
-    fn get<U : Decode>(self) -> U;
-
-    fn get_raw(self) -> Vec<u8>;
-}
-
 /// The environment API usable by contracts defined with pDSL.
 pub trait Env: EnvTypes {
-
-    type ReturnData : EnvReturnData;
-
     /// Returns the chain address of the contract.
     fn address() -> <Self as EnvTypes>::AccountId;
 
@@ -141,11 +131,21 @@ pub trait Env: EnvTypes {
     /// Deposits raw event data through Contracts module.
     fn deposit_raw_event(topics: &[<Self as EnvTypes>::Hash], data: &[u8]);
 
-    /// Calls a remote smart contract and return access to scratch buffer
-    fn call(
+
+    /// Calls a remote smart contract and return access to scratch buffer without return data
+    fn call_invoke(
+        callee: <Self as EnvTypes>::AccountId,
+        gas: u64,
+        value: <Self as EnvTypes>::Balance,
+        input_data: &[u8]
+    );
+
+    /// Calls a remote smart contract and return access to scratch buffer with return data
+    #[must_use]
+    fn call_evaluate<T: Decode>(
         callee: <Self as EnvTypes>::AccountId,
         gas: u64,
         value: <Self as EnvTypes>::Balance,
         input_data: &[u8],
-    ) -> Option<Self::ReturnData>;
+    ) -> Option<T>;
 }

model/src/exec_env.rs

@@ -28,6 +28,7 @@ use ink_core::{
         Initialize,
     },
 };
+use parity_codec::Decode;
 
 /// Provides a safe interface to an environment given a contract state.
 pub struct ExecutionEnv<State, Env> {
@@ -181,14 +182,25 @@ impl<T: Env> EnvHandler<T> {
         T::block_number()
     }
 
+    /// Calls a remote smart contract
+    pub fn call_invoke(
+        &self,
+        callee: T::AccountId,
+        gas: u64,
+        value: T::Balance,
+        input_data: &[u8],
+    ) {
+        T::call_invoke(callee, gas, value, input_data);
+    }
+
     /// Calls a remote smart contract and return access to scratch buffer
-    pub fn call(
+    pub fn call_evaluate<U:Decode>(
         &self,
         callee: T::AccountId,
         gas: u64,
         value: T::Balance,
         input_data: &[u8],
-    ) -> Option<T::ReturnData> {
-        T::call(callee, gas, value, input_data)
+    ) -> Option<U> {
+        T::call_evaluate(callee, gas, value, input_data)
     }
 }