Struct Error 

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

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<Self>

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) -> Selector

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

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a duplicate 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

Formats the value using the given formatter.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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

Converts to this type from the input type.

impl From<Error> for AbiItem<'_>

fn from(item: Error) -> Self

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<Self, Self::Err>

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

impl Hash for Error

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

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 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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

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: 24 bytes