Struct fuels_core::json_abi::ABIParser

pub struct ABIParser { /* private fields */ }

Implementations

impl ABIParser

pub fn new() -> Self

pub fn encode(
    &mut self,
    abi: &str,
    fn_name: &str,
    values: &[String]
) -> Result<String, Error>

Higher-level layer of the ABI encoding module. Encode is essentially a wrapper of crate::abi_encoder, but it is responsible for parsing strings into proper Token that can be encoded by the crate::abi_encoder. Note that encode only encodes the parameters for an ABI call, It won’t include the function selector in it. To get the function selector, use encode_with_function_selector.

Examples

use fuels_core::json_abi::ABIParser;
let json_abi = r#"
    [
        {
            "type":"contract",
            "inputs":[
                {
                    "name":"arg",
                    "type":"u32"
                }
            ],
            "name":"takes_u32_returns_bool",
            "outputs":[
                {
                    "name":"",
                    "type":"bool"
                }
            ]
        }
    ]
    "#;

    let values: Vec<String> = vec!["10".to_string()];

    let mut abi = ABIParser::new();

    let function_name = "takes_u32_returns_bool";
    let encoded = abi.encode(json_abi, function_name, &values).unwrap();
    let expected_encode = "000000000000000a";
    assert_eq!(encoded, expected_encode);

pub fn encode_with_function_selector(
    &mut self,
    abi: &str,
    fn_name: &str,
    values: &[String]
) -> Result<String, Error>

Similar to encode, but includes the function selector in the final encoded string.

Examples

use fuels_core::json_abi::ABIParser;
let json_abi = r#"
    [
        {
            "type":"contract",
            "inputs":[
                {
                    "name":"arg",
                    "type":"u32"
                }
            ],
            "name":"takes_u32_returns_bool",
            "outputs":[
                {
                    "name":"",
                    "type":"bool"
                }
            ]
        }
    ]
    "#;

    let values: Vec<String> = vec!["10".to_string()];

    let mut abi = ABIParser::new();
    let function_name = "takes_u32_returns_bool";

    let encoded = abi
        .encode_with_function_selector(json_abi, function_name, &values)
        .unwrap();

    let expected_encode = "000000006355e6ee000000000000000a";
    assert_eq!(encoded, expected_encode);

pub fn get_encoded_function_selector(&self) -> String

Helper function to return the encoded function selector. It must already be encoded.

pub fn encode_params(&self, params: &[String]) -> Result<String, Error>

Similar to encode, but it encodes only an array of strings containing [<type_1>, <param_1>, <type_2>, <param_2>, <type_n>, <param_n>] Without having to reference to a JSON specification of the ABI.

pub fn parse_tokens<'a>(
    &self,
    params: &'a [(ParamType, &str)]
) -> Result<Vec<Token>, Error>

Helper function to turn a list of tuples(ParamType, &str) into a vector of Tokens ready to be encoded. Essentially a wrapper on tokenize.

pub fn tokenize(&self, param: &ParamType, value: String) -> Result<Token, Error>

Takes a ParamType and a value string and joins them as a single Token that holds the value within it. This Token is used in the encoding process.

pub fn tokenize_struct(
    &self,
    value: &str,
    params: &[ParamType]
) -> Result<Token, Error>

Creates a Token::Struct from an array of parameter types and a string of values. I.e. it takes a string containing values “value_1, value_2, value_3” and an array of ParamType containing the type of each value, in order: [ParamType::, ParamType::, ParamType::] And attempts to return a Token::Struct() containing the inner types. It works for nested/recursive structs.

pub fn tokenize_array<'a>(
    &self,
    value: &'a str,
    param: &ParamType
) -> Result<Token, Error>

Creates a Token::Array from one parameter type and a string of values. I.e. it takes a string containing values “value_1, value_2, value_3” and a ParamType sepecifying the type. It works for nested/recursive arrays.

pub fn tokenize_tuple(
    &self,
    value: &str,
    params: &[ParamType]
) -> Result<Token, Error>

Creates Token::Tuple from an array of parameter types and a string of values. I.e. it takes a string containing values “value_1, value_2, value_3” and an array of ParamType containing the type of each value, in order: [ParamType::, ParamType::, ParamType::] And attempts to return a Token::Tuple() containing the inner types. It works for nested/recursive tuples.

pub fn decode<'a>(
    &self,
    abi: &str,
    fn_name: &str,
    value: &'a [u8]
) -> Result<Vec<Token>, Error>

Higher-level layer of the ABI decoding module. Decodes a value of a given ABI and a target function’s output. Note that the value has to be a byte array, meaning that the caller must properly cast the “upper” type into a &[u8],

pub fn decode_params(
    &self,
    params: &[ParamType],
    data: &[u8]
) -> Result<Vec<Token>, Error>

Similar to decode, but it decodes only an array types and the encoded data without having to reference to a JSON specification of the ABI.

pub fn build_fn_selector(
    &self,
    fn_name: &str,
    params: &[Property]
) -> Result<String, Error>

Builds a string representation of a function selector, i.e: <fn_name>(<type_1>, <type_2>, …, <type_n>)

Trait Implementations

impl Default for ABIParser

fn default() -> Self

Returns the “default value” for a type.