Minting & Burning

# CLI amounts are UI amounts; burn takes a token account, not the mint
spl-token mint <MINT> <UI_AMOUNT> <RECIPIENT_TOKEN_ACCOUNT>
spl-token burn <TOKEN_ACCOUNT> <UI_AMOUNT>

use anchor_spl::token::{self, MintTo, Burn};
 
token::mint_to(cpi_ctx, amount)?;
token::burn(cpi_ctx, amount)?;

solana config set --url devnet
MINT=$(spl-token create-token --decimals 9 | awk '/Creating token/{print $3}')
spl-token create-account "$MINT"
ATA=$(spl-token address --token "$MINT" --verbose | awk '/Associated token address/{print $NF}')
 
# CLI amounts are UI amounts - the CLI scales by the mint's 9 decimals for you
spl-token mint "$MINT" 5            # 5.0 tokens = raw 5_000_000_000
spl-token supply "$MINT"
spl-token burn "$ATA" 1             # burn 1.0 token; burn takes the token account
spl-token supply "$MINT"

use anchor_lang::prelude::*;
use anchor_lang::solana_program::program_option::COption;
use anchor_spl::token::{self, Mint, MintTo, Token, TokenAccount};
 
#[derive(Accounts)]
pub struct IssueReward<'info> {
    #[account(mut, mint::authority = mint_authority)]
    pub mint: Account<'info, Mint>,
    #[account(mut, token::mint = mint)]
    pub recipient_ata: Account<'info, TokenAccount>,
    pub mint_authority: Signer<'info>,
    pub token_program: Program<'info, Token>,
}
 
pub fn issue_reward(ctx: Context<IssueReward>, amount: u64) -> Result<()> {
    require!(amount > 0, ErrorCode::ZeroAmount);
    // `mint::authority` already enforces this; the explicit check documents intent
    // and avoids the panic that `.unwrap()` on a revoked (None) authority would cause.
    require!(
        ctx.accounts.mint.mint_authority == COption::Some(ctx.accounts.mint_authority.key()),
        ErrorCode::Unauthorized
    );
    let cpi = CpiContext::new(
        ctx.accounts.token_program.to_account_info(),
        MintTo {
            mint: ctx.accounts.mint.to_account_info(),
            to: ctx.accounts.recipient_ata.to_account_info(),
            authority: ctx.accounts.mint_authority.to_account_info(),
        },
    );
    token::mint_to(cpi, amount)?;
    Ok(())
}
 
#[error_code]
pub enum ErrorCode {
    Unauthorized,
    ZeroAmount,
}

// Validate mint matches recipient ATA
require_keys_eq!(recipient_ata.mint, mint.key(), ErrorCode::MintMismatch);
require!(amount > 0, ErrorCode::ZeroAmount);