Struct CreateMint 

pub struct CreateMint<'a, 'b: 'a> {
    pub token_program_id: &'a Pubkey,
    pub payer: CpiAuthority<'a, 'b>,
    pub mint: CpiAuthority<'a, 'b>,
    pub mint_authority: &'a Pubkey,
    pub decimals: u8,
    pub freeze_authority: Option<&'a Pubkey>,
    pub extensions: InitializeMintExtensions<'a>,
}

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

Example

use sealevel_tools::{
    account_info::{
        try_next_enumerated_account, try_next_enumerated_account_info, TokenProgram,
        AccountInfoConstraints, Account, Signer,
    },
    cpi::token_program::{CreateMint, InitializeMetadataPointerData, InitializeMintExtensions},
    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::<Signer<true>>(&mut accounts_iter, Default::default())?;

    let (new_mint_addr, new_mint_bump) =
        Pubkey::find_program_address(&[b"mint"], program_id);

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

    // Next account is the mint authority.
    let (_, mint_authority) =
        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())?;

    CreateMint {
        token_program_id: token_program.key(),
        payer: payer.as_cpi_authority(),
        mint: new_mint_account.as_cpi_authority(Some(&[b"mint", &[new_mint_bump]])),
        mint_authority: mint_authority.key(),
        decimals: 9,
        freeze_authority: None,
        extensions: InitializeMintExtensions {
            metadata_pointer: Some(InitializeMetadataPointerData {
                authority: Some(mint_authority.key()),
                metadata: new_mint_account.key(),
            }),
            non_transferable: true,
            ..Default::default()
        }
    }
    .try_into_invoke()?;

    Ok(())
}

Fields

token_program_id: &'a Pubkey

payer: CpiAuthority<'a, 'b>

mint: CpiAuthority<'a, 'b>

mint_authority: &'a Pubkey

decimals: u8

freeze_authority: Option<&'a Pubkey>

extensions: InitializeMintExtensions<'a>

Implementations

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

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

Try to consume arguments to perform CPI calls.

Notes

Extension CPI calls are optional and will only be invoked when Some is provided for any of the optional extension arguments. See InitializeMintExtensions for more information.

Trait Implementations

impl<'a, 'b: 'a> Clone for CreateMint<'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 CreateMint<'a, 'b>

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

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

Equality operator ==.

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

Inequality operator !=.

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