Burn Tokens

Burn a specified amount of SPL tokens, reducing the total supply.

Code Implementation

#!/usr/bin/env python3
"""
Solana Cookbook - How to Burn Tokens
"""

import asyncio
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.pubkey import Pubkey
from solders.transaction import VersionedTransaction
from solders.message import MessageV0
from spl.token.instructions import burn
from spl.token.models import BurnParams
from spl.token.constants import TOKEN_PROGRAM_ID

async def main():
    rpc = AsyncClient("https://api.devnet.solana.com")

    # Example keypairs and addresses
    payer = Keypair()
    owner = Keypair()
    mint_address = Pubkey.from_string("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU")
    token_account = Pubkey.from_string("GfVPzUxMDvhFJ1Xs6C9i47XQRSapTd8LHw5grGuTquyQ")

    # Amount to burn (in smallest unit)
    amount_to_burn = 500000000  # 0.5 tokens with 9 decimals

    async with rpc:
        # Create burn instruction
        burn_instruction = burn(
            BurnParams(
                program_id=TOKEN_PROGRAM_ID,
                account=token_account,
                mint=mint_address,
                owner=owner.pubkey(),
                amount=amount_to_burn
            )
        )

        # Get latest blockhash
        recent_blockhash = await rpc.get_latest_blockhash()

        # Create message
        message = MessageV0.try_compile(
            payer=payer.pubkey(),
            instructions=[burn_instruction],
            address_lookup_table_accounts=[],
            recent_blockhash=recent_blockhash.value.blockhash,
        )

        # Create and sign transaction
        transaction = VersionedTransaction(message, [payer, owner])

        # Send transaction
        result = await rpc.send_transaction(transaction)
        print(f"Transaction signature: {result.value}")

if __name__ == "__main__":
    asyncio.run(main())

Code Explanation

This example shows how to burn SPL tokens:

1. Set Parameters: Define the payer, token owner, mint address, and token account
2. Create Burn Instruction: Use the burn() function to create a burn instruction
3. Build Transaction: Create a message and build a signed transaction
4. Send Transaction: Send the transaction to the network for execution

Key Concepts

• Token Owner: The owner of the token account, only the owner can burn their tokens
• Token Account: The account containing the tokens to be burned
• Mint Address: The mint address of the token, used to identify the token type
• Burn Amount: The amount of tokens to burn, calculated in the smallest unit

Usage

1. Set the token account owner as owner
2. Specify the token_account containing tokens to burn
3. Specify the token's mint_address
4. Set the amount of tokens to burn (pay attention to decimal places)
5. Run the script to execute the burn operation

Important Notes

• Only the token account owner can burn tokens
• The burn operation is irreversible, tokens are permanently removed from the total supply
• The burn amount cannot exceed the token balance in the account
• Sufficient SOL is required to pay transaction fees
• Burned tokens cannot be recovered