New error type. Now with 99% less enum cases

Author: aumetra

packages/check/src/main.rs

@@ -9,7 +9,7 @@ use anyhow::Context;
 use clap::{Arg, ArgAction, Command};
 use colored::Colorize;
 
-use cosmwasm_std::from_json;
+use cosmwasm_std::{from_json, StdResultExt};
 use cosmwasm_vm::internals::{check_wasm, compile, make_compiling_engine, LogOutput, Logger};
 use cosmwasm_vm::{capabilities_from_csv, WasmLimits};
 
@@ -119,11 +119,18 @@ If this is not provided, the default values are used.")
 fn read_wasm_limits(input: &str) -> anyhow::Result<WasmLimits> {
     // try to parse JSON, if that fails, try to open as File and parse that
     from_json::<WasmLimits>(input)
+        .unwrap_std_error()
+        .map_err(anyhow::Error::from_boxed)
         .context("error parsing wasm limits")
         .or_else(|_| {
             std::fs::read_to_string(input)
                 .context("error reading wasm limits file")
-                .and_then(|s| from_json(s).context("error parsing wasm limits file"))
+                .and_then(|s| {
+                    from_json(s)
+                        .unwrap_std_error()
+                        .map_err(anyhow::Error::from_boxed)
+                        .context("error parsing wasm limits file")
+                })
         })
 }
 

packages/check/tests/cosmwasm_check_tests.rs

@@ -1,5 +1,5 @@
 use assert_cmd::prelude::*;
-use cosmwasm_std::{to_json_string, to_json_vec};
+use cosmwasm_std::{to_json_string, to_json_vec, StdResult};
 use cosmwasm_vm::WasmLimits;
 use predicates::prelude::*;
 use std::{io::Write, process::Command};
