Enum DynSolValue

pub enum DynSolValue {
    Bool(bool),
    Int(I256, usize),
    Uint(U256, usize),
    FixedBytes(Word, usize),
    Address(Address),
    Function(Function),
    Bytes(Vec<u8>),
    String(String),
    Array(Vec<DynSolValue>),
    FixedArray(Vec<DynSolValue>),
    Tuple(Vec<DynSolValue>),
    CustomStruct {
        name: String,
        prop_names: Vec<String>,
        tuple: Vec<DynSolValue>,
    },
}

A dynamic Solidity value.

It is broadly similar to serde_json::Value in that it is an enum of possible types, and the user must inspect and disambiguate.

Examples

Basic usage:

use alloy_dyn_abi::{DynSolType, DynSolValue};

let ty: DynSolType = "uint64".parse()?;
let value: DynSolValue = 183u64.into();

let encoded: Vec<u8> = value.abi_encode();
let decoded: DynSolValue = ty.abi_decode(&encoded)?;

assert_eq!(decoded, value);

Coerce a string using DynSolType:

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

let ty: DynSolType = "(string, uint256)".parse()?;
let value = ty.coerce_str("(foo bar, 2.5 gwei)")?;
assert_eq!(
    value,
    DynSolValue::Tuple(vec![
        DynSolValue::String(String::from("foo bar")),
        DynSolValue::Uint(U256::from(2_500_000_000u64), 256)
    ]),
);

Variants

Bool(bool)

A boolean.

Int(I256, usize)

A signed integer. The second parameter is the number of bits, not bytes.

Uint(U256, usize)

An unsigned integer. The second parameter is the number of bits, not bytes.

FixedBytes(Word, usize)

A fixed-length byte array. The second parameter is the number of bytes.

Address(Address)

An address.

Function(Function)

A function pointer.

Bytes(Vec<u8>)

A dynamic-length byte array.

String(String)

A string.

Array(Vec<DynSolValue>)

A dynamically-sized array of values.

FixedArray(Vec<DynSolValue>)

A fixed-size array of values.

Tuple(Vec<DynSolValue>)

A tuple of values.

CustomStruct

A named struct, treated as a tuple with a name parameter.

Fields

name: String

The name of the struct.

prop_names: Vec<String>

The struct’s prop names, in declaration order.

tuple: Vec<DynSolValue>

The inner types.

Implementations

impl DynSolValue

