Configurazione degli Account

Dimostra come inizializzare direttamente lo stato degli account con SetAccount, senza eseguire transazioni. Questo approccio è significativamente più veloce rispetto all'airdrop e al finanziamento tramite il runtime quando si ha bisogno di molti account pronti per un test.

Configurazione Base degli Account

package mytest

import (
    "testing"

    litesvm "github.com/LiteSVM/litesvm-go"
    solana "github.com/gagliardetto/solana-go"
)

func TestBasicAccountSetup(t *testing.T) {
    svm, err := litesvm.New()
    if err != nil {
        t.Fatal(err)
    }
    defer svm.Close()

    // Calculate minimum balance for rent exemption.
    accountData := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    minBalance, err := svm.MinimumBalanceForRentExemption(len(accountData))
    if err != nil {
        t.Fatal(err)
    }
    t.Logf("minimum balance for %d bytes: %d lamports", len(accountData), minBalance)

    // Owner program (system program in this trivial example).
    owner := solana.SystemProgramID
    testAddr := solana.NewWallet().PublicKey()

    // Build the account handle, then store it.
    acct, err := litesvm.NewAccount(minBalance, accountData, owner, false, 0)
    if err != nil {
        t.Fatal(err)
    }
    defer acct.Close()

    if err := svm.SetAccount(testAddr, acct); err != nil {
        t.Fatal(err)
    }
    t.Log("account state set successfully")

    // Retrieve the account back.
    retrieved := svm.GetAccount(testAddr)
    if retrieved == nil {
        t.Fatal("expected account to exist")
    }
    defer retrieved.Close()

    t.Logf("  address:    %s", testAddr)
    t.Logf("  lamports:   %d", retrieved.Lamports())
    t.Logf("  owner:      %s", retrieved.Owner())
    t.Logf("  executable: %v", retrieved.Executable())
    t.Logf("  data:       %v", retrieved.Data())

    // Or just read the balance.
    bal, _, err := svm.Balance(testAddr)
    if err != nil {
        t.Fatal(err)
    }
    t.Logf("balance: %d lamports", bal)
}

Configurazione di Più Account

func TestMultipleAccounts(t *testing.T) {
    svm, err := litesvm.New()
    if err != nil {
        t.Fatal(err)
    }
    defer svm.Close()

    owner := solana.SystemProgramID

    // Set up 5 accounts with different data payloads.
    addrs := make([]solana.PublicKey, 5)
    for i := range addrs {
        addrs[i] = solana.NewWallet().PublicKey()

        data := []byte{byte(i), byte(i + 1), byte(i + 2)}
        rent, err := svm.MinimumBalanceForRentExemption(len(data))
        if err != nil {
            t.Fatal(err)
        }

        acct, err := litesvm.NewAccount(rent, data, owner, false, 0)
        if err != nil {
            t.Fatal(err)
        }
        if err := svm.SetAccount(addrs[i], acct); err != nil {
            acct.Close()
            t.Fatal(err)
        }
        acct.Close()

        t.Logf("account %d: %s", i, addrs[i])
    }

    // Verify each account.
    for i, addr := range addrs {
        a := svm.GetAccount(addr)
        if a == nil {
            t.Fatalf("account %d missing", i)
        }
        t.Logf("  account %d: %d lamports, data[0]=%d", i, a.Lamports(), a.Data()[0])
        a.Close()
    }
}

Configurazione del program data account

Configura un account dati di proprietà di un programma serializzando il layout della tua struct nel campo data dell'account. Questo snippet importa inoltre encoding/binary:

import "encoding/binary"

func TestProgramDataAccount(t *testing.T) {
    svm, err := litesvm.New()
    if err != nil {
        t.Fatal(err)
    }
    defer svm.Close()

    programID := solana.NewWallet().PublicKey()
    dataAddr := solana.NewWallet().PublicKey()

    // Example layout: [u8 discriminator, u64 counter, 32-byte owner pubkey]
    data := make([]byte, 1+8+32)
    data[0] = 0x01                                      // discriminator
    binary.LittleEndian.PutUint64(data[1:9], 100)       // counter
    // copy(data[9:], ownerPubkey[:])                   // owner

    rent, err := svm.MinimumBalanceForRentExemption(len(data))
    if err != nil {
        t.Fatal(err)
    }

    acct, err := litesvm.NewAccount(rent, data, programID, false, 0)
    if err != nil {
        t.Fatal(err)
    }
    defer acct.Close()

    if err := svm.SetAccount(dataAddr, acct); err != nil {
        t.Fatal(err)
    }

    t.Logf("program data account set up: %s", dataAddr)
}

SetAccount è più veloce dell'esecuzione di transazioni per la configurazione in blocco degli account, e mantiene il codice di test focalizzato sul comportamento testato anziché sulla logica di costruzione dello stato.

Punti Chiave

Stato diretto - SetAccount scrive lo stato dell'account senza passare per il runtime.
Esenzione dall'affitto - usa MinimumBalanceForRentExemption per calcolare i lamport prima di costruire l'account.
Proprietà - NewAccount restituisce un handle di cui sei ancora proprietario. La SVM mantiene una propria copia dopo SetAccount; rilascia la tua quando hai finito.
Verifica - usa GetAccount per rileggere i dati in un handle, oppure Balance per un controllo basato solo sui lamport.

Configurazione degli Account

Configurazione Base degli Account

Configurazione di Più Account

Configurazione del program data account

Punti Chiave

Indice dei contenuti