WIP add info trait

crates/env/src/call/invocation.rs

@@ -15,6 +15,17 @@
 use crate::Environment;
 use super::{ExecutionInput, utils::ReturnType};
 
+/// todo: docs
+pub trait InvokableMessage {
+    const SELECTOR: [u8; 4];
+    type Input: codec::Encode;
+    type Args;
+    type Output: codec::Decode;
+
+    /// todo: docs
+    fn exec_input(input: Self::Input) -> ExecutionInput<Self::Args>;
+}
+
 /// todo: create a new generated type a la ContractBuilder which produces an instance of this per message.
 /// `ink::invoke!(Flip)::flip()` // returns Invoke instance
 pub struct Invoke<Args, Output> {

crates/env/src/call/mod.rs

@@ -60,6 +60,6 @@ pub use self::{
         LimitParamsV2,
     },
     execution_input::ExecutionInput,
-    invocation::{Invoke, Invoker},
+    invocation::{InvokableMessage, Invoke, Invoker},
     selector::Selector,
 };

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

@@ -327,12 +327,22 @@ impl TraitRegistry<'_> {
         let local_id = message.local_id();
         let selector_bytes = selector.hex_lits();
         let is_payable = message.ink_attrs().is_payable();
+        let input_types = generator::input_types(message.inputs());
+        let arg_list = generator::generate_argument_list(input_types.iter().cloned());
+        let output_type =
+            message.output().map_or_else(|| quote! { () }, |output| quote! { #output });
         quote_spanned!(span=>
             impl<E> ::ink::reflect::TraitMessageInfo<#local_id> for #trait_info_ident<E> {
                 const PAYABLE: ::core::primitive::bool = #is_payable;
 
                 const SELECTOR: [::core::primitive::u8; 4usize] = [ #( #selector_bytes ),* ];
             }
+
+            impl<E> ::ink::reflect::InvokableMessageInfo<#local_id> for #trait_info_ident<E> {
+                const SELECTOR: [::core::primitive::u8; 4usize] = [ #( #selector_bytes ),* ];
+                type Input: ::ink::env::call::ExecutionInput<#arg_list>;
+                type Output: #output_type;
+            }
         )
     }
 }

crates/ink/src/reflect/invoke.rs

@@ -0,0 +1,20 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// todo: docs
+pub trait InvokableMessageInfo<const ID: u32> {
+    const SELECTOR: [u8; 4];
+    type Input: codec::Encode;
+    type Output: codec::Decode;
+}

crates/ink/src/reflect/mod.rs

@@ -26,6 +26,7 @@
 mod contract;
 mod dispatch;
 mod trait_def;
+mod invoke;
 
 pub use self::{
     contract::ContractName,
@@ -40,6 +41,7 @@ pub use self::{
         DispatchableMessageInfo,
         ExecuteDispatchable,
     },
+    invoke::InvokableMessageInfo,
     trait_def::{
         TraitDefinitionRegistry,
         TraitInfo,

integration-tests/public/runtime-call-contract/sandbox-runtime/pallet-contract-caller/src/lib.rs

@@ -68,6 +68,8 @@ pub mod pallet {
                 marker: Default::default()
             };
 
+            // flipper.flip().invoke(invoker);
+
             let call = call_builder.flip().params();
 
             let invoke = Invoke::<EmptyArgumentList, ()>::new(call.exec_input().clone());
@@ -90,12 +92,14 @@ struct PalletContractsInvoker<E: Environment, Runtime: pallet_contracts::Config>
     marker: core::marker::PhantomData<E>,
 }
 
-impl<E, R> Invoker<E> for PalletContractsInvoker<E, R>
+use ink::reflect::InvokableMessageInfo;
+
+impl<E, R> PalletContractsInvoker<E, R>
 where
     E: Environment,
     R: pallet_contracts::Config,
 {
-    fn invoke<Args, Output>(self, input: &ExecutionInput<Args>) -> Result<ink::MessageResult<Output>, ()>
+    fn invoke<<MessageInfo: >>(self, input: &ExecutionInput<Args>) -> Result<ink::MessageResult<Output>, ()>
     where
         Args: codec::Encode,
         Output: codec::Decode,