Enum fadroma::prelude::StdError

#[non_exhaustive]
pub enum StdError {
    GenericErr {
        msg: String,
        backtrace: Option<Backtrace>,
    },
    InvalidBase64 {
        msg: String,
        backtrace: Option<Backtrace>,
    },
    InvalidUtf8 {
        msg: String,
        backtrace: Option<Backtrace>,
    },
    NotFound {
        kind: String,
        backtrace: Option<Backtrace>,
    },
    ParseErr {
        target: String,
        msg: String,
        backtrace: Option<Backtrace>,
    },
    SerializeErr {
        source: String,
        msg: String,
        backtrace: Option<Backtrace>,
    },
    Unauthorized {
        backtrace: Option<Backtrace>,
    },
    Underflow {
        minuend: String,
        subtrahend: String,
        backtrace: Option<Backtrace>,
    },
}

Structured error type for init, handle and query.

This can be serialized and passed over the Wasm/VM boundary, which allows us to use structured error types in e.g. integration tests. In that process backtraces are stripped off.

The prefix “Std” means “the standard error within the standard library”. This is not the only result/error type in cosmwasm-std.

When new cases are added, they should describe the problem rather than what was attempted (e.g. InvalidBase64 is preferred over Base64DecodingErr). In the long run this allows us to get rid of the duplication in “StdError::FooErr”.

Checklist for adding a new error:

• Add enum case
• Add to PartialEq implementation
• Add serialize/deserialize test
• Add creator function in std_error_helpers.rs
• Regenerate schemas

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

GenericErr

Fields

msg: String

backtrace: Option<Backtrace>

Whenever there is no specific error type available

InvalidBase64

Fields

msg: String

backtrace: Option<Backtrace>

InvalidUtf8

Fields

msg: String

backtrace: Option<Backtrace>

Whenever UTF-8 bytes cannot be decoded into a unicode string, e.g. in String::from_utf8 or str::from_utf8.

NotFound

Fields

kind: String

backtrace: Option<Backtrace>

ParseErr

Fields

target: String

the target type that was attempted

msg: String

backtrace: Option<Backtrace>

SerializeErr

Fields

source: String

the source type that was attempted

msg: String

backtrace: Option<Backtrace>

Unauthorized

Fields

backtrace: Option<Backtrace>

Underflow

Fields

minuend: String

subtrahend: String

backtrace: Option<Backtrace>

Implementations

impl StdError

pub fn generic_err<S>(msg: S) -> StdError where
    S: Into<String>, 

pub fn invalid_base64<S>(msg: S) -> StdError where
    S: ToString, 

pub fn invalid_utf8<S>(msg: S) -> StdError where
    S: ToString, 

pub fn not_found<S>(kind: S) -> StdError where
    S: Into<String>, 

pub fn parse_err<T, M>(target: T, msg: M) -> StdError where
    T: Into<String>,
    M: ToString, 

pub fn serialize_err<S, M>(source: S, msg: M) -> StdError where
    S: Into<String>,
    M: ToString, 

pub fn underflow<U>(minuend: U, subtrahend: U) -> StdError where
    U: ToString, 

pub fn unauthorized() -> StdError

Trait Implementations

impl Debug for StdError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StdError

fn deserialize<__D>(
    __deserializer: __D
) -> Result<StdError, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for StdError

fn fmt(
    &self,
    __snafu_display_formatter: &mut Formatter<'_>
) -> Result<(), Error>

Formats the value using the given formatter.

impl Error for StdError where
    StdError: Debug,
    StdError: Display, 

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

impl ErrorCompat for StdError

fn backtrace(&self) -> Option<&Backtrace>

Returns a Backtrace that may be printed.

impl JsonSchema for StdError

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq<StdError> for StdError

fn eq(&self, other: &StdError) -> bool

Two errors are considered equal if and only if their payloads (i.e. all fields other than backtrace) are equal.

The origin of the error (expressed by its backtrace) is ignored, which allows equality checks on errors and results in tests. This is a property that might not always be desired depending on the use case and something you should be aware of.

Note: We destruct the unused backtrace as _ to avoid the use of .. which silently ignores newly added fields.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for StdError

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.