Transferências e Delegados

# Quantidades da CLI são quantidades de UI (tokens inteiros), nunca unidades base brutas
spl-token transfer <MINT> <UI_AMOUNT> <RECIPIENT> --fund-recipient
# approve recebe a CONTA DE TOKEN DE ORIGEM, não a mint
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 envia 2.5 tokens - a CLI pega a quantidade de UI e escala pelos decimais da mint
spl-token transfer "$MINT" 2.5 <BOB_WALLET> --fund-recipient
 
# Alice aprova o roteador para gastar até 1 token de sua conta de token.
# O argumento 1 é a conta de token que está sendo delegada, não a mint.
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: a chave pública que está recebendo direitos de delegado; o programa Token a armazena literalmente.
    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");
// Construa instruções de transferência via helpers do @solana-program/token
// Sempre derive o ATA do destinatário; financie se ausente