Acuñar y Quemar

Acuñar aumenta el suministro de tokens SPL acreditando una cuenta de token. Quemar destruye tokens de la cuenta de un titular y reduce el suministro. Ambos requieren la autoridad correcta y cantidades enteras brutas.

Receta

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)?;

Cuándo usar esto:

• Distribución inicial de tokens después del lanzamiento
• Inflación del tesoro o emisiones de recompensas
• Tokenomics de recompra y quema
• Reducir el suministro antes de revocar la autoridad de acuñación

Ejemplo Funcional

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 con 9 decimales
spl-token supply "$MINT"
spl-token burn "$MINT" 1000000000     # quemar 1.0 token de tu 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,
}

Lo que esto demuestra:

• El firmante de la autoridad de acuñación debe coincidir con el campo mint_authority de la acuñación
• mint_to acredita cualquier cuenta de token para esa acuñación
• burn debita la cuenta de token del firmante y actualiza el suministro de la acuñación

Análisis Profundo

Cómo Funciona

• La cuenta de acuñación almacena supply: u64 que se actualiza en cada acuñación/quema
• Las cantidades son siempre enteros brutos; los decimales solo se muestran en la visualización
• Si la autoridad de acuñación es None, la acuñación se deshabilita permanentemente
• La quema requiere la firma del propietario de la cuenta (o un delegado con la asignación suficiente)

Ciclo de Vida del Suministro

Notas de Rust

// Validar que la acuñación coincida con el ATA del destinatario
require_keys_eq!(recipient_ata.mint, mint.key(), ErrorCode::MintMismatch);
require!(amount > 0, ErrorCode::ZeroAmount);

Trampas Comunes

• Errores de cálculo de decimales: acuñar 100 con 6 decimales es 0.0001 tokens. Solución: multiplicar la cantidad de la UI por 10^decimales.
• Acuñar después de revocar la autoridad: la instrucción falla. Solución: verificar mint_authority antes de los flujos de la UI.
• Acuñar en el ATA de una acuñación incorrecta: la CPI falla o acredita el activo incorrecto. Solución: require_keys_eq! en token_account.mint.
• Quemar más que el saldo: error de fondos insuficientes. Solución: leer primero la cantidad del ATA.
• Desbordamiento en acuñaciones grandes: el suministro es u64. Solución: limitar las emisiones; usar matemáticas comprobadas en la planificación fuera de la cadena.

Alternativas

Preguntas Frecuentes

Relacionado

• Autoridades - revocar la autoridad de acuñación
• Decimales y Cantidades - cantidades brutas vs. UI
• SPL Token en Programas - patrones de CPI

Versiones de Stack: Esta página fue 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, y LiteSVM 0.6.x.