Vanja/feat/767 code coverage staker (#1279)

* Increase coverage in staker package

* fix after merge

* Fix weight bug, add tests

* Fix after merge

* Fix comment fixes

* Add more tests

Author: vanja-vechain

builtin/staker/transition_test.go

@@ -0,0 +1,74 @@
+// Copyright (c) 2025 The VeChainThor developers
+//
+// Distributed under the GNU Lesser General Public License v3.0 software license, see the accompanying
+// file LICENSE or <https://www.gnu.org/licenses/lgpl-3.0.html>
+package staker
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/vechain/thor/v2/builtin/params"
+	"github.com/vechain/thor/v2/muxdb"
+	"github.com/vechain/thor/v2/state"
+	"github.com/vechain/thor/v2/test/datagen"
+	"github.com/vechain/thor/v2/thor"
+	"github.com/vechain/thor/v2/trie"
+)
+
+func TestTransition(t *testing.T) {
+	db := muxdb.NewMem()
+	st := state.New(db, trie.Root{})
+
+	param := params.New(thor.BytesToAddress([]byte("params")), st)
+
+	assert.NoError(t, param.Set(thor.KeyMaxBlockProposers, big.NewInt(2)))
+	stakerAddr := thor.BytesToAddress([]byte("stkr"))
+	staker := New(stakerAddr, st, param, nil)
+
+	isExecuted, err := staker.transition(thor.EpochLength())
+	assert.NoError(t, err)
+	assert.False(t, isExecuted)
+
+	node1 := datagen.RandAddress()
+	stake := RandomStake()
+	err = staker.AddValidation(node1, node1, uint32(360)*24*15, stake)
+	assert.NoError(t, err)
+
+	isExecuted, err = staker.transition(thor.EpochLength())
+	assert.NoError(t, err)
+	assert.False(t, isExecuted)
+
+	node2 := datagen.RandAddress()
+	err = staker.AddValidation(node2, node2, uint32(360)*24*15, stake)
+	assert.NoError(t, err)
+
+	staker.params.Set(thor.KeyMaxBlockProposers, big.NewInt(0))
+
+	isExecuted, err = staker.transition(thor.EpochLength())
+	assert.NoError(t, err)
+	assert.False(t, isExecuted)
+
+	staker.params.Set(thor.KeyMaxBlockProposers, big.NewInt(2))
+
+	isExecuted, err = staker.transition(thor.EpochLength())
+	assert.NoError(t, err)
+	assert.True(t, isExecuted)
+
+	isExecuted, err = staker.transition(thor.EpochLength())
+	assert.NoError(t, err)
+	assert.False(t, isExecuted)
+
+	activeCountSlot := thor.BytesToBytes32([]byte(("validations-active-group-size")))
+	st.SetRawStorage(stakerAddr, activeCountSlot, rlp.RawValue{0xFF})
+	isExecuted, err = staker.transition(thor.EpochLength())
+	assert.Error(t, err)
+	assert.False(t, isExecuted)
+
+	queuedCountSlot := thor.BytesToBytes32([]byte(("validations-queued-group-size")))
+	st.SetRawStorage(stakerAddr, activeCountSlot, rlp.RawValue{0x0})
+	st.SetRawStorage(stakerAddr, queuedCountSlot, rlp.RawValue{0xFF})
+}

builtin/staker/validation/service_test.go

@@ -43,6 +43,10 @@ func poisonValidationSlot(st *state.State, contract thor.Address, id thor.Addres
 	st.SetRawStorage(contract, slot, rlp.RawValue{0xFF})
 }
 
+func poisonQueueSlot(st *state.State, contract thor.Address) {
+	st.SetRawStorage(contract, slotQueuedGroupSize, rlp.RawValue{0xFF})
+}
+
 func TestService_SetGetValidation_RoundTrip(t *testing.T) {
 	svc, _, _ := newSvc()
 
@@ -630,3 +634,220 @@ func TestService_GetCompletedPeriods(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, uint32(0), periods)
 }
