Standardize errors

examples/error-handling/.cargo/config.toml

@@ -0,0 +1,5 @@
+[target.wasm32-unknown-unknown]
+rustflags = ["-C", "link-arg=-s"]
+
+[build]
+target-dir = "../../target"

examples/error-handling/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "error-handling"
+version = "0.1.0"
+authors = ["Near Inc <[email protected]>"]
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+near-sdk = { path = "../../near-sdk" }
+
+[dev-dependencies]
+near-workspaces = { version = "0.9.0", default-features = false, features = ["install"] }
+test-case = "2.0"
+tokio = { version = "1.14", features = ["full"] }
+anyhow = "1.0"
+
+[profile.release]
+codegen-units = 1
+# Tell `rustc` to optimize for small code size.
+opt-level = "z"
+lto = true
+debug = false
+panic = "abort"

examples/error-handling/README.md

@@ -0,0 +1,37 @@
+# error-handling
+
+cargo-near-new-project-description
+
+## How to Build Locally?
+
+Install [`cargo-near`](https://github.com/near/cargo-near) and run:
+
+```bash
+cargo near build
+```
+
+## How to Test Locally?
+
+```bash
+cargo test
+```
+
+## How to Deploy?
+
+Deployment is automated with GitHub Actions CI/CD pipeline.
+To deploy manually, install [`cargo-near`](https://github.com/near/cargo-near) and run:
+
+```bash
+cargo near deploy <account-id>
+```
+
+## Useful Links
+
+- [cargo-near](https://github.com/near/cargo-near) - NEAR smart contract development toolkit for Rust
+- [near CLI](https://near.cli.rs) - Iteract with NEAR blockchain from command line
+- [NEAR Rust SDK Documentation](https://docs.near.org/sdk/rust/introduction)
+- [NEAR Documentation](https://docs.near.org)
+- [NEAR StackOverflow](https://stackoverflow.com/questions/tagged/nearprotocol)
+- [NEAR Discord](https://near.chat)
+- [NEAR Telegram Developers Community Group](https://t.me/neardev)
+- NEAR DevHub: [Telegram](https://t.me/neardevhub), [Twitter](https://twitter.com/neardevhub)

examples/error-handling/build.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+TARGET="${CARGO_TARGET_DIR:-../../target}"
+set -e
+cd "$(dirname $0)"
+
+cargo build --all --target wasm32-unknown-unknown --release
+cp $TARGET/wasm32-unknown-unknown/release/error_handling.wasm ./res/

examples/error-handling/src/lib.rs

@@ -0,0 +1,66 @@
+// Find all our documentation at https://docs.near.org
+use near_sdk::borsh::{BorshDeserialize, BorshSerialize};
+use near_sdk::contract_error;
+use near_sdk::near;
+use near_sdk::FunctionError;
+
+#[contract_error]
+enum MyErrorEnum {
+    X,
+}
+
+#[contract_error]
+struct MyErrorStruct {
+    x: u32,
+}
+
+#[near(contract_state)]
+#[derive(Default)]
+pub struct Contract {
+    value: u32,
+}
+
+#[near]
+impl Contract {
+    #[handle_result]
+    pub fn inc_handle_result(&mut self, is_error: bool) -> Result<u32, &'static str> {
+        self.value += 1;
+        if is_error {
+            return Err("error in inc_handle_result");
+        } else {
+            return Ok(self.value);
+        }
+    }
+
+    #[persist_on_error]
+    pub fn inc_persist_on_err(&mut self, is_error: bool) -> Result<u32, MyErrorEnum> {
+        self.value += 1;
+        if is_error {
+            return Err(MyErrorEnum::X);
+        } else {
+            return Ok(self.value);
+        }
+    }
+
+    pub fn inc_just_result(&mut self, is_error: bool) -> Result<u32, MyErrorStruct> {
+        self.value += 1;
+        if is_error {
+            return Err(MyErrorStruct { x: 5 });
+        } else {
+            return Ok(self.value);
+        }
+    }
+
+    pub fn inc_just_simple(&mut self, is_error: bool) -> u32 {
+        self.value += 1;
+        if is_error {
+            ::near_sdk::env::panic_str("Error");
+        } else {
+            return self.value;
+        }
+    }
+
+    pub fn get_value(&self) -> u32 {
+        self.value
+    }
+}

examples/error-handling/tests/test_basics.rs

@@ -0,0 +1,58 @@
+use near_sdk::serde_json;
+use near_workspaces::Contract;
+use serde_json::json;
+use test_case::test_case;
+
+async fn get_value(contract: &Contract) -> anyhow::Result<u64> {
+    let get_value: serde_json::Value =
+        contract.call("get_value").args_json(json!({})).view().await?.json()?;
+
+    println!("get_value: {:?}", get_value);
+
+    get_value.as_u64().ok_or_else(|| anyhow::anyhow!("get_value is not a u64"))
+}
+
+async fn check_call(
+    contract: &Contract,
+    method: &str,
+    is_error: bool,
+    expected_value: u64,
+    expected_error: Option<String>,
+) {
+    let res = contract
+        .call(method)
+        .args_json(json!({ "is_error": is_error }))
+        .max_gas()
+        .transact()
+        .await
+        .unwrap();
+    if is_error {
+        assert!(res.is_failure());
+        if let Some(expected_error) = expected_error {
+            let string_error =
+                format!("{:?}", res.failures()[0].clone().into_result().unwrap_err());
+            assert_eq!(string_error, expected_error);
+        }
+    } else {
+        assert!(res.is_success());
+    }
+    assert_eq!(get_value(&contract).await.unwrap(), expected_value);
+}
+
+#[tokio::test]
+async fn test_factorial() -> anyhow::Result<()> {
+    let worker = near_workspaces::sandbox().await?;
+    let contract =
+        worker.dev_deploy(&std::fs::read(format!("res/{}.wasm", "error_handling"))?).await?;
+
+    check_call(&contract, "inc_handle_result", false, 1, None).await;
+    check_call(&contract, "inc_persist_on_err", false, 2, None).await;
+    check_call(&contract, "inc_just_result", false, 3, None).await;
+    check_call(&contract, "inc_just_simple", false, 4, None).await;
+    check_call(&contract, "inc_handle_result", true, 4, None).await;
+    check_call(&contract, "inc_persist_on_err", true, 5, Some("Error { repr: Custom { kind: Execution, error: ActionError(ActionError { index: Some(0), kind: FunctionCallError(ExecutionError(\"Smart contract panicked: {\\\"error\\\":{\\\"error_type\\\":\\\"error_handling::MyErrorEnum\\\",\\\"value\\\":\\\"X\\\"}}\")) }) } }".to_string())).await;
+    check_call(&contract, "inc_just_result", true, 5, Some("Error { repr: Custom { kind: Execution, error: ActionError(ActionError { index: Some(0), kind: FunctionCallError(ExecutionError(\"Smart contract panicked: {\\\"error\\\":{\\\"error_type\\\":\\\"error_handling::MyErrorStruct\\\",\\\"value\\\":{\\\"x\\\":5}}}\")) }) } }".to_string())).await;
+    check_call(&contract, "inc_just_simple", true, 5, None).await;
+
+    Ok(())
+}

near-sdk-macros/src/core_impl/abi/abi_generator.rs

@@ -204,11 +204,15 @@ impl ImplItemMethodInfo {
         match &self.attr_signature_info.returns.kind {
             Default => quote! { ::std::option::Option::None },
             General(ty) => self.abi_result_tokens_with_return_value(ty),
-            HandlesResult(ty) => {
+            HandlesResultExplicit(ty) => {
                 // extract the `Ok` type from the result
                 let ty = parse_quote! { <#ty as near_sdk::__private::ResultTypeExt>::Okay };
                 self.abi_result_tokens_with_return_value(&ty)
             }
+            HandlesResultImplicit(ty) => {
+                let ty = parse_quote! { <#ty as near_sdk::__private::ResultTypeExt>::Okay };
+                self.abi_result_tokens_with_return_value(&ty)
+            }
         }
     }
 

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

@@ -0,0 +1 @@
+

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

@@ -1,7 +1,10 @@
 use crate::core_impl::info_extractor::{ImplItemMethodInfo, SerializerType};
+use crate::core_impl::utils;
 use crate::core_impl::{MethodKind, ReturnKind};
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
+use serde::de::value;
+use syn::token::Token;
 use syn::Receiver;
 
 impl ImplItemMethodInfo {
@@ -28,7 +31,8 @@ impl ImplItemMethodInfo {
             // here.
             ReturnKind::Default => self.void_return_body_tokens(),
             ReturnKind::General(_) => self.value_return_body_tokens(),
-            ReturnKind::HandlesResult { .. } => self.result_return_body_tokens(),
+            ReturnKind::HandlesResultExplicit { .. } => self.result_return_body_tokens(),
+            ReturnKind::HandlesResultImplicit { .. } => self.result_return_body_tokens(),
         };
 
         quote! {
@@ -84,6 +88,7 @@ impl ImplItemMethodInfo {
         let value_ser = self.value_ser_tokens();
         let value_return = self.value_return_tokens();
         let result_identifier = self.result_identifier();
+        let handle_error = self.error_handling_tokens();
 
         quote! {
             #contract_init
@@ -94,11 +99,39 @@ impl ImplItemMethodInfo {
                     #value_return
                     #contract_ser
                 }
-                ::std::result::Result::Err(err) => ::near_sdk::FunctionError::panic(&err)
+                ::std::result::Result::Err(err) => {
+                    #contract_ser
+                    #handle_error
+                }
             }
         }
     }
 
+    fn error_handling_tokens(&self) -> TokenStream2 {
+        if let ReturnKind::HandlesResultImplicit(status_result) =
+            &self.attr_signature_info.returns.kind
+        {
+            if status_result.persist_on_error {
+                let error_method_name =
+                    quote::format_ident!("{}_error", self.attr_signature_info.ident);
+                quote! {
+                    let promise = Contract::ext(::near_sdk::env::current_account_id()).#error_method_name(err).as_return();
+                }
+            } else {
+                let error_type = utils::get_error_type_from_status(status_result);
+                utils::standardized_error_panic_tokens(&error_type)
+            }
+        } else if let ReturnKind::HandlesResultExplicit { .. } =
+            &self.attr_signature_info.returns.kind
+        {
+            quote! {
+                ::near_sdk::FunctionError::panic(&err)
+            }
+        } else {
+            quote! {}
+        }
+    }
+
     fn panic_hook_tokens(&self) -> TokenStream2 {
         quote! {
             ::near_sdk::env::setup_panic_hook();

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

@@ -1,16 +1,45 @@
 use crate::core_impl::ext::generate_ext_function_wrappers;
+use crate::core_impl::utils;
+use crate::core_impl::ReturnKind;
 use crate::ItemImplInfo;
 use proc_macro2::TokenStream as TokenStream2;
-use quote::ToTokens;
+use quote::{format_ident, quote, ToTokens};
 use syn::{spanned::Spanned, Ident};
 
 impl ItemImplInfo {
     /// Generate the code that wraps
     pub fn wrapper_code(&self) -> TokenStream2 {
         let mut res = TokenStream2::new();
+        let mut checks = quote! {};
         for method in &self.methods {
             res.extend(method.method_wrapper());
+            match method.attr_signature_info.returns.kind {
+                ReturnKind::HandlesResultImplicit { .. } => {
+                    let error_type = match &method.attr_signature_info.returns.original {
+                        syn::ReturnType::Default => quote! { () },
+                        syn::ReturnType::Type(_, ty) => {
+                            let x = utils::extract_error_type(&ty);
+                            quote! { #x }
+                        }
+                    };
+                    let method_name = &method.attr_signature_info.ident;
+                    let concatenated = format_ident!("assert_implements_my_trait{}", method_name);
+
+                    checks.extend(quote! {
+                        fn #concatenated() {
+                            let _ = near_sdk::check_trait as fn(&#error_type);
+                        }
+                    });
+                }
+                _ => {}
+            }
         }
+        let current_type = &self.ty;
+        res.extend(quote! {
+            impl #current_type {
+                #checks
+            }
+        });
         res
     }
 

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

@@ -6,6 +6,8 @@ mod item_trait_info;
 
 mod item_impl_info;
 
+mod error_generation;
+
 pub(crate) mod ext;
 pub(crate) mod metadata;
 

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

@@ -13,7 +13,7 @@ pub fn generate_serializer(
     let struct_decl = attr_sig_info.input_struct_ser();
     let constructor_call = attr_sig_info.constructor_expr_ref();
     let constructor = quote! { let __args = #constructor_call; };
-    let value_ser = match serializer {
+    let value_ser: TokenStream2 = match serializer {
         SerializerType::JSON => quote! {
             ::near_sdk::serde_json::to_vec(&__args).expect("Failed to serialize the cross contract args using JSON.")
         },

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

@@ -135,6 +135,9 @@ impl AttrSigInfo {
                     }
                     visitor.visit_result_serializer_attr(attr, &serializer)?;
                 }
+                "persist_on_error" => {
+                    visitor.visit_persist_on_error_attr(attr)?;
+                }
                 "handle_result" => {
                     if let Some(value) = args.aliased {
                         let handle_result = HandleResultAttr { check: value };

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

@@ -87,7 +87,7 @@ mod tests {
     }
 
     #[test]
-    fn init_result_without_handle_result() {
+    fn init_result_without_w() {
         let impl_type: Type = syn::parse_str("Hello").unwrap();
         let mut method: ImplItemMethod = parse_quote! {
             #[init]

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

@@ -87,5 +87,12 @@ pub struct Returns {
 pub enum ReturnKind {
     Default,
     General(Type),
-    HandlesResult(Type),
+    HandlesResultExplicit(Type),
+    HandlesResultImplicit(StatusResult),
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct StatusResult {
+    pub result_type: Type,
+    pub persist_on_error: bool,
 }