Struct chia_sdk_driver::Nft

pub struct Nft<M> {
    pub coin: Coin,
    pub proof: Proof,
    pub info: NftInfo<M>,
}

Everything that is required to spend an NFT coin.

Fields

coin: Coin

The coin that holds this NFT.

proof: Proof

The lineage proof for the singleton.

info: NftInfo<M>

The info associated with the NFT, including the metadata.

Implementations

impl<M> Nft<M>

pub fn new(coin: Coin, proof: Proof, info: NftInfo<M>) -> Self

pub fn child_lineage_proof(&self) -> LineageProof

where M: ToTreeHash,

Returns the lineage proof that would be used by the child.

pub fn create_child( &self, p2_puzzle_hash: Bytes32, new_owner: Option<Option<Bytes32>>, ) -> Self

where M: ToTreeHash + Clone,

Creates a new spendable NFT for the child.

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

pub fn with_hashed_metadata( &self, allocator: &mut Allocator, ) -> Result<Nft<TreeHash>, DriverError>

where M: ToClvm<Allocator>,

impl<M> Nft<M>

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

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

Creates a coin spend for this NFT.

pub fn transfer( self, ctx: &mut SpendContext, owner_synthetic_key: PublicKey, p2_puzzle_hash: Bytes32, extra_conditions: Conditions, ) -> Result<(CoinSpend, Nft<M>), DriverError>

pub fn transfer_to_did( self, ctx: &mut SpendContext, owner_synthetic_key: PublicKey, p2_puzzle_hash: Bytes32, new_did_owner: &TransferNft, extra_conditions: Conditions, ) -> Result<(CoinSpend, Conditions, Nft<M>), DriverError>

Trait Implementations

impl<M: Clone> Clone for Nft<M>

fn clone(&self) -> Nft<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Nft<M>

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

Formats the value using the given formatter.

impl<M: PartialEq> PartialEq for Nft<M>

fn eq(&self, other: &Nft<M>) -> 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> Primitive for Nft<M>

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

fn from_parent_spend( allocator: &mut Allocator, parent_coin: Coin, parent_puzzle: Puzzle, parent_solution: NodePtr, coin: Coin, ) -> Result<Option<Self>, DriverError>

where Self: Sized,

Parses the full information required to spend a coin of this primitive type. If it’s not a match, it will return None. If it should be a match but an error occurs, it will return that error.

impl<M: Copy> Copy for Nft<M>

impl<M: Eq> Eq for Nft<M>

impl<M> StructuralPartialEq for Nft<M>