Struct MintActionCompressedInstructionData 

#[repr(C)]
pub struct MintActionCompressedInstructionData {
    pub leaf_index: u32,
    pub prove_by_index: bool,
    pub root_index: u16,
    pub max_top_up: u16,
    pub create_mint: Option<CreateMint>,
    pub actions: Vec<Action>,
    pub proof: Option<CompressedProof>,
    pub cpi_context: Option<CpiContext>,
    pub mint: Option<MintInstructionData>,
}

Fields

leaf_index: u32

Only set if mint already exists

prove_by_index: bool

Only set if mint already exists

root_index: u16

If create mint, root index of address proof If mint already exists, root index of validity proof If proof by index not used.

max_top_up: u16

Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (u16::MAX = no limit, 0 = no top-ups allowed)

create_mint: Option<CreateMint>

actions: Vec<Action>

proof: Option<CompressedProof>

cpi_context: Option<CpiContext>

mint: Option<MintInstructionData>

Implementations

impl MintActionCompressedInstructionData

pub fn new( mint_with_context: MintWithContext, proof: Option<CompressedProof>, ) -> Self

Create instruction data from MintWithContext (for existing mints)

pub fn new_mint( address_merkle_tree_root_index: u16, proof: CompressedProof, mint: MintInstructionData, ) -> Self

Create instruction data for new mint creation

pub fn new_mint_write_to_cpi_context( address_merkle_tree_root_index: u16, mint: MintInstructionData, cpi_context: CpiContext, ) -> Self

Create instruction data for new mint creation via CPI context write

pub fn with_mint_to_compressed(self, action: MintToCompressedAction) -> Self

pub fn with_mint_to(self, action: MintToAction) -> Self

pub fn with_update_mint_authority(self, authority: UpdateAuthority) -> Self

pub fn with_update_freeze_authority(self, authority: UpdateAuthority) -> Self

pub fn with_update_metadata_field( self, action: UpdateMetadataFieldAction, ) -> Self

pub fn with_update_metadata_authority( self, action: UpdateMetadataAuthorityAction, ) -> Self

pub fn with_remove_metadata_key(self, action: RemoveMetadataKeyAction) -> Self

pub fn with_decompress_mint(self, action: DecompressMintAction) -> Self

pub fn with_compress_and_close_mint( self, action: CompressAndCloseMintAction, ) -> Self

pub fn with_cpi_context(self, cpi_context: CpiContext) -> Self

pub fn with_max_top_up(self, max_top_up: u16) -> Self

pub fn write_to_cpi_context_first(self) -> Self

pub fn write_to_cpi_context_set(self) -> Self

Trait Implementations

impl BorshDeserialize for MintActionCompressedInstructionData

where u32: BorshDeserialize, bool: BorshDeserialize, u16: BorshDeserialize, Option<CreateMint>: BorshDeserialize, Vec<Action>: BorshDeserialize, Option<CompressedProof>: BorshDeserialize, Option<CpiContext>: BorshDeserialize, Option<MintInstructionData>: 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 MintActionCompressedInstructionData

where u32: BorshSerialize, bool: BorshSerialize, u16: BorshSerialize, Option<CreateMint>: BorshSerialize, Vec<Action>: BorshSerialize, Option<CompressedProof>: BorshSerialize, Option<CpiContext>: BorshSerialize, Option<MintInstructionData>: 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 MintActionCompressedInstructionData

fn clone(&self) -> MintActionCompressedInstructionData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MintActionCompressedInstructionData

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

Formats the value using the given formatter.

impl InstructionDiscriminator for MintActionCompressedInstructionData

fn discriminator(&self) -> &'static [u8]

impl LightInstructionData for MintActionCompressedInstructionData

fn data(&self) -> Result<Vec<u8>, CompressedAccountError>

fn data_array<const N: usize>( &self, ) -> Result<ArrayVec<[u8; N]>, CompressedAccountError>

impl<'a> ZeroCopyAt<'a> for MintActionCompressedInstructionData

type ZeroCopyAt = ZMintActionCompressedInstructionData<'a>

fn zero_copy_at( __remaining_bytes: &'a [u8], ) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError>

impl ZeroCopyStructInner for MintActionCompressedInstructionData

type ZeroCopyInner = ZMintActionCompressedInstructionData<'static>