Struct Param

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

JSON specification of a parameter.

Parameters are the inputs and outputs of Functions, and the fields of Errors.

Fields

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

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 Param

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

Parse a parameter from a Solidity parameter string.

Examples

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

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

Validate and create new instance of Param.

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 a function or error 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 a function or error selector.

Trait Implementations

impl Clone for Param

fn clone(&self) -> Param

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Param

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

Formats the value using the given formatter.

impl Default for Param

fn default() -> Param

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Param

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

Deserialize this value from the given Serde deserializer.

impl Display for Param

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

Formats the value using the given formatter.

impl FromStr for Param

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 Param

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 Param

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

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

Serialize this value into the given Serde serializer.

impl Eq for Param

impl StructuralPartialEq for Param