Struct TypedData

pub struct TypedData {
    pub domain: Eip712Domain,
    pub resolver: Resolver,
    pub primary_type: String,
    pub message: Value,
}

Represents the EIP-712 typed data object.

Typed data is a JSON object containing type information, domain separator parameters and the message object which has the following schema:

{
    "type": "object",
    "properties": {
        "types": {
            "type": "object",
            "properties": {
                "EIP712Domain": { "type": "array" }
            },
            "additionalProperties": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "name": { "type": "string" },
                        "type": { "type": "string" }
                    },
                    "required": ["name", "type"]
                }
            },
            "required": ["EIP712Domain"]
        },
        "primaryType": { "type": "string" },
        "domain": { "type": "object" },
        "message": { "type": "object" }
    },
    "required": ["types", "primaryType", "domain", "message"]
}

Fields

domain: Eip712Domain

Signing domain metadata. The signing domain is the intended context for the signature (e.g. the dapp, protocol, etc. that it’s intended for). This data is used to construct the domain separator of the message.

resolver: Resolver

The custom types used by this message.

primary_type: String

The type of the message.

message: Value

The message to be signed.

Implementations

impl TypedData

pub fn from_struct<S: SolStruct + Serialize>( s: &S, domain: Option<Eip712Domain>, ) -> Self

Instantiate TypedData from a SolStruct that implements serde::Serialize.

pub const fn domain(&self) -> &Eip712Domain

Returns the domain for this typed data.

pub fn coerce(&self) -> Result<DynSolValue>

Coerce the message to the type specified by primary_type, using the types map as a resolver.

pub fn type_hash(&self) -> Result<B256>

Calculates the EIP-712 typeHash for this value.

This is defined as the Keccak-256 hash of the encodeType string.

Fails if this type is not a struct.

pub fn hash_struct(&self) -> Result<B256>

Calculates the hashStruct for this value.

Fails if this type is not a struct.

pub fn encode_data(&self) -> Result<Vec<u8>>

Calculate the encodeData for this value.

Fails if this type is not a struct.

pub fn encode_type(&self) -> Result<String>

Calculate the encodeType for this value.

Fails if this type is not a struct.

pub fn eip712_signing_hash(&self) -> Result<B256>

Calculate the EIP-712 signing hash for this value. Note that this does not sign the hash, only calculates it.

This is the hash of the magic bytes 0x1901 concatenated with the domain separator and the hashStruct result: keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message))

Trait Implementations

impl Clone for TypedData

fn clone(&self) -> TypedData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypedData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypedData

TypedData is most likely going to be a stringified JSON object, so we have to implement Deserialize manually to parse the string first.

See:

• Ethers.js: https://github.com/ethers-io/ethers.js/blob/17969fe4169b44389dbd4da1dd85682eb3284d6f/src.ts/providers/provider-jsonrpc.ts#L415
• Viem: https://github.com/wagmi-dev/viem/blob/9aba19289832b22422e57265258fdf4beba83570/src/actions/wallet/signTypedData.ts#L178-L185

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

Deserialize this value from the given Serde deserializer.

impl PartialEq for TypedData

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TypedData

impl StructuralPartialEq for TypedData