fix(staker): various increase/decrease/renew test cases (#1171)

Author: darrenkel

builtin/staker/delegations.go

@@ -60,9 +60,9 @@ func (d *delegations) Add(
 	if aggregated.IsEmpty() {
 		aggregated = newAggregation()
 	}
-	nextPeriodStake := validation.NextPeriodStakes(aggregated)
-	nextPeriodStake = nextPeriodStake.Add(nextPeriodStake, stake)
-	if nextPeriodStake.Cmp(MaxStake) > 0 {
+	nextPeriodTVL := big.NewInt(0).Add(validation.NextPeriodTVL(), aggregated.NextPeriodTVL())
+	nextPeriodTVL = nextPeriodTVL.Add(nextPeriodTVL, stake)
+	if nextPeriodTVL.Cmp(MaxStake) > 0 {
 		return thor.Bytes32{}, errors.New("validation's next period stake exceeds max stake")
 	}
 
@@ -84,30 +84,23 @@ func (d *delegations) Add(
 		ValidationID:   validationID,
 		FirstIteration: validation.CurrentIteration() + 1,
 	}
-
 	weight := delegation.Weight()
-
-	if !autoRenew {
+	if delegation.AutoRenew {
+		aggregated.PendingRecurringVET = big.NewInt(0).Add(aggregated.PendingRecurringVET, delegation.Stake)
+		aggregated.PendingRecurringWeight = big.NewInt(0).Add(aggregated.PendingRecurringWeight, weight)
+	} else {
+		aggregated.PendingOneTimeVET = big.NewInt(0).Add(aggregated.PendingOneTimeVET, delegation.Stake)
+		aggregated.PendingOneTimeWeight = big.NewInt(0).Add(aggregated.PendingOneTimeWeight, weight)
 		last := validation.CurrentIteration() + 1
 		delegation.LastIteration = &last
 	}
 
 	if err := d.queuedVET.Add(stake); err != nil {
 		return thor.Bytes32{}, err
 	}
-
 	if err := d.queuedWeight.Add(weight); err != nil {
 		return thor.Bytes32{}, err
 	}
-
-	if delegation.AutoRenew {
-		aggregated.PendingRecurringVET = big.NewInt(0).Add(aggregated.PendingRecurringVET, delegation.Stake)
-		aggregated.PendingRecurringWeight = big.NewInt(0).Add(aggregated.PendingRecurringWeight, weight)
-	} else {
-		aggregated.PendingOneTimeVET = big.NewInt(0).Add(aggregated.PendingOneTimeVET, delegation.Stake)
-		aggregated.PendingOneTimeWeight = big.NewInt(0).Add(aggregated.PendingOneTimeWeight, weight)
-	}
-
 	if err := d.storage.SetAggregation(validationID, aggregated, false); err != nil {
 		return thor.Bytes32{}, err
 	}
@@ -166,9 +159,18 @@ func (d *delegations) EnableAutoRenew(delegationID thor.Bytes32) error {
 	if err != nil {
 		return err
 	}
-
+	if delegation.AutoRenew {
+		return errors.New("delegation is already autoRenew")
+	}
 	weight := delegation.Weight()
 
+	// validate that the enablement does not exceed the max stake considering next staking period changes
+	nextPeriodTVL := big.NewInt(0).Add(validation.NextPeriodTVL(), aggregation.NextPeriodTVL())
+	nextPeriodTVL.Add(nextPeriodTVL, delegation.Stake)
+	if nextPeriodTVL.Cmp(MaxStake) > 0 {
+		return errors.New("validation's next period stake exceeds max stake")
+	}
+
 	if delegation.IsLocked(validation) {
 		// move the delegation's portion of non-recurring to locked.
 		// this means the funds will not be available until the validator is inactive, or the delegation signals an exit

builtin/staker/delegations_test.go

@@ -168,16 +168,26 @@ func Test_AddDelegator_StakeRange(t *testing.T) {
 	assert.ErrorContains(t, err, "validation's next period stake exceeds max stake")
 
 	// should be able stake 1 VET
-	_, err = staker.AddDelegation(validator.ID, big.NewInt(1), true, 255)
+	id1, err := staker.AddDelegation(validator.ID, big.NewInt(1), true, 255)
 	assert.NoError(t, err)
+	delegation, _, err := staker.GetDelegation(id1)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(1), delegation.Stake)
+	aggregation, err := staker.storage.GetAggregation(validator.ID)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(1), aggregation.PendingRecurringVET)
 
 	// should be able stake for all remaining space
 	validator = validators[1]
 	validation, err := staker.Get(validator.ID)
 	assert.NoError(t, err)
-	remaining := big.NewInt(0).Sub(MaxStake, validation.NextPeriodStakes(newAggregation()))
+	remaining := big.NewInt(0).Sub(MaxStake, validation.NextPeriodTVL())
 	_, err = staker.AddDelegation(validator.ID, remaining, true, 255)
 	assert.NoError(t, err)
+
+	// should not be able to stake more than max stake
+	_, err = staker.AddDelegation(validator.ID, big.NewInt(1000000000000000000), true, 255)
+	assert.ErrorContains(t, err, "validation's next period stake exceeds max stake")
 }
 
 func Test_AddDelegator_ValidatorNotFound(t *testing.T) {
@@ -309,6 +319,9 @@ func Test_Delegator_DisableAutoRenew_InAStakingPeriod(t *testing.T) {
 	// And a delegation is added with auto renew enabled
 	validator := validators[0]
 	stake := RandomStake()
+	validation, err := staker.Get(validator.ID)
+	assert.NoError(t, err)
+	validationStake := big.NewInt(0).Set(validation.LockedVET)
 
 	id, err := staker.AddDelegation(validator.ID, stake, true, 255)
 	assert.NoError(t, err)
@@ -350,6 +363,9 @@ func Test_Delegator_DisableAutoRenew_InAStakingPeriod(t *testing.T) {
 	aggregation, err = staker.storage.GetAggregation(validator.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, stake, aggregation.WithdrawableVET)
+	validation, err = staker.Get(validator.ID)
+	assert.NoError(t, err)
+	assert.Equal(t, validationStake, validation.LockedVET)
 }
 
 func Test_Delegator_EnableAutoRenew_PendingLocked(t *testing.T) {
@@ -626,3 +642,42 @@ func Test_Delegator_Queued_Weight_MultipleDelegations_Withdraw(t *testing.T) {
 	assert.Equal(t, initialQueuedVET, afterWithdraw2QueuedVET)
 	assert.Equal(t, initialQueuedWeight, afterWithdraw2QueuedWeight)
 }
+
+func Test_Delegations_EnableAutoRenew_MatchStakeReached(t *testing.T) {
+	staker, validators := newDelegationStaker(t)
+
+	validator := validators[0]
+	maxStake := big.NewInt(0).Sub(MaxStake, validator.LockedVET)
+
+	// Add a delegation with auto renew enabled
+	delegationID, err := staker.AddDelegation(validator.ID, maxStake, false, 255)
+	assert.NoError(t, err)
+
+	// Should be pending
+	delegation1, _, err := staker.GetDelegation(delegationID)
+	assert.NoError(t, err)
+	validation, err := staker.Get(validator.ID)
+	assert.NoError(t, err)
+	assert.False(t, delegation1.IsLocked(validation))
+
+	// Delegation should become active
+	_, _, err = staker.Housekeep(validator.Period)
+	assert.NoError(t, err)
+	delegation1, _, err = staker.GetDelegation(delegationID)
+	assert.NoError(t, err)
+	validation, err = staker.Get(validator.ID)
+	assert.NoError(t, err)
+	assert.True(t, delegation1.IsLocked(validation))
+
+	// Enable auto renew for delegation. Should be possible since the max stake won't be reached.
+	assert.NoError(t, staker.UpdateDelegationAutoRenew(delegationID, true))
+	// Immediately turn it off again for the test
+	assert.NoError(t, staker.UpdateDelegationAutoRenew(delegationID, false))
+
+	// Add a new delegation. It should be possible to add the delegation since the previous one is due to withdraw.
+	_, err = staker.AddDelegation(validator.ID, maxStake, true, 255)
+	assert.NoError(t, err)
+
+	// Enable auto renew for the first delegation - should fail since the presence of other delegator's exceeds max stake
+	assert.ErrorContains(t, staker.UpdateDelegationAutoRenew(delegationID, true), "validation's next period stake exceeds max stake")
+}

builtin/staker/housekeeping.go

@@ -112,7 +112,7 @@ func (s *Staker) performRenewalUpdates(id thor.Bytes32, validator *Validation) e
 	queuedWeight := big.NewInt(0).Add(validatorRenewal.QueuedDecreaseWeight, delegationsRenewal.QueuedDecreaseWeight)
 
 	// set the new totals
-	validator.LockedVET = big.NewInt(0).Add(validator.LockedVET, changeTVL)
+	validator.LockedVET = big.NewInt(0).Add(validator.LockedVET, validatorRenewal.ChangeTVL)
 	validator.Weight = big.NewInt(0).Add(validator.Weight, changeWeight)
 	if err := s.lockedVET.Add(changeTVL); err != nil {
 		return err

builtin/staker/staker.go

@@ -352,8 +352,9 @@ func (s *Staker) GetValidatorsTotals(validationID thor.Bytes32) (*ValidationTota
 	if err != nil {
 		return nil, err
 	}
+	delegationLockedStake := big.NewInt(0).Add(aggregation.CurrentRecurringVET, aggregation.CurrentOneTimeVET)
 	return &ValidationTotals{
-		TotalLockedStake:        validator.LockedVET,
+		TotalLockedStake:        big.NewInt(0).Add(validator.LockedVET, delegationLockedStake),
 		TotalLockedWeight:       validator.Weight,
 		DelegationsLockedStake:  big.NewInt(0).Add(aggregation.CurrentRecurringVET, aggregation.CurrentOneTimeVET),
 		DelegationsLockedWeight: big.NewInt(0).Add(aggregation.CurrentRecurringWeight, aggregation.CurrentOneTimeWeight),

builtin/staker/types.go

@@ -31,7 +31,7 @@ type Validation struct {
 	StartBlock         uint32       // the block number when the validation started the first staking period
 	ExitBlock          *uint32      `rlp:"nil"` // the block number when the validation moved to cooldown
 
-	LockedVET          *big.Int // the amount of VET locked for the current staking period
+	LockedVET          *big.Int // the amount of VET locked for the current staking period, for the validator only
 	NextPeriodDecrease *big.Int // the amount of VET that will be unlocked in the next staking period. DOES NOT contribute to the TVL
 	PendingLocked      *big.Int // the amount of VET that will be locked in the next staking period
 	CooldownVET        *big.Int // the amount of VET that is locked into the validation's cooldown
@@ -61,10 +61,11 @@ func (v *Validation) IsPeriodEnd(current uint32) bool {
 	return diff%v.Period == 0
 }
 
-// NextPeriodStakes returns the validation stake and all the delegator stakes for the next staking period.
-func (v *Validation) NextPeriodStakes(delegation *Aggregation) *big.Int {
+// NextPeriodTVL returns the amount of VET that will be locked in the next staking period for the validator only.
+func (v *Validation) NextPeriodTVL() *big.Int {
 	validationTotal := big.NewInt(0).Add(v.LockedVET, v.PendingLocked)
-	return validationTotal.Add(validationTotal, delegation.NextPeriodLocked())
+	validationTotal = big.NewInt(0).Sub(validationTotal, v.NextPeriodDecrease)
+	return validationTotal
 }
 
 func (v *Validation) CurrentIteration() uint32 {
@@ -187,16 +188,15 @@ func (a *Aggregation) IsEmpty() bool {
 	return a.CurrentRecurringVET == nil && a.CurrentOneTimeVET == nil && a.PendingRecurringVET == nil && a.PendingOneTimeVET == nil && a.WithdrawableVET == nil
 }
 
-// PeriodLocked returns the VET locked for a given validation's delegations for the current staking period.
-func (a *Aggregation) PeriodLocked() *big.Int {
-	return big.NewInt(0).Add(a.CurrentRecurringVET, a.CurrentOneTimeVET)
-}
-
-// NextPeriodLocked returns the PeriodLocked for the next staking period
-func (a *Aggregation) NextPeriodLocked() *big.Int {
-	total := big.NewInt(0).Add(a.CurrentRecurringVET, a.PendingRecurringVET)
-	total = total.Add(total, a.PendingOneTimeVET)
-	return total
+// NextPeriodTVL is the total value locked (TVL) for the next period.
+// It is the sum of the currently recurring VET, plus any pending recurring and one-time VET.
+// Does not include CurrentOneTimeVET since that stake is due to withdraw.
+func (a *Aggregation) NextPeriodTVL() *big.Int {
+	nextTVL := big.NewInt(0)
+	nextTVL.Add(nextTVL, a.CurrentRecurringVET)
+	nextTVL.Add(nextTVL, a.PendingRecurringVET)
+	nextTVL.Add(nextTVL, a.PendingOneTimeVET)
+	return nextTVL
 }
 
 // Renew moves the stakes and weights around as follows:

builtin/staker/validations.go

@@ -319,7 +319,10 @@ func (v *validations) IncreaseStake(id thor.Bytes32, endorsor thor.Address, amou
 	if err != nil {
 		return err
 	}
-	nextPeriodTVL := entry.NextPeriodStakes(aggregation)
+	validatorTVL := entry.NextPeriodTVL()
+	// we do not consider aggregation.CurrentRecurringVET since the delegator could enable auto-renew
+	delegationTVL := big.NewInt(0).Add(aggregation.CurrentRecurringVET, aggregation.PendingRecurringVET)
+	nextPeriodTVL := big.NewInt(0).Add(validatorTVL, delegationTVL)
 	newTVL := big.NewInt(0).Add(nextPeriodTVL, amount)
 
 	if newTVL.Cmp(MaxStake) > 0 {
@@ -354,21 +357,30 @@ func (v *validations) DecreaseStake(id thor.Bytes32, endorsor thor.Address, amou
 	if entry.Status == StatusActive && !entry.AutoRenew {
 		return errors.New("validator is not set to renew in the next period, all funds will be withdrawable")
 	}
-	newStake := big.NewInt(0).Add(entry.LockedVET, entry.PendingLocked)
-	newStake = newStake.Sub(newStake, amount)
-	if newStake.Cmp(MinStake) < 0 {
-		return errors.New("stake is too low for validator")
-	}
+
 	aggregation, err := v.storage.GetAggregation(id)
 	if err != nil {
 		return err
 	}
 
 	if entry.Status == StatusActive {
+		// We don't consider any increases, i.e., entry.PendingLocked. We only consider locked and current decreases.
+		// The reason is that validator can instantly withdraw PendingLocked at any time.
+		// We need to make sure the locked VET minus the sum of the current decreases is still above the minimum stake.
+		nextPeriodTVL := big.NewInt(0).Sub(entry.LockedVET, entry.NextPeriodDecrease)
+		nextPeriodTVL = nextPeriodTVL.Sub(nextPeriodTVL, amount)
+		if nextPeriodTVL.Cmp(MinStake) < 0 {
+			return errors.New("next period stake is too low for validator")
+		}
 		entry.NextPeriodDecrease = big.NewInt(0).Add(entry.NextPeriodDecrease, amount)
 	}
 
 	if entry.Status == StatusQueued {
+		// All the validator's stake exists within PendingLocked, so we need to make sure it maintains a minimum of MinStake.
+		nextPeriodTVL := big.NewInt(0).Sub(entry.PendingLocked, amount)
+		if nextPeriodTVL.Cmp(MinStake) < 0 {
+			return errors.New("next period stake is too low for validator")
+		}
 		entry.PendingLocked = big.NewInt(0).Sub(entry.PendingLocked, amount)
 		entry.WithdrawableVET = big.NewInt(0).Add(entry.WithdrawableVET, amount)
 		if err := v.queuedVET.Sub(amount); err != nil {

builtin/staker/staker_test.go builtin/staker/validations_test.gobuiltin/staker/staker_test.go renamed to builtin/staker/validations_test.go

@@ -2269,13 +2269,19 @@ func Test_GetValidatorTotals(t *testing.T) {
 	_, _, err = staker.Housekeep(validator.Period)
 	assert.NoError(t, err)
 
+	aggregation, err = staker.storage.GetAggregation(validator.ID)
+	assert.NoError(t, err)
+
 	totals, err := staker.GetValidatorsTotals(validator.ID)
 	assert.NoError(t, err)
 
 	fetchedValidator, err := staker.Get(validator.ID)
 	assert.NoError(t, err)
 
-	assert.Equal(t, fetchedValidator.LockedVET, totals.TotalLockedStake)
+	expectedStake := big.NewInt(0).Add(aggregation.CurrentRecurringVET, aggregation.CurrentOneTimeVET)
+	expectedStake.Add(expectedStake, validator.LockedVET)
+
+	assert.Equal(t, expectedStake, totals.TotalLockedStake)
 	assert.Equal(t, fetchedValidator.Weight, totals.TotalLockedWeight)
 	assert.Equal(t, delegation.Stake, totals.DelegationsLockedStake)
 	assert.Equal(t, delegation.Weight(), totals.DelegationsLockedWeight)
@@ -2310,3 +2316,78 @@ func Test_Validator_Decrease_Exit_Withdraw(t *testing.T) {
 	assert.Equal(t, StatusExit, validator.Status)
 	assert.Equal(t, originalStake, validator.CooldownVET)
 }
+
+func Test_Validator_Decrease_SeveralTimes(t *testing.T) {
+	staker, _ := newStaker(t, 0, 1, false)
+
+	acc := datagen.RandAddress()
+
+	originalStake := big.NewInt(0).Mul(big.NewInt(3), MinStake)
+	id, err := staker.AddValidator(acc, acc, LowStakingPeriod, originalStake, true, 0)
+	assert.NoError(t, err)
+	_, err = staker.validations.ActivateNext(0, staker.params)
+	assert.NoError(t, err)
+
+	// Decrease stake - ok 75m - 25m = 50m
+	err = staker.DecreaseStake(acc, id, MinStake)
+	assert.NoError(t, err)
+
+	// Decrease stake - ok 50m - 25m = 25m
+	err = staker.DecreaseStake(acc, id, MinStake)
+	assert.NoError(t, err)
+
+	// Decrease stake - should fail, min stake is 25m
+	err = staker.DecreaseStake(acc, id, MinStake)
+	assert.ErrorContains(t, err, "next period stake is too low for validator")
+}
+
+func Test_Validator_IncreaseDecrease_Combinations(t *testing.T) {
+	staker, _ := newStaker(t, 0, 1, false)
+	acc := datagen.RandAddress()
+
+	// Add & activate validator
+	id, err := staker.AddValidator(acc, acc, LowStakingPeriod, MinStake, true, 0)
+	assert.NoError(t, err)
+
+	// Increase and decrease - both should be okay since we're only dealing with PendingLocked
+	assert.NoError(t, staker.IncreaseStake(acc, id, MinStake)) // 25m + 25m = 50m
+	assert.NoError(t, staker.DecreaseStake(acc, id, MinStake)) // 25m - 50m = 25m
+
+	// Activate the validator.
+	_, err = staker.validations.ActivateNext(0, staker.params)
+	assert.NoError(t, err)
+
+	// Withdraw the previous decrease amount
+	withdrawal, err := staker.WithdrawStake(acc, id, 0)
+	assert.NoError(t, err)
+	assert.Equal(t, MinStake, withdrawal, "withdraw should be 0 since we are withdrawing from pending locked")
+
+	// Assert previous increase/decrease had no effect since they requested the same amount
+	validation, err := staker.Get(id)
+	assert.NoError(t, err)
+	assert.Equal(t, StatusActive, validation.Status)
+	assert.Equal(t, MinStake, validation.LockedVET)
+
+	// Increase stake (ok): 25m + 25m = 50m
+	assert.NoError(t, staker.IncreaseStake(acc, id, MinStake))
+	// Decrease stake (NOT ok): 25m - 25m = 0. The Previous increase is not applied since it is still currently withdrawable.
+	assert.ErrorContains(t, staker.DecreaseStake(acc, id, MinStake), "next period stake is too low for validator")
+	// Instantly withdraw - This is bad, it pulls from the PendingLocked, which means total stake later will be 0.
+	// The decrease previously marked as okay since the current TVL + pending TVL was greater than the min stake.
+	withdraw1, err := staker.WithdrawStake(acc, id, 0)
+	assert.NoError(t, err)
+	assert.Equal(t, MinStake, withdraw1, "withdraw should be 0 since we are withdrawing from pending locked")
+
+	// Housekeep, should move pending locked to locked, and pending withdraw to withdrawable
+	_, _, err = staker.Housekeep(LowStakingPeriod)
+	assert.NoError(t, err)
+
+	// Withdraw again
+	withdraw2, err := staker.WithdrawStake(acc, id, LowStakingPeriod+cooldownPeriod)
+	assert.NoError(t, err)
+	assert.Equal(t, big.NewInt(0), withdraw2)
+
+	validator, err := staker.Get(id)
+	assert.NoError(t, err)
+	assert.Equal(t, 0, validator.LockedVET.Cmp(MinStake), "locked vet should be greater than or equal to min stake")
+}