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 (@todo update doctest)

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 (@todo update doctest)

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 parse_tokens<'a>(
    &self,
    params: &'a [(ParamType, &str)]
) -> Result<Vec<Token>, 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. TODO: This is currently disabled because it needs to be updated to the new ABI spec. 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 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.

Trait Implementations

impl Default for ABIParser

fn default() -> Self

Returns the “default value” for a type.