Struct access_protocol::instruction::claim_rewards::Accounts

pub struct Accounts<'a, T> {
    pub stake_pool: &'a T,
    pub stake_account: &'a T,
    pub owner: &'a T,
    pub rewards_destination: &'a T,
    pub central_state: &'a T,
    pub mint: &'a T,
    pub spl_token_program: &'a T,
    pub owner_royalty_account: &'a T,
    pub royalty_ata: Option<&'a T>,
    pub royalty_account: Option<&'a T>,
}

The required accounts for the claim_rewards instruction

Fields

stake_pool: &'a T

The stake pool account

stake_account: &'a T

The stake account

owner: &'a T

The owner of the stake account

rewards_destination: &'a T

The rewards destination

central_state: &'a T

The central state account

mint: &'a T

The mint address of the ACS token

spl_token_program: &'a T

The SPL token program account

owner_royalty_account: &'a T

The owner’s royalty split account to check if royalties need to be paid

royalty_ata: Option<&'a T>

The royalty ATA account

royalty_account: Option<&'a T>

The optional royalty account to pay royalties to if there is no owner royalty split account this is be used by the Access NFT contract to pay royalties even for the NFTs owned by the owner

Implementations

impl<'a, 'b: 'a> Accounts<'a, AccountInfo<'b>>

pub fn parse( accounts: &'a [AccountInfo<'b>], program_id: &Pubkey ) -> Result<Self, ProgramError>

Trait Implementations

impl<'a> InstructionsAccount for Accounts<'a, Pubkey>

fn get_accounts_vec(&self) -> Vec<AccountMeta>

fn get_instruction<P>( &self, program_id: Pubkey, instruction_id: u8, params: P ) -> Instruction

where P: BorshDeserialize + BorshSerialize + BorshSize,

fn get_instruction_cast<P>( &self, program_id: Pubkey, instruction_id: u8, params: P ) -> Instruction

where P: NoUninit,

fn get_instruction_wrapped_pod<'a, P>( &self, program_id: Pubkey, instruction_id: u8, params: P ) -> Instruction

where P: WrappedPod<'a>,