Struct Nft

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

Contains all information needed to spend the outer puzzles of NFT coins. The NftInfo is used to construct the puzzle, but the Proof is needed for the solution.

The only thing missing to create a valid coin spend is the inner puzzle and solution. However, this is handled separately to provide as much flexibility as possible.

This type should contain all of the information you need to store in a database for later. As long as you can figure out what puzzle the p2 puzzle hash corresponds to and spend it, you have enough information to spend the NFT coin.

Fields

coin: Coin

The coin that this Nft represents. Its puzzle hash should match the NftInfo::puzzle_hash.

proof: Proof

The proof is needed by the singleton puzzle to prove that this coin is a legitimate singleton. It’s typically obtained by looking up and parsing the parent coin.

Note that while the proof will be a LineageProof for most coins, for the first singleton in the lineage it will be an EveProof instead. However, the eve coin is typically unhinted and spent in the same transaction as it was created, so this is not relevant for database storage or syncing unspent coins.

info: NftInfo<M>

The information needed to construct the outer puzzle of an NFT. See NftInfo for more details.

Implementations

impl<M> Nft<M>

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

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

impl<M> Nft<M>

where M: ToTreeHash,

pub fn child_lineage_proof(&self) -> LineageProof

Creates a LineageProof for which would be valid for any children created by this Nft.

pub fn child<N>( &self, p2_puzzle_hash: Bytes32, current_owner: Option<Bytes32>, metadata: N, amount: u64, ) -> Nft<N>

where M: Clone, N: ToTreeHash,

Creates a new Nft that represents a child of this one.

pub fn child_with<N>(&self, info: NftInfo<N>, amount: u64) -> Nft<N>

where N: ToTreeHash,

Creates a new Nft that represents a child of this one.

You can specify the NftInfo to use for the child manually. In most cases, you will want to use Nft::child instead.

It’s important to use the right NftInfo beforehand, otherwise the puzzle hash of the child will not match the one expected by the coin.

impl<M> Nft<M>

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

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

Spends this NFT coin with the provided inner spend. The spend is added to the SpendContext for convenience.

pub fn spend_with<I>( &self, ctx: &mut SpendContext, inner: &I, conditions: Conditions, ) -> Result<Self, DriverError>

where I: SpendWithConditions,

Spends this NFT coin with a Layer that supports SpendWithConditions. This is a building block for built in spend methods, but can also be used to spend NFTs with conditions more easily.

However, if you need full flexibility of the inner spend, you can use Nft::spend instead.

pub fn transfer_with_metadata<I>( self, ctx: &mut SpendContext, inner: &I, p2_puzzle_hash: Bytes32, metadata_update: Spend, extra_conditions: Conditions, ) -> Result<Nft<M>, DriverError>

where I: SpendWithConditions,

Transfers this NFT coin to a new p2 puzzle hash and runs the metadata updater with the provided spend.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

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

where I: SpendWithConditions,

Transfers this NFT coin to a new p2 puzzle hash.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

pub fn lock_settlement<I>( self, ctx: &mut SpendContext, inner: &I, trade_prices: Vec<TradePrice>, extra_conditions: Conditions, ) -> Result<Nft<M>, DriverError>

where I: SpendWithConditions,

Transfers this NFT coin to the settlement puzzle hash and runs the transfer program to remove the assigned owner and reveal the trade prices for the offer.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

pub fn unlock_settlement( self, ctx: &mut SpendContext, notarized_payments: Vec<NotarizedPayment>, ) -> Result<Nft<M>, DriverError>

Spends this NFT with the settlement puzzle as its inner puzzle, with the provided notarized payments. This only works if the NFT has been locked in an offer already.

pub fn assign_owner<I>( self, ctx: &mut SpendContext, inner: &I, p2_puzzle_hash: Bytes32, transfer_condition: TransferNft, extra_conditions: Conditions, ) -> Result<(Conditions, Nft<M>), DriverError>

where I: SpendWithConditions,

Transfers this NFT coin to a new p2 puzzle hash and runs the transfer program.

This will return the conditions that must be emitted by the singleton you’re assigning the NFT to. The singleton must be spent in the same spend bundle as the NFT spend and emit these conditions.

However, if the NFT is being unassigned, there is no singleton spend and the conditions are empty.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

impl<M> Nft<M>

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

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

where Self: Sized, M: Clone,

Parses the child of an Nft from the parent coin spend.

This can be used to construct a valid spendable Nft for a hinted coin. You simply need to look up the parent coin’s spend, parse the child, and ensure it matches the hinted coin.

This will automatically run the transfer program or metadata updater, if they are revealed in the p2 spend’s output conditions. This way the returned Nft will have the correct owner (if present) and metadata.

Trait Implementations

impl AddAsset for Nft<HashedPtr>

fn add(self, spends: &mut Spends)

impl Asset for Nft<HashedPtr>

fn coin_id(&self) -> Bytes32

fn full_puzzle_hash(&self) -> Bytes32

fn p2_puzzle_hash(&self) -> Bytes32

fn amount(&self) -> u64

fn constraints(&self) -> OutputConstraints

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

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

Returns a duplicate of the value.

const 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 SingletonAsset for Nft<HashedPtr>

type ChildInfo = ChildNftInfo

fn default_child_info(_asset: &Self, spend_kind: &SpendKind) -> Self::ChildInfo

fn needs_additional_spend(child_info: &Self::ChildInfo) -> bool

fn finalize( ctx: &mut SpendContext, singleton: &mut SingletonSpend<Self>, intermediate_puzzle_hash: Bytes32, change_puzzle_hash: Bytes32, ) -> Result<Option<SingletonSpend<Self>>, DriverError>

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

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

impl<M> StructuralPartialEq for Nft<M>