Enum alloy_dyn_abi::DynSolType

pub enum DynSolType {
    Bool,
    Int(usize),
    Uint(usize),
    FixedBytes(usize),
    Address,
    Function,
    Bytes,
    String,
    Array(Box<DynSolType>),
    FixedArray(Box<DynSolType>, usize),
    Tuple(Vec<DynSolType>),
    CustomStruct {
        name: String,
        prop_names: Vec<String>,
        tuple: Vec<DynSolType>,
    },
}

A dynamic Solidity type.

Equivalent to an enum wrapper around all implementers of SolType.

This is used to represent Solidity types that are not known at compile time. It is used in conjunction with DynToken and DynSolValue to allow for dynamic ABI encoding and decoding.

Examples

Parsing Solidity type strings:

use alloy_dyn_abi::DynSolType;

let type_name = "(bool,address)[]";
let ty = DynSolType::parse(type_name)?;
assert_eq!(
    ty,
    DynSolType::Array(Box::new(DynSolType::Tuple(
        vec![DynSolType::Bool, DynSolType::Address,]
    )))
);
assert_eq!(ty.sol_type_name(), type_name);

// alternatively, you can use the FromStr impl
let ty2 = type_name.parse::<DynSolType>()?;
assert_eq!(ty, ty2);

Decoding dynamic types:

use alloy_dyn_abi::{DynSolType, DynSolValue};
use alloy_primitives::U256;

let my_type = DynSolType::Uint(256);
let my_data: DynSolValue = U256::from(183u64).into();

let encoded = my_data.abi_encode();
let decoded = my_type.abi_decode(&encoded)?;

assert_eq!(decoded, my_data);

let my_type = DynSolType::Array(Box::new(my_type));
let my_data = DynSolValue::Array(vec![my_data.clone()]);

let encoded = my_data.abi_encode();
let decoded = my_type.abi_decode(&encoded)?;

assert_eq!(decoded, my_data);

Variants

Bool

Boolean.

Int(usize)

Signed Integer.

Uint(usize)

Unsigned Integer.

FixedBytes(usize)

Fixed-size bytes, up to 32.

Address

Address.

Function

Function.

Bytes

Dynamic bytes.

String

String.

Array(Box<DynSolType>)

Dynamically sized array.

FixedArray(Box<DynSolType>, usize)

Fixed-sized array.

Tuple(Vec<DynSolType>)

Tuple.

CustomStruct

Available on crate feature eip712 only.

User-defined struct.

Fields

name: String

Name of the struct.

prop_names: Vec<String>

Prop names.

tuple: Vec<DynSolType>

Inner types.

Implementations

impl DynSolType

