Struct Resolver

pub struct Resolver { /* private fields */ }

A dependency graph built from the Eip712Types object. This is used to safely resolve JSON into a crate::DynSolType by detecting cycles in the type graph and traversing the dep graph.

Implementations

impl Resolver

pub fn from_struct<S: SolStruct>() -> Self

Instantiate a new resolver from a SolStruct type.

pub fn ingest_string(&mut self, s: impl AsRef<str>) -> Result<()>

Ingest types from an EIP-712 encodeType.

pub fn ingest_sol_struct<S: SolStruct>(&mut self)

Ingest a sol struct typedef.

pub fn ingest(&mut self, type_def: TypeDef)

Ingest a type.

pub fn ingest_types(&mut self, types: &Eip712Types)

Ingest a Types object into the resolver, discarding any invalid types.

pub fn linearize(&self, type_name: &str) -> Result<Vec<&TypeDef>>

This function linearizes a type into a list of typedefs of its dependencies.

pub fn resolve(&self, type_name: &str) -> Result<DynSolType>

Resolve a typename into a crate::DynSolType or return an error if the type is missing, or contains a circular dependency.

pub fn encode_type(&self, name: &str) -> Result<String>

Encode the type into an EIP-712 encodeType string

https://eips.ethereum.org/EIPS/eip-712#definition-of-encodetype

pub fn type_hash(&self, name: &str) -> Result<B256>

Compute the keccak256 hash of the EIP-712 encodeType string.

pub fn encode_data(&self, value: &DynSolValue) -> Result<Option<Vec<u8>>>

Encode the data according to EIP-712 encodeData rules.

pub fn eip712_data_word(&self, value: &DynSolValue) -> Result<B256>

Encode the data as a struct property according to EIP-712 encodeData rules. Atomic types are encoded as-is, while non-atomic types are encoded as their encodeData hash.

pub fn contains_type_name(&self, name: &str) -> bool

Check if the resolver graph contains a type by its name.

Warning

This checks by NAME only. It does NOT check for type

pub fn non_dependent_types(&self) -> impl Iterator<Item = &TypeDef>

Returns those types which do not depend on any other nodes in the resolver graph.

Trait Implementations

impl Clone for Resolver

fn clone(&self) -> Resolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Resolver

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

Formats the value using the given formatter.

impl Default for Resolver

fn default() -> Resolver

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Resolver

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl From<&Eip712Types> for Resolver

fn from(types: &Eip712Types) -> Self

Converts to this type from the input type.

impl From<&Resolver> for Eip712Types

fn from(resolver: &Resolver) -> Self

Converts to this type from the input type.

impl From<Eip712Types> for Resolver

fn from(types: Eip712Types) -> Self

Converts to this type from the input type.

impl PartialEq for Resolver

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

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for Resolver

impl StructuralPartialEq for Resolver