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. Ambas operaciones requieren la autoridad correcta y cantidades enteras brutas.

Receta

# Las cantidades de la CLI son cantidades de UI; la quema toma una cuenta de token, no la acuñación
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)?;

Cuándo recurrir a 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"
ATA=$(spl-token address --token "$MINT" --verbose | awk '/Associated token address/{print $NF}')
 
# Las cantidades de la CLI son cantidades de UI - la CLI escala por los 9 decimales de la acuñación por ti
spl-token mint "$MINT" 5            # 5.0 tokens = 5_000_000_000 brutos
spl-token supply "$MINT"
spl-token burn "$ATA" 1             # quemar 1.0 token; la quema toma la cuenta 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` ya impone esto; la comprobación explícita documenta la intención
    // y evita el pánico que causaría `.unwrap()` en una autoridad revocada (None).
    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,
}

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_authority es un COption, y .unwrap() en una acuñación revocada causaría un pánico.
• token::mint = mint fija el destino a esta acuñación antes de la CPI.
• 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 usan para mostrar en la acuñació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);

Errores Comunes

• Errores de cálculo de decimales - una cantidad de instrucción MintTo de 100 en una acuñación de 6 decimales es 0.0001 tokens. Solución: multiplicar la cantidad de la UI por 10^decimals al construir las instrucciones.
• Tratar las cantidades de la CLI como brutas - spl-token mint <MINT> 1000000 acuña un millón de tokens, no uno. Solución: la CLI toma cantidades de UI; solo los datos de la instrucción toman unidades base brutas.
• Pasar la acuñación a spl-token burn - el primer argumento de burn es la dirección de la cuenta de token. Solución: primero usar spl-token address --token <MINT>.
• 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.