import ext_call to trait and add function to generate input_data of ext_call

remove #[allow(unused)] from ext_call()

implment call_invoke and call_evaluate

fix format

call_invoke and call_evaluate returns Return<_,CallError>

fixed

Author: taskooh

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

@@ -25,7 +25,10 @@ use crate::{
     storage::Key,
 };
 use core::marker::PhantomData;
-use scale::Decode;
+use scale::{
+    Decode,
+    Encode,
+};
 
 /// Load the contents of the scratch buffer
 fn read_scratch_buffer() -> Vec<u8> {
@@ -69,6 +72,8 @@ impl EnvStorage for SrmlEnvStorage {
     }
 }
 
+pub struct CallError;
+
 /// The SRML contracts environment.
 pub struct SrmlEnv<T>
 where
@@ -107,6 +112,8 @@ impl<T> Env for SrmlEnv<T>
 where
     T: EnvTypes,
 {
+    type CallError = CallError;
+
     fn input() -> Vec<u8> {
         read_scratch_buffer()
     }
@@ -153,4 +160,56 @@ where
     fn dispatch_raw_call(data: &[u8]) {
         unsafe { sys::ext_dispatch_call(data.as_ptr() as u32, data.len() as u32) }
     }
+
+    fn call_invoke(
+        callee: <Self as EnvTypes>::AccountId,
+        gas: u64,
+        value: <Self as EnvTypes>::Balance,
+        input_data: &[u8],
+    ) -> Result<(), CallError> {
+        let callee = callee.encode();
+        let value = value.encode();
+        unsafe {
+            let success = 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
+            );
+            if success == 0 {
+                Ok(())
+            } else {
+                Err(CallError{})
+            }
+        }
+    }
+
+    fn call_evaluate<U: Decode>(
+        callee: <Self as EnvTypes>::AccountId,
+        gas: u64,
+        value: <Self as EnvTypes>::Balance,
+        input_data: &[u8],
+    ) -> Result<U, CallError> {
+        let callee = callee.encode();
+        let value = value.encode();
+        unsafe {
+            let success = 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
+            );
+            if success == 0 {
+                Ok(U::decode(&mut &read_scratch_buffer()[..]).unwrap())
+            } else {
+                Err(CallError{})
+            }
+        }
+    }
 }

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

@@ -32,7 +32,6 @@ extern "C" {
     ) -> u32;
 
     /// Calls a remote smart contract.
-    #[allow(unused)]
     pub fn ext_call(
         callee_ptr: u32,
         callee_len: u32,

core/src/env/test_env.rs

@@ -47,6 +47,13 @@ impl EventData {
     }
 }
 
+struct CallData {
+    calee: Vec<u8>,
+    gas: u64,
+    value: Vec<u8>,
+    input_data: Vec<u8>,
+}
+
 /// An entry in the storage of the test environment.
 ///
 /// # Note
@@ -179,6 +186,8 @@ pub struct TestEnvData {
     gas_left: Vec<u8>,
     /// The total transferred value.
     value_transferred: Vec<u8>,
+    /// The calls.
+    calls: Vec<CallData>,
 }
 
 impl Default for TestEnvData {
@@ -200,6 +209,7 @@ impl Default for TestEnvData {
             gas_left: Vec::new(),
             value_transferred: Vec::new(),
             dispatched_calls: Vec::new(),
+            calls: Vec::new(),
         }
     }
 }
@@ -220,6 +230,7 @@ impl TestEnvData {
         self.total_writes = 0;
         self.events.clear();
         self.dispatched_calls.clear();
+        self.calls.clear();
     }
 
     /// Increments the total number of reads from the storage.
@@ -317,6 +328,23 @@ impl TestEnvData {
     pub fn dispatched_calls(&self) -> impl DoubleEndedIterator<Item = &[u8]> {
         self.dispatched_calls.iter().map(Vec::as_slice)
     }
+
+    /// Appends new call to the end of the bytearray.
+    pub fn add_call(
+        &mut self,
+        callee: &[u8],
+        gas: u64,
+        value: &[u8],
+        input_data: &[u8],
+    ) {
+        let new_call = CallData {
+            callee: callee.to_vec(),
+            gas: u64,
+            value: value.to_vec(),
+            input_data: input_data.to_vec(),
+        };
+        self.calls.push(new_call);
+    }
 }
 
 impl TestEnvData {
@@ -417,6 +445,18 @@ impl TestEnvData {
     pub fn dispatch_call(&mut self, call: &[u8]) {
         self.add_dispatched_call(call);
     }
+
+    pub fn call<T: Decode>(
+        &mut self,
+        callee: &[u8],
+        gas: u64,
+        value: &[u8],
+        input_data: &[u8],
+    ) -> Result<T,CallError> {
+        add_call(callee, gas, value, input_data);
+        unimplemented!();
+    }
+
 }
 
 thread_local! {
@@ -567,6 +607,31 @@ where
     fn dispatch_raw_call(data: &[u8]) {
         TEST_ENV_DATA.with(|test_env| test_env.borrow_mut().dispatch_call(data))
     }
+
+    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));
+        return Result<(),CallError{}>;
+    }
+
+    fn call_evaluate<U : Decode>(
+        callee: T::AccountId,
+        gas: u64,
+        value: T::Balance,
+        input_data: &[u8],
+    ) -> Option<U> {
+        let callee = &(callee.encode())[..];
+        let value = &(value.encode())[..];
+        TEST_ENV_DATA
+            .with(|test_env| test_env.borrow_mut().call(callee, gas, value, input_data))
+    }
 }
 
 pub enum TestEnvStorage {}

