Time & Sysvars

Methods for manipulating time and accessing system variables. Every sysvar getter has a matching setter; the structs are plain Go mirrors of the Solana source.

Clock Manipulation

WarpToSlot

func (s *LiteSVM) WarpToSlot(slot uint64) error

Advance the internal clock to a specific slot.

before, err := svm.Clock()
if err != nil {
    t.Fatal(err)
}
t.Logf("current slot: %d", before.Slot)

if err := svm.WarpToSlot(10_000_000); err != nil {
    t.Fatal(err)
}

after, err := svm.Clock()
if err != nil {
    t.Fatal(err)
}
t.Logf("new slot:     %d", after.Slot)

Clock

type Clock struct {
    Slot                uint64
    EpochStartTimestamp int64
    Epoch               uint64
    LeaderScheduleEpoch uint64
    UnixTimestamp       int64
}

func (s *LiteSVM) Clock() (Clock, error)

Read the Clock sysvar.

c, err := svm.Clock()
if err != nil {
    t.Fatal(err)
}
t.Logf("slot=%d epoch=%d unix=%d", c.Slot, c.Epoch, c.UnixTimestamp)

SetClock

func (s *LiteSVM) SetClock(c Clock) error

Overwrite the Clock sysvar. Read it, mutate fields, write it back when you need control over Epoch or UnixTimestamp (which WarpToSlot does not update).

c, err := svm.Clock()
if err != nil {
    t.Fatal(err)
}
c.Slot = 1_000
c.Epoch = 10
c.UnixTimestamp = 1_735_689_600
if err := svm.SetClock(c); err != nil {
    t.Fatal(err)
}

WarpToSlot only updates Slot. Use SetClock when your program reads Epoch or UnixTimestamp from the Clock sysvar.

Rent

Rent / SetRent

type Rent struct {
    LamportsPerByteYear uint64
    ExemptionThreshold  float64
    BurnPercent         uint8
}

func (s *LiteSVM) Rent() (Rent, error)
func (s *LiteSVM) SetRent(r Rent) error

r, err := svm.Rent()
if err != nil {
    t.Fatal(err)
}
t.Logf("lamports/byte-year: %d", r.LamportsPerByteYear)
t.Logf("exemption threshold: %.2f", r.ExemptionThreshold)
t.Logf("burn percent: %d", r.BurnPercent)

MinimumBalanceForRentExemption

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

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

Epoch Schedule

type EpochSchedule struct {
    SlotsPerEpoch            uint64
    LeaderScheduleSlotOffset uint64
    Warmup                   bool
    FirstNormalEpoch         uint64
    FirstNormalSlot          uint64
}

func (s *LiteSVM) EpochSchedule() (EpochSchedule, error)
func (s *LiteSVM) SetEpochSchedule(e EpochSchedule) error

es, err := svm.EpochSchedule()
if err != nil {
    t.Fatal(err)
}
t.Logf("slots per epoch: %d", es.SlotsPerEpoch)
t.Logf("first normal epoch: %d", es.FirstNormalEpoch)
t.Logf("first normal slot:  %d", es.FirstNormalSlot)

Epoch Rewards

type EpochRewards struct {
    DistributionStartingBlockHeight uint64
    NumPartitions                   uint64
    ParentBlockhash                 solana.Hash
    TotalPointsLo                   uint64 // low 64 bits of the u128 total_points
    TotalPointsHi                   uint64 // high 64 bits
    TotalRewards                    uint64
    DistributedRewards              uint64
    Active                          bool
}

func (s *LiteSVM) EpochRewards() (EpochRewards, error)
func (s *LiteSVM) SetEpochRewards(e EpochRewards) error

total_points is a u128 on the Solana side; litesvm-go surfaces both halves explicitly so Go callers do not need a u128 library. For values that fit in 64 bits, TotalPointsHi is 0 and TotalPointsLo is the value.

Slot Information

LastRestartSlot / SetLastRestartSlot

func (s *LiteSVM) LastRestartSlot() (uint64, error)
func (s *LiteSVM) SetLastRestartSlot(slot uint64) error

last, err := svm.LastRestartSlot()
if err != nil {
    t.Fatal(err)
}
if err := svm.SetLastRestartSlot(last + 1); err != nil {
    t.Fatal(err)
}

SlotHashes / SetSlotHashes

type SlotHash struct {
    Slot uint64
    Hash solana.Hash
}

func (s *LiteSVM) SlotHashes() ([]SlotHash, error)
func (s *LiteSVM) SetSlotHashes(items []SlotHash) error

SlotHistory

SlotHistory is a ~128 KB bitvec; litesvm-go exposes it as a handle rather than a slice.

sh, err := litesvm.NewSlotHistory()
if err != nil {
    t.Fatal(err)
}
defer sh.Close()

sh.Add(42)

switch sh.Check(42) {
case litesvm.SlotHistoryFound:
    // ...
case litesvm.SlotHistoryNotFound:
    // ...
case litesvm.SlotHistoryTooOld:
    // ...
case litesvm.SlotHistoryFuture:
    // ...
}

if err := svm.SetSlotHistory(sh); err != nil {
    t.Fatal(err)
}

Method	Description
`litesvm.NewSlotHistory() (*SlotHistory, error)`	Empty handle
`sh.Add(slot uint64)`	Record a slot
`sh.Check(slot uint64) SlotHistoryCheck`	`Future` / `TooOld` / `Found` / `NotFound`
`sh.Oldest() uint64`	Oldest slot tracked
`sh.Newest() uint64`	Newest slot tracked
`sh.NextSlot() uint64`	Next slot to record
`sh.SetNextSlot(slot uint64) error`	Override the next-slot marker
`sh.Close()`	Release the handle
`svm.SlotHistory() (*SlotHistory, error)`	Read into a fresh handle
`svm.SetSlotHistory(*SlotHistory) error`	Install on the SVM

Stake History

type StakeHistoryItem struct {
    Epoch        uint64
    Effective    uint64
    Activating   uint64
    Deactivating uint64
}

func (s *LiteSVM) StakeHistory() ([]StakeHistoryItem, error)
func (s *LiteSVM) SetStakeHistory(items []StakeHistoryItem) error

Testing Time-Dependent Logic

Use WarpToSlot for plain slot-based advancement, SetClock for full control:

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

    const unlockSlot = uint64(10_000)

    // Setup: create the time-locked account ...

    // Test 1: Try to withdraw before unlock (should fail)
    before, err := svm.Clock()
    if err != nil {
        t.Fatal(err)
    }
    t.Logf("current slot: %d", before.Slot)
    // ... attempt withdrawal, expect failure ...

    // Warp time forward past unlock slot
    if err := svm.WarpToSlot(unlockSlot + 1); err != nil {
        t.Fatal(err)
    }

    // Test 2: Try to withdraw after unlock (should succeed)
    after, err := svm.Clock()
    if err != nil {
        t.Fatal(err)
    }
    t.Logf("new slot: %d", after.Slot)
    // ... attempt withdrawal, expect success ...
}

목차