+
+func TestService_GetQueuedAndLeaderGroups(t *testing.T) {
+	svc, _, _ := newSvc()
+
+	a1 := thor.BytesToAddress([]byte("a1"))
+	a2 := thor.BytesToAddress([]byte("a2"))
+	a3 := thor.BytesToAddress([]byte("a3"))
+	for _, id := range []thor.Address{a1, a2, a3} {
+		assert.NoError(t, svc.Add(id, id, thor.LowStakingPeriod(), big.NewInt(1)))
+	}
+
+	queuedCnt, err := svc.QueuedGroupSize()
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(3), queuedCnt)
+
+	leaderCnt, err := svc.LeaderGroupSize()
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(0).String(), leaderCnt.String())
+
+	idPtr, err := svc.NextToActivate(big.NewInt(10))
+	assert.NoError(t, err)
+	assert.Equal(t, a1, *idPtr)
+	_, err = svc.ActivateValidator(*idPtr, 1, &delta.Renewal{NewLockedWeight: big.NewInt(0)})
+	assert.NoError(t, err)
+
+	queuedCnt, err = svc.QueuedGroupSize()
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(2), queuedCnt)
+
+	leaderCnt, err = svc.LeaderGroupSize()
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(1), leaderCnt)
+
+	val, err := svc.GetLeaderGroupHead()
+	assert.NoError(t, err)
+	assert.Equal(t, a1, val.Endorser)
+	assert.Nil(t, val.Beneficiary)
+	assert.Equal(t, big.NewInt(1), val.LockedVET)
+	assert.Equal(t, big.NewInt(1), val.Weight)
+	assert.Equal(t, thor.LowStakingPeriod(), val.Period)
+	assert.Equal(t, uint32(0), val.CompleteIterations)
+	assert.Equal(t, StatusActive, val.Status)
+	assert.Equal(t, uint32(1), val.StartBlock)
+	assert.Nil(t, val.ExitBlock)
+	assert.Nil(t, val.OfflineBlock)
+	assert.Equal(t, big.NewInt(0), val.PendingUnlockVET)
+	assert.Equal(t, big.NewInt(0), val.QueuedVET)
+	assert.Equal(t, big.NewInt(0), val.CooldownVET)
+	assert.Equal(t, big.NewInt(0), val.WithdrawableVET)
+}
+
+func TestService_Add_Error(t *testing.T) {
+	svc, addr, st := newSvc()
+	id1 := thor.BytesToAddress([]byte("id1"))
+	id2 := thor.BytesToAddress([]byte("id2"))
+
+	assert.ErrorContains(t, svc.Add(id1, id1, uint32(1), big.NewInt(1)), "period is out of boundaries")
+	assert.ErrorContains(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(0)), "stake is out of range")
+	assert.NoError(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(1)))
+	assert.ErrorContains(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(1)), "validator already exists")
+
+	poisonValidationSlot(st, addr, id1)
+	assert.Error(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(1)))
+
+	slot := thor.Blake2b(id1.Bytes(), slotValidations.Bytes())
+	st.SetRawStorage(addr, slot, rlp.RawValue{0x0})
+	poisonQueueSlot(st, addr)
+	assert.Error(t, svc.Add(id2, id2, thor.LowStakingPeriod(), big.NewInt(1)))
+}
+
+func TestService_Evict(t *testing.T) {
+	svc, addr, st := newSvc()
+	id1 := thor.BytesToAddress([]byte("id1"))
+
+	assert.NoError(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(1)))
+
+	assert.NoError(t, svc.Evict(id1, 5))
+	val, err := svc.GetValidation(id1)
+	assert.NoError(t, err)
+	expectedExitBlock := uint32(5) + thor.EpochLength()
+	assert.Equal(t, &expectedExitBlock, val.ExitBlock)
+
+	assert.NoError(t, svc.Evict(id1, 7))
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, &expectedExitBlock, val.ExitBlock)
+
+	poisonExitSlot(st, addr, 7+thor.EpochLength())
+	assert.Error(t, svc.Evict(id1, 7))
+
+	poisonValidationSlot(st, addr, id1)
+	assert.Error(t, svc.Evict(id1, 8))
+}
+
+func TestService_SetBeneficiary(t *testing.T) {
+	svc, addr, st := newSvc()
+	id1 := thor.BytesToAddress([]byte("id1"))
+	assert.NoError(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(1)))
+
+	val, err := svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Nil(t, val.Beneficiary)
+
+	assert.NoError(t, svc.SetBeneficiary(id1, id1, id1))
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, &id1, val.Beneficiary)
+
+	assert.NoError(t, svc.SetBeneficiary(id1, id1, thor.Address{}))
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Nil(t, val.Beneficiary)
+
+	assert.ErrorContains(t, svc.SetBeneficiary(id1, thor.Address{}, id1), "invalid endorser")
+	assert.NoError(t, svc.Evict(id1, 2))
+	assert.ErrorContains(t, svc.SetBeneficiary(id1, id1, id1), "validator has exited or signaled exit, cannot set beneficiary")
+
+	poisonValidationSlot(st, addr, id1)
+	assert.Error(t, svc.SetBeneficiary(id1, id1, id1))
+}
+
+func TestService_UpdateOfflineBlock(t *testing.T) {
+	svc, _, _ := newSvc()
+
+	id1 := thor.BytesToAddress([]byte("id1"))
+	assert.NoError(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(1)))
+
+	val, err := svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Nil(t, val.OfflineBlock)
+
+	assert.NoError(t, svc.UpdateOfflineBlock(id1, 2, false))
+
+	expectedOfflineBlk := uint32(2)
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, &expectedOfflineBlk, val.OfflineBlock)
+
+	assert.NoError(t, svc.UpdateOfflineBlock(id1, 2, true))
+
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Nil(t, val.OfflineBlock)
+}
+
+func TestService_Renew(t *testing.T) {
+	svc, _, _ := newSvc()
+
+	id1 := thor.BytesToAddress([]byte("id1"))
+	assert.NoError(t, svc.Add(id1, id1, thor.LowStakingPeriod(), big.NewInt(50)))
+
+	err := svc.IncreaseStake(id1, id1, big.NewInt(600))
+	assert.NoError(t, err)
+	_, err = svc.DecreaseStake(id1, id1, big.NewInt(300))
+	assert.NoError(t, err)
+
+	val, err := svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(0), val.LockedVET)
+	assert.Equal(t, big.NewInt(0), val.Weight)
+	assert.Equal(t, big.NewInt(0), val.PendingUnlockVET)
+	assert.Equal(t, big.NewInt(350), val.QueuedVET)
+	assert.Equal(t, big.NewInt(0), val.CooldownVET)
+	assert.Equal(t, big.NewInt(300), val.WithdrawableVET)
+
+	renewal := delta.Renewal{
+		NewLockedVET:         big.NewInt(1000),
+		NewLockedWeight:      big.NewInt(1500),
+		QueuedDecrease:       big.NewInt(100),
+		QueuedDecreaseWeight: big.NewInt(15),
+	}
+	delta, err := svc.Renew(id1, &renewal, false)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(350), delta.NewLockedVET)
+	assert.Equal(t, big.NewInt(350), delta.NewLockedWeight)
+	assert.Equal(t, big.NewInt(350), delta.QueuedDecrease)
+	assert.Equal(t, big.NewInt(350), delta.QueuedDecreaseWeight)
+
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(350), val.LockedVET)
+	assert.Equal(t, big.NewInt(1850), val.Weight)
+	assert.Equal(t, big.NewInt(0), val.PendingUnlockVET)
+	assert.Equal(t, big.NewInt(0), val.QueuedVET)
+	assert.Equal(t, big.NewInt(0), val.CooldownVET)
+	assert.Equal(t, big.NewInt(300), val.WithdrawableVET)
+
+	err = svc.IncreaseStake(id1, id1, big.NewInt(400))
+	assert.NoError(t, err)
+	_, err = svc.DecreaseStake(id1, id1, big.NewInt(200))
+	assert.NoError(t, err)
+
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(350), val.LockedVET)
+	assert.Equal(t, big.NewInt(1850), val.Weight)
+	assert.Equal(t, big.NewInt(0), val.PendingUnlockVET)
+	assert.Equal(t, big.NewInt(200), val.QueuedVET)
+	assert.Equal(t, big.NewInt(0), val.CooldownVET)
+	assert.Equal(t, big.NewInt(500), val.WithdrawableVET)
+
+	delta, err = svc.Renew(id1, &renewal, true)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(200), delta.NewLockedVET)
+	assert.Equal(t, big.NewInt(200), delta.NewLockedWeight)
+	assert.Equal(t, big.NewInt(200), delta.QueuedDecrease)
+	assert.Equal(t, big.NewInt(200), delta.QueuedDecreaseWeight)
+
+	val, err = svc.GetValidation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(550), val.LockedVET)
+	assert.Equal(t, big.NewInt(3550), val.Weight)
+	assert.Equal(t, big.NewInt(0), val.PendingUnlockVET)
+	assert.Equal(t, big.NewInt(0), val.QueuedVET)
+	assert.Equal(t, big.NewInt(0), val.CooldownVET)
+	assert.Equal(t, big.NewInt(500), val.WithdrawableVET)
+}

