SPL Token en Programas

Los programas on-chain interactúan con SPL Token a través de invocaciones entre programas (CPIs). Anchor 0.32.1 anchor-spl encapsula la validación de cuentas, deserialización y constructores de instrucciones para lógica de tokens de grado de producción.

Receta

use anchor_spl::token::{self, Mint, Token, TokenAccount, TransferChecked};
 
pub mint: Account<'info, Mint>,
#[account(mut, token::mint = mint, token::authority = authority)]
pub from: Account<'info, TokenAccount>,
pub token_program: Program<'info, Token>,
// ...
token::transfer_checked(cpi_ctx, amount, decimals)?;

Cuándo usar esto:

• Programas de escrow, bóveda o pagos que mueven tokens SPL.
• Validar ATAs de usuario en instrucciones DeFi.
• Emitir tokens de recompensa desde una autoridad de emisión PDA.
• Aplicar reglas de coincidencia de emisión y firmante en CPIs de tokens.

Ejemplo Funcional

use anchor_lang::prelude::*;
use anchor_spl::associated_token::AssociatedToken;
use anchor_spl::token::{self, Mint, Token, TokenAccount, TransferChecked};
 
#[derive(Accounts)]
pub struct Deposit<'info> {
    pub mint: Account<'info, Mint>,
    #[account(
        mut,
        associated_token::mint = mint,
        associated_token::authority = user,
        associated_token::token_program = token_program,
    )]
    pub user_ata: Account<'info, TokenAccount>,
    #[account(
        mut,
        token::mint = mint,
        token::authority = vault_authority,
    )]
    pub vault_ata: Account<'info, TokenAccount>,
    pub user: Signer<'info>,
    /// CHECK: PDA authority over vault ATA
    pub vault_authority: UncheckedAccount<'info>,
    pub token_program: Program<'info, Token>,
    pub associated_token_program: Program<'info, AssociatedToken>,
    pub system_program: Program<'info, System>,
}
 
pub fn deposit(ctx: Context<Deposit>, amount: u64) -> Result<()> {
    require!(amount > 0, ErrorCode::ZeroAmount);
    let decimals = ctx.accounts.mint.decimals;
    let cpi = CpiContext::new(
        ctx.accounts.token_program.to_account_info(),
        TransferChecked {
            mint: ctx.accounts.mint.to_account_info(),
            from: ctx.accounts.user_ata.to_account_info(),
            to: ctx.accounts.vault_ata.to_account_info(),
            authority: ctx.accounts.user.to_account_info(),
        },
    );
    token::transfer_checked(cpi, amount, decimals)?;
    Ok(())
}
 
#[error_code]
pub enum ErrorCode {
    ZeroAmount,
}

Qué demuestra esto:

• Account<'info, TokenAccount> valida que el propietario sea el programa Token clásico; rechaza las cuentas Token-2022.
• Las restricciones token::mint y associated_token reducen las comprobaciones manuales de pubkey.
• transfer_checked incluye los decimales para un manejo más seguro de los activos; la Transfer no verificada está obsoleta y Token-2022 la rechaza en las emisiones con tarifa de transferencia.

Análisis Profundo

Cómo Funciona

• ID del programa SPL Token: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
• CPI pasa la instrucción serializada + metadatos de cuenta al programa Token.
• Requisitos de firmante: propietario para débito, autoridad de emisión para mint_to, etc.
• anchor_spl::token_interface soporta Token-2022 con el tipo TokenInterface.

Instrucciones Comunes de CPI

Notas de Rust

use anchor_lang::prelude::*;
use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
 
// Nunca mezcles los dos árboles de módulos. `anchor_spl::token::{Mint, TokenAccount}` son
// solo para Token clásico y su comprobación de propietario rechaza las cuentas Token-2022; los
// tipos de token_interface despachan sobre ambos programas.
#[derive(Accounts)]
pub struct EitherProgram<'info> {
    pub mint: InterfaceAccount<'info, Mint>,
    #[account(mut, token::mint = mint)]
    pub from: InterfaceAccount<'info, TokenAccount>,
    pub token_program: Interface<'info, TokenInterface>,
}

Errores Comunes

• Falta la comprobación de igualdad de emisión - ATA de bóveda con activo incorrecto. Solución: Restricción token::mint = mint en todas las cuentas de token.
• UncheckedAccount como autoridad de bóveda - sin validación de semilla PDA. Solución: Restricciones seeds + bump en la PDA de autoridad.
• Cuenta token_program incorrecta - Program<'info, Token> fija Tokenkeg..., y Account<'info, TokenAccount> rechaza cuentas propiedad de Token-2022, por lo que no hay una ruta de "simplemente pasar la cuenta del programa Token-2022". Solución: cambia toda la estructura de cuenta a anchor_spl::token_interface (InterfaceAccount + Interface<TokenInterface>), o en Rust nativo usa spl_token_2022::instruction::* - spl_token::instruction::* llama a check_program_account y devuelve IncorrectProgramId para cualquier ID que no sea Tokenkeg....
• Mezclar tipos de anchor_spl::token y anchor_spl::token_interface - la comprobación de propietario de los tipos clásicos rechaza las emisiones de extensión. Solución: elige un árbol de módulos por estructura de cuenta.
• La PDA no puede firmar la transferencia - faltan las semillas with_signer. Solución: CpiContext::new_with_signer con las semillas de la bóveda.
• Profundidad CPI extra a través de hooks de Token-2022 - una emisión enganchada añade una CPI anidada a un programa de hook separado, costando profundidad y CU. Un hook nunca puede volver a entrar en un programa que ya está en la pila (incluido el tuyo o Token-2022 mismo) - Solana rechaza eso con ReentrancyNotAllowed. Solución: presupuesta CU y profundidad CPI; ver la documentación de transfer hook.

cGJxcnRodnFyZi52YnxwdHZiMjgwfDIwMjYwNw==

Alternativas

Preguntas Frecuentes

Relacionado

• Cuentas de Token Asociadas (ATAs) - Restricciones de ATA
• Transferencias y Delegados - Flujos de delegación
• Invocaciones entre Programas (CPI) - Fundamentos 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.