Thời Gian & Sysvar

Các phương thức để thao tác thời gian và truy cập biến hệ thống. Mỗi hàm getter của sysvar đều có một setter tương ứng; các struct là bản sao Go thuần túy của nguồn Solana.

Thao Tác Đồng Hồ

WarpToSlot

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

Tiến đồng hồ nội bộ đến một slot cụ thể.

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)

Đọc sysvar Clock.

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

Ghi đè sysvar Clock. Đọc nó, thay đổi các trường, ghi lại khi bạn cần kiểm soát Epoch hoặc UnixTimestamp (mà WarpToSlot không cập nhật).

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 chỉ cập nhật Slot. Sử dụng SetClock khi chương trình của bạn đọc Epoch hoặc UnixTimestamp từ sysvar Clock.

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 là kiểu u128 ở phía Solana; litesvm-go hiển thị cả hai nửa một cách tường minh để các caller Go không cần thư viện u128. Đối với các giá trị vừa trong 64 bit, TotalPointsHi là 0 và TotalPointsLo là giá trị.

Thông Tin Slot

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 là một bitvec ~128 KB; litesvm-go hiển thị nó dưới dạng handle thay vì một 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)
}

Phương thức	Mô tả
`litesvm.NewSlotHistory() (*SlotHistory, error)`	Handle rỗng
`sh.Add(slot uint64)`	Ghi lại một slot
`sh.Check(slot uint64) SlotHistoryCheck`	`Future` / `TooOld` / `Found` / `NotFound`
`sh.Oldest() uint64`	Slot cũ nhất được theo dõi
`sh.Newest() uint64`	Slot mới nhất được theo dõi
`sh.NextSlot() uint64`	Slot tiếp theo cần ghi lại
`sh.SetNextSlot(slot uint64) error`	Ghi đè điểm đánh dấu slot tiếp theo
`sh.Close()`	Giải phóng handle
`svm.SlotHistory() (*SlotHistory, error)`	Đọc vào một handle mới
`svm.SetSlotHistory(*SlotHistory) error`	Cài đặt lên SVM

Lịch Sử Stake

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

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

Kiểm Thử Logic Phụ Thuộc Thời Gian

Sử dụng WarpToSlot để tiến theo slot thông thường, SetClock để kiểm soát toàn bộ:

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

Mục lục