Transferencias y Delegados

# Las cantidades de la CLI son cantidades de UI (tokens completos), nunca unidades base brutas
spl-token transfer <MINT> <UI_AMOUNT> <RECIPIENT> --fund-recipient
# approve toma la CUENTA DE TOKEN DE ORIGEN, no la emisión
spl-token approve <TOKEN_ACCOUNT> <UI_AMOUNT> <DELEGATE_PUBKEY>

use anchor_spl::token::{self, TransferChecked, Approve};
 
token::transfer_checked(cpi_ctx, amount, decimals)?;
token::approve(cpi_ctx, amount)?;

# Alice envía 2.5 tokens - la CLI toma la cantidad de UI y la escala por los decimales de la emisión
spl-token transfer "$MINT" 2.5 <BOB_WALLET> --fund-recipient
 
# Alice aprueba al enrutador para gastar hasta 1 token de SU cuenta de token.
# El argumento 1 es la cuenta de token que se delega, no la emisión.
ALICE_ATA=$(spl-token address --token "$MINT" --verbose | awk '/Associated token address/{print $NF}')
spl-token approve "$ALICE_ATA" 1 <ROUTER_DELEGATE_PUBKEY>

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Approve, Mint, Token, TokenAccount, TransferChecked};
 
#[derive(Accounts)]
pub struct TransferPayment<'info> {
    pub mint: Account<'info, Mint>,
    #[account(mut, token::mint = mint, token::authority = authority)]
    pub from: Account<'info, TokenAccount>,
    #[account(mut, token::mint = mint)]
    pub to: Account<'info, TokenAccount>,
    pub authority: Signer<'info>,
    pub token_program: Program<'info, Token>,
}
 
pub fn transfer_payment(ctx: Context<TransferPayment>, amount: u64) -> Result<()> {
    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.from.to_account_info(),
            to: ctx.accounts.to.to_account_info(),
            authority: ctx.accounts.authority.to_account_info(),
        },
    );
    token::transfer_checked(cpi, amount, decimals)?;
    Ok(())
}
 
#[derive(Accounts)]
pub struct ApproveRouter<'info> {
    #[account(mut, token::authority = owner)]
    pub owner_token: Account<'info, TokenAccount>,
    /// CHECK: la clave pública a la que se otorgan los derechos de delegado; el programa Token la almacena textualmente.
    pub delegate: UncheckedAccount<'info>,
    pub owner: Signer<'info>,
    pub token_program: Program<'info, Token>,
}
 
pub fn approve_router(ctx: Context<ApproveRouter>, amount: u64) -> Result<()> {
    let cpi = CpiContext::new(
        ctx.accounts.token_program.to_account_info(),
        Approve {
            to: ctx.accounts.owner_token.to_account_info(),
            delegate: ctx.accounts.delegate.to_account_info(),
            authority: ctx.accounts.owner.to_account_info(),
        },
    );
    token::approve(cpi, amount)?;
    Ok(())
}

import { createSolanaRpc, address } from "@solana/kit";
 
const rpc = createSolanaRpc("https://api.devnet.solana.com");
// Construir instrucciones de transferencia a través de los ayudantes de token de @solana-program/
// Siempre derivar el ATA del destinatario; financiar si falta