Can I burn SPL Tokens that are sent from a user to a Solana Program?

Question

I am trying to write a simple anchor program that will burn the SPL tokens that the user sends to my anchor program. I followed the guide below on QuickNode to build a new program that allows minting.

QuickNode Guide I followed

I then modified the code a bit so that when the user sends SOL to the program, it calculates how much of the SPL Token to mint and sends it back to the users ATA account they provded.

I am now trying to do it the other way around. I want to have the user send the SPL token to the function in the program. Burn the token, and then send sol back.

I followed a couple guides, however, I cant seem to find if it is possible to burn the SPL token right then and there, or if I have to have them transfer the SPL to another program owned PDA and then burn it there.

Is there a way to just have instruction for the SPL token to be burned right when its sent to the program function without first sending it to a program owned ata? Just a simple burn with the sender signature?

I followed a couple guides including Burning Guide but they all seem to need the program to own the token before they are burned.

I also checked out this documentation and it just seems like gibberish to me without someone to explain it. Burn Information Solana

Answer 1

Here is a simple snippet to achieve this

#[program]
pub mod anchor_basics_spl {
    use super::*;

    pub fn burn_spl_tokens(ctx: Context<BurnSPLToken>, amount: u64) -> Result<()> {
        let cpi_program = ctx.accounts.token_program.to_account_info();
        let cpi_accounts = Burn {
            mint: ctx.accounts.mint.to_account_info(),
            from: ctx.accounts.token_account.to_account_info(),
            authority: ctx.accounts.payer.to_account_info(),
        };

        let bump = &[ctx.bumps.mint];
        let signer_seeds: &[&[&[u8]]] = &[&[b"mint", bump]];

        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer_seeds);
        burn(cpi_ctx, amount)?;

        // todo: calc and transfer sol back to user

        Ok(())
    }
}

#[derive(Accounts)]
pub struct BurnSPLToken<'info> {
    #[account(
        mut,
        seeds = [b"mint"],
        bump,
        mint::authority = mint,
    )]
    pub mint: Account<'info, Mint>,
    #[account(mut)]
    pub token_account: Account<'info, TokenAccount>,
    #[account(mut)]
    pub payer: Signer<'info>,
    pub rent: Sysvar<'info, Rent>,
    pub system_program: Program<'info, System>,
    pub token_program: Program<'info, Token>,
    pub associated_token_program: Program<'info, AssociatedToken>,
}

In this guide, the mint is a PDA and it maintains authority over itself. This means that any operation that you need to perform must happen through this program.