core/src/env/traits.rs

@@ -18,7 +18,10 @@ use crate::{
     memory::vec::Vec,
     storage::Key,
 };
-use scale::Codec;
+use scale::{
+    Codec,
+    Decode,
+};
 
 #[cfg(not(feature = "test-env"))]
 /// The environmental types usable by contracts defined with ink!.
@@ -85,6 +88,10 @@ pub trait EnvStorage {
 
 /// The environment API usable by contracts defined with pDSL.
 pub trait Env: EnvTypes {
+
+    /// Error type of remote call;
+    type CallError;
+
     /// Returns the chain address of the contract.
     fn address() -> <Self as EnvTypes>::AccountId;
 
@@ -136,4 +143,21 @@ pub trait Env: EnvTypes {
 
     /// Dispatches a call into the Runtime.
     fn dispatch_raw_call(data: &[u8]);
+
+    /// Calls a remote smart contract without returning data
+    fn call_invoke(
+        callee: <Self as EnvTypes>::AccountId,
+        gas: u64,
+        value: <Self as EnvTypes>::Balance,
+        input_data: &[u8]
+    ) -> Result<(), Self::CallError>;
+
+    /// Calls a remote smart contract and return encoded data
+    #[must_use]
+    fn call_evaluate<T: Decode>(
+        callee: <Self as EnvTypes>::AccountId,
+        gas: u64,
+        value: <Self as EnvTypes>::Balance,
+        input_data: &[u8],
+    ) -> Result<T, Self::CallError>;
 }

lang/src/encode_input_data.rs

@@ -0,0 +1,78 @@
+use ink_core::memory::vec::Vec;
+use ink_utils;
+use parity_codec::Encode;
+
+pub trait EncodeSafe{
+    fn encode_safe(&self) -> Vec<u8>;
+}
+
+macro_rules! impl_encode_safe {
+	($( $one:ty ),*) => { $(
+		impl EncodeSafe for $one {
+			fn encode_safe(&self) -> Vec<u8> {
+				parity_codec::Encode::encode(&self)
+			}
+		}
+    )* }
+}
+
+impl_encode_safe!(bool,u16,u32,u64,u128,i8,i16,i32,i64,i128,Vec<u8>);
+
+/// make selector from method name
+#[allow(unused)]
+fn raw_message_selector(name: &str) -> u32 {
+    let keccak = ink_utils::hash::keccak256(name.as_bytes());
+    u32::from_le_bytes([keccak[0], keccak[1], keccak[2], keccak[3]])
+}
+
+/// encode to input_data from Box wrapped params
+#[allow(unused)]
+pub fn gen_input_data(method: &str, params: &[Box<EncodeSafe>]) -> Vec<u8>
+where
+{
+    let selector = raw_message_selector(method);
+    let mut input_data = selector.encode();
+    for param in params.iter() {
+        let mut encoded_param = param.encode_safe();
+        input_data.append(&mut encoded_param);
+    }
+    return input_data.encode()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn message_selectors() {
+        assert_eq!(raw_message_selector("inc"), 257544423);
+        assert_eq!(raw_message_selector("get"), 4266279973);
+        assert_eq!(raw_message_selector("compare"), 363906316);
+    }
+
+    #[test]
+    fn encode(){
+        let var:bool = false;
+        assert_eq!(var.encode(), vec![0]);
+
+        let var:bool = true;
+        assert_eq!(var.encode(), vec![1]);
+
+        let var :u32 = 22;
+        assert_eq!(var.encode(), vec![22,0,0,0]);
+
+        let var :u32 = 257544423;
+        assert_eq!(var.encode(), vec![231, 208, 89, 15]);
+
+        let mut vec1 : Vec<u8> = Vec::new(); vec1.push(11);
+        assert_eq!(vec1.encode(), vec![4,11]);
+    }
+
+    #[test]
+    fn input_data_works(){
+        let mut params : Vec<Box<EncodeSafe>> = Vec::new();
+        params.push(Box::new(true));
+        params.push(Box::new(12u64));
+        assert_eq!(gen_input_data("inc",&params),vec![52, 231, 208, 89, 15, 1, 12, 0, 0, 0, 0, 0, 0, 0]);
+    }
+}

model/src/exec_env.rs

@@ -28,7 +28,10 @@ use ink_core::{
         Initialize,
     },
 };
-use scale::Encode as _;
+use scale::{
+    Encode as _,
+    Decode,
+};
 
 /// Provides a safe interface to an environment given a contract state.
 pub struct ExecutionEnv<State, Env> {
@@ -190,4 +193,27 @@ impl<T: Env> EnvHandler<T> {
     {
         T::dispatch_raw_call(call.into().encode().as_slice())
     }
+
+    /// Calls a remote smart contract without returning data.
+    pub fn call_invoke(
+        &mut self,
+        callee: T::AccountId,
+        gas: u64,
+        value: T::Balance,
+        input_data: &[u8],
+    ) -> Result<(), <T as Env>::CallError> {
+        T::call_invoke(callee, gas, value, input_data)
+    }
+
+    /// Calls a remote smart contract with returning encoded data.
+    #[must_use]
+    pub fn call_evaluate<U:Decode>(
+        &mut self,
+        callee: T::AccountId,
+        gas: u64,
+        value: T::Balance,
+        input_data: &[u8],
+    ) -> Result<U, <T as Env>::CallError>  {
+        T::call_evaluate(callee, gas, value, input_data)
+    }
 }