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

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> {
@@ -107,6 +110,7 @@ impl<T> Env for SrmlEnv<T>
 where
     T: EnvTypes,
 {
+
     fn input() -> Vec<u8> {
         read_scratch_buffer()
     }
@@ -153,4 +157,51 @@ 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],
+    ) {
+        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_evaluate<U: Decode>(
+        callee: <Self as EnvTypes>::AccountId,
+        gas: u64,
+        value: <Self as EnvTypes>::Balance,
+        input_data: &[u8],
+    ) -> Option<U> {
+        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 {
+                Some(U::decode(&mut &read_scratch_buffer()[..]).unwrap())
+            } else {
+                None
+            }
+        }
+    }
 }

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

@@ -414,8 +414,20 @@ impl TestEnvData {
         self.add_event(topics, data);
     }
 
+<<<<<<< HEAD
     pub fn dispatch_call(&mut self, call: &[u8]) {
         self.add_dispatched_call(call);
+=======
+    #[allow(unused_variables)]
+    pub fn call<T: Decode>(
+        &mut self,
+        callee: &[u8],
+        gas: u64,
+        value: &[u8],
+        input_data: &[u8],
+    ) -> Option<T> {
+        unimplemented!();
+>>>>>>> import ext_call to trait and add function to generate input_data of ext_call
     }
 }
 
@@ -564,8 +576,33 @@ where
         })
     }
 
+<<<<<<< HEAD
     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));
+    }
+
+    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))
+>>>>>>> import ext_call to trait and add function to generate input_data of ext_call
     }
 }
 

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!.
@@ -136,4 +139,21 @@ pub trait Env: EnvTypes {
 
     /// Dispatches a call into the Runtime.
     fn dispatch_raw_call(data: &[u8]);
+
+    /// 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<T>;
 }

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,26 @@ impl<T: Env> EnvHandler<T> {
     {
         T::dispatch_raw_call(call.into().encode().as_slice())
     }
+
+    /// 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_evaluate<U:Decode>(
+        &self,
+        callee: T::AccountId,
+        gas: u64,
+        value: T::Balance,
+        input_data: &[u8],
+    ) -> Option<U> {
+        T::call_evaluate(callee, gas, value, input_data)
+    }
 }