Environment agnostic contract invocation API

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - [Linter] Add links to detailed lint description ‒ [#2170](https://github.com/use-ink/ink/pull/2170)
+-  Environment agnostic contract invocation API ‒ [#219](https://github.com/use-ink/ink/pull/2219)
 
 ### Changed
 - [E2E] Update `subxt` and `polkadot-sdk` dependencies ‒ [#2174](https://github.com/use-ink/ink/pull/2174)

crates/env/src/call/call_builder.rs

@@ -20,6 +20,7 @@ use crate::{
             Set,
             Unset,
         },
+        Execution,
         ExecutionInput,
     },
     types::Gas,
@@ -513,6 +514,27 @@ where
     _phantom: PhantomData<fn() -> E>,
 }
 
+impl<E, Args, RetType> From<Execution<Args, RetType>>
+    for CallBuilder<
+        E,
+        Unset<Call<E>>,
+        Set<ExecutionInput<Args>>,
+        Set<ReturnType<RetType>>,
+    >
+where
+    E: Environment,
+{
+    fn from(invoke: Execution<Args, RetType>) -> Self {
+        CallBuilder {
+            call_type: Default::default(),
+            call_flags: CallFlags::empty(),
+            exec_input: Set(invoke.input),
+            return_type: Set(invoke.output),
+            _phantom: Default::default(),
+        }
+    }
+}
+
 impl<E, CallType, Args, RetType> CallBuilder<E, Unset<CallType>, Args, RetType>
 where
     E: Environment,

crates/env/src/call/execution_input.rs → crates/env/src/call/execution.rs

@@ -12,7 +12,59 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::call::Selector;
+use super::{
+    utils::ReturnType,
+    Selector,
+};
+use crate::Environment;
+
+/// The input data and the expected return type of a contract execution.
+pub struct Execution<Args, Output> {
+    /// The input data for initiating a contract execution.
+    pub input: ExecutionInput<Args>,
+    /// The type of the expected return value of the contract execution.
+    pub output: ReturnType<Output>,
+}
+
+impl<Args, Output> Execution<Args, Output>
+where
+    Args: scale::Encode,
+    Output: scale::Decode,
+{
+    /// Construct a new contract execution with the given input data.
+    pub fn new(input: ExecutionInput<Args>) -> Self {
+        Self {
+            input,
+            output: ReturnType::default(),
+        }
+    }
+
+    /// Perform the execution of the contract with the given executor.
+    pub fn exec<I, E>(
+        self,
+        executor: &I,
+    ) -> Result<ink_primitives::MessageResult<Output>, I::Error>
+    where
+        E: Environment,
+        I: Executor<E>,
+    {
+        executor.exec(&self.input)
+    }
+}
+
+/// Implemented in different environments to perform contract execution.
+pub trait Executor<E: Environment> {
+    /// The type of the error that can be returned during execution.
+    type Error;
+    /// Perform the contract execution with the given input data, and return the result.
+    fn exec<Args, Output>(
+        &self,
+        input: &ExecutionInput<Args>,
+    ) -> Result<ink_primitives::MessageResult<Output>, Self::Error>
+    where
+        Args: scale::Encode,
+        Output: scale::Decode;
+}
 
 /// The input data for a smart contract execution.
 #[derive(Clone, Default, Debug)]

crates/env/src/call/mod.rs

@@ -17,7 +17,7 @@
 mod call_builder;
 mod common;
 mod create_builder;
-mod execution_input;
+mod execution;
 mod selector;
 
 /// Utility types for the cross-contract calling API.
@@ -29,7 +29,7 @@ pub mod utils {
             Unset,
             Unwrap,
         },
-        execution_input::{
+        execution::{
             ArgsList,
             Argument,
             ArgumentList,
@@ -58,6 +58,10 @@ pub use self::{
         LimitParamsV1,
         LimitParamsV2,
     },
-    execution_input::ExecutionInput,
+    execution::{
+        Execution,
+        ExecutionInput,
+        Executor,
+    },
     selector::Selector,
 };

crates/ink/codegen/src/generator/trait_def/call_builder.rs

@@ -59,12 +59,14 @@ impl GenerateCode for CallBuilder<'_> {
         let storage_layout_impl = self.generate_storage_layout_impl();
         let auxiliary_trait_impls = self.generate_auxiliary_trait_impls();
         let to_from_account_id_impls = self.generate_to_from_account_id_impls();
+        let message_builder_trait_impl = self.generate_message_builder_trait_impl();
         let ink_trait_impl = self.generate_ink_trait_impl();
         quote! {
             #struct_definition
             #storage_layout_impl
             #auxiliary_trait_impls
             #to_from_account_id_impls
+            #message_builder_trait_impl
             #ink_trait_impl
         }
     }
@@ -271,6 +273,28 @@ impl CallBuilder<'_> {
         )
     }
 
