Add support for language level errors (LangError)

call-contract.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -ex
+
+F="${1:-pass}"
+CROSS_CONTRACT_ADDR=$2
+FLIPPER_ADDR=$3
+
+SELECTOR="0x633aa551"
+BAD_SELECTOR="0x00000000"
+
+args=()
+args+=( --contract ${CROSS_CONTRACT_ADDR} )
+args+=( --message call )
+args+=( --suri //Alice )
+args+=( --manifest-path ./examples/cross_chain_test/Cargo.toml )
+args+=( --verbose )
+args+=( --skip-confirm )
+
+case $F in
+    '--fail')
+        args+=( --args $FLIPPER_ADDR $BAD_SELECTOR ) ;;
+    *)
+        args+=( --args $FLIPPER_ADDR $SELECTOR ) ;;
+ esac
+
+cargo contract call "${args[@]}"

crates/env/src/engine/on_chain/ext.rs

@@ -28,6 +28,7 @@ macro_rules! define_error_codes {
     ) => {
         /// Every error that can be returned to a contract when it calls any of the host functions.
         #[repr(u32)]
+        #[derive(::core::fmt::Debug)]
         pub enum Error {
             $(
                 $( #[$attr] )*

crates/env/src/engine/on_chain/impls.rs

@@ -425,9 +425,23 @@ impl TypedEnvBackend for EnvInstance {
             output,
         );
         match call_result {
-            Ok(()) | Err(ext::Error::CalleeReverted) => {
-                let decoded = scale::Decode::decode(&mut &output[..])?;
-                Ok(decoded)
+            Ok(()) => {
+                // let decoded = scale::Decode::decode(&mut &output[..])?;
+                // Ok(decoded)
+                if let Ok(decoded) = scale::Decode::decode(&mut &output[..]) {
+                    Ok(decoded)
+                } else {
+                    ::core::panic!("failed to decode successful message output");
+                }
+            }
+            Err(ext::Error::CalleeReverted) => {
+                // let decoded = scale::Decode::decode(&mut &output[..])?;
+                // Ok(decoded)
+                if let Ok(decoded) = scale::Decode::decode(&mut &output[..]) {
+                    Ok(decoded)
+                } else {
+                    ::core::panic!("failed to decode reverted message output");
+                }
             }
             Err(actual_error) => Err(actual_error.into()),
         }

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

@@ -369,10 +369,12 @@ impl CallBuilder<'_> {
         let input_types = generator::input_types(message.inputs());
         let arg_list = generator::generate_argument_list(input_types.iter().cloned());
         let mut_tok = callable.receiver().is_ref_mut().then(|| quote! { mut });
-        let output = message.output();
-        let return_type =
-            output.map_or_else(|| quote! { () }, |output| quote! { #output });
-        let output_span = output.span();
+
+        let return_type = message
+            .wrapped_output()
+            .expect("TODO: Always returns Some atm");
+
+        let output_span = message.output().span();
         let output_type = quote_spanned!(output_span=>
             ::ink::env::call::CallBuilder<
                 Environment,

crates/ink/codegen/src/generator/as_dependency/contract_ref.rs

@@ -343,14 +343,16 @@ impl ContractRef<'_> {
         let mut_token = message.receiver().is_ref_mut().then(|| quote! { mut });
         let input_bindings = message.inputs().map(|input| &input.pat).collect::<Vec<_>>();
         let input_types = message.inputs().map(|input| &input.ty).collect::<Vec<_>>();
-        let output_type = message.output().map(|ty| quote! { -> #ty });
+        let output_type = message
+            .wrapped_output()
+            .expect("TODO: This always returns Some atm");
         quote_spanned!(span=>
             #( #attrs )*
             #[inline]
             pub fn #message_ident(
                 & #mut_token self
                 #( , #input_bindings : #input_types )*
-            ) #output_type {
+            ) -> #output_type {
                 <Self as ::ink::codegen::TraitCallBuilder>::#call_operator(self)
                     .#message_ident( #( #input_bindings ),* )
                     .fire()

crates/ink/codegen/src/generator/dispatch.rs

@@ -301,10 +301,11 @@ impl Dispatch<'_> {
                 let mutates = message.receiver().is_ref_mut();
                 let selector_id = message.composed_selector().into_be_u32().hex_padded_suffixed();
                 let selector_bytes = message.composed_selector().hex_lits();
-                let output_tuple_type = message
-                    .output()
-                    .map(quote::ToTokens::to_token_stream)
-                    .unwrap_or_else(|| quote! { () });
+
+                let output_tuple_type = message.wrapped_output()
+                    .map(|ty| quote::ToTokens::to_token_stream(&ty))
+                    .expect("TODO: Always returns Some atm");
+
                 let input_bindings = generator::input_bindings(message.inputs());
                 let input_tuple_type = generator::input_types_tuple(message.inputs());
                 let input_tuple_bindings = generator::input_bindings_tuple(message.inputs());
@@ -435,16 +436,38 @@ impl Dispatch<'_> {
                         .unwrap_or_else(|error| ::core::panic!("{}", error))
                 }
 
-                ::ink::env::decode_input::<
-                        <#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type>()
-                    .map_err(|_| ::ink::reflect::DispatchError::CouldNotReadInput)
-                    .and_then(|decoder| {
-                        <<#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type
-                            as ::ink::reflect::ExecuteDispatchable>::execute_dispatchable(decoder)
-                    })
-                    .unwrap_or_else(|error| {
-                        ::core::panic!("dispatching ink! message failed: {}", error)
-                    })
+                let dispatchable = match ::ink::env::decode_input::<
+                        <#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type>() {
+                        Ok(decoded_dispatchable) => {
+                            ::ink::env::debug_println!("Result from `decode_input` {:?}", &decoded_dispatchable);
+                            decoded_dispatchable
+                        },
+                        Err(_decoding_error) => {
+                        ::ink::env::debug_println!("Result from `decode_input` {:?}", &_decoding_error);
+
+                        // TODO: Here will pick out the `Dispatch` error we're interested in telling the
+                        // user about and encode it correctly
+                        let error = ::core::result::Result::Err(
+                            ::ink::LangError::CouldNotReadInput
+                        );
+
+                        // At this point we're unable to set the `Ok` variant to be the any "real"
+                        // message output since we were unable to figure out what the caller wanted
+                        // to dispatch in the first place, so we set it to `()`.
+                        //
+                        // This is okay since we're going to only be encoding the `Err` variant
+                        // into the output buffer anyways.
+                        ::ink::env::return_value::<::core::result::Result<(), ::ink::LangError>>(
+                            ::ink::env::ReturnFlags::default().set_reverted(true), &error
+                        );
+                    }
+                };
+
+                <<#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type
+                    as ::ink::reflect::ExecuteDispatchable>::execute_dispatchable(dispatchable)
+                .unwrap_or_else(|error| {
+                    ::core::panic!("dispatching ink! message failed: {}", error)
+                })
             }
         )
     }
@@ -772,19 +795,18 @@ impl Dispatch<'_> {
 
                     push_contract(contract, #mutates_storage);
 
-                    if ::core::any::TypeId::of::<#message_output>() != ::core::any::TypeId::of::<()>() {
-                        // In case the return type is `()` we do not return a value.
-                        ::ink::env::return_value::<#message_output>(
-                            ::ink::env::ReturnFlags::default(), &result
-                        )
-                    }
+                    ::ink::env::return_value::<#message_output>(
+                        ::ink::env::ReturnFlags::default(), &result
+                    )
+
                 }
             )
         });
 
         quote_spanned!(span=>
             const _: () = {
                 #[allow(non_camel_case_types)]
+                #[derive(::core::fmt::Debug)]
                 pub enum __ink_MessageDecoder {
                     #( #message_variants ),*
                 }
@@ -848,8 +870,6 @@ impl Dispatch<'_> {
                         match self {
                             #( #message_execute ),*
                         };
-
-                        ::core::result::Result::Ok(())
                     }
                 }
 