builtin/staker/validation/validation_test.go

@@ -0,0 +1,85 @@
+// Copyright (c) 2025 The VeChainThor developers
+//
+// Distributed under the GNU Lesser General Public License v3.0 software license, see the accompanying
+// file LICENSE or <https://www.gnu.org/licenses/lgpl-3.0.html>
+package validation
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/vechain/thor/v2/builtin/staker/aggregation"
+	"github.com/vechain/thor/v2/thor"
+)
+
+var baseVal = Validation{
+	Endorser:           thor.Address{},
+	Beneficiary:        nil,
+	Period:             5,
+	CompleteIterations: 0,
+	Status:             StatusActive,
+	StartBlock:         0,
+	ExitBlock:          nil,
+	OfflineBlock:       nil,
+	LockedVET:          big.NewInt(1000),
+	PendingUnlockVET:   big.NewInt(900),
+	QueuedVET:          big.NewInt(800),
+	CooldownVET:        big.NewInt(700),
+	WithdrawableVET:    big.NewInt(600),
+	Weight:             big.NewInt(1000),
+}
+
+func TestValidation_Totals(t *testing.T) {
+	agg := aggregation.Aggregation{
+		LockedVET:     big.NewInt(500),
+		LockedWeight:  big.NewInt(1000),
+		PendingVET:    big.NewInt(400),
+		PendingWeight: big.NewInt(800),
+		ExitingVET:    big.NewInt(300),
+		ExitingWeight: big.NewInt(600),
+	}
+	totals := baseVal.Totals(&agg)
+	assert.Equal(t, big.NewInt(1500), totals.TotalLockedStake)
+	assert.Equal(t, big.NewInt(1000), totals.TotalLockedWeight)
+	assert.Equal(t, big.NewInt(1200), totals.TotalQueuedStake)
+	assert.Equal(t, big.NewInt(1600), totals.TotalQueuedWeight)
+	assert.Equal(t, big.NewInt(1200), totals.TotalExitingStake)
+	assert.Equal(t, big.NewInt(1500), totals.TotalExitingWeight)
+
+	exitBlock := uint32(2)
+	val := baseVal
+	val.ExitBlock = &exitBlock
+	totals = val.Totals(&agg)
+	assert.Equal(t, big.NewInt(1500), totals.TotalLockedStake)
+	assert.Equal(t, big.NewInt(1000), totals.TotalLockedWeight)
+	assert.Equal(t, big.NewInt(1200), totals.TotalQueuedStake)
+	assert.Equal(t, big.NewInt(1600), totals.TotalQueuedWeight)
+	assert.Equal(t, big.NewInt(1500), totals.TotalExitingStake)
+	assert.Equal(t, big.NewInt(1000), totals.TotalExitingWeight)
+}
+
+func TestValidation_IsPeriodEnd(t *testing.T) {
+	assert.True(t, baseVal.IsPeriodEnd(5))
+	assert.False(t, baseVal.IsPeriodEnd(6))
+}
+
+func TestValidation_NextPeriodTVL(t *testing.T) {
+	assert.Equal(t, big.NewInt(900), baseVal.NextPeriodTVL())
+}
+
+func TestValidation_Exit(t *testing.T) {
+	val := baseVal
+	delta := val.exit()
+	assert.Equal(t, StatusExit, val.Status)
+	assert.Equal(t, big.NewInt(1000), val.CooldownVET)
+	assert.Equal(t, big.NewInt(0), val.LockedVET)
+	assert.Equal(t, big.NewInt(0), val.PendingUnlockVET)
+	assert.Equal(t, big.NewInt(0), val.Weight)
+
+	assert.Equal(t, big.NewInt(1000), delta.ExitedTVL)
+	assert.Equal(t, big.NewInt(1000), delta.ExitedTVLWeight)
+	assert.Equal(t, big.NewInt(800), delta.QueuedDecrease)
+	assert.Equal(t, big.NewInt(800), delta.QueuedDecreaseWeight)
+}