Signer & Owner Checks

#[derive(Accounts)]
pub struct TransferOut<'info> {
    #[account(mut, has_one = authority)]
    pub vault: Account<'info, Vault>,
    pub authority: Signer<'info>,
}
 
// Manual signer check on an UncheckedAccount authority
require!(ctx.accounts.authority.is_signer, ErrorCode::MissingSigner);
 
// Manual owner check on an UncheckedAccount mint (a mint does not sign)
require_keys_eq!(*ctx.accounts.mint.owner, anchor_spl::token::ID, ErrorCode::InvalidOwner);

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Token, TokenAccount, Transfer};
 
#[account]
pub struct Vault {
    pub authority: Pubkey,
    pub bump: u8,
}
 
#[derive(Accounts)]
pub struct Withdraw<'info> {
    #[account(
        mut,
        seeds = [b"vault", authority.key().as_ref()],
        bump = vault.bump,
        has_one = authority,
    )]
    pub vault: Account<'info, Vault>,
 
    #[account(mut)]
    pub vault_token: Account<'info, TokenAccount>,
 
    #[account(mut)]
    pub destination: Account<'info, TokenAccount>,
 
    pub authority: Signer<'info>,
    pub token_program: Program<'info, Token>,
}
 
pub fn withdraw(ctx: Context<Withdraw>, amount: u64) -> Result<()> {
    // Bind the Pubkey to a local first - `authority.key()` returns by value and the
    // temporary would be dropped while `seeds` still borrows it (E0716).
    let authority_key = ctx.accounts.authority.key();
    let bump = ctx.accounts.vault.bump;
    let seeds: &[&[u8]] = &[b"vault", authority_key.as_ref(), &[bump]];
    let signer = &[seeds];
 
    let cpi = CpiContext::new_with_signer(
        ctx.accounts.token_program.to_account_info(),
        Transfer {
            from: ctx.accounts.vault_token.to_account_info(),
            to: ctx.accounts.destination.to_account_info(),
            authority: ctx.accounts.vault.to_account_info(),
        },
        signer,
    );
    token::transfer(cpi, amount)?;
    Ok(())
}

// Native program equivalent
if !authority.is_signer {
    return Err(ProgramError::MissingRequiredSignature);
}
if vault.owner != program_id {
    return Err(ProgramError::IncorrectProgramId);
}