chore: replace expect calls

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

@@ -222,11 +222,12 @@ 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(concat!("Callback computation ", stringify!(i), " was not successful")),
+
                             };
                         };
                         let invocation = deserialize_data(serializer_ty);
@@ -298,7 +299,7 @@ impl AttrSigInfo {
                         |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)),
+                                _ =>  ::near_sdk::env::panic_str(concat!("Callback computation ", stringify!(i), " was not successful")),
                             };
                             #invocation
                         }));
@@ -310,10 +311,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);
 }
-

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

@@ -15,24 +15,41 @@ pub extern "C" fn method() {
     struct Input {
         y: ::std::string::String,
     }
-    let Input { y }: 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 { y }: 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 data: ::std::vec::Vec<u8> = match ::near_sdk::env::promise_result(0u64) {
         ::near_sdk::PromiseResult::Successful(x) => x,
-        _ => ::near_sdk::env::panic_str("Callback computation 0 was not successful"),
+        _ => {
+            ::near_sdk::env::panic_str(
+                concat!("Callback computation ", stringify!(i), " was not successful"),
+            )
+        }
+    };
+    let mut x: u64 = match ::near_sdk::serde_json::from_slice(&data) {
+        Ok(deserialized) => deserialized,
+        Err(_) => ::near_sdk::env::panic_str("Failed to deserialize callback using JSON"),
     };
-    let mut x: u64 = ::near_sdk::serde_json::from_slice(&data)
-        .expect("Failed to deserialize callback using JSON");
     let data: ::std::vec::Vec<u8> = match ::near_sdk::env::promise_result(1u64) {
         ::near_sdk::PromiseResult::Successful(x) => x,
-        _ => ::near_sdk::env::panic_str("Callback computation 1 was not successful"),
+        _ => {
+            ::near_sdk::env::panic_str(
+                concat!("Callback computation ", stringify!(i), " was not successful"),
+            )
+        }
+    };
+    let z: ::std::vec::Vec<u8> = match ::near_sdk::serde_json::from_slice(&data) {
+        Ok(deserialized) => deserialized,
+        Err(_) => ::near_sdk::env::panic_str("Failed to deserialize callback using JSON"),
     };
-    let z: ::std::vec::Vec<u8> = ::near_sdk::serde_json::from_slice(&data)
-        .expect("Failed to deserialize callback using JSON");
     let contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     Hello::method(&contract, &mut x, y, z);
 }
-