Struct alloy_json_abi::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 copy 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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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