chore: replace expect calls

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

@@ -208,6 +208,13 @@ impl AttrSigInfo {
 
     /// Create code that deserializes arguments that were decorated with `#[callback*]`
     pub fn callback_deserialization(&self) -> TokenStream2 {
+        let error_messages: Vec<proc_macro2::TokenStream> = (0..10)
+            .map(|i| {
+                let msg = format!("Callback computation {} was not successful", i);
+                quote! { #msg }
+            })
+            .collect();
+
         self.args
             .iter()
             .filter(|arg| {
@@ -222,11 +229,13 @@ impl AttrSigInfo {
                 let ArgInfo { mutability, ident, ty, bindgen_ty, serializer_ty, .. } = arg;
                 match &bindgen_ty {
                     BindgenArgType::CallbackArg => {
-                        let error_msg = format!("Callback computation {} was not successful", idx);
                         let read_data = quote! {
                             let data: ::std::vec::Vec<u8> = match ::near_sdk::env::promise_result(#idx) {
                                 ::near_sdk::PromiseResult::Successful(x) => x,
-                                _ => ::near_sdk::env::panic_str(#error_msg)
+                                _ => ::near_sdk::env::panic_str(match #idx {
+                                    #(#idx => #error_messages,)*
+                                    _ => "Callback computation was not successful",
+                                })
                             };
                         };
                         let invocation = deserialize_data(serializer_ty);
@@ -245,16 +254,6 @@ impl AttrSigInfo {
                         };
                         let deserialize = deserialize_data(serializer_ty);
                         let deserialization_branch = match ok_type {
-                            // The unit type in this context is a bit special because functions
-                            // without an explicit return type do not serialize their response.
-                            // But when someone tries to refer to their callback result with
-                            // `#[callback_result]` they specify the callback type as
-                            // `Result<(), PromiseError>` which cannot be correctly deserialized from
-                            // an empty byte array.
-                            //
-                            // So instead of going through serde, we consider deserialization to be
-                            // successful if the byte array is empty or try the normal
-                            // deserialization otherwise.
                             syn::Type::Tuple(type_tuple) if type_tuple.elems.is_empty() =>
                                 quote! {
                                     ::near_sdk::PromiseResult::Successful(data) if data.is_empty() =>
@@ -281,24 +280,34 @@ impl AttrSigInfo {
                 }
             })
     }
-
     /// Create code that deserializes arguments that were decorated with `#[callback_vec]`.
     pub fn callback_vec_deserialization(&self) -> TokenStream2 {
-        self
-            .args
+        self.args
             .iter()
             .filter(|arg| matches!(arg.bindgen_ty, BindgenArgType::CallbackArgVec))
             .fold(TokenStream2::new(), |acc, arg| {
                 let ArgInfo { mutability, ident, ty, .. } = arg;
                 let invocation = deserialize_data(&arg.serializer_ty);
+                // Pre-compute error strings for a reasonable number of callbacks
+                let error_strings: Vec<proc_macro2::TokenStream> = (0..10).map(|i| {
+                    let error_msg = format!("Callback computation {} was not successful", i);
+                    quote! { #error_msg }
+                }).collect();
+
                 quote! {
                     #acc
                     let #mutability #ident: #ty = ::std::iter::Iterator::collect(::std::iter::Iterator::map(
                         0..::near_sdk::env::promise_results_count(),
                         |i| {
                             let data: ::std::vec::Vec<u8> = match ::near_sdk::env::promise_result(i) {
                                 ::near_sdk::PromiseResult::Successful(x) => x,
-                                _ => ::near_sdk::env::panic_str(&::std::format!("Callback computation {} was not successful", i)),
+                                _ => {
+                                    let error_msg = match i {
+                                        #(i => #error_strings,)*
+                                        _ => "Callback computation was not successful",
+                                    };
+                                    ::near_sdk::env::panic_str(error_msg)
+                                },
                             };
                             #invocation
                         }));
@@ -310,10 +319,16 @@ impl AttrSigInfo {
 fn deserialize_data(ty: &SerializerType) -> TokenStream2 {
     match ty {
         SerializerType::JSON => quote! {
-            ::near_sdk::serde_json::from_slice(&data).expect("Failed to deserialize callback using JSON")
+            match ::near_sdk::serde_json::from_slice(&data) {
+                Ok(deserialized) => deserialized,
+                Err(_) => ::near_sdk::env::panic_str("Failed to deserialize callback using JSON"),
+            }
         },
         SerializerType::Borsh => quote! {
-            ::near_sdk::borsh::BorshDeserialize::try_from_slice(&data).expect("Failed to deserialize callback using Borsh")
+            match ::near_sdk::borsh::BorshDeserialize::try_from_slice(&data) {
+                Ok(deserialized) => deserialized,
+                Err(_) => ::near_sdk::env::panic_str("Failed to deserialize callback using Borsh"),
+            }
         },
     }
 }

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

@@ -118,14 +118,22 @@ impl ImplItemMethodInfo {
             let decomposition = self.attr_signature_info.decomposition_pattern();
             let serializer_invocation = match self.attr_signature_info.input_serializer {
                 SerializerType::JSON => quote! {
-                    ::near_sdk::serde_json::from_slice(
-                        &::near_sdk::env::input().expect("Expected input since method has arguments.")
-                    ).expect("Failed to deserialize input from JSON.")
+                    match ::near_sdk::env::input() {
+                        Some(input) => match ::near_sdk::serde_json::from_slice(&input) {
+                            Ok(deserialized) => deserialized,
+                            Err(_) => ::near_sdk::env::panic_str("Failed to deserialize input from JSON.")
+                        },
+                        None => ::near_sdk::env::panic_str("Expected input since method has arguments.")
+                    };
                 },
                 SerializerType::Borsh => quote! {
-                    ::near_sdk::borsh::BorshDeserialize::try_from_slice(
-                        &::near_sdk::env::input().expect("Expected input since method has arguments.")
-                    ).expect("Failed to deserialize input from Borsh.")
+                    match ::near_sdk::env::input() {
+                        Some(input) => match ::near_sdk::borsh::BorshDeserialize::try_from_slice(&input) {
+                            Ok(deserialized) => deserialized,
+                            Err(_) => ::near_sdk::env::panic_str("Failed to deserialize input from Borsh.")
+                        },
+                        None => ::near_sdk::env::panic_str("Expected input since method has arguments.")
+                    };
                 },
             };
             quote! {
@@ -354,10 +362,16 @@ impl ImplItemMethodInfo {
 
         let value_ser = |result_serializer: &SerializerType| match result_serializer {
             SerializerType::JSON => quote! {
-                let result = ::near_sdk::serde_json::to_vec(&result).expect("Failed to serialize the return value using JSON.");
+                let result = match near_sdk::serde_json::to_vec(&result) {
+                    Ok(v) => v,
+                    Err(_) => ::near_sdk::env::panic_str("Failed to serialize the return value using JSON."),
+                };
             },
             SerializerType::Borsh => quote! {
-                let result = ::near_sdk::borsh::to_vec(&result).expect("Failed to serialize the return value using Borsh.");
+                let result = match near_sdk::borsh::to_vec(&result) {
+                    Ok(v) => v,
+                    Err(_) => ::near_sdk::env::panic_str("Failed to serialize the return value using Borsh."),
+                };
             },
         };
 

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

@@ -15,10 +15,16 @@ pub fn generate_serializer(
     let constructor = quote! { let __args = #constructor_call; };
     let value_ser = match serializer {
         SerializerType::JSON => quote! {
-            ::near_sdk::serde_json::to_vec(&__args).expect("Failed to serialize the cross contract args using JSON.")
+            match near_sdk::serde_json::to_vec(&__args) {
+                Ok(serialized) => serialized,
+                Err(_) => ::near_sdk::env::panic_str("Failed to serialize the cross contract args using JSON."),
+            }
         },
         SerializerType::Borsh => quote! {
-            ::near_sdk::borsh::to_vec(&__args).expect("Failed to serialize the cross contract args using Borsh.")
+            match near_sdk::borsh::to_vec(&__args) {
+                Ok(serialized) => serialized,
+                Err(_) => ::near_sdk::env::panic_str("Failed to serialize the cross contract args using Borsh."),
+            }
         },
     };
 

near-sdk-macros/src/core_impl/code_generator/snapshots/arg_mut_ref.snap

@@ -11,12 +11,17 @@ pub extern "C" fn method() {
     struct Input {
         k: u64,
     }
-    let Input { mut k }: Input = ::near_sdk::serde_json::from_slice(
-            &::near_sdk::env::input()
-                .expect("Expected input since method has arguments."),
-        )
-        .expect("Failed to deserialize input from JSON.");
+    let Input { mut k }: Input = match ::near_sdk::env::input() {
+        Some(input) => {
+            match ::near_sdk::serde_json::from_slice(&input) {
+                Ok(deserialized) => deserialized,
+                Err(_) => {
+                    ::near_sdk::env::panic_str("Failed to deserialize input from JSON.")
+                }
+            }
+        }
+        None => ::near_sdk::env::panic_str("Expected input since method has arguments."),
+    };
     let contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     Hello::method(&contract, &mut k);
 }
-

near-sdk-macros/src/core_impl/code_generator/snapshots/arg_no_return_no_mut.snap

@@ -11,12 +11,17 @@ pub extern "C" fn method() {
     struct Input {
         k: u64,
     }
-    let Input { k }: Input = ::near_sdk::serde_json::from_slice(
-            &::near_sdk::env::input()
-                .expect("Expected input since method has arguments."),
-        )
-        .expect("Failed to deserialize input from JSON.");
+    let Input { k }: Input = match ::near_sdk::env::input() {
+        Some(input) => {
+            match ::near_sdk::serde_json::from_slice(&input) {
+                Ok(deserialized) => deserialized,
+                Err(_) => {
+                    ::near_sdk::env::panic_str("Failed to deserialize input from JSON.")
+                }
+            }
+        }
+        None => ::near_sdk::env::panic_str("Expected input since method has arguments."),
+    };
     let contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     Hello::method(&contract, k);
 }
-

near-sdk-macros/src/core_impl/code_generator/snapshots/arg_ref.snap

@@ -11,12 +11,17 @@ pub extern "C" fn method() {
     struct Input {
         k: u64,
     }
-    let Input { k }: Input = ::near_sdk::serde_json::from_slice(
-            &::near_sdk::env::input()
-                .expect("Expected input since method has arguments."),
-        )
-        .expect("Failed to deserialize input from JSON.");
+    let Input { k }: Input = match ::near_sdk::env::input() {
+        Some(input) => {
+            match ::near_sdk::serde_json::from_slice(&input) {
+                Ok(deserialized) => deserialized,
+                Err(_) => {
+                    ::near_sdk::env::panic_str("Failed to deserialize input from JSON.")
+                }
+            }
+        }
+        None => ::near_sdk::env::panic_str("Expected input since method has arguments."),
+    };
     let contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     Hello::method(&contract, &k);
 }
-

near-sdk-macros/src/core_impl/code_generator/snapshots/args_no_return_mut.snap

@@ -15,13 +15,18 @@ pub extern "C" fn method() {
         k: u64,
         m: Bar,
     }
-    let Input { k, m }: Input = ::near_sdk::serde_json::from_slice(
-            &::near_sdk::env::input()
-                .expect("Expected input since method has arguments."),
-        )
-        .expect("Failed to deserialize input from JSON.");
+    let Input { k, m }: Input = match ::near_sdk::env::input() {
+        Some(input) => {
+            match ::near_sdk::serde_json::from_slice(&input) {
+                Ok(deserialized) => deserialized,
+                Err(_) => {
+                    ::near_sdk::env::panic_str("Failed to deserialize input from JSON.")
+                }
+            }
+        }
+        None => ::near_sdk::env::panic_str("Expected input since method has arguments."),
+    };
     let mut contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     Hello::method(&mut contract, k, m);
     ::near_sdk::env::state_write(&contract);
 }
-

near-sdk-macros/src/core_impl/code_generator/snapshots/args_return_mut.snap

@@ -15,16 +15,27 @@ pub extern "C" fn method() {
         k: u64,
         m: Bar,
     }
-    let Input { k, m }: Input = ::near_sdk::serde_json::from_slice(
-            &::near_sdk::env::input()
-                .expect("Expected input since method has arguments."),
-        )
-        .expect("Failed to deserialize input from JSON.");
+    let Input { k, m }: Input = match ::near_sdk::env::input() {
+        Some(input) => {
+            match ::near_sdk::serde_json::from_slice(&input) {
+                Ok(deserialized) => deserialized,
+                Err(_) => {
+                    ::near_sdk::env::panic_str("Failed to deserialize input from JSON.")
+                }
+            }
+        }
+        None => ::near_sdk::env::panic_str("Expected input since method has arguments."),
+    };
     let mut contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     let result = Hello::method(&mut contract, k, m);
-    let result = ::near_sdk::serde_json::to_vec(&result)
-        .expect("Failed to serialize the return value using JSON.");
+    let result = match near_sdk::serde_json::to_vec(&result) {
+        Ok(v) => v,
+        Err(_) => {
+            ::near_sdk::env::panic_str(
+                "Failed to serialize the return value using JSON.",
+            )
+        }
+    };
     ::near_sdk::env::value_return(&result);
     ::near_sdk::env::state_write(&contract);
 }
-

near-sdk-macros/src/core_impl/code_generator/snapshots/args_return_mut_borsh.snap

@@ -15,16 +15,27 @@ pub extern "C" fn method() {
         k: u64,
         m: Bar,
     }
-    let Input { k, m }: Input = ::near_sdk::borsh::BorshDeserialize::try_from_slice(
-            &::near_sdk::env::input()
-                .expect("Expected input since method has arguments."),
-        )
-        .expect("Failed to deserialize input from Borsh.");
+    let Input { k, m }: Input = match ::near_sdk::env::input() {
+        Some(input) => {
+            match ::near_sdk::borsh::BorshDeserialize::try_from_slice(&input) {
+                Ok(deserialized) => deserialized,
+                Err(_) => {
+                    ::near_sdk::env::panic_str("Failed to deserialize input from Borsh.")
+                }
+            }
+        }
+        None => ::near_sdk::env::panic_str("Expected input since method has arguments."),
+    };
     let mut contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     let result = Hello::method(&mut contract, k, m);
-    let result = ::near_sdk::borsh::to_vec(&result)
-        .expect("Failed to serialize the return value using Borsh.");
+    let result = match near_sdk::borsh::to_vec(&result) {
+        Ok(v) => v,
+        Err(_) => {
+            ::near_sdk::env::panic_str(
+                "Failed to serialize the return value using Borsh.",
+            )
+        }
+    };
     ::near_sdk::env::value_return(&result);
     ::near_sdk::env::state_write(&contract);
 }
-

near-sdk-macros/src/core_impl/code_generator/snapshots/args_return_ref.snap

@@ -8,8 +8,13 @@ pub extern "C" fn method() {
     ::near_sdk::env::setup_panic_hook();
     let contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     let result = Hello::method(&contract);
-    let result = ::near_sdk::serde_json::to_vec(&result)
-        .expect("Failed to serialize the return value using JSON.");
+    let result = match near_sdk::serde_json::to_vec(&result) {
+        Ok(v) => v,
+        Err(_) => {
+            ::near_sdk::env::panic_str(
+                "Failed to serialize the return value using JSON.",
+            )
+        }
+    };
     ::near_sdk::env::value_return(&result);
 }
-