Minting e Burning

Minting aumenta o supply de tokens SPL creditando uma conta de token. Burning destrói tokens da conta de um holder e reduz o supply. Ambos exigem autoridade correta e amounts inteiros brutos.

Receita

spl-token mint <MINT> <RAW_AMOUNT> <RECIPIENT_TOKEN_ACCOUNT>
spl-token burn <MINT> <RAW_AMOUNT>

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

Quando usar isso:

• Distribuição inicial de token após lançamento
• Inflação de tesouraria ou emissões de recompensa
• Tokenomics de buyback-and-burn
• Reduzir supply antes de revogar mint authority

Exemplo de Trabalho

solana config set --url devnet
MINT=$(spl-token create-token --decimals 9 | awk '/Creating token/{print $3}')
spl-token create-account "$MINT"
spl-token mint "$MINT" 5000000000   # 5.0 tokens at 9 decimals
spl-token supply "$MINT"
spl-token burn "$MINT" 1000000000     # burn 1.0 token from your ATA
spl-token supply "$MINT"

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Mint, Token, TokenAccount, MintTo, Burn};
 
#[derive(Accounts)]
pub struct IssueReward<'info> {
    #[account(mut)]
    pub mint: Account<'info, Mint>,
    #[account(mut)]
    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!(ctx.accounts.mint.mint_authority.unwrap() == 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,
}

O que isso demonstra:

• Signer mint authority deve corresponder ao campo mint_authority do mint
• mint_to credita qualquer conta de token daquele mint
• burn debita conta de token do signer e atualiza supply do mint

Deep Dive

Como Funciona

• Conta mint armazena supply: u64 atualizado em todo mint/burn
• Amounts são sempre inteiros brutos; decimais são apenas display no mint
• Mint authority None significa minting permanentemente desabilitado
• Burn exige assinatura do owner da conta (ou delegate com allowance suficiente)

Ciclo de Vida do Supply

Notas Rust

// Valide mint corresponde à ATA do destinatário
require_keys_eq!(recipient_ata.mint, mint.key(), ErrorCode::MintMismatch);
require!(amount > 0, ErrorCode::ZeroAmount);

Armadilhas

• Erros de matemática decimal - mintar 100 com 6 decimais é 0,0001 tokens. Correção: multiplique amount de UI por 10^decimals.
• Mintar após authority revogada - instrução falha. Correção: verifique mint_authority antes dos fluxos de UI.
• Mint para ATA de mint errado - CPI falha ou credita ativo errado. Correção: require_keys_eq! em token_account.mint.
• Burn maior que saldo - erro de fundos insuficientes. Correção: leia amount da ATA primeiro.
• Overflow em mints grandes - supply é u64. Correção: limite emissões; use math verificada no planejamento off-chain.

Alternativas

FAQs

Relacionado

• Autoridades - revogar mint authority
• Decimais e Amounts - amounts brutos vs UI
• SPL Token em Programas - padrões CPI

Versões da stack: Esta página foi escrita para Agave 4.1.1, Solana CLI 3.0.10, Anchor 0.32.1, anchor-lang 0.32.1, Rust 1.91.1, @solana/kit 7.0.0, Surfpool 0.12.0 e LiteSVM 0.6.x.