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

* Increase coverage in staker package

* fix after merge

* Fix weight bug, add tests

* Fix after merge

* Fix comment fixes

Author: vanja-vechain

builtin/staker/aggregation/service.go

@@ -76,19 +76,20 @@ func (s *Service) SubPendingVet(validator thor.Address, stake *stakes.WeightedSt
 
 // Renew transitions the validator's delegations to the next staking period.
 // Called during staking period renewal process.
-func (s *Service) Renew(validator thor.Address) (*delta.Renewal, error) {
+func (s *Service) Renew(validator thor.Address) (*delta.Renewal, bool, error) {
 	agg, err := s.GetAggregation(validator)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 
 	renew := agg.renew()
 
 	if err = s.setAggregation(validator, agg, false); err != nil {
-		return nil, err
+		return nil, false, err
 	}
+	hasDelegations := agg.LockedVET.Sign() == 1
 
-	return renew, nil
+	return renew, hasDelegations, nil
 }
 
 // Exit moves all delegations to withdrawable state when validator exits.

builtin/staker/aggregation/service_test.go

@@ -74,7 +74,7 @@ func TestService_Renew(t *testing.T) {
 	wsAdd := stakes.NewWeightedStake(big.NewInt(3000), 200)
 	assert.NoError(t, svc.AddPendingVET(v, wsAdd))
 
-	renew1, err := svc.Renew(v)
+	renew1, _, err := svc.Renew(v)
 	assert.NoError(t, err)
 	assert.Equal(t, big.NewInt(3000), renew1.NewLockedVET)
 	assert.Equal(t, big.NewInt(6000), renew1.NewLockedWeight)
@@ -83,7 +83,7 @@ func TestService_Renew(t *testing.T) {
 
 	assert.NoError(t, svc.AddPendingVET(v, stakes.NewWeightedStake(big.NewInt(500), 200)))
 
-	renew2, err := svc.Renew(v)
+	renew2, _, err := svc.Renew(v)
 	assert.NoError(t, err)
 	assert.Equal(t, big.NewInt(-500), renew2.NewLockedVET)
 	assert.Equal(t, big.NewInt(-1000), renew2.NewLockedWeight)
@@ -103,7 +103,7 @@ func TestService_Exit(t *testing.T) {
 	v := thor.BytesToAddress([]byte("v"))
 
 	assert.NoError(t, svc.AddPendingVET(v, stakes.NewWeightedStake(big.NewInt(2000), 200)))
-	_, err := svc.Renew(v)
+	_, _, err := svc.Renew(v)
 	assert.NoError(t, err)
 
 	assert.NoError(t, svc.AddPendingVET(v, stakes.NewWeightedStake(big.NewInt(800), 200)))
@@ -165,7 +165,7 @@ func TestService_Renew_ErrorOnGet(t *testing.T) {
 	v := thor.BytesToAddress([]byte("v"))
 	poisonMapping(st, contract, v)
 
-	_, err := svc.Renew(v)
+	_, _, err := svc.Renew(v)
 	assert.ErrorContains(t, err, "failed to get validator aggregation")
 }
 

builtin/staker/housekeep.go

@@ -189,13 +189,13 @@ func (s *Staker) applyEpochTransition(transition *EpochTransition) error {
 	accumulatedRenewal := delta.NewRenewal()
 	// Apply renewals
 	for _, validator := range transition.Renewals {
-		aggRenewal, err := s.aggregationService.Renew(validator)
+		aggRenewal, hasDelegations, err := s.aggregationService.Renew(validator)
 		if err != nil {
 			return err
 		}
 		accumulatedRenewal.Add(aggRenewal)
 		// Update validator state
-		valRenewal, err := s.validationService.Renew(validator, aggRenewal)
+		valRenewal, err := s.validationService.Renew(validator, aggRenewal, hasDelegations)
 		if err != nil {
 			return err
 		}
@@ -258,7 +258,7 @@ func (s *Staker) activateNextValidation(currentBlk uint32, maxLeaderGroupSize *b
 	logger.Debug("activating validator", "validatorID", validatorID, "block", currentBlk)
 
 	// renew the current delegations aggregation
-	aggRenew, err := s.aggregationService.Renew(*validatorID)
+	aggRenew, _, err := s.aggregationService.Renew(*validatorID)
 	if err != nil {
 		return nil, err
 	}

builtin/staker/staker.go

@@ -253,9 +253,24 @@ func (s *Staker) IncreaseStake(validator thor.Address, endorser thor.Address, am
 	if err := s.validateNextPeriodTVL(validator); err != nil {
 		return err
 	}
+	agg, err := s.aggregationService.GetAggregation(validator)
+	if err != nil {
+		return err
+	}
+
+	weightedStake := stakes.NewWeightedStake(amount, validation.Multiplier)
+	if agg.LockedVET.Sign() == 1 || agg.PendingVET.Sign() == 1 {
+		weightedStake.AddWeight(*amount)
+		aggWeightIncrease := stakes.NewWeightedStake(big.NewInt(0), validation.Multiplier)
+		aggWeightIncrease.AddWeight(*amount)
+		err = s.aggregationService.AddPendingVET(validator, aggWeightIncrease)
+		if err != nil {
+			return err
+		}
+	}
 
 	// update global totals
-	if err := s.globalStatsService.AddQueued(stakes.NewWeightedStake(amount, validation.Multiplier)); err != nil {
+	if err := s.globalStatsService.AddQueued(weightedStake); err != nil {
 		return err
 	}
 
@@ -272,8 +287,20 @@ func (s *Staker) DecreaseStake(validator thor.Address, endorser thor.Address, am
 		return err
 	}
 
+	agg, err := s.aggregationService.GetAggregation(validator)
+	if err != nil {
+		return err
+	}
+
+	weightedStake := stakes.NewWeightedStake(amount, validation.Multiplier)
+	if agg.LockedVET.Sign() == 1 || agg.PendingVET.Sign() == 1 {
+		weightedStake.AddWeight(*amount)
+		aggWeightDecrease := stakes.NewWeightedStake(big.NewInt(0), validation.Multiplier)
+		aggWeightDecrease.AddWeight(*amount)
+	}
+
 	if queued {
-		err = s.globalStatsService.RemoveQueued(stakes.NewWeightedStake(amount, validation.Multiplier))
+		err = s.globalStatsService.RemoveQueued(weightedStake)
 		if err != nil {
 			return err
 		}
@@ -357,6 +384,9 @@ func (s *Staker) AddDelegation(
 		}
 		if agg.PendingWeight.Cmp(big.NewInt(0).Add(valStake, stake)) < 0 {
 			weightedStake.AddWeight(*valStake)
+			if val.Status != validation.StatusQueued {
+				weightedStake.AddWeight(*val.QueuedVET)
+			}
 		}
 	}
 
@@ -374,7 +404,9 @@ func (s *Staker) AddDelegation(
 	}
 
 	// update global figures
-	weightedStake.AddWeight(*val.QueuedVET)
+	if val.Status == validation.StatusQueued {
+		weightedStake.AddWeight(*val.QueuedVET)
+	}
 	if err = s.globalStatsService.AddQueued(weightedStake); err != nil {
 		return nil, err
 	}

builtin/staker/validation/service.go

@@ -514,12 +514,12 @@ func (s *Service) UpdateOfflineBlock(validator thor.Address, block uint32, onlin
 	return s.repo.setValidation(validator, validation, false)
 }
 
-func (s *Service) Renew(validator thor.Address, aggRenew *delta.Renewal) (*delta.Renewal, error) {
+func (s *Service) Renew(validator thor.Address, aggRenew *delta.Renewal, hasDelegations bool) (*delta.Renewal, error) {
 	validation, err := s.GetExistingValidation(validator)
 	if err != nil {
 		return nil, err
 	}
-	delta := validation.renew(aggRenew)
+	delta := validation.renew(aggRenew, hasDelegations)
 	if err = s.repo.setValidation(validator, validation, false); err != nil {
 		return nil, errors.Wrap(err, "failed to renew validator")
 	}

builtin/staker/validation/service_test.go

@@ -102,7 +102,7 @@ func TestService_ActivateAndExit_Flow(t *testing.T) {
 	}
 	assert.NoError(t, svc.repo.setValidation(id, val, true))
 
-	renew := (&Validation{QueuedVET: big.NewInt(100), LockedVET: big.NewInt(0), Weight: big.NewInt(0)}).renew(delta.NewRenewal())
+	renew := (&Validation{QueuedVET: big.NewInt(100), LockedVET: big.NewInt(0), Weight: big.NewInt(0)}).renew(delta.NewRenewal(), false)
 
 	_, err := svc.ActivateValidator(id, 1, renew)
 	assert.NoError(t, err)
@@ -610,3 +610,23 @@ func TestService_LeaderGroupNext_Order(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, thor.Address{}, n4)
 }
+
+func TestService_GetCompletedPeriods(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)))
+		idPtr, err := svc.NextToActivate(big.NewInt(10))
+		assert.NoError(t, err)
+		assert.Equal(t, id, *idPtr)
+		_, err = svc.ActivateValidator(*idPtr, 1, &delta.Renewal{NewLockedWeight: big.NewInt(0)})
+		assert.NoError(t, err)
+	}
+
+	periods, err := svc.GetCompletedPeriods(a1)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(0), periods)
+}

builtin/staker/validation/validation.go

@@ -25,7 +25,7 @@ const (
 )
 
 const (
-	Multiplier = uint8(100) // 200% for validators
+	Multiplier = uint8(100) // 100% for validators if no delegations
 )
 
 type Validation struct {
@@ -114,7 +114,7 @@ func (v *Validation) CurrentIteration() uint32 {
 // 3. Increase WithdrawableVET by PendingUnlockVET
 // 4. Set QueuedVET to 0
 // 5. Set PendingUnlockVET to 0
-func (v *Validation) renew(aggregations *delta.Renewal) *delta.Renewal {
+func (v *Validation) renew(aggregations *delta.Renewal, hasDelegations bool) *delta.Renewal {
 	newLockedVET := big.NewInt(0)
 
 	if v.QueuedVET == nil {
@@ -132,21 +132,26 @@ func (v *Validation) renew(aggregations *delta.Renewal) *delta.Renewal {
 	queuedDecrease := big.NewInt(0).Set(v.QueuedVET)
 	v.WithdrawableVET = big.NewInt(0).Add(v.WithdrawableVET, v.PendingUnlockVET)
 	v.QueuedVET = big.NewInt(0)
+	pendingUnlock := v.PendingUnlockVET
 	v.PendingUnlockVET = big.NewInt(0)
 
 	v.CompleteIterations++
 
-	changeWeight := big.NewInt(0).Add(newLockedVET, aggregations.NewLockedWeight)
 	v.LockedVET = big.NewInt(0).Add(v.LockedVET, newLockedVET)
+	newLockedWeight := newLockedVET
+	if hasDelegations {
+		newLockedWeight = big.NewInt(0).Sub(newLockedWeight, pendingUnlock)
+	}
+
+	changeWeight := big.NewInt(0).Add(newLockedWeight, aggregations.NewLockedWeight)
 	v.Weight = big.NewInt(0).Add(v.Weight, changeWeight)
 
 	// deltas
-	weight := stakes.NewWeightedStake(newLockedVET, Multiplier).Weight()
 	queuedDecreaseWeight := stakes.NewWeightedStake(queuedDecrease, Multiplier).Weight()
 
 	return &delta.Renewal{
 		NewLockedVET:         newLockedVET,
-		NewLockedWeight:      weight,
+		NewLockedWeight:      newLockedWeight,
 		QueuedDecrease:       queuedDecrease,
 		QueuedDecreaseWeight: queuedDecreaseWeight,
 	}