Transfers & Delegates

# CLI amounts are UI amounts (whole tokens), never raw base units
spl-token transfer <MINT> <UI_AMOUNT> <RECIPIENT> --fund-recipient
# approve takes the SOURCE TOKEN ACCOUNT, not the 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 sends 2.5 tokens - the CLI takes the UI amount and scales by mint decimals
spl-token transfer "$MINT" 2.5 <BOB_WALLET> --fund-recipient
 
# Alice approves the router to spend up to 1 token from HER token account.
# Arg 1 is the token account being delegated, not the 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: the pubkey being granted delegate rights; the Token program stores it verbatim.
    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");
// Build transfer instructions via @solana-program/token helpers
// Always derive recipient ATA; fund if missing