> For the complete documentation index, see [llms.txt](https://wiki.solaxy.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wiki.solaxy.io/using-custom-code/minting-+-burning-spl-tokens.md). # Minting + Burning SPL Tokens SPL tokens are Solana’s fungible token standard, and they can be thought of as the equivalent of ERC20s in Ethereum. * Create Mint 
pub(crate) async fn create_mint(client: &TestClient, payer: &Keypair) -> anyhow::Result<Keypair> {
      let mint_account = Keypair::new();

      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let rent_balance = client
          .get_minimum_balance_for_rent_exemption(Mint::LEN)
          .await
          .map_err(|e| anyhow!("Failed to get a rent exempt balance: {e}"))?;

      let create_mint_account = solana_sdk::system_instruction::create_account(
          &payer.pubkey(),
          &mint_account.pubkey(),
          rent_balance,
          Mint::LEN as u64,
          &spl_token::id(),
      );

      let initialize_mint = spl_token::instruction::initialize_mint(
          &spl_token::id(),
          &mint_account.pubkey(),
          &payer.pubkey(), // mint authority
          None,
          0,
      )
      .map_err(|e| anyhow!("Failed to create initialize mint instruction: {e}"))?;

      let create_mint_tx = Transaction::new_signed_with_payer(
          &[create_mint_account, initialize_mint],
          Some(&payer.pubkey()),
          &[payer, &mint_account],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&create_mint_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let mint_acc_info = client
          .svm_get_account_info(mint_account.pubkey())
          .await
          .map_err(|e| anyhow!("Mint account should exist after transaction: {e}"))?;

      // Deserialize the mint account data
      let mint_data = Mint::unpack(&mint_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack mint account data: {e}"))?;

      Ok(mint_account)
  }
* Create Associated Token Account 
pub(crate) async fn create_associated_token_account(
      client: &TestClient,
      payer: &Keypair,
      target_account_pubkey: &Pubkey,
      mint_account_pubkey: &Pubkey,
  ) -> anyhow::Result<()> {
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let create_ata = spl_associated_token_account::instruction::create_associated_token_account(
          &payer.pubkey(),
          target_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let create_ata_tx = Transaction::new_signed_with_payer(
          &[create_ata],
          Some(&payer.pubkey()),
          &[&payer],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&create_ata_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let ata_pubkey = get_associated_token_address_with_program_id(
          target_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let ata_acc_info = client.svm_get_account_info(ata_pubkey).await.map_err(|e| {
          anyhow!("Failed to retrieve associated token account after transaction: {e}")
      })?;

      Ok(())
  }
* Mint Tokens 
pub(crate) async fn transfer_tokens(
      client: &TestClient,
      payer: &Keypair,
      sender: &Keypair,
      receiver_account_pubkey: &Pubkey,
      mint_account_pubkey: &Pubkey,
      amount: u64,
  ) -> anyhow::Result<()> {
      let sender_key = sender.pubkey();
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let sender_ata_pubkey = get_associated_token_address_with_program_id(
          &sender_key,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let receiver_ata_pubkey = get_associated_token_address_with_program_id(
          receiver_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let sender_ata_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;

      let receiver_ata_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;

      // Get initial balances for tests
      let initial_sender_tokens = sender_token_account_data.amount;
      let initial_receiver_tokens = receiver_token_account_data.amount;

      let transfer = spl_token::instruction::transfer_checked(
          &spl_token::id(),
          &sender_ata_pubkey,
          mint_account_pubkey,
          &receiver_ata_pubkey,
          &sender_key,
          &[],
          amount,
          0,
      )
      .map_err(|e| anyhow!("Failed to create transfer checked instruction: {e}"))?;

      let transfer_tx = Transaction::new_signed_with_payer(
          &[transfer],
          Some(&payer.pubkey()),
          &[&payer, &sender],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&transfer_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let sender_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;

      let receiver_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;

      Ok(())
  }
* Transfer Tokens 
pub(crate) async fn transfer_tokens(
      client: &TestClient,
      payer: &Keypair,
      sender: &Keypair,
      receiver_account_pubkey: &Pubkey,
      mint_account_pubkey: &Pubkey,
      amount: u64,
  ) -> anyhow::Result<()> {
      let sender_key = sender.pubkey();
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let sender_ata_pubkey = get_associated_token_address_with_program_id(
          &sender_key,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let receiver_ata_pubkey = get_associated_token_address_with_program_id(
          receiver_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let sender_ata_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;
      debug!("Sender's token account data:: {sender_token_account_data:?}");

      let receiver_ata_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;
      debug!("Receiver's token account data: {receiver_token_account_data:?}");

      // Get initial balances for tests
      let initial_sender_tokens = sender_token_account_data.amount;
      let initial_receiver_tokens = receiver_token_account_data.amount;

      let transfer = spl_token::instruction::transfer_checked(
          &spl_token::id(),
          &sender_ata_pubkey,
          mint_account_pubkey,
          &receiver_ata_pubkey,
          &sender_key,
          &[],
          amount,
          0,
      )
      .map_err(|e| anyhow!("Failed to create transfer checked instruction: {e}"))?;

      let transfer_tx = Transaction::new_signed_with_payer(
          &[transfer],
          Some(&payer.pubkey()),
          &[&payer, &sender],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&transfer_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let sender_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;

      let receiver_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;

      Ok(())
  }
* Burn Tokens 
pub(crate) async fn burn_tokens(
      client: &TestClient,
      payer: &Keypair,
      target_account: &Keypair,
      mint_account_pubkey: &Pubkey,
      amount: u64,
  ) -> anyhow::Result<()> {
      let target_key = target_account.pubkey();
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let target_ata_pubkey = get_associated_token_address_with_program_id(
          &target_key,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let target_acc_info = client
          .svm_get_account_info(target_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {target_ata_pubkey}: {e}"))?;
      let target_token_account_data = TokenAccount::unpack(&target_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack token account data: {e}"))?;
      debug!("Target's token account data:: {target_token_account_data:?}");

      let initial_target_tokens = target_token_account_data.amount;

      let burn = spl_token::instruction::burn_checked(
          &spl_token::id(),
          &target_ata_pubkey,
          mint_account_pubkey,
          &target_key,
          &[],
          amount,
          0,
      )
      .map_err(|e| anyhow!("Failed to create burn tx: {e}"))?;

      let burn_tx = Transaction::new_signed_with_payer(
          &[burn],
          Some(&payer.pubkey()),
          &[&payer, &target_account],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&burn_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let target_acc_info = client
          .svm_get_account_info(target_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {target_ata_pubkey}: {e}"))?;
      let target_token_account_data = TokenAccount::unpack(&target_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack token account data: {e}"))?;

      Ok(())
  }