Struct Error

pub struct Error {
    pub name: String,
    pub inputs: Vec<Param>,
}

Available on crate feature json-abi only.

A JSON ABI error.

Fields

name: String

The name of the error.

inputs: Vec<Param>

A list of the error’s components, in order.

Implementations

impl Error

pub fn parse(s: &str) -> Result<Error, Error>

Parses a Solidity error signature string: $(error)? $name($($inputs),*)

If you want to parse a generic Human-Readable ABI string, use AbiItem::parse.

Examples

Basic usage:

assert_eq!(
    Error::parse("foo(bool bar)"),
    Ok(Error { name: "foo".to_string(), inputs: vec![Param::parse("bool bar").unwrap()] }),
);

pub fn signature(&self) -> String

Computes this error’s signature: $name($($inputs),*).

This is the preimage input used to compute the selector.

pub fn selector(&self) -> FixedBytes<4>

Computes this error’s selector: keccak256(self.signature())[..4]

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Error

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ErrorExt for Error

fn decode_error(&self, data: &[u8]) -> Result<DecodedError, Error>

Decode the error from the given data.

impl<'a> From<&'a Error> for AbiItem<'a>

fn from(item: &'a Error) -> AbiItem<'a>

Converts to this type from the input type.

impl From<Error> for AbiItem<'_>

fn from(item: Error) -> AbiItem<'_>

Converts to this type from the input type.

impl FromStr for Error

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Error, <Error as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Error

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonAbiExt for Error

fn abi_encode_input(&self, values: &[DynSolValue]) -> Result<Vec<u8>, Error>

ABI-encodes the given values, prefixed by this item’s selector, if any.

fn abi_encode_input_raw(&self, values: &[DynSolValue]) -> Result<Vec<u8>, Error>

ABI-encodes the given values, without prefixing the data with the item’s selector.

fn abi_decode_input( &self, data: &[u8], validate: bool, ) -> Result<Vec<DynSolValue>, Error>

ABI-decodes the given data according to this item’s input types.

impl PartialEq for Error

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Error

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.

impl Specifier<DynSolError> for Error

fn resolve(&self) -> Result<DynSolError, Error>

Resolve the type into a value.

impl Eq for Error

impl StructuralPartialEq for Error

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes