chore: replace expect calls

near-sdk-macros/Cargo.toml

@@ -15,14 +15,14 @@ Main macro of the library for writing NEAR smart contracts.
 proc-macro = true
 
 [dependencies]
-proc-macro2 = { version = "1",  default-features = false }
+proc-macro2 = { version = "1", default-features = false }
 syn = { version = "2", default-features = false }
-strum = { version = "0.26",  default-features = false }
+strum = { version = "0.26", default-features = false }
 strum_macros = "0.26"
-quote = { version = "1.0",  default-features = false }
+quote = { version = "1.0", default-features = false }
 Inflector = { version = "0.11.4", default-features = false, features = [] }
 darling = { version = "0.20.3", default-features = false }
-serde = { version = "1",  default-features = false, features = ["serde_derive"] }
+serde = { version = "1", default-features = false, features = ["serde_derive"] }
 serde_json = "1"
 
 [dev-dependencies]

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

@@ -310,10 +310,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,33 @@ 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"),
     };
-    let mut x: u64 = ::near_sdk::serde_json::from_slice(&data)
-        .expect("Failed to deserialize callback using JSON");
+    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 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"),
     };
-    let z: ::std::vec::Vec<u8> = ::near_sdk::serde_json::from_slice(&data)
-        .expect("Failed to deserialize callback using JSON");
+    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 contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     Hello::method(&contract, &mut x, y, z);
 }
-

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

@@ -15,24 +15,35 @@ pub extern "C" fn method() {
     struct Input {
         y: ::std::string::String,
     }
-    let Input { y }: 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 { y }: 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 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"),
     };
-    let mut x: u64 = ::near_sdk::borsh::BorshDeserialize::try_from_slice(&data)
-        .expect("Failed to deserialize callback using Borsh");
+    let mut x: u64 = match ::near_sdk::borsh::BorshDeserialize::try_from_slice(&data) {
+        Ok(deserialized) => deserialized,
+        Err(_) => {
+            ::near_sdk::env::panic_str("Failed to deserialize callback using Borsh")
+        }
+    };
     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"),
     };
-    let z: ::std::vec::Vec<u8> = ::near_sdk::serde_json::from_slice(&data)
-        .expect("Failed to deserialize callback using JSON");
+    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 contract: Hello = ::near_sdk::env::state_read().unwrap_or_default();
     Hello::method(&contract, &mut x, y, z);
 }
-