Enum nft_pixelboard_io::NFTPixelboardAction

pub enum NFTPixelboardAction {
    Mint {
        rectangle: Rectangle,
        token_metadata: TokenMetadata,
        painting: Vec<Color>,
    },
    Buy(TokenId),
    ChangeSaleState {
        token_id: TokenId,
        pixel_price: Option<u128>,
    },
    Paint {
        token_id: TokenId,
        painting: Vec<Color>,
    },
}

Sends a program info about what it should do.

Variants

Mint

Mints one NFT on a pixelboard with given token_metadata & painting.

Transfers a minted NFT to msg::source().

Requirements

• rectangle coordinates mustn’t be out of a canvas.
• rectangle coordinates mustn’t be mixed up or belong to wrong corners.
• rectangle coordinates must observe a block layout. In other words, each rectangle coordinate must be a multiple of a block side length in the canvas. The block side length can be obtained by block_side_length().
• NFT rectangle mustn’t collide with already minted one.
• painting length must equal a pixel count in an NFT (which can be calculated by multiplying a width & height from rectangle).
• msg::source() must have enough fungible tokens to buy all free pixels that rectangle will occupy. An enough number of tokens can be calculated by multiplying a rectangle area and the price of a free pixel. The area can be calculated by multiplying a width & height from rectangle. The price of a free pixel can be obtained by pixel_price().

On success, returns NFTPixelboardEvent::Minted.

Fields

rectangle: Rectangle

token_metadata: TokenMetadata

painting: Vec<Color>

A painting that’ll be displayed in a place of an NFT on a pixelboard after a successful minting.

Buy(TokenId)

Buys an NFT minted on a pixelboard.

Transfers a purchased NFT from a pixelboard program to msg::source().

Note: If msg::source() has enough fungible tokens to pay a resale commission but not the entire NFT, then the commission will still be withdrawn from its account.

Requirements

• An NFT must be minted on a pixelboard.
• An NFT must be for sale. This can be found out by token_info(). See also the documentation of TokenInfo.
• msg::source() must have enough fungible tokens to buy all pixels that an NFT occupies. This can be found out by token_info(). See also the documentation of TokenInfo.

On success, returns NFTPixelboardEvent::Bought.

ChangeSaleState

Changes a sale state of an NFT minted on a pixelboard.

There are 3 options of a sale state change:

• Putting up for sale
  If an NFT is not for sale, then assigning pixel_price to Some price will transfer it to a pixelboard program & put it up for sale.
• Updating a pixel price
  If an NFT is for sale, then assigning pixel_price to Some price will update its pixel price.
• Removing from sale
  Assigning the pixel_price to None will transfer an NFT back to its owner & remove an NFT from sale.

Note: A commission is included in each NFT resale, so a seller will receive not all fungible tokens but tokens with a commission deduction. A commission percentage can be obtained by commission_percentage().

Requirements

• An NFT must be minted on a pixelboard.
• msg::source() must be the owner of an NFT.
• pixel_price mustn’t be more than MAX_PIXEL_PRICE.

On success, returns NFTPixelboardEvent::SaleStateChanged.

Fields

token_id: TokenId

pixel_price: Option<u128>

A price of each pixel that an NFT occupies. To calculate a price of the entire NFT, see the documentation of TokenInfo.

Paint

Paints with painting an NFT minted on a pixelboard.

Requirements

• An NFT must be minted on a pixelboard.
• msg::source() must be the owner of an NFT.
• painting length must equal a pixel count in an NFT. The count can be calculated by multiplying a width & height from a rectangle of the NFT. The NFT rectangle can be obtained by token_info().

On success, returns NFTPixelboardEvent::Painted.

Fields

token_id: TokenId

painting: Vec<Color>

Trait Implementations

impl Clone for NFTPixelboardAction

fn clone(&self) -> NFTPixelboardAction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Decode for NFTPixelboardAction

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Encode for NFTPixelboardAction

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for NFTPixelboardAction

fn eq(&self, other: &NFTPixelboardAction) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeInfo for NFTPixelboardAction

type Identity = NFTPixelboardAction

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike for NFTPixelboardAction

impl Eq for NFTPixelboardAction

impl StructuralPartialEq for NFTPixelboardAction