Aloittaminen

Solana-testipaketit, jotka käynnistävät solana-test-validator-prosessin, vievät sekunteja testiä kohden – odotusaika kuluu prosessin käynnistykseen, RPC-yhteyksiin ja verkkopyyntöihin. LiteSVM ajaa samat testit millisekunteissa. Ei ulkoisia prosesseja, ei verkkoa, kaikki tapahtuu muistissa testiajoympäristösi sisällä.

litesvm-go on virallinen Go-sidonta. Perustyypit (PublicKey, Hash, Signature) tulevat suoraan gagliardetto/solana-go-kirjastosta, joten arvot siirtyvät luontevasti litesvm-go-paketin ja muun Go Solana -ekosysteemin välillä.

Vaatimukset: Go 1.24+. Rust-työkaluketjua ei tarvita – esikäännetyt staattiset arkistot on toimitettu moduulin mukana ja valitaan automaattisesti GOOS- / GOARCH-muuttujien perusteella. Tuetut alustat: macOS (amd64, arm64), Linux (amd64, arm64; glibc tai musl), Windows (amd64).

Uusi LiteSVM-kahva tarjoaa ilmaiset siirrot (airdrop), tapahtumat (legacy + v0), simuloinnin, tilien luku-/kirjoitustoiminnot, sysvars-muuttujat, laskentabudjetin, ominaisuusportit, aikasiirtymän, mukautetut ohjelmat ja tapahtumahistorian – kaikki saman Rust-ytimen tukemana, joka toimii myös Rust- ja TypeScript-SDK:iden pohjana.

Pikaopas

Asenna moduuli

go get ratkaisee riippuvuudet Go-moduuliin, joten alusta sellainen ensin, jos sinulla ei vielä ole go.mod-tiedostoa:

go mod init mytest

Lisää sitten moduuli:

go get github.com/LiteSVM/litesvm-go

Hae myös solana-go keypair-, ohje- ja tapahtumarakentamista varten:

go get github.com/gagliardetto/solana-go

Alpine / musl-käyttäjät: lisää -tags musl go build- / go test- kutsuusi, jotta oikea toimitettu arkisto linkitetään.

Luo SVM-instanssisi

package mytest

import (
    "testing"

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

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

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

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

    // Check the balance
    lamports, ok, err := svm.Balance(payer)
    if err != nil {
        t.Fatal(err)
    }
    if !ok {
        t.Fatal("payer account missing")
    }
    t.Logf("balance: %d lamports", lamports)
}

litesvm.New() palauttaa *LiteSVM-arvon ja error-arvon. Jokainen sisäänkäyntipiste litesvm-go-paketissa noudattaa samaa (arvo, error)-muotoa; Rust-puolen panickit otetaan kiinni ja muunnetaan virheiksi. Kutsu aina defer svm.Close(), jotta taustalla oleva Rust-kahva vapautetaan – tai luota finaliseriin, vaikka eksplisiittinen Close on suositeltava ennakoitavan siivouksen kannalta.

Kahvan ymmärtäminen

litesvm.New()-kutsun jälkeen palautettu *LiteSVM tarjoaa nämä ominaisuusryhmät:

Ryhmä	Metodit
Tilit	`Airdrop`, `Balance`, `GetAccount`, `SetAccount`, `MinimumBalanceForRentExemption`
Tapahtumat	`SendLegacyTransaction`, `SendVersionedTransaction`, `SimulateLegacyTransaction`, `SimulateVersionedTransaction`, `GetTransaction`
Lohkohajautusarvo	`LatestBlockhash`, `ExpireBlockhash`
Ohjelmat	`AddProgram`, `AddProgramFromFile`, `AddProgramWithLoader`
Aika ja sysvars	`WarpToSlot`, `Clock`, `SetClock`, `Rent`, `SetRent`, `EpochSchedule`, `SetEpochSchedule`, `EpochRewards`, ...
Asetukset	`SetSigverify`, `SetBlockhashCheck`, `SetTransactionHistory`, `SetLogBytesLimit`, `SetSysvars`, `SetBuiltins`, ...
Laskenta ja ominaisuudet	`ComputeBudget`, `SetComputeBudget`, `SetFeatureSet`

Uusi LiteSVM toimitetaan Solanan ydinohjelmat valmiiksi ladattuina (System Program, SPL Token jne.), joten yksinkertaiset siirrot toimivat heti ilman lisäasetuksia.

Tapahtumien lähettäminen

Rakenna ohjeet solana-go-paketilla, serialisoi tapahtuma ja lähetä tavut. litesvm-go hyväksyy bincode-koodatut tavut, jotka tuottaa (*solana.Transaction).MarshalBinary:

package mytest

