Struct Eip712Domain

pub struct Eip712Domain {
    pub name: Option<Cow<'static, str>>,
    pub version: Option<Cow<'static, str>>,
    pub chain_id: Option<U256>,
    pub verifying_contract: Option<Address>,
    pub salt: Option<B256>,
}

EIP-712 domain attributes used in determining the domain separator.

Unused fields are left out of the struct type.

Protocol designers only need to include the fields that make sense for their signing domain.

Fields

name: Option<Cow<'static, str>>

The user readable name of signing domain, i.e. the name of the DApp or the protocol.

version: Option<Cow<'static, str>>

The current major version of the signing domain. Signatures from different versions are not compatible.

chain_id: Option<U256>

The EIP-155 chain ID. The user-agent should refuse signing if it does not match the currently active chain.

verifying_contract: Option<Address>

The address of the contract that will verify the signature.

salt: Option<B256>

A disambiguating salt for the protocol. This can be used as a domain separator of last resort.

Implementations

impl Eip712Domain

pub const NAME: &'static str = "EIP712Domain"

The name of the struct.

pub const fn new( name: Option<Cow<'static, str>>, version: Option<Cow<'static, str>>, chain_id: Option<U256>, verifying_contract: Option<Address>, salt: Option<B256>, ) -> Self

Instantiate a new EIP-712 domain.

Use the eip712_domain! macro for easier instantiation.

pub fn separator(&self) -> B256

Calculate the domain separator for the domain object.

pub fn encode_type(&self) -> String

The EIP-712-encoded type string.

See EIP-712 encodeType.

pub fn type_hash(&self) -> B256

Calculates the EIP-712 typeHash for this domain.

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

pub const fn num_words(&self) -> usize

Returns the number of ABI words (32 bytes) that will be used to encode the domain.

pub const fn abi_encoded_size(&self) -> usize

Returns the number of bytes that will be used to encode the domain.

pub fn encode_data_to(&self, out: &mut Vec<u8>)

Encodes this domain using EIP-712 encodeData into the given buffer.

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

Encodes this domain using EIP-712 encodeData.

pub fn hash_struct(&self) -> B256

Hashes this domain according to EIP-712 hashStruct.

Trait Implementations

impl Clone for Eip712Domain

fn clone(&self) -> Eip712Domain

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Eip712Domain

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

Formats the value using the given formatter.

impl Default for Eip712Domain

fn default() -> Eip712Domain

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Eip712Domain

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Eip712Domain

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 Eip712Domain

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

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 Eip712Domain

impl StructuralPartialEq for Eip712Domain