> 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(())
}
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://wiki.solaxy.io/using-custom-code/minting-+-burning-spl-tokens.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.