Struct EventParam 

pub struct EventParam {
    pub indexed: bool,
    pub components: Vec<Param>,
    pub internal_type: Option<InternalType>,
    /* private fields */
}

A Solidity Event parameter.

Event parameters are distinct from function parameters in that they have an indexed field.

Fields

indexed: bool

Whether the parameter is indexed. Indexed parameters have their value, or the hash of their value, stored in the log topics.

components: Vec<Param>

If the parameter is a compound type (a struct or tuple), a list of the parameter’s components, in order. Empty otherwise. Because the components are not top-level event params, they will not have an indexed field.

internal_type: Option<InternalType>

The internal type of the parameter. This type represents the type that the author of the Solidity contract specified. E.g. for a contract, this will be contract MyContract while the type field will be address.

Implementations

impl EventParam

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

Parse an event parameter from a Solidity parameter string.

Examples

use alloy_json_abi::EventParam;
assert_eq!(
    EventParam::parse("uint256[] indexed foo"),
    Ok(EventParam {
        name: "foo".into(),
        ty: "uint256[]".into(),
        indexed: true,
        components: vec![],
        internal_type: None,
    })
);

pub fn new( name: &str, ty: &str, indexed: bool, components: Vec<Param>, internal_type: Option<InternalType>, ) -> Result<Self>

Validate and create new instance of EventParam

pub const fn internal_type(&self) -> Option<&InternalType>

The internal type of the parameter.

pub fn is_udt(&self) -> bool

True if the parameter is a UDT (user-defined type).

A UDT will have

• an internal type that does not match its canonical type
• no space in its internal type (as it does not have a keyword body)

Any Other specifier will definitely be a UDT if it contains a contract.

pub const fn is_struct(&self) -> bool

True if the parameter is a struct.

pub const fn is_enum(&self) -> bool

True if the parameter is an enum.

pub const fn is_contract(&self) -> bool

True if the parameter is a contract.

pub fn udt_specifier(&self) -> Option<TypeSpecifier<'_>>

The UDT specifier is a TypeSpecifier containing the UDT name and any array sizes. It is computed from the internal_type. If this param is not a UDT, this function will return None.

pub fn struct_specifier(&self) -> Option<TypeSpecifier<'_>>

The struct specifier is a TypeSpecifier containing the struct name and any array sizes. It is computed from the internal_type If this param is not a struct, this function will return None.

pub fn enum_specifier(&self) -> Option<TypeSpecifier<'_>>

The enum specifier is a TypeSpecifier containing the enum name and any array sizes. It is computed from the internal_type. If this param is not a enum, this function will return None.

pub fn contract_specifier(&self) -> Option<TypeSpecifier<'_>>

The struct specifier is a TypeSpecifier containing the contract name and any array sizes. It is computed from the internal_type If this param is not a struct, this function will return None.

pub fn is_simple_type(&self) -> bool

True if the type is simple

pub fn is_complex_type(&self) -> bool

True if the type is complex (tuple or struct)

pub fn selector_type_raw(&self, s: &mut String)

Formats the canonical type of this parameter into the given string.

This is used to encode the preimage of the event selector.

pub fn full_selector_type_raw(&self, s: &mut String)

Formats the canonical type of this parameter into the given string including then names of the params.

pub fn selector_type(&self) -> Cow<'_, str>

Returns the canonical type of this parameter.

This is used to encode the preimage of the event selector.

Trait Implementations

impl Clone for EventParam

fn clone(&self) -> EventParam

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventParam

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

Formats the value using the given formatter.

impl Default for EventParam

fn default() -> EventParam

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EventParam

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for EventParam

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

Formats the value using the given formatter.

impl FromStr for EventParam

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 EventParam

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 EventParam

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

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for EventParam

impl StructuralPartialEq for EventParam

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