chore(validations): make SetValidation private (#1262)

Author: darrenkel

builtin/staker/housekeep.go

@@ -21,16 +21,20 @@ import (
 
 type EpochTransition struct {
 	Block           uint32
-	Renewals        []ValidatorRenewal
+	Renewals        []thor.Address
 	ExitValidator   *thor.Address
+	Evictions       []thor.Address
 	ActivationCount int64
 }
 
-type ValidatorRenewal struct {
-	Validator       thor.Address
-	NewState        *validation.Validation
-	ValidatorDelta  *delta.Renewal
-	DelegationDelta *delta.Renewal
+func (et *EpochTransition) HasUpdates() bool {
+	if et == nil {
+		return false
+	}
+	return len(et.Renewals) > 0 || // renewing existing staking periods
+		(et.ExitValidator != nil && !et.ExitValidator.IsZero()) || // exiting 1 validator
+		len(et.Evictions) > 0 || // forcing eviction of offline validators
+		et.ActivationCount > 0 // activating new validators
 }
 
 // Housekeep performs epoch transitions at epoch boundaries
@@ -46,7 +50,7 @@ func (s *Staker) Housekeep(currentBlock uint32) (bool, error) {
 		return false, err
 	}
 
-	if transition == nil || (len(transition.Renewals) == 0 && transition.ExitValidator == nil && transition.ActivationCount == 0) {
+	if !transition.HasUpdates() {
 		return false, nil
 	}
 
@@ -62,22 +66,21 @@ func (s *Staker) Housekeep(currentBlock uint32) (bool, error) {
 func (s *Staker) computeEpochTransition(currentBlock uint32) (*EpochTransition, error) {
 	var err error
 
-	transition := &EpochTransition{Block: currentBlock}
-
-	var renewals []ValidatorRenewal
+	var renewals []thor.Address
+	var evictions []thor.Address
 	active := make(map[thor.Address]*validation.Validation)
 	exitValidator := thor.Address{}
 	err = s.validationService.LeaderGroupIterator(
 		s.renewalCallback(currentBlock, &renewals),
 		s.exitsCallback(currentBlock, &exitValidator),
 		s.collectActiveCallback(active),
-		s.evictionCallback(currentBlock),
+		s.evictionCallback(currentBlock, &evictions),
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	transition.Renewals = renewals
+	transition := &EpochTransition{Block: currentBlock, Renewals: renewals, Evictions: evictions}
 
 	if !exitValidator.IsZero() {
 		transition.ExitValidator = &exitValidator
@@ -92,7 +95,7 @@ func (s *Staker) computeEpochTransition(currentBlock uint32) (*EpochTransition,
 	return transition, nil
 }
 
-func (s *Staker) renewalCallback(currentBlock uint32, renewals *[]ValidatorRenewal) func(thor.Address, *validation.Validation) error {
+func (s *Staker) renewalCallback(currentBlock uint32, renewals *[]thor.Address) func(thor.Address, *validation.Validation) error {
 	// Collect all validators due for renewal
 	return func(validator thor.Address, entry *validation.Validation) error {
 		// Skip validators due to exit
@@ -105,24 +108,7 @@ func (s *Staker) renewalCallback(currentBlock uint32, renewals *[]ValidatorRenew
 			return nil
 		}
 
-		// Compute renewal deltas
-		validatorRenewal := entry.Renew()
-		delegationsRenewal, err := s.aggregationService.Renew(validator)
-		if err != nil {
-			return err
-		}
-
-		// Calculate new weight and locked VET
-		changeWeight := big.NewInt(0).Add(validatorRenewal.NewLockedWeight, delegationsRenewal.NewLockedWeight)
-		entry.LockedVET = big.NewInt(0).Add(entry.LockedVET, validatorRenewal.NewLockedVET)
-		entry.Weight = big.NewInt(0).Add(entry.Weight, changeWeight)
-
-		*renewals = append(*renewals, ValidatorRenewal{
-			Validator:       validator,
-			NewState:        entry,
-			ValidatorDelta:  validatorRenewal,
-			DelegationDelta: delegationsRenewal,
-		})
+		*renewals = append(*renewals, validator)
 
 		return nil
 	}
@@ -144,19 +130,11 @@ func (s *Staker) exitsCallback(currentBlock uint32, exitAddress *thor.Address) f
 	}
 }
 
-func (s *Staker) evictionCallback(currentBlock uint32) func(thor.Address, *validation.Validation) error {
+func (s *Staker) evictionCallback(currentBlock uint32, evictions *[]thor.Address) func(thor.Address, *validation.Validation) error {
 	return func(validator thor.Address, entry *validation.Validation) error {
 		if entry.OfflineBlock != nil && currentBlock > *entry.OfflineBlock+(thor.OfflineValidatorEvictionThresholdEpochs*EpochLength.Get()) {
-			exitBlock, err := s.validationService.SetExitBlock(validator, currentBlock+EpochLength.Get())
-			if err != nil {
-				return err
-			}
-			if entry.ExitBlock != nil && *entry.ExitBlock < exitBlock {
-				exitBlock = *entry.ExitBlock
-			}
-			entry.ExitBlock = &exitBlock
-
-			return s.validationService.SetValidation(validator, entry, false)
+			*evictions = append(*evictions, validator)
+			return nil
 		}
 		return nil
 	}
@@ -210,14 +188,18 @@ func (s *Staker) applyEpochTransition(transition *EpochTransition) error {
 
 	accumulatedRenewal := delta.NewRenewal()
 	// Apply renewals
-	for _, renewal := range transition.Renewals {
-		accumulatedRenewal.Add(renewal.ValidatorDelta)
-		accumulatedRenewal.Add(renewal.DelegationDelta)
-
+	for _, validator := range transition.Renewals {
+		aggRenewal, err := s.aggregationService.Renew(validator)
+		if err != nil {
+			return err
+		}
+		accumulatedRenewal.Add(aggRenewal)
 		// Update validator state
-		if err := s.validationService.SetValidation(renewal.Validator, renewal.NewState, false); err != nil {
+		valRenewal, err := s.validationService.Renew(validator, aggRenewal)
+		if err != nil {
 			return err
 		}
+		accumulatedRenewal.Add(valRenewal)
 	}
 	// Apply accumulated renewals to global stats
 	if err := s.globalStatsService.ApplyRenewal(accumulatedRenewal); err != nil {
@@ -244,6 +226,14 @@ func (s *Staker) applyEpochTransition(transition *EpochTransition) error {
 		}
 	}
 
+	// Apply evictions
+	for _, validator := range transition.Evictions {
+		logger.Info("evicting validator", "validator", validator)
+		if err := s.validationService.Evict(validator, transition.Block); err != nil {
+			return err
+		}
+	}
+
 	// Apply activations using existing method
 	maxLeaderGroupSize, err := s.params.Get(thor.KeyMaxBlockProposers)
 	if err != nil {

builtin/staker/staker.go

@@ -306,24 +306,20 @@ func (s *Staker) DecreaseStake(validator thor.Address, endorser thor.Address, am
 func (s *Staker) WithdrawStake(validator thor.Address, endorser thor.Address, currentBlock uint32) (*big.Int, error) {
 	logger.Debug("withdrawing stake", "endorser", endorser, "validator", validator)
 
-	// remove validator QueuedVET if the validator is still queued
-	val, err := s.validationService.GetValidation(validator)
+	stake, queued, err := s.validationService.WithdrawStake(validator, endorser, currentBlock)
 	if err != nil {
+		logger.Info("withdraw failed", "validator", validator, "error", err)
 		return nil, err
 	}
-	if val.Status == validation.StatusQueued {
-		err = s.globalStatsService.RemoveQueued(stakes.NewWeightedStake(val.QueuedVET, validation.Multiplier))
+
+	// remove validator QueuedVET if the validator is still queued or had a pending increase
+	if queued.Sign() == 1 {
+		err = s.globalStatsService.RemoveQueued(stakes.NewWeightedStake(queued, validation.Multiplier))
 		if err != nil {
 			return nil, err
 		}
 	}
 
-	stake, err := s.validationService.WithdrawStake(val, validator, endorser, currentBlock)
-	if err != nil {
-		logger.Info("withdraw failed", "validator", validator, "error", err)
-		return nil, err
-	}
-
 	logger.Info("withdrew validator staker", "validator", validator)
 	return stake, nil
 }

builtin/staker/validation/service.go

@@ -201,7 +201,7 @@ func (s *Service) Add(
 		return err
 	}
 
-	return s.SetValidation(validator, entry, true)
+	return s.repo.SetValidation(validator, entry, true)
 }
 
 func (s *Service) SignalExit(validator thor.Address, endorser thor.Address) error {
@@ -226,6 +226,24 @@ func (s *Service) SignalExit(validator thor.Address, endorser thor.Address) erro
 	return s.repo.SetValidation(validator, validation, false)
 }
 
+func (s *Service) Evict(validator thor.Address, currentBlock uint32) error {
+	validation, err := s.GetExistingValidation(validator)
+	if err != nil {
+		return err
+	}
+
+	exitBlock, err := s.SetExitBlock(validator, currentBlock+s.epochLength)
+	if err != nil {
+		return err
+	}
+	if validation.ExitBlock != nil && *validation.ExitBlock < exitBlock {
+		exitBlock = *validation.ExitBlock
+	}
+	validation.ExitBlock = &exitBlock
+
+	return s.repo.SetValidation(validator, validation, false)
+}
+
 func (s *Service) IncreaseStake(validator thor.Address, endorser thor.Address, amount *big.Int) error {
 	entry, err := s.GetExistingValidation(validator)
 	if err != nil {
@@ -243,7 +261,7 @@ func (s *Service) IncreaseStake(validator thor.Address, endorser thor.Address, a
 
 	entry.QueuedVET = big.NewInt(0).Add(amount, entry.QueuedVET)
 
-	return s.SetValidation(validator, entry, false)
+	return s.repo.SetValidation(validator, entry, false)
 }
 
 func (s *Service) SetBeneficiary(validator, endorser, beneficiary thor.Address) error {
@@ -262,7 +280,7 @@ func (s *Service) SetBeneficiary(validator, endorser, beneficiary thor.Address)
 	} else {
 		entry.Beneficiary = &beneficiary
 	}
-	if err = s.SetValidation(validator, entry, false); err != nil {
+	if err = s.repo.SetValidation(validator, entry, false); err != nil {
 		return errors.Wrap(err, "failed to set beneficiary")
 	}
 	return nil
@@ -305,19 +323,22 @@ func (s *Service) DecreaseStake(validator thor.Address, endorser thor.Address, a
 		entry.WithdrawableVET = big.NewInt(0).Add(entry.WithdrawableVET, amount)
 	}
 
-	return entry.Status == StatusQueued, s.SetValidation(validator, entry, false)
+	return entry.Status == StatusQueued, s.repo.SetValidation(validator, entry, false)
 }
 
 // WithdrawStake allows validations to withdraw any withdrawable stake.
 // It also verifies the endorser and updates the validator totals.
 func (s *Service) WithdrawStake(
-	val *Validation,
 	validator thor.Address,
 	endorser thor.Address,
 	currentBlock uint32,
-) (*big.Int, error) {
+) (*big.Int, *big.Int, error) {
+	val, err := s.GetExistingValidation(validator)
+	if err != nil {
+		return nil, nil, err
+	}
 	if val.Endorser != endorser {
-		return big.NewInt(0), reverts.New("invalid endorser")
+		return big.NewInt(0), big.NewInt(0), reverts.New("invalid endorser")
 	}
 
 	// calculate currently available VET to withdraw
@@ -333,21 +354,22 @@ func (s *Service) WithdrawStake(
 		val.QueuedVET = big.NewInt(0)
 		val.Status = StatusExit
 		if err := s.validatorQueue.Remove(validator); err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
+	queuedVET := big.NewInt(0).Set(val.QueuedVET)
 	// remove any que
 	if val.QueuedVET.Sign() > 0 {
 		val.QueuedVET = big.NewInt(0)
 	}
 
 	// no more withdraw after this
 	val.WithdrawableVET = big.NewInt(0)
-	if err := s.SetValidation(validator, val, false); err != nil {
-		return nil, err
+	if err := s.repo.SetValidation(validator, val, false); err != nil {
+		return nil, nil, err
 	}
 
-	return withdrawable, nil
+	return withdrawable, queuedVET, nil
 }
 
 func (s *Service) NextToActivate(maxLeaderGroupSize *big.Int) (*thor.Address, error) {
@@ -388,12 +410,12 @@ func (s *Service) ExitValidator(validator thor.Address) (*delta.Exit, error) {
 	if entry.IsEmpty() {
 		return nil, nil
 	}
-	exit := entry.Exit()
+	exit := entry.exit()
 	if err = s.leaderGroup.Remove(validator); err != nil {
 		return nil, err
 	}
 
-	if err = s.SetValidation(validator, entry, false); err != nil {
+	if err = s.repo.SetValidation(validator, entry, false); err != nil {
 		return nil, err
 	}
 
@@ -477,7 +499,7 @@ func (s *Service) ActivateValidator(
 	}
 
 	// Persist the updated validation state
-	if err = s.SetValidation(validationID, val, false); err != nil {
+	if err = s.repo.SetValidation(validationID, val, false); err != nil {
 		return nil, err
 	}
 
@@ -504,7 +526,20 @@ func (s *Service) UpdateOfflineBlock(validator thor.Address, block uint32, onlin
 		validation.OfflineBlock = &block
 	}
 
-	return s.SetValidation(validator, validation, false)
+	return s.repo.SetValidation(validator, validation, false)
+}
+
+func (s *Service) Renew(validator thor.Address, aggRenew *delta.Renewal) (*delta.Renewal, error) {
+	validation, err := s.GetExistingValidation(validator)
+	if err != nil {
+		return nil, err
+	}
+	delta := validation.renew(aggRenew)
+	if err = s.repo.SetValidation(validator, validation, false); err != nil {
+		return nil, errors.Wrap(err, "failed to renew validator")
+	}
+
+	return delta, nil
 }
 
 //
@@ -526,10 +561,6 @@ func (s *Service) GetExistingValidation(validator thor.Address) (*Validation, er
 	return v, nil
 }
 
-func (s *Service) SetValidation(validator thor.Address, entry *Validation, isNew bool) error {
-	return s.repo.SetValidation(validator, entry, isNew)
-}
-
 func (s *Service) LeaderGroupNext(prev thor.Address) (thor.Address, error) {
 	return s.leaderGroup.Next(prev)
 }