Struct RoyaltyTransferLayer

pub struct RoyaltyTransferLayer {
    pub launcher_id: Bytes32,
    pub royalty_puzzle_hash: Bytes32,
    pub royalty_ten_thousandths: u16,
}

The royalty transfer Layer is used to transfer NFTs with royalties. When an NFT is transferred, a percentage of the transfer amount is paid to an address. This address can for example be the creator, or a royalty split puzzle.

Fields

launcher_id: Bytes32

The launcher id of the NFT this transfer program belongs to.

royalty_puzzle_hash: Bytes32

The puzzle hash that receives royalties paid when transferring this NFT.

royalty_ten_thousandths: u16

The percentage of the transfer amount that is paid as royalties. This is represented in ten thousandths, so a value of 300 means 3%.

Implementations

impl RoyaltyTransferLayer

pub fn new( launcher_id: Bytes32, royalty_puzzle_hash: Bytes32, royalty_ten_thousandths: u16, ) -> Self

Trait Implementations

impl Clone for RoyaltyTransferLayer

fn clone(&self) -> RoyaltyTransferLayer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RoyaltyTransferLayer

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

Formats the value using the given formatter.

impl Layer for RoyaltyTransferLayer

type Solution = Infallible

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 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 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 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 parse_solution( _allocator: &Allocator, _solution: NodePtr, ) -> Result<Self::Solution, DriverError>

Parses the Layer::Solution type from a CLVM solution pointer.

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 PartialEq for RoyaltyTransferLayer

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

fn tree_hash(&self) -> TreeHash

impl Copy for RoyaltyTransferLayer

impl Eq for RoyaltyTransferLayer

impl StructuralPartialEq for RoyaltyTransferLayer