feat: add an optional way to handle contract errors with Result

near-sdk-macros/src/core_impl/code_generator/attr_sig_info.rs

@@ -3,8 +3,8 @@ use proc_macro2::TokenStream as TokenStream2;
 use crate::core_impl::info_extractor::{
     ArgInfo, AttrSigInfo, BindgenArgType, InputStructType, SerializerType,
 };
+use crate::core_impl::utils;
 use quote::quote;
-use syn::{GenericArgument, Path, PathArguments, Type};
 
 impl AttrSigInfo {
     /// Create struct representing input arguments.
@@ -192,7 +192,7 @@ impl AttrSigInfo {
                         }
                     }
                     BindgenArgType::CallbackResultArg => {
-                        let ok_type = if let Some(ok_type) = extract_ok_type(ty) {
+                        let ok_type = if let Some(ok_type) = utils::extract_ok_type(ty) {
                             ok_type
                         } else {
                             return syn::Error::new_spanned(ty, "Function parameters marked with \
@@ -262,38 +262,6 @@ impl AttrSigInfo {
     }
 }
 
-/// Checks whether the given path is literally "Result".
-/// Note that it won't match a fully qualified name `core::result::Result` or a type alias like
-/// `type StringResult = Result<String, String>`.
-fn path_is_result(path: &Path) -> bool {
-    path.leading_colon.is_none()
-        && path.segments.len() == 1
-        && path.segments.iter().next().unwrap().ident == "Result"
-}
-
-/// Extracts the Ok type from a `Result` type.
-///
-/// For example, given `Result<String, u8>` type it will return `String` type.
-fn extract_ok_type(ty: &Type) -> Option<&Type> {
-    match ty {
-        Type::Path(type_path) if type_path.qself.is_none() && path_is_result(&type_path.path) => {
-            // Get the first segment of the path (there should be only one, in fact: "Result"):
-            let type_params = &type_path.path.segments.first()?.arguments;
-            // We are interested in the first angle-bracketed param responsible for Ok type ("<String, _>"):
-            let generic_arg = match type_params {
-                PathArguments::AngleBracketed(params) => Some(params.args.first()?),
-                _ => None,
-            }?;
-            // This argument must be a type:
-            match generic_arg {
-                GenericArgument::Type(ty) => Some(ty),
-                _ => None,
-            }
-        }
-        _ => None,
-    }
-}
-
 pub fn deserialize_data(ty: &SerializerType) -> TokenStream2 {
     match ty {
         SerializerType::JSON => quote! {

near-sdk-macros/src/core_impl/code_generator/impl_item_method_info.rs

@@ -1,6 +1,7 @@
 use crate::core_impl::info_extractor::{
     AttrSigInfo, ImplItemMethodInfo, InputStructType, MethodType, SerializerType,
 };
+use crate::core_impl::utils;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 use syn::{ReturnType, Signature};
@@ -53,6 +54,7 @@ impl ImplItemMethodInfo {
             method_type,
             is_payable,
             is_private,
+            is_returns_result,
             ..
         } = attr_signature_info;
         let deposit_check = if *is_payable || matches!(method_type, &MethodType::View) {
@@ -136,6 +138,30 @@ impl ImplItemMethodInfo {
                     #method_invocation;
                     #contract_ser
                 },
+                ReturnType::Type(_, return_type)
+                    if utils::type_is_result(return_type) && *is_returns_result =>
+                {
+                    let value_ser = match result_serializer {
+                        SerializerType::JSON => quote! {
+                            let result = near_sdk::serde_json::to_vec(&result).expect("Failed to serialize the return value using JSON.");
+                        },
+                        SerializerType::Borsh => quote! {
+                            let result = near_sdk::borsh::BorshSerialize::try_to_vec(&result).expect("Failed to serialize the return value using Borsh.");
+                        },
+                    };
+                    quote! {
+                        #contract_deser
+                        let result = #method_invocation;
+                        match result {
+                            Ok(result) => {
+                                #value_ser
+                                near_sdk::env::value_return(&result);
+                                #contract_ser
+                            }
+                            Err(err) => near_sdk::FunctionError::panic(&err)
+                        }
+                    }
+                }
                 ReturnType::Type(_, _) => {
                     let value_ser = match result_serializer {
                         SerializerType::JSON => quote! {
@@ -146,11 +172,11 @@ impl ImplItemMethodInfo {
                         },
                     };
                     quote! {
-                    #contract_deser
-                    let result = #method_invocation;
-                    #value_ser
-                    near_sdk::env::value_return(&result);
-                    #contract_ser
+                        #contract_deser
+                        let result = #method_invocation;
+                        #value_ser
+                        near_sdk::env::value_return(&result);
+                        #contract_ser
                     }
                 }
             }

near-sdk-macros/src/core_impl/info_extractor/attr_sig_info.rs

@@ -18,6 +18,8 @@ pub struct AttrSigInfo {
     pub is_payable: bool,
     /// Whether method can accept calls from self (current account)
     pub is_private: bool,
+    /// Whether method returns Result type where only Ok type is serialized
+    pub is_returns_result: bool,
     /// The serializer that we use for `env::input()`.
     pub input_serializer: SerializerType,
     /// The serializer that we use for the return type.
@@ -61,6 +63,7 @@ impl AttrSigInfo {
         let mut method_type = MethodType::Regular;
         let mut is_payable = false;
         let mut is_private = false;
+        let mut is_returns_result = false;
         // By the default we serialize the result with JSON.
         let mut result_serializer = SerializerType::JSON;
 
@@ -87,6 +90,9 @@ impl AttrSigInfo {
                     let serializer: SerializerAttr = syn::parse2(attr.tokens.clone())?;
                     result_serializer = serializer.serializer_type;
                 }
+                "return_result" => {
+                    is_returns_result = true;
+                }
                 _ => {
                     non_bindgen_attrs.push((*attr).clone());
                 }
@@ -136,6 +142,7 @@ impl AttrSigInfo {
             method_type,
             is_payable,
             is_private,
+            is_returns_result,
             result_serializer,
             receiver,
             returns,

near-sdk-macros/src/core_impl/mod.rs

@@ -1,6 +1,7 @@
 mod code_generator;
 mod info_extractor;
 mod metadata;
+mod utils;
 pub use code_generator::*;
 pub use info_extractor::*;
 pub use metadata::metadata_visitor::MetadataVisitor;

near-sdk-macros/src/core_impl/utils/mod.rs

@@ -0,0 +1,41 @@
+use syn::{GenericArgument, Path, PathArguments, Type};
+
+/// Checks whether the given path is literally "Result".
+/// Note that it won't match a fully qualified name `core::result::Result` or a type alias like
+/// `type StringResult = Result<String, String>`.
+pub(crate) fn path_is_result(path: &Path) -> bool {
+    path.leading_colon.is_none()
+        && path.segments.len() == 1
+        && path.segments.iter().next().unwrap().ident == "Result"
+}
+
+/// Equivalent to `path_is_result` except that it works on `Type` values.
+pub(crate) fn type_is_result(ty: &Type) -> bool {
+    match ty {
+        Type::Path(type_path) if type_path.qself.is_none() => path_is_result(&type_path.path),
+        _ => false,
+    }
+}
+
+/// Extracts the Ok type from a `Result` type.
+///
+/// For example, given `Result<String, u8>` type it will return `String` type.
+pub(crate) fn extract_ok_type(ty: &Type) -> Option<&Type> {
+    match ty {
+        Type::Path(type_path) if type_path.qself.is_none() && path_is_result(&type_path.path) => {
+            // Get the first segment of the path (there should be only one, in fact: "Result"):
+            let type_params = &type_path.path.segments.first()?.arguments;
+            // We are interested in the first angle-bracketed param responsible for Ok type ("<String, _>"):
+            let generic_arg = match type_params {
+                PathArguments::AngleBracketed(params) => Some(params.args.first()?),
+                _ => None,
+            }?;
+            // This argument must be a type:
+            match generic_arg {
+                GenericArgument::Type(ty) => Some(ty),
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}

near-sdk-macros/src/lib.rs

@@ -184,3 +184,30 @@ pub fn borsh_storage_key(item: TokenStream) -> TokenStream {
         impl near_sdk::BorshIntoStorageKey for #name {}
     })
 }
+
+/// `FunctionError` generates implementation for `near_sdk::FunctionError` trait.
+/// It allows contract runtime to panic with the type using its `ToString` implementation
+/// as the message.
+#[proc_macro_derive(FunctionError)]
+pub fn function_error(item: TokenStream) -> TokenStream {
+    let name = if let Ok(input) = syn::parse::<ItemEnum>(item.clone()) {
+        input.ident
+    } else if let Ok(input) = syn::parse::<ItemStruct>(item) {
+        input.ident
+    } else {
+        return TokenStream::from(
+            syn::Error::new(
+                Span::call_site(),
+                "FunctionError can only be used as a derive on enums or structs.",
+            )
+            .to_compile_error(),
+        );
+    };
+    TokenStream::from(quote! {
+        impl near_sdk::FunctionError for #name {
+            fn panic(&self) {
+                near_sdk::env::panic_str(&std::string::ToString::to_string(&self))
+            }
+        }
+    })
+}

near-sdk/compilation_tests/all.rs

@@ -19,4 +19,5 @@ fn compilation_tests() {
     t.pass("compilation_tests/cond_compilation.rs");
     t.compile_fail("compilation_tests/payable_view.rs");
     t.pass("compilation_tests/borsh_storage_key.rs");
+    t.pass("compilation_tests/function_error.rs");
 }

near-sdk/compilation_tests/function_error.rs

@@ -0,0 +1,50 @@
+//! Testing FunctionError macro.
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use near_sdk::{near_bindgen, FunctionError};
+use std::fmt;
+
+#[derive(FunctionError, BorshSerialize)]
+struct ErrorStruct {
+    message: String,
+}
+
+impl fmt::Display for ErrorStruct {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "error ocurred: {}", self.message)
+    }
+}
+
+#[derive(FunctionError, BorshSerialize)]
+enum ErrorEnum {
+    NotFound,
+    Banned { account_id: String },
+}
+
+impl fmt::Display for ErrorEnum {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ErrorEnum::NotFound => write!(f, "not found"),
+            ErrorEnum::Banned { account_id } => write!(f, "account {} is banned", account_id)
+        }
+    }
+}
+
+#[near_bindgen]
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+struct Contract {}
+
+#[near_bindgen]
+impl Contract {
+    #[return_result]
+    pub fn set(&self, value: String) -> Result<String, ErrorStruct> {
+        Err(ErrorStruct { message: format!("Could not set to {}", value) })
+    }
+
+    #[return_result]
+    pub fn get(&self) -> Result<String, ErrorEnum> {
+        Err(ErrorEnum::NotFound)
+    }
+}
+
+fn main() {}

near-sdk/src/lib.rs

@@ -7,7 +7,7 @@ extern crate quickcheck;
 
 pub use near_sdk_macros::{
     callback, callback_vec, ext_contract, init, metadata, near_bindgen, result_serializer,
-    serializer, BorshStorageKey, PanicOnDefault,
+    serializer, BorshStorageKey, FunctionError, PanicOnDefault,
 };
 
 #[cfg(feature = "unstable")]

near-sdk/src/types/error.rs

@@ -0,0 +1,36 @@
+use std::borrow::Borrow;
+
+/// Enables contract runtime to panic with the given type. Any error type used in conjunction
+/// with `#[return_result]` has to implement this trait.
+///
+/// ```
+/// use near_sdk::FunctionError;
+///
+/// enum Error {
+///     NotFound,
+///     Unexpected { message: String },
+/// }
+///
+/// impl FunctionError for Error {
+///     fn panic(&self) {
+///         match self {
+///             Error::NotFound =>
+///                 near_sdk::env::panic_str("not found"),
+///             Error::Unexpected { message } =>
+///                 near_sdk::env::panic_str(&format!("unexpected error: {}", message))
+///         }
+///     }
+/// }
+/// ```
+pub trait FunctionError {
+    fn panic(&self);
+}
+
+impl<T> FunctionError for T
+where
+    T: Borrow<str>,
+{
+    fn panic(&self) {
+        crate::env::panic_str(self.borrow())
+    }
+}

near-sdk/src/types/mod.rs

@@ -13,6 +13,9 @@ pub use self::account_id::{AccountId, ParseAccountIdError};
 mod gas;
 pub use self::gas::Gas;
 
+mod error;
+pub use self::error::FunctionError;
+
 /// Raw type for duration in nanoseconds
 pub type Duration = u64;