Minting & Burning

Minting aumenta a oferta de tokens SPL creditando uma conta de token. Burning destrói tokens da conta de um detentor e reduz a oferta. Ambas as operações exigem a autoridade correta e quantidades inteiras brutas.

Receita

# Quantidades da CLI são quantidades de UI; burn aceita uma conta de token, não o 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)?;

Quando usar isso:

• Distribuição inicial de token após o lançamento
• Inflação do tesouro ou emissão de recompensas
• Tokenomics de recompra e destruição (buyback-and-burn)
• Reduzir a oferta antes de revogar a autoridade de mint

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"
ATA=$(spl-token address --token "$MINT" --verbose | awk '/Associated token address/{print $NF}')
 
# Quantidades da CLI são quantidades de UI - a CLI escala pelos 9 decimais do mint para você
spl-token mint "$MINT" 5            # 5.0 tokens = raw 5_000_000_000
spl-token supply "$MINT"
spl-token burn "$ATA" 1             # queima 1.0 token; burn aceita a conta de token
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` já impõe isso; a verificação explícita documenta a intenção
    // e evita o pânico que `.unwrap()` em uma autoridade revogada (None) causaria.
    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,
}

O que isso demonstra:

• O signatário da autoridade de mint deve corresponder ao campo mint_authority do mint; mint_authority é um COption, e .unwrap() em um mint revogado causaria pânico.
• token::mint = mint fixa o destino para este mint antes do CPI.
• mint_to credita qualquer conta de token para aquele mint.
• burn debita a conta de token do signatário e atualiza a oferta do mint.

Deep Dive

Como Funciona

• A conta mint armazena supply: u64 atualizado a cada mint/burn.
• As quantidades são sempre inteiros brutos; os decimais são apenas para exibição no mint.
• Autoridade de mint None significa que o minting está permanentemente desabilitado.
• Burn exige a assinatura do proprietário da conta (ou um delegado com permissão suficiente).

Ciclo de Vida da Oferta

Notas Rust

// Valida se o 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 com decimais - uma quantidade de instrução MintTo de 100 em um mint com 6 decimais é 0,0001 tokens. Correção: multiplique a quantidade de UI por 10^decimals ao construir instruções.
• Tratar quantidades da CLI como brutas - spl-token mint <MINT> 1000000 cria um milhão de tokens, não um. Correção: a CLI aceita quantidades de UI; apenas os dados da instrução aceitam unidades base brutas.
• Passar o mint para spl-token burn - o primeiro argumento de burn é o endereço da conta de token. Correção: use spl-token address --token <MINT> primeiro.
• Mintar após a autoridade ser revogada - a instrução falha. Correção: verifique mint_authority antes dos fluxos de UI.
• Mintar para a ATA do mint errado - o CPI falha ou credita o ativo errado. Correção: use require_keys_eq! em token_account.mint.
• Queimar mais do que o saldo - erro de fundos insuficientes. Correção: leia o valor da ATA primeiro.
• Estouro (Overflow) em mints grandes - a oferta é u64. Correção: limite as emissões; use matemática verificada no planejamento off-chain.

Alternativas

FAQs

Relacionado

• Autoridades - revogar autoridade de mint
• Decimais & Quantidades - quantidades brutas 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.