Gestion des comptes

Méthodes pour alimenter, lire et écrire des comptes.

Airdrop

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

Alimenter un compte en lamports. Implémenté comme un vrai transfert de System Program depuis le faucet interne, donc le destinataire doit être en mesure de détenir le solde résultant.

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)
}

Solde

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

Retourne le solde SOL du compte. La seconde valeur est false lorsque le compte n'existe pas — à distinguer de « le compte existe avec zéro 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

Récupère un handle de compte opaque, ou nil si le compte n'existe pas. Toujours Close le handle (ou se fier au finaliseur).

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)

Méthodes du compte

Méthode	Retourne	Description
`Lamports()`	`uint64`	Solde SOL
`Owner()`	`solana.PublicKey`	Programme propriétaire
`Executable()`	`bool`	Indique si le compte est exécutable
`RentEpoch()`	`uint64`	epoch de rent
`Data()`	`[]byte`	Copie des données du compte
`Close()`	-	Libère le handle Rust sous-jacent

NewAccount

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

Construit une valeur Account à passer à SetAccount. L'appelant reste propriétaire du handle retourné et doit le 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

Stocke une copie de acct à pubkey. Le SVM conserve sa propre copie ; l'appelant reste propriétaire de acct et doit le Close.

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

SetAccount est nettement plus rapide que l'exécution de transactions lorsque vous avez simplement besoin de seed de nombreux comptes pour un test. Assurez-vous que la valeur en lamports est au moins le minimum d'exemption de rent pour la taille des données.

MinimumBalanceForRentExemption

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

Calcule les lamports requis pour qu'un compte d'une longueur de données donnée soit exempt de 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)
}

Gestion des programmes

AddProgram

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

Charge un programme SBF depuis des octets en mémoire.

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

Charge un programme SBF depuis le chemin d'un fichier .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

Charge un programme SBF avec un chargeur spécifique. Utile pour tester avec une version de chargeur BPF non définie par défaut.

Configuration des comptes par lot

Pour les tests nécessitant de nombreux comptes avec seed, itérez sur 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()
}

Toujours Close le *Account retourné par NewAccount une fois que le SVM a stocké sa copie via SetAccount — le SVM ne prend pas possession du handle.

Table des matières