Struct Event

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

Available on crate feature json-abi only.

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<Event, Error>

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) -> FixedBytes<32>

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 copy 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<(), Error>

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventExt for Event

fn decode_log_parts<I>( &self, topics: I, data: &[u8], validate: bool, ) -> Result<DecodedEvent, Error>

where I: IntoIterator<Item = FixedBytes<32>>,

Decodes the given log info according to this item’s input types.

fn decode_log( &self, log: &LogData, validate: bool, ) -> Result<DecodedEvent, Error>

Decodes the given log object according to this item’s input types.

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

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

Converts to this type from the input type.

impl From<Event> for AbiItem<'_>

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

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<Event, <Event as FromStr>::Err>

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

impl Hash for Event

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Specifier<DynSolEvent> for Event

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

Resolve the type into a value.

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