Struct Function 

pub struct Function {
    pub name: String,
    pub inputs: Vec<Param>,
    pub outputs: Vec<Param>,
    pub state_mutability: StateMutability,
}

A JSON ABI function.

Fields

name: String

The name of the function.

inputs: Vec<Param>

The input types of the function. May be empty.

outputs: Vec<Param>

The output types of the function. May be empty.

state_mutability: StateMutability

The state mutability of the function.

Implementations

impl Function

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

Parses a Solidity function signature string: $(function)? $name($($inputs),*) [visibility] [s_mutability] $(returns ($($outputs),+))?

Note:

• visibility is ignored

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

Examples

Basic usage:

assert_eq!(
    Function::parse("foo(bool bar)"),
    Ok(Function {
        name: "foo".to_string(),
        inputs: vec![Param::parse("bool bar").unwrap()],
        outputs: vec![],
        state_mutability: StateMutability::NonPayable,
    }),
);

Functions also support parsing output parameters:

assert_eq!(
    Function::parse("function toString(uint number) external view returns (string s)"),
    Ok(Function {
        name: "toString".to_string(),
        inputs: vec![Param::parse("uint number").unwrap()],
        outputs: vec![Param::parse("string s").unwrap()],
        state_mutability: StateMutability::View,
    }),
);

pub fn signature(&self) -> String

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

This is the preimage input used to compute the selector.

pub fn signature_with_outputs(&self) -> String

Returns this function’s full signature: $name($($inputs),*)($(outputs),*).

This is the same as signature, but also includes the output types.

pub fn full_signature(&self) -> String

Returns this function’s full signature including names of params: function $name($($inputs $names),*) state_mutability returns ($($outputs $names),*).

This is a full human-readable string, including all parameter names, any optional modifiers (e.g. view, payable, pure) 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) -> Selector

Computes this error’s selector: keccak256(self.signature())[..4]

Trait Implementations

impl Clone for Function

fn clone(&self) -> Function

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Function

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Function

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

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

Converts to this type from the input type.

impl From<Function> for AbiItem<'_>

fn from(item: Function) -> Self

Converts to this type from the input type.

impl FromStr for Function

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 Function

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 Function

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

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 Function

impl StructuralPartialEq for Function

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