import (
    "testing"

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

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

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

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

    blockhash, err := svm.LatestBlockhash()
    if err != nil {
        t.Fatal(err)
    }
    ix := system.NewTransferInstruction(1_000_000_000, payer, recipient).Build()
    tx, err := solana.NewTransaction(
        []solana.Instruction{ix},
        blockhash,
        solana.TransactionPayer(payer),
    )
    if err != nil {
        t.Fatal(err)
    }
    if _, err := tx.Sign(func(k solana.PublicKey) *solana.PrivateKey {
        if k.Equals(payer) {
            return &priv
        }
        return nil
    }); err != nil {
        t.Fatal(err)
    }
    txBytes, err := tx.MarshalBinary()
    if err != nil {
        t.Fatal(err)
    }

    out, err := svm.SendLegacyTransaction(txBytes)
    if err != nil {
        t.Fatal(err)
    }
    defer out.Close()

    if !out.IsOk() {
        t.Fatalf("tx failed: %s\nlogs: %v", out.Error(), out.Logs())
    }

    lamports, _, err := svm.Balance(recipient)
    if err != nil {
        t.Fatal(err)
    }
    if lamports != 1_000_000_000 {
        t.Fatalf("recipient balance = %d, want 1_000_000_000", lamports)
    }
}

SendLegacyTransaction ja SendVersionedTransaction palauttavat molemmat *TxOutcome-arvon riippumatta siitä, onnistuiko tapahtuma vai ei. Kutsu IsOk() ennen vain onnistumistilanteessa käytettävien kenttien lukemista, ja kutsu aina defer out.Close() Rust-kahvan vapauttamiseksi.

TxOutcome-arvon käsittely

Jokainen lähetys- ja simulointisisäänkäyntipiste palauttaa *TxOutcome-arvon. Sama kahva kantaa metatietoja sekä onnistumis- että epäonnistumistilanteelle:

out, err := svm.SendLegacyTransaction(txBytes)
if err != nil {
    t.Fatal(err)
}
defer out.Close()

if !out.IsOk() {
    t.Fatalf("error: %s", out.Error())
}

_ = out.Signature()    // solana.Signature
_ = out.ComputeUnits() // uint64
_ = out.Fee()          // uint64
_ = out.Logs()         // []string
_ = out.InnerInstructions()

// Programs that call set_return_data expose it here.
if pid, data, ok := out.ReturnData(); ok {
    _ = pid
    _ = data
}

SimulateLegacyTransaction- / SimulateVersionedTransaction-kutsuissa sama *TxOutcome tarjoaa lisäksi PostAccounts()-metodin – tileiden oletettu tila suorituksen jälkeen:

sim, err := svm.SimulateLegacyTransaction(txBytes)
if err != nil {
    t.Fatal(err)
}
defer sim.Close()

posts, err := sim.PostAccounts()
if err != nil {
    t.Fatal(err)
}
for _, p := range posts {
    _ = p.Address
    _ = p.Account.Lamports()
    p.Account.Close()
}

Asetukset

litesvm-go tarjoaa samat rakentajakytkimet kuin Rust-crate, Set*-metodeina:

// Each setter returns an error. In tests where the values are known good,
// the calls are infallible and assigning to _ keeps the example readable;
// in production code, check the error or wrap with require.NoError(t, ...).
_ = svm.SetSigverify(false)        // accept unsigned / badly-signed txs
_ = svm.SetBlockhashCheck(false)   // skip recent-blockhash enforcement
_ = svm.SetTransactionHistory(0)   // 0 disables dedup; any N caps history
_ = svm.SetLogBytesLimit(-1)       // negative = unlimited
_ = svm.SetLamports(1 << 40)       // default lamports for new accounts
_ = svm.SetSysvars()               // reset sysvars to defaults
_ = svm.SetBuiltins()              // reload built-in programs
_ = svm.SetDefaultPrograms()       // reload SPL Token, Memo, etc.
_ = svm.SetPrecompiles()           // enable ed25519 / secp256k1 precompiles
_ = svm.WithNativeMints()          // seed wrapped-SOL mint

Huomioita

Säieturvallisuus. *LiteSVM-kahva ei ole turvallinen samanaikaiseen käyttöön useilta goroutiineilta (taustalla oleva Rust-tyyppi ei ole Sync, ja useimmat metodit muokkaavat sisäistä tilaa). Rajoita kahva yhteen goroutiiniin tai suojaa se sync.Mutex-lukolla.

Panic-käyttäytyminen. Toimitetut julkaisuarkistot on rakennettu immediate-abort-asetuksella: jokainen Rust-puolen panic keskeyttää isäntäprosessin välittömästi ilman pinon purkamista. Tämä on tietoinen valinta pienempien arkistojen puolesta. Jos kohtaat sellaisen käytännössä, avaa ongelmaraportti ja liitä mukaan toistettava esimerkki.

Mitä seuraavaksi

Tässä käsiteltiin ydinosa – tilien luominen, ohjeiden lähettäminen ja tilan lukeminen. Täydellinen metodi kerrallaan -viite löytyy API-dokumentaatiosta. Ajettavia esimerkkejä (SOL-siirto, tilien alustus, ohjelmien testaus, aikapohjainen logiikka) löytyy Esimerkit-osiosta.

Sisällysluettelo