crates/ink/codegen/src/generator/item_impls.rs

@@ -255,15 +255,20 @@ impl ItemImpls<'_> {
         let attrs = message.attrs();
         let vis = message.visibility();
         let receiver = message.receiver();
+        let mut_token = message.receiver().is_ref_mut().then(|| quote! { mut });
         let ident = message.ident();
         let inputs = message.inputs();
-        let output_arrow = message.output().map(|_| quote! { -> });
-        let output = message.output();
+        let output = message
+            .wrapped_output()
+            .map(|ty| quote::ToTokens::to_token_stream(&ty))
+            .expect("This should always be Some atm");
         let statements = message.statements();
         quote_spanned!(span =>
             #( #attrs )*
-            #vis fn #ident(#receiver #( , #inputs )* ) #output_arrow #output {
-                #( #statements )*
+            #vis fn #ident(#receiver #( , #inputs )* ) -> #output {
+                let #mut_token  message_body = || { #( #statements )* };
+                ::core::result::Result::Ok(message_body())
+
             }
         )
     }

crates/ink/codegen/src/generator/metadata.rs

@@ -166,6 +166,7 @@ impl Metadata<'_> {
         fn without_display_name(ty: &syn::Type) -> TokenStream2 {
             quote! { ::ink::metadata::TypeSpec::new::<#ty>() }
         }
+
         if let syn::Type::Path(type_path) = ty {
             if type_path.qself.is_some() {
                 return without_display_name(ty)
@@ -219,7 +220,8 @@ impl Metadata<'_> {
                 let mutates = message.receiver().is_ref_mut();
                 let ident = message.ident();
                 let args = message.inputs().map(Self::generate_dispatch_argument);
-                let ret_ty = Self::generate_return_type(message.output());
+                let ret_ty =
+                    Self::generate_return_type(message.wrapped_output().as_ref());
                 quote_spanned!(span =>
                     ::ink::metadata::MessageSpec::from_label(::core::stringify!(#ident))
                         .selector([

crates/ink/ir/src/ir/item_impl/message.rs

@@ -291,6 +291,25 @@ impl Message {
         }
     }
 
+    // TODO: Maybe get rid of `Option` here, only keeping for initial compatibility
+    pub fn wrapped_output(&self) -> Option<syn::Type> {
+        let return_type = match &self.item.sig.output {
+            syn::ReturnType::Default => None,
+            syn::ReturnType::Type(_, return_type) => Some(return_type),
+        }
+        .map(quote::ToTokens::to_token_stream)
+        .unwrap_or_else(|| quote::quote! { () });
+
+        let wrapped_return = quote::quote! {
+            ::core::result::Result<#return_type, ::ink::LangError>
+        };
+
+        let wrapped_return = syn::parse2::<syn::Type>(wrapped_return)
+            .expect("TODO: Failed to parse into Type");
+
+        Some(wrapped_return)
+    }
+
     /// Returns a local ID unique to the ink! message with respect to its implementation block.
     ///
     /// # Note

crates/ink/src/lib.rs

@@ -71,3 +71,4 @@ pub use ink_macro::{
     test,
     trait_definition,
 };
+pub use ink_primitives::LangError;

crates/ink/src/reflect/dispatch.rs

@@ -515,7 +515,7 @@ pub trait ExecuteDispatchable {
 }
 
 /// An error that can occur during dispatch of ink! dispatchables.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ::scale::Encode, ::scale::Decode)]
 pub enum DispatchError {
     /// Failed to decode into a valid dispatch selector.
     InvalidSelector,

crates/metadata/src/lib.rs

@@ -28,6 +28,8 @@ pub mod layout;
 mod specs;
 mod utils;
 
+pub use ink_primitives::LangError;
+
 pub use self::specs::{
     ConstructorSpec,
     ConstructorSpecBuilder,

crates/metadata/src/specs.rs

@@ -57,6 +57,8 @@ pub struct ContractSpec<F: Form = MetaForm> {
     events: Vec<EventSpec<F>>,
     /// The contract documentation.
     docs: Vec<F::String>,
+    /// The language specific error type.
+    lang_error: F::Type,
 }
 
 impl IntoPortable for ContractSpec {
@@ -80,6 +82,7 @@ impl IntoPortable for ContractSpec {
                 .map(|event| event.into_portable(registry))
                 .collect::<Vec<_>>(),
             docs: registry.map_into_portable(self.docs),
+            lang_error: registry.register_type(&self.lang_error),
         }
     }
 }
@@ -211,6 +214,7 @@ impl ContractSpec {
                 messages: Vec::new(),
                 events: Vec::new(),
                 docs: Vec::new(),
+                lang_error: meta_type::<ink_primitives::LangError>(),
             },
             marker: PhantomData,
         }

crates/primitives/src/lib.rs

@@ -41,3 +41,14 @@ pub use self::{
         Hash,
     },
 };
+
+/// An error that comes from the smart contracting language, but not necessarily the smart contract
+/// itself nor the underlying execution environment.
+#[non_exhaustive]
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ::scale::Encode, ::scale::Decode)]
+#[cfg_attr(feature = "std", derive(::scale_info::TypeInfo))]
+pub enum LangError {
+    /// Failed to read execution input for the dispatchable.
+    CouldNotReadInput = 1u32,
+}

deploy-contract.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -ex
+
+F="${1:-pass}"
+
+cargo contract build --manifest-path examples/flipper/Cargo.toml --skip-linting
+cargo contract instantiate \
+    --manifest-path examples/flipper/Cargo.toml \
+    --suri //Alice --output-json \
+    --constructor default \
+    --salt $(date +%s) \
+    --skip-confirm > /tmp/deployment-output.json
+
+FLIPPER_ADDRESS=$(tail -n +2 /tmp/deployment-output.json | jq --raw-output .contract)
+echo $FLIPPER_ADDRESS
+
+cargo contract build --manifest-path examples/cross_chain_test/Cargo.toml --skip-linting
+cargo contract instantiate \
+     --manifest-path examples/cross_chain_test/Cargo.toml \
+     --suri //Alice --output-json \
+     --salt $(date +%s) \
+     --skip-confirm > /tmp/deployment-output.json
+
+ CROSS_ADDRESS=$(tail -n +2 /tmp/deployment-output.json | jq --raw-output .contract)
+ echo $CROSS_ADDRESS
+
+ ./call-contract.sh $F $CROSS_ADDRESS $FLIPPER_ADDRESS

examples/cross_chain_test/.gitignore

@@ -0,0 +1,9 @@
+# Ignore build artifacts from the local tests sub-crate.
+/target/
+
+# Ignore backup files creates by cargo fmt.
+**/*.rs.bk
+
+# Remove Cargo.lock when creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

examples/cross_chain_test/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "cross_chain_test"
+version = "0.1.0"
+authors = ["[your_name] <[your_email]>"]
+edition = "2021"
+
+[dependencies]
+ink = { path = "../../crates/ink", default-features = false }
+
+scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
+scale-info = { version = "2", default-features = false, features = ["derive"], optional = true }
+
+[lib]
+name = "cross_chain_test"
+path = "lib.rs"
+crate-type = [
+	# Used for normal contract Wasm blobs.
+	"cdylib",
+]
+
+[features]
+default = ["std"]
+std = [
+    "ink/std",
+    "scale/std",
+    "scale-info/std",
+]
+ink-as-dependency = []