pub fn arbitrary_from_type( ty: &DynSolType, u: &mut Unstructured<'_>, ) -> Result<Self>

Generate an arbitrary DynSolValue from the given DynSolType.

pub fn type_strategy(ty: &DynSolType) -> SBoxedStrategy<Self>

Create a proptest strategy to generate DynSolValues from the given type.

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

Create a proptest strategy to generate DynSolValues from the given value’s type.

impl DynSolValue

pub fn as_type(&self) -> Option<DynSolType>

The Solidity type. 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 sol_type_name(&self) -> Option<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 const fn is_word(&self) -> bool

Trust if this value is encoded as a single word. False otherwise.

pub fn as_word(&self) -> Option<Word>

Fallible cast to a single word. Will succeed for any single-word type.

pub const fn as_address(&self) -> Option<Address>

Fallible cast to the contents of a variant DynSolValue {.

pub const fn as_bool(&self) -> Option<bool>

Fallible cast to the contents of a variant.

pub fn as_bytes(&self) -> Option<&[u8]>

Fallible cast to the contents of a variant.

pub const fn as_fixed_bytes(&self) -> Option<(&[u8], usize)>

Fallible cast to the contents of a variant.

pub const fn as_int(&self) -> Option<(I256, usize)>

Fallible cast to the contents of a variant.

pub const fn as_uint(&self) -> Option<(U256, usize)>

Fallible cast to the contents of a variant.

pub fn as_str(&self) -> Option<&str>

Fallible cast to the contents of a variant.

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

Fallible cast to the contents of a variant.

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

Fallible cast to the contents of a variant.

pub fn as_fixed_array(&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 const fn is_sequence(&self) -> bool

Returns true if the value is a sequence type.

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

Fallible cast to a fixed-size array. Any of a FixedArray, a Tuple, or a CustomStruct.

pub fn as_packed_seq(&self) -> Option<&[u8]>

Fallible cast to a packed sequence. Any of a String, or a Bytes.

pub fn is_dynamic(&self) -> bool

Returns true if the value is an instance of a dynamically sized type.

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

Check that these values have the same type as the given DynSolTypes.

See DynSolType::matches for more information.

pub fn matches(&self, ty: &DynSolType) -> bool

Check that this value has the same type as the given DynSolType.

See DynSolType::matches for more information.

pub fn head_append(&self, enc: &mut Encoder)

Append this data to the head of an in-progress blob via the encoder.

pub fn tail_append(&self, enc: &mut Encoder)

Append this data to the tail of an in-progress blob via the encoder.

pub fn abi_encode_packed(&self) -> Vec<u8>

Non-standard Packed Mode ABI encoding.

Note that invalid value sizes will saturate to the maximum size, e.g. Uint(x, 300) will behave the same as Uint(x, 256).

See SolType::abi_encode_packed for more details.

pub fn abi_encode_packed_to(&self, buf: &mut Vec<u8>)

Non-standard Packed Mode ABI encoding.

See abi_encode_packed for more details.

pub fn abi_packed_encoded_size(&self) -> usize

Returns the length of this value when ABI-encoded in Non-standard Packed Mode.

See abi_encode_packed for more details.

pub fn tokenize(&self) -> DynToken<'_>

Tokenize this value into a DynToken.

pub fn abi_encode(&self) -> Vec<u8>

Encode this value into a byte array by wrapping it into a 1-element sequence.

pub fn abi_encode_params(&self) -> Vec<u8>

Encode this value into a byte array suitable for passing to a function. If this value is a tuple, it is encoded as is. Otherwise, it is wrapped into a 1-element sequence.

Examples

// Encoding for function foo(address)
DynSolValue::Address(_).abi_encode_params();

// Encoding for function foo(address, uint256)
DynSolValue::Tuple(vec![
    DynSolValue::Address(_),
    DynSolValue::Uint(_, 256),
]).abi_encode_params();

pub fn abi_encode_sequence(&self) -> Option<Vec<u8>>

If this value is a fixed sequence, encode it into a byte array. If this value is not a fixed sequence, return None.

Trait Implementations

impl<'a> Arbitrary<'a> for DynSolValue

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.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

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

impl Arbitrary for DynSolValue

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<DynSolValue, fn(BoxedStrategy<DynSolValue>) -> TupleUnion<((u32, Arc<BoxedStrategy<DynSolValue>>), (u32, Arc<Map<Flatten<Map<BoxedStrategy<DynSolValue>, fn(<BoxedStrategy<DynSolValue> as Strategy>::Value) -> VecStrategy<SBoxedStrategy<DynSolValue>>>>, fn(<Flatten<Map<BoxedStrategy<DynSolValue>, fn(<BoxedStrategy<DynSolValue> as Strategy>::Value) -> VecStrategy<SBoxedStrategy<DynSolValue>>>> as Strategy>::Value) -> DynSolValue>>), (u32, Arc<Map<Flatten<Map<BoxedStrategy<DynSolValue>, fn(<BoxedStrategy<DynSolValue> as Strategy>::Value) -> VecStrategy<SBoxedStrategy<DynSolValue>>>>, fn(<Flatten<Map<BoxedStrategy<DynSolValue>, fn(<BoxedStrategy<DynSolValue> as Strategy>::Value) -> VecStrategy<SBoxedStrategy<DynSolValue>>>> as Strategy>::Value) -> DynSolValue>>), (u32, Arc<Map<VecStrategy<BoxedStrategy<DynSolValue>>, fn(<VecStrategy<BoxedStrategy<DynSolValue>> as Strategy>::Value) -> DynSolValue>>), (u32, Arc<BoxedStrategy<DynSolValue>>))>>

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 DynSolValue

fn clone(&self) -> DynSolValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynSolValue

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

Formats the value using the given formatter.

impl<const N: usize> From<[DynSolValue; N]> for DynSolValue

fn from(value: [Self; N]) -> Self

Converts to this type from the input type.

impl From<Address> for DynSolValue

fn from(value: Address) -> Self

Converts to this type from the input type.

impl From<FixedBytes<32>> for DynSolValue

fn from(value: Word) -> Self

Converts to this type from the input type.

impl From<Signed<256, 4>> for DynSolValue

fn from(value: I256) -> Self

Converts to this type from the input type.

impl From<String> for DynSolValue

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Uint<256, 4>> for DynSolValue

fn from(value: U256) -> Self

Converts to this type from the input type.

impl From<Vec<DynSolValue>> for DynSolValue

fn from(value: Vec<Self>) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for DynSolValue

fn from(value: Vec<u8>) -> Self

Converts to this type from the input type.

impl From<bool> for DynSolValue

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<i128> for DynSolValue

fn from(value: i128) -> Self

Converts to this type from the input type.

impl From<i16> for DynSolValue

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for DynSolValue

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for DynSolValue

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for DynSolValue

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<isize> for DynSolValue

fn from(value: isize) -> Self

Converts to this type from the input type.

impl From<u128> for DynSolValue

fn from(value: u128) -> Self

Converts to this type from the input type.

impl From<u16> for DynSolValue

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for DynSolValue

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for DynSolValue

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for DynSolValue

fn from(value: u8) -> Self

Converts to this type from the input type.

impl From<usize> for DynSolValue

fn from(value: usize) -> Self

Converts to this type from the input type.

impl PartialEq for DynSolValue

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