Struct P2Eip712MessageLayer 

pub struct P2Eip712MessageLayer {
    pub prefix_and_domain_separator: Eip712PrefixAndDomainSeparator,
    pub public_key: K1PublicKey,
}

The CHIP-0037 EIP-712 message Layer.

Allows a coin to be controlled by an Ethereum-style wallet that signs an EIP-712 typed-data message of type ChiaCoinSpend(bytes32 coin_id, bytes32 delegated_puzzle_hash). The puzzle reconstructs the EIP-712 digest from the signed envelope (\x19\x01 || domainSeparator || keccak256(typeHash || coin_id || delegated_puzzle_hash)) inside a softfork guard so the spend is bound to this exact coin and chosen delegated_puzzle.

Fields

prefix_and_domain_separator: Eip712PrefixAndDomainSeparator

public_key: K1PublicKey

Implementations

impl P2Eip712MessageLayer

pub fn new( public_key: K1PublicKey, prefix_and_domain_separator: Eip712PrefixAndDomainSeparator, ) -> Self

pub fn from_genesis_challenge( public_key: K1PublicKey, genesis_challenge: Bytes32, ) -> Self

Convenience constructor that derives the prefix-and-domain-separator from a network’s genesis challenge.

pub fn domain_separator(genesis_challenge: Bytes32) -> Bytes32

Compute the EIP-712 domain separator for the given Chia network.

Domain matches the schema mandated by CHIP-0037: { name: "Chia Coin Spend", version: "1", salt: <genesis_challenge> }.

pub fn prefix_and_domain_separator( genesis_challenge: Bytes32, ) -> Eip712PrefixAndDomainSeparator

Compute the 34-byte concatenation of the EIP-712 prefix (\x19\x01) and the domain separator for a given network.

pub fn type_hash() -> Bytes32

Keccak-256 hash of the canonical CHIP-0037 EIP-712 type signature.

pub fn hash_to_sign( &self, coin_id: Bytes32, delegated_puzzle_hash: Bytes32, ) -> Bytes32

Compute the 32-byte EIP-712 digest the off-chain wallet must sign.

digest = keccak256(prefix_and_domain || keccak256(type_hash || coin_id || delegated_puzzle_hash))

pub fn spend( &self, ctx: &mut SpendContext, my_id: Bytes32, signature: K1Signature, delegated_spend: Spend, ) -> Result<Spend, DriverError>

Construct a Spend for a coin locked by this layer using a previously obtained signature over hash_to_sign(coin_id, tree_hash(delegated)).

Trait Implementations

impl Clone for P2Eip712MessageLayer

fn clone(&self) -> P2Eip712MessageLayer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for P2Eip712MessageLayer

impl Debug for P2Eip712MessageLayer

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

Formats the value using the given formatter.

impl Eq for P2Eip712MessageLayer

impl Layer for P2Eip712MessageLayer

type Solution = P2Eip712MessageSolution<NodePtr, NodePtr>

Most of the time, this is an actual CLVM type representing the solution. However, you can also use a helper struct and customize Layer::construct_solution and Layer::parse_solution.

fn parse_puzzle( allocator: &Allocator, puzzle: Puzzle, ) -> Result<Option<Self>, DriverError>

Parses this layer from the given puzzle, returning None if the puzzle doesn’t match. An error is returned if the puzzle should have matched but couldn’t be parsed.

fn parse_solution( allocator: &Allocator, solution: NodePtr, ) -> Result<Self::Solution, DriverError>

Parses the Layer::Solution type from a CLVM solution pointer.

fn construct_puzzle( &self, ctx: &mut SpendContext, ) -> Result<NodePtr, DriverError>

Constructs the full curried puzzle for this layer. Ideally, the puzzle itself should be cached in the SpendContext.

fn construct_solution( &self, ctx: &mut SpendContext, solution: Self::Solution, ) -> Result<NodePtr, DriverError>

Constructs the full solution for this layer. Can be used to construct the solution from a helper struct, if it’s not directly a CLVM type. It’s also possible to influence the solution based on the puzzle, if needed.

fn construct_spend( &self, ctx: &mut SpendContext, solution: Self::Solution, ) -> Result<Spend, DriverError>

Creates a spend for this layer.

fn construct_coin_spend( &self, ctx: &mut SpendContext, coin: Coin, solution: Self::Solution, ) -> Result<CoinSpend, DriverError>

Creates a coin spend for this layer.

impl PartialEq for P2Eip712MessageLayer

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for P2Eip712MessageLayer