@@ -116,7 +116,7 @@ fn wasm_limits_string_check() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn wasm_limits_file_check() -> Result<(), Box<dyn std::error::Error>> {
+fn wasm_limits_file_check() -> StdResult<()> {
     let mut cmd = Command::cargo_bin("cosmwasm-check")?;
 
     let mut limits = WasmLimits::default();

packages/std/src/addresses.rs

@@ -299,8 +299,7 @@ impl fmt::Display for Instantiate2AddressError {
 ///     let canonical_creator = deps.api.addr_canonicalize(env.contract.address.as_str())?;
 ///     let checksum = HexBinary::from_hex("9af782a3a1bcbcd22dbb6a45c751551d9af782a3a1bcbcd22dbb6a45c751551d")?;
 ///     let salt = b"instance 1231";
-///     let canonical_addr = instantiate2_address(&checksum, &canonical_creator, salt)
-///         .map_err(|_| StdError::generic_err("Could not calculate addr"))?;
+///     let canonical_addr = instantiate2_address(&checksum, &canonical_creator, salt)?;
 ///     let addr = deps.api.addr_humanize(&canonical_addr)?;
 ///
 /// #   Ok(Default::default())

packages/std/src/assertions.rs

@@ -107,30 +107,30 @@ macro_rules! ensure_ne {
 
 #[cfg(test)]
 mod tests {
-    use crate::StdError;
+    use crate::{errors::ErrorKind, StdError};
 
     #[test]
     fn ensure_works() {
         fn check(a: usize, b: usize) -> Result<(), StdError> {
-            ensure!(a == b, StdError::generic_err("foobar"));
+            ensure!(a == b, StdError::msg("foobar"));
             Ok(())
         }
 
         let err = check(5, 6).unwrap_err();
-        assert!(matches!(err, StdError::GenericErr { .. }));
+        assert!(matches!(err.kind(), ErrorKind::Other));
 
         check(5, 5).unwrap();
     }
 
     #[test]
     fn ensure_can_infer_error_type() {
         let check = |a, b| {
-            ensure!(a == b, StdError::generic_err("foobar"));
+            ensure!(a == b, StdError::msg("foobar"));
             Ok(())
         };
 
-        let err = check(5, 6).unwrap_err();
-        assert!(matches!(err, StdError::GenericErr { .. }));
+        let err: StdError = check(5, 6).unwrap_err();
+        assert!(matches!(err.kind(), ErrorKind::Other));
 
         check(5, 5).unwrap();
     }
@@ -147,7 +147,7 @@ mod tests {
         }
 
         fn check(a: usize, b: usize) -> Result<(), ContractError> {
-            ensure!(a == b, StdError::generic_err("foobar"));
+            ensure!(a == b, StdError::msg("foobar"));
             Ok(())
         }
 
@@ -160,12 +160,12 @@ mod tests {
     #[test]
     fn ensure_eq_works() {
         let check = |a, b| {
-            ensure_eq!(a, b, StdError::generic_err("foobar"));
+            ensure_eq!(a, b, StdError::msg("foobar"));
             Ok(())
         };
 
-        let err = check("123", "456").unwrap_err();
-        assert!(matches!(err, StdError::GenericErr { .. }));
+        let err: StdError = check("123", "456").unwrap_err();
+        assert!(matches!(err.kind(), ErrorKind::Other));
         check("123", "123").unwrap();
     }
 
@@ -176,7 +176,7 @@ mod tests {
 
         #[allow(clippy::nonminimal_bool)]
         fn check() -> Result<(), StdError> {
-            ensure_eq!(true || false, false, StdError::generic_err("foobar"));
+            ensure_eq!(true || false, false, StdError::msg("foobar"));
             Ok(())
         }
 
@@ -186,12 +186,12 @@ mod tests {
     #[test]
     fn ensure_ne_works() {
         let check = |a, b| {
-            ensure_ne!(a, b, StdError::generic_err("foobar"));
+            ensure_ne!(a, b, StdError::msg("foobar"));
             Ok(())
         };
 
-        let err = check("123", "123").unwrap_err();
-        assert!(matches!(err, StdError::GenericErr { .. }));
+        let err: StdError = check("123", "123").unwrap_err();
+        assert!(matches!(err.kind(), ErrorKind::Other));
         check("123", "456").unwrap();
     }
 
@@ -202,7 +202,7 @@ mod tests {
 
         #[allow(clippy::nonminimal_bool)]
         fn check() -> Result<(), StdError> {
-            ensure_ne!(true || false, false, StdError::generic_err("foobar"));
+            ensure_ne!(true || false, false, StdError::msg("foobar"));
             Ok(())
         }
 

packages/std/src/binary.rs

@@ -6,7 +6,7 @@ use serde::{de, ser, Deserialize, Deserializer, Serialize};
 
 use crate::{
     encoding::{from_base64, to_base64},
-    errors::{StdError, StdResult},
+    errors::{ErrorKind, StdError, StdResult},
 };
 
 /// Binary is a wrapper around Vec<u8> to add base64 de/serialization
@@ -62,7 +62,10 @@ impl Binary {
     /// ```
     pub fn to_array<const LENGTH: usize>(&self) -> StdResult<[u8; LENGTH]> {
         if self.len() != LENGTH {
-            return Err(StdError::invalid_data_size(LENGTH, self.len()));
+            return Err(StdError::msg(format_args!(
+                "invalid length. expected {LENGTH}, got {}",
+                self.len()
+            )));
         }
 
         let mut out: [u8; LENGTH] = [0; LENGTH];
@@ -71,7 +74,8 @@ impl Binary {
     }
 
     pub fn from_hex(input: &str) -> StdResult<Self> {
-        let binary = hex::decode(input).map_err(StdError::invalid_hex)?;
+        let binary = hex::decode(input)
+            .map_err(|err| StdError::from(err).with_kind(ErrorKind::InvalidData))?;
         Ok(Self(binary))
     }
 
@@ -280,7 +284,6 @@ impl de::Visitor<'_> for BytesVisitor {
 mod tests {
     use super::*;
     use crate::assert_hash_works;
-    use crate::errors::StdError;
 
     #[test]
     fn to_array_works() {
@@ -297,15 +300,9 @@ mod tests {
         // invalid size
         let binary = Binary::from(&[1, 2, 3]);
         let error = binary.to_array::<8>().unwrap_err();
-        match error {
-            StdError::InvalidDataSize {
-                expected, actual, ..
-            } => {
-                assert_eq!(expected, 8);
-                assert_eq!(actual, 3);
-            }
-            err => panic!("Unexpected error: {err:?}"),
-        }
+        assert!(error
+            .to_string()
+            .ends_with("invalid length. expected 8, got 3"));
 
         // long array (32 bytes)
         let binary = Binary::from_base64("t119JOQox4WUQEmO/nyqOZfO+wjJm91YG2sfn4ZglvA=").unwrap();
@@ -345,8 +342,8 @@ mod tests {
         ] {
             let value = Binary::from(value);
             assert_eq!(encoded, value.to_base64());
-            assert_eq!(Ok(value.clone()), Binary::from_base64(encoded));
-            assert_eq!(Ok(value.clone()), Binary::from_base64(encoded_no_pad));
+            assert_eq!(value.clone(), Binary::from_base64(encoded).unwrap());
+            assert_eq!(value.clone(), Binary::from_base64(encoded_no_pad).unwrap());
         }
     }
 
@@ -356,10 +353,10 @@ mod tests {
             ("cm%uZG9taVo", "Invalid symbol 37, offset 2."),
             ("cmFuZ", "Invalid input length: 5"),
         ] {
-            match Binary::from_base64(invalid_base64) {
-                Err(StdError::InvalidBase64 { msg, .. }) => assert_eq!(want, msg),
-                result => panic!("Unexpected result: {result:?}"),
-            }
+            assert!(Binary::from_base64(invalid_base64)
+                .unwrap_err()
+                .to_string()
+                .ends_with(want));
         }
     }
 

packages/std/src/checksum.rs

@@ -5,6 +5,7 @@ use serde::{de, ser, Deserialize, Deserializer, Serialize};
 use sha2::{Digest, Sha256};
 use thiserror::Error;
 
+use crate::errors::ErrorKind;
 use crate::prelude::*;
 use crate::{StdError, StdResult};
 
@@ -25,7 +26,8 @@ impl Checksum {
     /// Errors if the string contains non-hex characters or does not contain 32 bytes.
     pub fn from_hex(input: &str) -> StdResult<Self> {
         let mut binary = [0u8; 32];
-        hex::decode_to_slice(input, &mut binary).map_err(StdError::invalid_hex)?;
+        hex::decode_to_slice(input, &mut binary)
+            .map_err(|err| StdError::from(err).with_kind(ErrorKind::Parsing))?;
 
         Ok(Self(binary))
     }

packages/std/src/coins.rs

@@ -380,7 +380,7 @@ mod tests {
         assert_eq!(Coins::default().to_string(), "");
         assert_eq!(
             Coins::from_str(invalid).unwrap_err().to_string(),
-            "Generic error: Parsing Coin: Missing amount or non-digit characters in amount"
+            "kind: Other, error: Missing amount or non-digit characters in amount"
         );
     }
 
@@ -452,12 +452,10 @@ mod tests {
         let mut coins: Coins = coin(12345, "uatom").into();
 
         // sub more than available
-        let err = coins.sub(coin(12346, "uatom")).unwrap_err();
-        assert!(matches!(err, StdError::Overflow { .. }));
+        assert!(coins.sub(coin(12346, "uatom")).is_err());
 
         // sub non-existent denom
-        let err = coins.sub(coin(12345, "uusd")).unwrap_err();
-        assert!(matches!(err, StdError::Overflow { .. }));
+        assert!(coins.sub(coin(12345, "uusd")).is_err());
 
         // partial sub
         coins.sub(coin(1, "uatom")).unwrap();

packages/std/src/encoding.rs

@@ -1,7 +1,7 @@
 use alloc::{string::String, vec::Vec};
 use base64::{engine::GeneralPurpose, Engine};
 
-use crate::{StdError, StdResult};
+use crate::StdResult;
 
 /// Base64 encoding engine used in conversion to/from base64.
 ///
@@ -18,7 +18,7 @@ pub fn from_base64<I>(input: I) -> StdResult<Vec<u8>>
 where
     I: AsRef<[u8]>,
 {
-    B64_ENGINE.decode(input).map_err(StdError::invalid_base64)
+    Ok(B64_ENGINE.decode(input)?)
 }
 
 /// Encode a bag of bytes into the Base64 format
@@ -34,7 +34,7 @@ pub fn from_hex<I>(input: I) -> StdResult<Vec<u8>>
 where
     I: AsRef<[u8]>,
 {
-    hex::decode(input).map_err(StdError::invalid_hex)
+    Ok(hex::decode(input)?)
 }
 
 /// Encode a bag of bytes into the hex format

packages/std/src/errors/backtrace.rs

@@ -54,24 +54,6 @@ impl Display for Stub {
     }
 }
 
-/// This macro implements `From` for a given error type to a given error type where
-/// the target error has a `backtrace` field.
-/// This is meant as a replacement for `thiserror`'s `#[from]` attribute, which does not
-/// work with our custom backtrace wrapper.
-macro_rules! impl_from_err {
-    ($from:ty, $to:ty, $map:path) => {
-        impl From<$from> for $to {
-            fn from(err: $from) -> Self {
-                $map {
-                    source: err,
-                    backtrace: $crate::errors::backtrace::BT::capture(),
-                }
-            }
-        }
-    };
-}
-pub(crate) use impl_from_err;
-
 #[cfg(test)]
 mod tests {
     use super::*;

packages/std/src/errors/mod.rs

@@ -4,13 +4,13 @@ mod std_error;
 mod system_error;
 mod verification_error;
 
-pub(crate) use backtrace::{impl_from_err, BT};
+pub(crate) use backtrace::BT;
 pub use recover_pubkey_error::RecoverPubkeyError;
 pub use std_error::{
     CheckedFromRatioError, CheckedMultiplyFractionError, CheckedMultiplyRatioError,
     CoinFromStrError, CoinsError, ConversionOverflowError, DivideByZeroError, DivisionError,
-    OverflowError, OverflowOperation, RoundDownOverflowError, RoundUpOverflowError, StdError,
-    StdResult,
+    ErrorKind, OverflowError, OverflowOperation, RoundDownOverflowError, RoundUpOverflowError,
+    StdError, StdResult, StdResultExt,
 };
 pub use system_error::SystemError;
 pub use verification_error::{AggregationError, PairingEqualityError, VerificationError};