Struct chia_sdk_driver::SingletonLayer

pub struct SingletonLayer<I> {
    pub launcher_id: Bytes32,
    pub inner_puzzle: I,
}

The singleton Layer enforces uniqueness on a coin, which is identified by the launcher id. It contains an inner puzzle layer, which determines the actual behavior of the coin. Only one singleton can be created when the coin is spent, preserving the lineage of the asset.

Examples of singletons include:

• DidLayer for Decentralized Identifiers (DIDs).
• NftStateLayer for Non-Fungible Tokens (NFTs).

However, assets like CATs (Chia Asset Tokens) are not singletons, as they are fungible.

Fields

launcher_id: Bytes32

The unique launcher id for the singleton. Also referred to as the singleton id.

inner_puzzle: I

The inner puzzle layer. For singletons, this determines the actual behavior of the coin.

Implementations

impl<I> SingletonLayer<I>

pub fn new(launcher_id: Bytes32, inner_puzzle: I) -> Self

impl<I> SingletonLayer<I>

where I: ToTreeHash,

pub fn lineage_proof(&self, this_coin: Coin) -> LineageProof

Returns the LineageProof for this singleton’s child.

Trait Implementations

impl<I: Clone> Clone for SingletonLayer<I>

fn clone(&self) -> SingletonLayer<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for SingletonLayer<I>

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

Formats the value using the given formatter.

impl<I> Layer for SingletonLayer<I>

where I: Layer,

type Solution = SingletonSolution<<I as Layer>::Solution>

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<I: PartialEq> PartialEq for SingletonLayer<I>

fn eq(&self, other: &SingletonLayer<I>) -> 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<I> ToTreeHash for SingletonLayer<I>

where I: ToTreeHash,

fn tree_hash(&self) -> TreeHash

impl<I: Copy> Copy for SingletonLayer<I>

impl<I: Eq> Eq for SingletonLayer<I>

impl<I> StructuralPartialEq for SingletonLayer<I>