Tokenbewerkingen

Een Token Mint Aanmaken

Een mint is de basis van elk SPL-token. Het definieert de eigenschappen van het token en bepaakt wie nieuwe tokens kan aanmaken.

use litesvm::LiteSVM;
use litesvm_token::{
    spl_token::native_mint::DECIMALS,
    CreateMint,
};
use solana_sdk::{
    native_token::LAMPORTS_PER_SOL,
    signature::{Keypair, Signer},
};

#[test]
fn test_create_mint() {
    let mut svm = LiteSVM::new();

    // Create payer account and fund it
    let payer = Keypair::new();
    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();

    // Create a new SPL token mint with the payer as the mint authority
    let mint = CreateMint::new(&mut svm, &payer)
        .authority(&payer.pubkey())
        .decimals(DECIMALS)
        .send()
        .unwrap();
}

Een Token Account Aanmaken

Een token account bevat het saldo van een specifiek spl-token voor een specifieke gebruiker. Lees voor meer informatie over het verschil tussen dit en een ATA dit gedeelte.

use litesvm::LiteSVM;
use litesvm_token::{
    spl_token::native_mint::DECIMALS,
    CreateMint, CreateAccount,
};
use solana_sdk::{
    native_token::LAMPORTS_PER_SOL,
    signature::{Keypair, Signer},
};

#[test]
fn test_create_mint() {
    let mut svm = LiteSVM::new();

    // Create payer account and fund it
    let payer = Keypair::new();
    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();

    // Create a new SPL token mint with the payer as the mint authority
    let mint = CreateMint::new(&mut svm, &payer)
        .authority(&payer.pubkey())
        .decimals(DECIMALS)
        .send()
        .unwrap();

    // Create a token account for the payer
    // You must have created a Mint Account to be able to create a Token Account
    let token_account = CreateAccount::new(&mut svm, &payer, &mint)
        .owner(&payer.pubkey())
        .send()
        .unwrap();
}

Een Associated Token Account Aanmaken

Associated Token Accounts (ATAs) zijn deterministische adressen voor het bewaren van tokens voor een specifieke gebruiker. Lees voor meer informatie over het verschil tussen dit en een ATA dit gedeelte.

use litesvm::LiteSVM;
use litesvm_token::{
    spl_token::native_mint::DECIMALS,
    CreateMint, CreateAssociatedTokenAccount,
};
use solana_sdk::{
    native_token::LAMPORTS_PER_SOL,
    signature::{Keypair, Signer},
};

#[test]
fn test_create_mint() {
    let mut svm = LiteSVM::new();

    // Create payer account and fund it
    let payer = Keypair::new();
    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();

    // Create a new SPL token mint with the payer as the mint authority
    let mint = CreateMint::new(&mut svm, &payer)
        .authority(&payer.pubkey())
        .decimals(DECIMALS)
        .send()
        .unwrap();

    // Create an ATA for the payer
    // You must have created a Mint Account to be able to create a Token Account
    let associated_token_account = CreateAssociatedTokenAccount::new(&mut svm, &payer, &mint)
        .owner(&payer.pubkey())
        .send()
        .unwrap();
}

Tokens Aanmaken in een Token Account

Zodra u een mint en token accounts heeft, kunt u tokens naar die accounts aanmaken.

use litesvm::LiteSVM;
use litesvm_token::{
    get_spl_account,
    spl_token::{native_mint::DECIMALS, state::Account as TokenAccount},
    CreateAssociatedTokenAccount, CreateMint, MintTo,
};
use solana_sdk::{
    native_token::LAMPORTS_PER_SOL,
    signature::{Keypair, Signer},
};

#[test]
fn test_mint_tokens() {
    let mut svm = LiteSVM::new();

    // Create payer account and fund it
    let payer = Keypair::new();
    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();

    // Create two users
    let alice = Keypair::new();

    // Create a new SPL token mint with alice as the mint authority
    let mint = CreateMint::new(&mut svm, &payer)
        .authority(&alice.pubkey())
        .decimals(DECIMALS)
        .send()
        .unwrap();

    // Create associated token accounts (ATAs) for alice and bob
    let alice_token_account = CreateAssociatedTokenAccount::new(&mut svm, &payer, &mint)
        .owner(&alice.pubkey())
        .send()
        .unwrap();

    // Mint 1000 tokens to Alice's account
    MintTo::new(&mut svm, &payer, &mint, &alice_token_account, 1000)
        .owner(&alice)
        .send()
        .unwrap();

    // Verify balance
    let alice_account: TokenAccount = get_spl_account(&svm, &alice_token_account).unwrap();
    let alice_balance = alice_account.amount;
    assert_eq!(alice_balance, 1000);
}

Een Tokenoverdracht Uitvoeren

Draag tokens over tussen accounts met behulp van de Transfer-instructie.

use litesvm::LiteSVM;
use litesvm_token::{
    get_spl_account,
    spl_token::{native_mint::DECIMALS, state::Account as TokenAccount},
    CreateAssociatedTokenAccount, CreateMint, MintTo, Transfer,
};
use solana_sdk::{
    native_token::LAMPORTS_PER_SOL,
    signature::{Keypair, Signer},
};

#[test]
fn test_token_transfer() {
        let mut svm = LiteSVM::new();

    // Create payer account and fund it
    let payer = Keypair::new();
    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();

    // Create two users
    let alice = Keypair::new();
    let bob = Keypair::new();

    // Create a new SPL token mint with alice as the mint authority
    let mint = CreateMint::new(&mut svm, &payer)
        .authority(&alice.pubkey())
        .decimals(DECIMALS)
        .send()
        .unwrap();

    // Create associated token accounts (ATAs) for alice and bob
    let alice_token_account = CreateAssociatedTokenAccount::new(&mut svm, &payer, &mint)
        .owner(&alice.pubkey())
        .send()
        .unwrap();

    let bob_token_account = CreateAssociatedTokenAccount::new(&mut svm, &payer, &mint)
        .owner(&bob.pubkey())
        .send()
        .unwrap();

    // Mint 1000 tokens to Alice's account
    MintTo::new(&mut svm, &payer, &mint, &alice_token_account, 1000)
        .owner(&alice)
        .send()
        .unwrap();

    // Transfer 400 tokens from Alice to Bob
    Transfer::new(&mut svm, &payer, &mint, &bob_token_account, 400)
        .source(&alice_token_account)
        .owner(&alice)
        .send()
        .unwrap();

    // Verify balances
    let alice_account: TokenAccount = get_spl_account(&svm, &alice_token_account).unwrap();
    let bob_account: TokenAccount = get_spl_account(&svm, &bob_token_account).unwrap();

    let alice_balance = alice_account.amount;
    let bob_balance = bob_account.amount;

    assert_eq!(alice_balance, 600);
    assert_eq!(bob_balance, 400);

    println!("SPL token transfer successful!");
}

Werken met Decimalen

De meeste tokens gebruiken decimalen om fractionele bedragen weer te geven. Zo gaat u er correct mee om:

// For a token with 6 decimals (like USDC)
let decimals = 6;
let one_token = 10_u64.pow(decimals as u32);
let amount_tokens = 100; // Want to send 100 tokens
let amount_raw = amount_tokens * one_token; // 100,000,000 raw units

// For a token with 9 decimals (like SOL)
let decimals = 9;
let one_sol = 10_u64.pow(decimals as u32);
let amount_sol = 1.5; // Want to send 1.5 SOL
let amount_lamports = (amount_sol * one_sol as f64) as u64; // 1,500,000,000 lamports