Struct Event 

pub struct Event {
    pub name: String,
    pub inputs: Vec<EventParam>,
    pub anonymous: bool,
}

A JSON ABI event.

Fields

name: String

The name of the event.

inputs: Vec<EventParam>

A list of the event’s inputs, in order.

anonymous: bool

Whether the event is anonymous. Anonymous events do not have their signature included in the topic 0. Instead, the indexed arguments are 0-indexed.

Implementations

impl Event

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

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

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

Examples

assert_eq!(
    Event::parse("event foo(bool bar, uint indexed baz)"),
    Ok(Event {
        name: "foo".to_string(),
        inputs: vec![
            EventParam::parse("bool bar").unwrap(),
            EventParam::parse("uint indexed baz").unwrap()
        ],
        anonymous: false,
    }),
);

pub fn signature(&self) -> String

Returns this event’s signature: $name($($inputs),*).

This is the preimage input used to compute the selector.

pub fn full_signature(&self) -> String

Returns this event’s full signature event $name($($inputs indexed $names),*).

This is a full human-readable string, including all parameter names, any optional modifiers (e.g. indexed) and white-space to aid in human readability. This is useful for storing a string which can still fully reconstruct the original Fragment

pub fn selector(&self) -> B256

Computes this event’s selector: keccak256(self.signature())

pub fn num_topics(&self) -> usize

Computes the number of this event’s indexed topics.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

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 Event> for AbiItem<'a>

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

Converts to this type from the input type.

impl From<Event> for AbiItem<'_>

fn from(item: Event) -> Self

Converts to this type from the input type.

impl FromStr for Event

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 Event

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 Event

fn eq(&self, other: &Event) -> 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 Event

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 Event

impl StructuralPartialEq for Event

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