Struct NftInfo

pub struct NftInfo<M> {
    pub launcher_id: Bytes32,
    pub metadata: M,
    pub metadata_updater_puzzle_hash: Bytes32,
    pub current_owner: Option<Bytes32>,
    pub royalty_puzzle_hash: Bytes32,
    pub royalty_basis_points: u16,
    pub p2_puzzle_hash: Bytes32,
}

Information needed to construct the outer puzzle of an NFT. It does not include the inner puzzle, which must be stored separately.

This type can be used on its own for parsing, or as part of the Nft primitive.

Fields

launcher_id: Bytes32

The coin id of the launcher coin that created this NFT’s singleton.

metadata: M

The metadata stored in the NftStateLayer. This can only be updated by going through the metadata_updater_puzzle_hash.

metadata_updater_puzzle_hash: Bytes32

The puzzle hash of the metadata updater. This is used to update the metadata of the NFT. This is typically NFT_METADATA_UPDATER_DEFAULT_HASH, which ensures the NftMetadata object remains immutable except for prepending additional URIs.

A custom metadata updater can be used, however support in existing wallets and display services may be limited.

current_owner: Option<Bytes32>

The current assigned owner of the NFT, if any. This is managed by the NftOwnershipLayer.

Historically this was always a DID, although it’s possible to assign any singleton including a vault.

It’s intended to unassign the owner after transferring to an external wallet or creating an offer.

royalty_puzzle_hash: Bytes32

The puzzle hash to which royalties will be paid out to in offers involving this NFT. This is required even if the royalty is 0. Currently, all NFTs must use the default RoyaltyTransferLayer, however this may change in the future.

royalty_basis_points: u16

The royalty percentage to be paid out to the owner in offers involving this NFT. This is represented as hundredths of a percent, so 300 is 3%.

p2_puzzle_hash: Bytes32

The hash of the inner puzzle to this NFT. If you encode this puzzle hash as bech32m, it’s the same as the current owner’s address.

Implementations

impl<M> NftInfo<M>

pub fn new( launcher_id: Bytes32, metadata: M, metadata_updater_puzzle_hash: Bytes32, current_owner: Option<Bytes32>, royalty_puzzle_hash: Bytes32, royalty_basis_points: u16, p2_puzzle_hash: Bytes32, ) -> Self

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

pub fn parse( allocator: &Allocator, puzzle: Puzzle, ) -> Result<Option<(Self, Puzzle)>, DriverError>

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

Parses an NftInfo from a Puzzle by extracting the NftStateLayer and NftOwnershipLayer.

This will return a tuple of the NftInfo and its p2 puzzle.

If the puzzle is not an NFT, this will return None instead of an error. However, if the puzzle should have been an NFT but had a parsing error, this will return an error.

pub fn from_layers<I>(layers: StandardNftLayers<M, I>) -> Self

where I: ToTreeHash,

pub fn into_layers<I>(self, p2_puzzle: I) -> StandardNftLayers<M, I>

pub fn inner_puzzle_hash(&self) -> TreeHash

where M: ToTreeHash,

Calculates the inner puzzle hash of the NFT singleton.

This includes both the NftStateLayer and NftOwnershipLayer, but not the SingletonLayer.

pub fn puzzle_hash(&self) -> TreeHash

where M: ToTreeHash,

Calculates the full puzzle hash of the NFT, which is the hash of the outer SingletonLayer.

pub fn child_from_p2_spend( &self, allocator: &mut Allocator, spend: Spend, ) -> Result<(Self, CreateCoin<NodePtr>), DriverError>

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

Parses the child of an NftInfo from the p2 spend.

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 NftInfo will have the correct owner (if present) and metadata.

Trait Implementations

impl<M: Clone> Clone for NftInfo<M>

fn clone(&self) -> NftInfo<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 NftInfo<M>

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

Formats the value using the given formatter.

impl<M: PartialEq> PartialEq for NftInfo<M>

fn eq(&self, other: &NftInfo<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: Copy> Copy for NftInfo<M>

impl<M: Eq> Eq for NftInfo<M>

impl<M> StructuralPartialEq for NftInfo<M>