Struct Function

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

Available on crate feature json-abi only.

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

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

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

Trait Implementations

impl Clone for Function

fn clone(&self) -> Function

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

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Function, <__D as Deserializer<'de>>::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) -> AbiItem<'a>

Converts to this type from the input type.

impl From<Function> for AbiItem<'_>

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

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

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

impl FunctionExt for Function

fn abi_encode_output(&self, values: &[DynSolValue]) -> Result<Vec<u8>, Error>

ABI-encodes the given values.

fn abi_decode_output( &self, data: &[u8], validate: bool, ) -> Result<Vec<DynSolValue>, Error>

ABI-decodes the given data according to this functions’s output types.

impl Hash for Function

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 JsonAbiExt for Function

fn abi_encode_input(&self, values: &[DynSolValue]) -> Result<Vec<u8>, Error>

ABI-encodes the given values, prefixed by this item’s selector, if any.

fn abi_encode_input_raw(&self, values: &[DynSolValue]) -> Result<Vec<u8>, Error>

ABI-encodes the given values, without prefixing the data with the item’s selector.

fn abi_decode_input( &self, data: &[u8], validate: bool, ) -> Result<Vec<DynSolValue>, Error>

ABI-decodes the given data according to this item’s input types.

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Specifier<DynSolCall> for Function

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

Resolve the type into a value.

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