Gestione degli Account

Metodi per finanziare, leggere e scrivere account.

Airdrop

func (s *LiteSVM) Airdrop(pubkey solana.PublicKey, lamports uint64) error

Finanzia un account con lamport. Implementato come un vero trasferimento tramite System Program dal faucet interno, quindi il destinatario deve essere in grado di mantenere il saldo risultante.

priv, err := solana.NewRandomPrivateKey()
if err != nil {
    t.Fatal(err)
}
payer := priv.PublicKey()

// Airdrop 5 SOL
if err := svm.Airdrop(payer, 5_000_000_000); err != nil {
    t.Fatal(err)
}

Balance

func (s *LiteSVM) Balance(pubkey solana.PublicKey) (uint64, bool, error)

Restituisce il saldo SOL dell'account. Il secondo valore è false quando l'account non esiste — distinto da "account esistente con zero lamport".

lamports, ok, err := svm.Balance(payer)
if err != nil {
    t.Fatal(err)
}
if !ok {
    t.Log("account does not exist")
} else {
    t.Logf("balance: %d lamports (%.3f SOL)", lamports, float64(lamports)/1e9)
}

GetAccount

func (s *LiteSVM) GetAccount(pubkey solana.PublicKey) *Account

Recupera un handle opaco dell'account, oppure nil se l'account non esiste. Chiudi sempre l'handle con Close (o affidati al finalizer).

acct := svm.GetAccount(payer)
if acct == nil {
    t.Fatal("account missing")
}
defer acct.Close()

_ = acct.Lamports()    // uint64
_ = acct.Owner()       // solana.PublicKey
_ = acct.Executable()  // bool
_ = acct.RentEpoch()   // uint64
_ = acct.Data()        // []byte (copy)

Metodi dell'account

Metodo	Restituisce	Descrizione
`Lamports()`	`uint64`	Saldo SOL
`Owner()`	`solana.PublicKey`	Programma proprietario
`Executable()`	`bool`	Indica se l'account è eseguibile
`RentEpoch()`	`uint64`	epoch di rent
`Data()`	`[]byte`	Copia dei dati dell'account
`Close()`	-	Rilascia l'handle Rust sottostante

NewAccount

func NewAccount(lamports uint64, data []byte, owner solana.PublicKey, executable bool, rentEpoch uint64) (*Account, error)

Costruisce un valore Account da passare a SetAccount. Il chiamante conserva la proprietà dell'handle restituito e deve chiamare Close.

payload := []byte{1, 2, 3, 4}
rent, err := svm.MinimumBalanceForRentExemption(len(payload))
if err != nil {
    t.Fatal(err)
}

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

SetAccount

func (s *LiteSVM) SetAccount(pubkey solana.PublicKey, acct *Account) error

Memorizza una copia di acct in corrispondenza di pubkey. La SVM mantiene una propria copia; il chiamante continua a possedere acct e deve chiamare Close.

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

SetAccount è significativamente più veloce dell'esecuzione di transazioni quando hai solo bisogno di fare il seed di molti account per un test. Assicurati che il valore in lamport sia almeno il minimo esente da rent per la dimensione dei dati.

MinimumBalanceForRentExemption

func (s *LiteSVM) MinimumBalanceForRentExemption(dataLen int) (uint64, error)

Calcola i lamport necessari affinché un account della lunghezza dati specificata sia esente da rent.

for _, size := range []int{0, 100, 1024} {
    min, err := svm.MinimumBalanceForRentExemption(size)
    if err != nil {
        t.Fatal(err)
    }
    t.Logf("%4d bytes -> %d lamports", size, min)
}

Gestione dei Programmi

AddProgram

func (s *LiteSVM) AddProgram(programID solana.PublicKey, bytes []byte) error

Carica un programma SBF da byte in memoria.

bytes, err := os.ReadFile("./target/deploy/my_program.so")
if err != nil {
    t.Fatal(err)
}
if err := svm.AddProgram(programID, bytes); err != nil {
    t.Fatal(err)
}

AddProgramFromFile

func (s *LiteSVM) AddProgramFromFile(programID solana.PublicKey, path string) error

Carica un programma SBF da un percorso di file .so.

if err := svm.AddProgramFromFile(programID, "./target/deploy/my_program.so"); err != nil {
    t.Fatal(err)
}

AddProgramWithLoader

func (s *LiteSVM) AddProgramWithLoader(programID solana.PublicKey, bytes []byte, loaderID solana.PublicKey) error

Carica un programma SBF con un loader specifico. Utile per testare con una versione non predefinita del loader BPF.

Configurazione Batch degli Account

Per i test che richiedono molti account con seed, itera su SetAccount:

const N = 10
for i := 0; i < N; i++ {
    pk := solana.NewWallet().PublicKey()
    data := []byte{byte(i)}
    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(pk, acct); err != nil {
        acct.Close()
        t.Fatal(err)
    }
    acct.Close()
}

Chiudi sempre l'*Account restituito da NewAccount una volta che la SVM ha memorizzato la propria copia tramite SetAccount — la SVM non acquisisce la proprietà dell'handle.

Indice dei contenuti