Struct hpl_asset_assembler::state::assembler::Assembler

pub struct Assembler {

    pub bump: u8,
    pub project: Pubkey,
    pub collection: Pubkey,
    pub collection_name: String,
    pub collection_symbol: String,
    pub collection_description: String,
    pub nft_base_uri: String,
    pub assembling_action: AssemblingAction,
    pub nfts: u16,
    pub allow_duplicates: bool,
    pub default_royalty: u16,
    pub token_standard: TokenStandard,
    pub rule_set: Option<Pubkey>,
    pub default_creators: Vec<Creator>,
}

Assembler state account

Fields

bump: u8

project: Pubkey

The wallet that has authority to modify the assembler

collection: Pubkey

The collection address of the assembler generated NFTs

collection_name: String

The collection name to be associated with each nft

collection_symbol: String

The collection symbol to be associated with each nft

collection_description: String

The collection description to be associated with each nft

nft_base_uri: String

The base uri of each nft metadata

assembling_action: AssemblingAction

Action to take for the block SFT while assembling

nfts: u16

The number of NFTs created by this assembler

allow_duplicates: bool

Should this assembler allow duplicate NFTs

default_royalty: u16

Default royalty percentage

token_standard: TokenStandard

Token Standard

rule_set: Option<Pubkey>

pNFT rule set

default_creators: Vec<Creator>

Default creators

Implementations

impl Assembler

pub const LEN: usize = 378usize

Trait Implementations

impl AccountDeserialize for Assembler

fn try_deserialize(buf: &mut &[u8]) -> Result<Self>

Deserializes previously initialized account data. Should fail for all uninitialized accounts, where the bytes are zeroed. Implementations should be unique to a particular account type so that one can never successfully deserialize the data of one account type into another. For example, if the SPL token program were to implement this trait, it should be impossible to deserialize a Mint account into a token Account.

fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self>

Deserializes account data without checking the account discriminator. This should only be used on account initialization, when the bytes of the account are zeroed.

impl AccountSerialize for Assembler

fn try_serialize<W: Write>(&self, writer: &mut W) -> Result<()>

Serializes the account data into writer.

impl BorshDeserialize for Assembler

where u8: BorshDeserialize, Pubkey: BorshDeserialize, String: BorshDeserialize, AssemblingAction: BorshDeserialize, u16: BorshDeserialize, bool: BorshDeserialize, TokenStandard: BorshDeserialize, Option<Pubkey>: BorshDeserialize, Vec<Creator>: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Assembler

where u8: BorshSerialize, Pubkey: BorshSerialize, String: BorshSerialize, AssemblingAction: BorshSerialize, u16: BorshSerialize, bool: BorshSerialize, TokenStandard: BorshSerialize, Option<Pubkey>: BorshSerialize, Vec<Creator>: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for Assembler

fn clone(&self) -> Assembler

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Discriminator for Assembler

const DISCRIMINATOR: [u8; 8] = _

fn discriminator() -> [u8; 8]

impl Owner for Assembler

fn owner() -> Pubkey