Enum cosmwasm_std::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

Whenever there is no specific error type available

Fields of GenericErr

msg: Stringbacktrace: Option<Backtrace>

InvalidBase64

Fields of InvalidBase64

msg: Stringbacktrace: Option<Backtrace>

InvalidUtf8

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

Fields of InvalidUtf8

msg: Stringbacktrace: Option<Backtrace>

NotFound

Fields of NotFound

kind: Stringbacktrace: Option<Backtrace>

ParseErr

Fields of ParseErr

target: String

the target type that was attempted

msg: Stringbacktrace: Option<Backtrace>

SerializeErr

Fields of SerializeErr

source: String

the source type that was attempted

msg: Stringbacktrace: Option<Backtrace>

Unauthorized

Fields of Unauthorized

backtrace: Option<Backtrace>

Underflow

Fields of Underflow

minuend: Stringsubtrahend: Stringbacktrace: Option<Backtrace>

Implementations

impl StdError

pub fn generic_err<S: Into<String>>(msg: S) -> Self

pub fn invalid_base64<S: ToString>(msg: S) -> Self

pub fn invalid_utf8<S: ToString>(msg: S) -> Self

pub fn not_found<S: Into<String>>(kind: S) -> Self

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

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

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

pub fn unauthorized() -> Self

Trait Implementations

impl Debug for StdError

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::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

Formats the value using the given formatter.

impl Error for StdError where
    Self: Debug + Display, 

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

if let Err(e) = "xc".parse::<u32>() { // Print e itself, no need for description(). eprintln!("Error: {}", e); }

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: &Self) -> 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.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for StdError

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

Serialize this value into the given Serde serializer.