Struct chia_sdk_driver::NftStateLayer

pub struct NftStateLayer<M, I> {
    pub metadata: M,
    pub metadata_updater_puzzle_hash: Bytes32,
    pub inner_puzzle: I,
}

The NFT state Layer keeps track of the current metadata of the NFT and how to change it. It’s typically an inner layer of the SingletonLayer.

Fields

metadata: M

The NFT metadata. The standard metadata type is NftMetadata.

metadata_updater_puzzle_hash: Bytes32

The tree hash of the metadata updater puzzle.

inner_puzzle: I

The inner puzzle layer. Typically, this is the NftOwnershipLayer. However, for the NFT0 standard this can be the p2 layer itself.

Implementations

impl<M, I> NftStateLayer<M, I>

pub fn new( metadata: M, metadata_updater_puzzle_hash: Bytes32, inner_puzzle: I, ) -> Self

pub fn with_metadata<N>(self, metadata: N) -> NftStateLayer<N, I>

impl<M, I> NftStateLayer<M, I>

pub fn get_next_metadata( allocator: &mut Allocator, current_metadata: &M, curent_metadata_updater_puzzle_hash: Bytes32, condition: UpdateNftMetadata<NodePtr, NodePtr>, ) -> Result<M, DriverError>

where M: ToClvm<Allocator> + FromClvm<Allocator>,

Trait Implementations

impl<M: Clone, I: Clone> Clone for NftStateLayer<M, I>

fn clone(&self) -> NftStateLayer<M, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug, I: Debug> Debug for NftStateLayer<M, I>

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

Formats the value using the given formatter.

impl<M, I> Layer for NftStateLayer<M, I>

where M: ToClvm<Allocator> + FromClvm<Allocator>, I: Layer,

type Solution = NftStateLayerSolution<<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<M: PartialEq, I: PartialEq> PartialEq for NftStateLayer<M, I>

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

where M: ToTreeHash, I: ToTreeHash,

fn tree_hash(&self) -> TreeHash

impl<M: Copy, I: Copy> Copy for NftStateLayer<M, I>

impl<M: Eq, I: Eq> Eq for NftStateLayer<M, I>

impl<M, I> StructuralPartialEq for NftStateLayer<M, I>