Struct CreateTokenAccount 

pub struct CreateTokenAccount<'a, 'b: 'a> {
    pub payer: CpiAuthority<'a, 'b>,
    pub token_account: CpiAuthority<'a, 'b>,
    pub mint: &'b NoStdAccountInfo,
    pub token_account_owner: &'a Pubkey,
    pub immutable_owner: bool,
}

Arguments to create a token account for a specific mint with a specified owner. This method creates an account for one of the Token programs and initializes it as a token account.

Example

use sealevel_tools::{
    account_info::{
        try_next_enumerated_account, try_next_enumerated_account_info, TokenProgram,
        AccountInfoConstraints, Payer, WritableAccount,
    },
    cpi::token_program::CreateTokenAccount,
    entrypoint::{NoStdAccountInfo, ProgramResult},
    pubkey::Pubkey,
};

fn process_instruction(
     program_id: &Pubkey,
     accounts: &[NoStdAccountInfo],
     instruction_data: &[u8],
) -> ProgramResult {
    let mut accounts_iter = accounts.iter().enumerate();

    // Next account must writable signer (A.K.A. our payer).
    let (_, payer) =
        try_next_enumerated_account::<Payer>(&mut accounts_iter, Default::default())?;

    let (new_token_addr, new_token_bump) =
        Pubkey::find_program_address(&[b"token"], program_id);

    // Next account must be writable data account matching PDA address.
    let (_, new_token_account) = try_next_enumerated_account::<WritableAccount>(
        &mut accounts_iter,
        AccountInfoConstraints {
            key: Some(&new_token_addr),
            ..Default::default()
        },
    )?;

    // Next account must be a mint account. If you do not want to enforce that this is a read-
    // only account, use `try_next_enumerated_account_info` instead.
    let (_, mint_account) = try_next_enumerated_account::<WritableAccount>(
        &mut accounts_iter,
        Default::default()
    )?;

    // Next account is the owner.
    let (_, token_account_owner) =
        try_next_enumerated_account_info(&mut accounts_iter, Default::default())?;

    // Next account is which token program to use.
    let (_, token_program) =
        try_next_enumerated_account::<TokenProgram>(&mut accounts_iter, Default::default())?;

    CreateTokenAccount {
        payer: payer.as_cpi_authority(),
        token_account: new_token_account.as_cpi_authority(Some(&[b"token", &[new_token_bump]])),
        mint: &mint_account,
        token_account_owner: token_account_owner.key(),
        immutable_owner: true,
    }
    .try_into_invoke()?;

    Ok(())
}

Fields

payer: CpiAuthority<'a, 'b>

token_account: CpiAuthority<'a, 'b>

mint: &'b NoStdAccountInfo

token_account_owner: &'a Pubkey

immutable_owner: bool

Implementations

impl<'a, 'b: 'a> CreateTokenAccount<'a, 'b>

pub fn try_into_invoke(self) -> Result<Account<'a, true>, ProgramError>

Try to consume arguments to perform CPI calls.

Trait Implementations

impl<'a, 'b: 'a> Clone for CreateTokenAccount<'a, 'b>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, 'b: 'a> Eq for CreateTokenAccount<'a, 'b>

impl<'a, 'b: 'a> PartialEq for CreateTokenAccount<'a, 'b>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a, 'b: 'a> StructuralPartialEq for CreateTokenAccount<'a, 'b>