+    /// Generate the trait implementation for `MessageBuilder` for the ink! trait call
+    /// builder.
+    ///
+    /// # Note
+    ///
+    /// Through the implementation of this trait it is possible to refer to the
+    /// ink! trait messsage builder that is associated to this ink! trait call builder.
+    fn generate_message_builder_trait_impl(&self) -> TokenStream2 {
+        let span = self.trait_def.span();
+        let call_builder_ident = self.ident();
+        let message_builder_ident = self.trait_def.message_builder_ident();
+        quote_spanned!(span=>
+            /// This trait allows to bridge from the call builder to message builder.
+            impl<E> ::ink::codegen::TraitMessageBuilder for #call_builder_ident<E>
+            where
+                E: ::ink::env::Environment
+            {
+                type MessageBuilder = #message_builder_ident<E>;
+            }
+        )
+    }
+
     /// Generates the implementation of the associated ink! trait definition.
     ///
     /// # Note
@@ -310,10 +334,9 @@ impl CallBuilder<'_> {
     /// builder.
     fn generate_ink_trait_impl_messages(&self) -> TokenStream2 {
         let messages = self.trait_def.trait_def.item().iter_items().filter_map(
-            |(item, selector)| {
-                item.filter_map_message().map(|message| {
-                    self.generate_ink_trait_impl_for_message(&message, selector)
-                })
+            |(item, _selector)| {
+                item.filter_map_message()
+                    .map(|message| self.generate_ink_trait_impl_for_message(&message))
             },
         );
         quote! {
@@ -326,9 +349,9 @@ impl CallBuilder<'_> {
     fn generate_ink_trait_impl_for_message(
         &self,
         message: &ir::InkTraitMessage,
-        selector: ir::Selector,
     ) -> TokenStream2 {
         let span = message.span();
+        let trait_ident = self.trait_def.trait_def.item().ident();
         let message_ident = message.ident();
         let attrs = self
             .trait_def
@@ -340,7 +363,6 @@ impl CallBuilder<'_> {
         let output = message.output();
         let output_type =
             output.map_or_else(|| quote! { () }, |output| quote! { #output });
-        let selector_bytes = selector.hex_lits();
         let input_bindings = generator::input_bindings(message.inputs());
         let input_types = generator::input_types(message.inputs());
         let arg_list = generator::generate_argument_list(input_types.iter().cloned());
@@ -362,17 +384,23 @@ impl CallBuilder<'_> {
                 & #mut_tok self
                 #( , #input_bindings : #input_types )*
             ) -> Self::#output_ident {
-                ::ink::env::call::build_call::<Self::Env>()
-                    .call(::ink::ToAccountId::to_account_id(self))
-                    .exec_input(
-                        ::ink::env::call::ExecutionInput::new(
-                            ::ink::env::call::Selector::new([ #( #selector_bytes ),* ])
+                <::ink::env::call::CallBuilder<
+                    Self::Env,
+                    ::ink::env::call::utils::Unset< ::ink::env::call::Call< Self::Env > >,
+                    ::ink::env::call::utils::Set< ::ink::env::call::ExecutionInput<#arg_list> >,
+                    ::ink::env::call::utils::Set< ::ink::env::call::utils::ReturnType<#output_type> >,
+                > as ::core::convert::From::<_>>::from(
+                    <<Self as ::ink::codegen::TraitMessageBuilder>::MessageBuilder as #trait_ident>
+                        ::#message_ident(
+                            & #mut_tok <<Self
+                                as ::ink::codegen::TraitMessageBuilder>::MessageBuilder
+                                as ::core::default::Default>::default()
+                            #(
+                                , #input_bindings
+                            )*
                         )
-                        #(
-                            .push_arg(#input_bindings)
-                        )*
-                    )
-                    .returns::<#output_type>()
+                )
+                    .call(::ink::ToAccountId::to_account_id(self))
             }
         )
     }