Struct StandardLayer 

pub struct StandardLayer {
    pub synthetic_key: PublicKey,
}

The standard Layer is used for most coins on the Chia blockchain. It allows a single key to spend the coin by providing a delegated puzzle (for example to output Conditions).

There is also additional hidden puzzle functionality which can be encoded in the key. To do this, you calculate a “synthetic key” from the original key and the hidden puzzle hash. When spending the coin, you can reveal this hidden puzzle and provide the original key. This functionality is seldom used in Chia, and usually the “default hidden puzzle” is used instead. The default hidden puzzle is not spendable, so you can only spend XCH coins by signing with your key.

Fields

synthetic_key: PublicKey

Implementations

impl StandardLayer

pub fn new(synthetic_key: PublicKey) -> Self

pub fn spend( &self, ctx: &mut SpendContext, coin: Coin, conditions: Conditions, ) -> Result<(), DriverError>

pub fn delegated_inner_spend( &self, ctx: &mut SpendContext, spend: Spend, ) -> Result<Spend, DriverError>

Trait Implementations

impl Clone for StandardLayer

fn clone(&self) -> StandardLayer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StandardLayer

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

Formats the value using the given formatter.

impl Layer for StandardLayer

type Solution = StandardSolution<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 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 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_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 StandardLayer

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

fn spend_with_conditions( &self, ctx: &mut SpendContext, conditions: Conditions, ) -> Result<Spend, DriverError>

impl ToTreeHash for StandardLayer

fn tree_hash(&self) -> TreeHash

impl Copy for StandardLayer

impl Eq for StandardLayer

impl StructuralPartialEq for StandardLayer