pub fn arbitrary_value(&self, u: &mut Unstructured<'_>) -> Result<DynSolValue>

Available on crate feature arbitrary only.

Generate an arbitrary DynSolValue from this type.

pub fn value_strategy(&self) -> SBoxedStrategy<DynSolValue>

Available on crate feature arbitrary only.

Create a proptest strategy to generate DynSolValues from this type.

impl DynSolType

pub fn coerce_str(&self, s: &str) -> Result<DynSolValue>

Coerces a string into a DynSolValue via this type.

Syntax

• Bool: true|false
• Int: [+-]?{Uint}
• Uint: {literal}(\.[0-9]+)?(\s*{unit})?
  • literal: base 2, 8, 10, or 16 integer literal. If not in base 10, must be prefixed with 0b, 0o, or 0x respectively.
  • unit: same as Solidity ether units
  • decimals with more digits than the unit’s exponent value are not allowed
• FixedBytes: (0x)?[0-9A-Fa-f]{$0*2}
• Address: (0x)?[0-9A-Fa-f]{40}
• Function: (0x)?[0-9A-Fa-f]{48}
• Bytes: (0x)?[0-9A-Fa-f]+
• String: .*
  • can be surrounded by a pair of " or '
  • trims whitespace if not surrounded
• Array: any number of the inner type delimited by commas (,) and surrounded by brackets ([])
• FixedArray: exactly the given number of the inner type delimited by commas (,) and surrounded by brackets ([])
• Tuple: the inner types delimited by commas (,) and surrounded by parentheses (())
• CustomStruct: the same as Tuple

Examples

use alloy_dyn_abi::{DynSolType, DynSolValue};
use alloy_primitives::U256;

let ty: DynSolType = "(uint256,string)[]".parse()?;
let value = ty.coerce_str("[(0, \"hello\"), (42, \"world\")]")?;
assert_eq!(
    value,
    DynSolValue::Array(vec![
        DynSolValue::Tuple(vec![
            DynSolValue::Uint(U256::from(0), 256),
            DynSolValue::String(String::from("hello"))
        ]),
        DynSolValue::Tuple(vec![
            DynSolValue::Uint(U256::from(42), 256),
            DynSolValue::String(String::from("world"))
        ]),
    ])
);
assert!(value.matches(&ty));
assert_eq!(value.as_type().unwrap(), ty);

impl DynSolType

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

Parses a Solidity type name string into a DynSolType.

Examples

let type_name = "uint256";
let ty = DynSolType::parse(type_name)?;
assert_eq!(ty, DynSolType::Uint(256));
assert_eq!(ty.sol_type_name(), type_name);
assert_eq!(ty.to_string(), type_name);

// alternatively, you can use the FromStr impl
let ty2 = type_name.parse::<DynSolType>()?;
assert_eq!(ty2, ty);

pub fn nesting_depth(&self) -> usize

Calculate the nesting depth of this type. Simple types have a nesting depth of 0, while all other types have a nesting depth of at least 1.

pub fn as_tuple(&self) -> Option<&[Self]>

Fallible cast to the contents of a variant.

pub fn as_custom_struct(&self) -> Option<(&str, &[String], &[Self])>

Fallible cast to the contents of a variant.

pub fn has_custom_struct(&self) -> bool

Returns whether this type is contains a custom struct.

pub fn matches_many(types: &[Self], values: &[DynSolValue]) -> bool

Check that the given DynSolValues match these types.

See matches for more information.

pub fn matches(&self, value: &DynSolValue) -> bool

Check that the given DynSolValue matches this type.

Note: this will not check any names, but just the types; e.g for CustomStruct, when the “eip712” feature is enabled, this will only check equality between the lengths and types of the tuple.

pub fn detokenize(&self, token: DynToken<'_>) -> Result<DynSolValue>

Dynamic detokenization.

pub fn sol_type_name(&self) -> Cow<'static, str>

The Solidity type name. This returns the Solidity type corresponding to this value, if it is known. A type will not be known if the value contains an empty sequence, e.g. T[0].

pub fn to_string(&self) -> String

The Solidity type name, as a String.

Note: this shadows the inherent ToString implementation, derived from fmt::Display, for performance reasons.

pub fn abi_decode(&self, data: &[u8]) -> Result<DynSolValue>

Decode a DynSolValue from a byte slice. Fails if the value does not match this type.

This method is used for decoding single values. It assumes the data argument is an encoded single-element sequence wrapping the self type.

pub fn abi_decode_params(&self, data: &[u8]) -> Result<DynSolValue>

Decode a DynSolValue from a byte slice. Fails if the value does not match this type.

This method is used for decoding function arguments. It tries to determine whether the user intended to decode a sequence or an individual value. If the self type is a tuple, the data will be decoded as a sequence, otherwise it will be decoded as a single value.

Examples

// This function takes a single simple param:
// DynSolType::Uint(256).decode_params(data)
function myFunc(uint256 a) public;

// This function takes 2 params:
// DynSolType::Tuple(vec![DynSolType::Uint(256), DynSolType::Bool])
//     .decode_params(data)
function myFunc(uint256 b, bool c) public;

pub fn abi_decode_sequence(&self, data: &[u8]) -> Result<DynSolValue>

Decode a DynSolValue from a byte slice. Fails if the value does not match this type.

pub fn minimum_words(&self) -> usize

Calculate the minimum number of ABI words necessary to encode this type.

pub fn is_zst(&self) -> bool

Return true if the type is zero-sized, e.g. () or T[0]

impl DynSolType

pub fn coerce_json(&self, value: &Value) -> Result<DynSolValue>

Available on crate feature eip712 only.

Coerce a serde_json::Value to a DynSolValue via this type.

Trait Implementations

impl<'a> Arbitrary<'a> for DynSolType

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl Arbitrary for DynSolType

Available on crate feature arbitrary only.

type Parameters = (u32, u32, u32)

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Recursive<DynSolType, fn(_: BoxedStrategy<DynSolType>) -> TupleUnion<((u32, Arc<BoxedStrategy<DynSolType>>), (u32, Arc<Map<BoxedStrategy<DynSolType>, fn(_: <BoxedStrategy<DynSolType> as Strategy>::Value) -> DynSolType>>), (u32, Arc<Map<(BoxedStrategy<DynSolType>, RangeInclusive<usize>), fn(_: <(BoxedStrategy<DynSolType>, RangeInclusive<usize>) as Strategy>::Value) -> DynSolType>>), (u32, Arc<Map<VecStrategy<BoxedStrategy<DynSolType>>, fn(_: <VecStrategy<BoxedStrategy<DynSolType>> as Strategy>::Value) -> DynSolType>>), (u32, Arc<BoxedStrategy<DynSolType>>))>>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

impl Clone for DynSolType

fn clone(&self) -> DynSolType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DynSolType

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

Formats the value using the given formatter.

impl Display for DynSolType

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

Formats the value using the given formatter.

impl FromStr for DynSolType

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 DynSolType

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 DynSolType

fn eq(&self, other: &DynSolType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ?Sized + Specifier<DynSolType>> Specifier<DynSolType> for &T

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl<T: ?Sized + Specifier<DynSolType>> Specifier<DynSolType> for &mut T

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl<T: ?Sized + Specifier<DynSolType>> Specifier<DynSolType> for Arc<T>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl<T: ?Sized + Specifier<DynSolType>> Specifier<DynSolType> for Box<T>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl<T: ?Sized + ToOwned + Specifier<DynSolType>> Specifier<DynSolType> for Cow<'_, T>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for EventParam

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for Param

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for ParameterSpecifier<'_>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for Parameters<'_>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl<T: ?Sized + Specifier<DynSolType>> Specifier<DynSolType> for Rc<T>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for RootType<'_>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for String

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for TupleSpecifier<'_>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for TypeSpecifier<'_>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for TypeStem<'_>

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Specifier<DynSolType> for str

fn resolve(&self) -> Result<DynSolType>

Resolve the type into a value.

impl Eq for DynSolType

impl StructuralPartialEq for DynSolType