Szybki start

Zobacz litesvm-token na crates.io

Instalacja

Upewnij się, że masz wszystkie potrzebne zależności:

cargo add --dev litesvm litesvm-token solana-sdk spl-token spl-associated-token-account

Podstawy tokenów SPL

W Solanie tworzenie token account to proces dwuetapowy.

Utwórz Mint Account

Nie posiada salda tokenów
Przechowuje wszystkie globalne informacje o tokenie, takie jak całkowita podaż, liczba miejsc dziesiętnych, uprawnienia itp.
Istnieje jeden mint account na token
Właścicielem jest Token Program (TokenKeg lub Token 2022)

Utwórz Token Account

Przechowuje saldo dla konkretnego tokena SPL
Zawiera mint account określający, który token SPL znajduje się na tym koncie
Dla jednego mint account może istnieć kilka token accounts
Właściciel to osoba mająca kontrolę nad tokenami na tym koncie

Typy token accounts

Zwykły token account

Token account przechowuje Twoje saldo dla konkretnego tokena SPL:

// Can create token accounts at ANY address
let token_account = Keypair::new();  // Random address
let create_ix = system_instruction::create_account(
    &payer.pubkey(),
    &token_account.pubkey(),  // Any address you want
    rent,
    165,  // Token account size
    &spl_token::id(),
);
let init_ix = spl_token::instruction::initialize_account(
    &spl_token::id(),
    &token_account.pubkey(),
    &mint,
    &owner.pubkey(),
)?;

✓ Zalety

•Możliwość tworzenia wielu kont dla tego samego mint/właściciela
•Elastyczność – możliwość użycia dowolnego adresu

✗ Wady

•Niedeterministyczne – adresy trzeba śledzić ręcznie
•Odbiorca musi wskazać, na które konto wysłać środki
•Wiele kont powoduje zamieszanie

Kiedy stosować: Tymczasowe konta / konta escrow, konta należące do programu z niestandardową logiką, gdy potrzeba wielu kont dla tego samego tokena, zaawansowane strategie DeFi.

Associated Token Account (ATA)

ATA to token account o deterministycznym adresie PDA:

// ATA address is ALWAYS the same for owner + mint
let ata = get_associated_token_address(&owner.pubkey(), &mint);
// Address derived from: [owner_pubkey, token_program_id, mint]

Sposób wyprowadzania adresu ATA:

// ATA is a PDA owned by the Associated Token Program
let (ata, bump) = Pubkey::find_program_address(
    &[
        owner.as_ref(),
        spl_token::id().as_ref(),
        mint.as_ref(),
    ],
    &spl_associated_token_account::id(),  // ATA program
);

✓ Zalety

•Jedno kanoniczne konto dla każdej pary właściciel/mint
•Deterministyczne – każdy może obliczyć adres
•Upraszcza płatności – wystarczy adres portfela i mint
•Standardowa konwencja we wszystkich aplikacjach Solana

✗ Wady

•Można mieć tylko JEDEN ATA dla danej pary właściciel/mint (z założenia)

Zalecane w większości przypadków: Aplikacje portfelowe, protokoły DeFi, zasoby NFT, systemy płatności oraz wszelkie transfery tokenów widoczne dla użytkownika.

Szybki przykład

Oto kompletny przykład tworzenia mint tokena i mintowania tokenów:

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

#[test]
fn test_create_and_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 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
    let token_account = CreateAccount::new(&mut svm, &payer, &mint)
        .owner(&payer.pubkey())
        .send()
        .unwrap();

    // Mint tokens into the payer's token account
    MintTo::new(&mut svm, &payer, &mint, &token_account, 1000)
        .owner(&payer)
        .send()
        .unwrap();

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

Kluczowe pojęcia

Miejsca dziesiętne tokena

Większość tokenów używa miejsc dziesiętnych do reprezentowania ułamkowych ilości:

// SOL has 9 decimals
let one_sol = 10_u64.pow(9);  // 1_000_000_000 lamports

// USDC has 6 decimals
let one_usdc = 10_u64.pow(6); // 1_000_000 micro-USDC

// Always account for decimals in calculations
let amount_tokens = 100;
let amount_raw = amount_tokens * 10_u64.pow(decimals as u32);

Relacje między kontami

Zrozumienie relacji między kontami jest kluczowe:

Konto Mint: Definiuje token (podaż, miejsca dziesiętne, uprawnienia)
Token account: Przechowuje tokeny dla określonego właściciela
Associated token account: Deterministyczne token account dla pary właściciel+mint
Uprawnienie Mint: Umożliwia tworzenie nowych tokenów
Uprawnienie Freeze: Umożliwia zamrażanie token account (opcjonalne)

Rozwiązywanie problemów

Typowe błędy

Błąd	Przyczyna	Rozwiązanie
`AccountNotFound`	Próba użycia konta, które nie istnieje	Upewnij się, że konto zostało utworzone przed użyciem
`AccountAlreadyInitialized`	Próba inicjalizacji już zainicjalizowanego konta	Sprawdź, czy konto istnieje przed jego utworzeniem
`InsufficientFunds`	Niewystarczająca ilość lamport na rent lub tokenów do transferu	Zapewnij odpowiednie finansowanie/mintowanie
`OwnerMismatch`	Konto należy do niewłaściwego programu	Zweryfikuj poprawne ID programu podczas tworzenia

✓ Zalety

✗ Wady

✓ Zalety

✗ Wady

Spis treści