refactor(staker): move trasition, housekeeping and status check to staker (#1259)

Author: darrenkel

builtin/staker/delegations_test.go

@@ -230,7 +230,7 @@ func Test_Delegator_DisableAutoRenew_PendingLocked(t *testing.T) {
 
 	// Then the delegation can't signal an exit until it has started
 	assert.ErrorContains(t, staker.SignalDelegationExit(id), "delegation has not started yet")
-	_, _, err = staker.Housekeep(validator.Period)
+	_, err = staker.Housekeep(validator.Period)
 	assert.NoError(t, err)
 	assert.NoError(t, staker.SignalDelegationExit(id))
 	aggregation, err = staker.aggregationService.GetAggregation(validator.ID)
@@ -239,7 +239,7 @@ func Test_Delegator_DisableAutoRenew_PendingLocked(t *testing.T) {
 	assert.Equal(t, stake, aggregation.ExitingVET) // ExitingVET takes effect in next staking period
 
 	// When the staking period is completed
-	_, _, err = staker.Housekeep(validator.Period)
+	_, err = staker.Housekeep(validator.Period)
 	assert.NoError(t, err)
 	aggregation, err = staker.aggregationService.GetAggregation(validator.ID)
 	assert.NoError(t, err)
@@ -330,7 +330,7 @@ func Test_Delegator_DisableAutoRenew_InAStakingPeriod(t *testing.T) {
 	assert.Equal(t, weight, queuedWeight)
 
 	// And the first staking period has occurred
-	_, _, err = staker.Housekeep(validator.Period)
+	_, err = staker.Housekeep(validator.Period)
 	assert.NoError(t, err)
 	aggregation, err := staker.aggregationService.GetAggregation(validator.ID)
 	assert.NoError(t, err)
@@ -353,7 +353,7 @@ func Test_Delegator_DisableAutoRenew_InAStakingPeriod(t *testing.T) {
 	assert.Equal(t, big.NewInt(0).String(), queuedWeight.String())
 
 	// And the funds should be withdrawable after the next iteration
-	_, _, err = staker.Housekeep(2 * validator.Period)
+	_, err = staker.Housekeep(2 * validator.Period)
 	assert.NoError(t, err)
 	_, err = staker.aggregationService.GetAggregation(validator.ID)
 	assert.NoError(t, err)
@@ -373,7 +373,7 @@ func Test_Delegator_AutoRenew_ValidatorExits(t *testing.T) {
 	assert.NoError(t, err)
 
 	// And the first staking period has occurred
-	_, _, err = staker.Housekeep(validator.Period)
+	_, err = staker.Housekeep(validator.Period)
 	assert.NoError(t, err)
 	aggregation, err := staker.aggregationService.GetAggregation(validator.ID)
 	assert.NoError(t, err)
@@ -383,7 +383,7 @@ func Test_Delegator_AutoRenew_ValidatorExits(t *testing.T) {
 	assert.NoError(t, staker.SignalExit(validator.ID, validator.Endorser))
 
 	// And the next staking period is over
-	_, _, err = staker.Housekeep(validator.Period * 2)
+	_, err = staker.Housekeep(validator.Period * 2)
 	assert.NoError(t, err)
 	_, err = staker.aggregationService.GetAggregation(validator.ID)
 	assert.NoError(t, err)
@@ -588,7 +588,7 @@ func Test_Delegations_EnableAutoRenew_MatchStakeReached(t *testing.T) {
 	assert.False(t, delegation1.Started(validation))
 
 	// Delegation should become active
-	_, _, err = staker.Housekeep(validator.Period)
+	_, err = staker.Housekeep(validator.Period)
 	assert.NoError(t, err)
 	delegation1, _, err = staker.GetDelegation(delegationID)
 	assert.NoError(t, err)
@@ -647,7 +647,7 @@ func TestStaker_DelegationExitingVET(t *testing.T) {
 	assert.Equal(t, delStake, qStake)
 	assert.Equal(t, delWeight, qWeight)
 
-	_, _, err = staker.Housekeep(MediumStakingPeriod.Get())
+	_, err = staker.Housekeep(MediumStakingPeriod.Get())
 	assert.NoError(t, err)
 
 	delegation, validation, err = staker.GetDelegation(delegationID)
@@ -657,6 +657,6 @@ func TestStaker_DelegationExitingVET(t *testing.T) {
 	assert.NoError(t, staker.SignalDelegationExit(delegationID))
 	assert.NoError(t, staker.SignalExit(*firstActive, validation.Endorser))
 
-	_, _, err = staker.Housekeep(MediumStakingPeriod.Get() * 2)
+	_, err = staker.Housekeep(MediumStakingPeriod.Get() * 2)
 	assert.NoError(t, err)
 }

builtin/staker/housekeep.go

@@ -20,11 +20,10 @@ import (
 //
 
 type EpochTransition struct {
-	Block            uint32
-	Renewals         []ValidatorRenewal
-	ExitValidator    *thor.Address
-	ActivationCount  int64
-	ActiveValidators map[thor.Address]*validation.Validation
+	Block           uint32
+	Renewals        []ValidatorRenewal
+	ExitValidator   *thor.Address
+	ActivationCount int64
 }
 
 type ValidatorRenewal struct {
@@ -35,31 +34,28 @@ type ValidatorRenewal struct {
 }
 
 // Housekeep performs epoch transitions at epoch boundaries
-func (s *Staker) Housekeep(currentBlock uint32) (bool, map[thor.Address]*validation.Validation, error) {
+func (s *Staker) Housekeep(currentBlock uint32) (bool, error) {
 	if currentBlock%EpochLength.Get() != 0 {
-		return false, nil, nil
+		return false, nil
 	}
 
 	logger.Info("🏠performing housekeeping", "block", currentBlock)
 
 	transition, err := s.computeEpochTransition(currentBlock)
 	if err != nil {
-		return false, nil, err
+		return false, err
 	}
 
 	if transition == nil || (len(transition.Renewals) == 0 && transition.ExitValidator == nil && transition.ActivationCount == 0) {
-		return false, nil, nil
+		return false, nil
 	}
 
 	if err := s.applyEpochTransition(transition); err != nil {
-		return false, nil, err
+		return false, err
 	}
 
-	// Build active validators map
-	activeValidators := transition.ActiveValidators
-
 	logger.Info("performed housekeeping", "block", currentBlock, "updates", true)
-	return true, activeValidators, nil
+	return true, nil
 }
 
 // computeEpochTransition calculates all state changes needed for an epoch transition
@@ -92,7 +88,6 @@ func (s *Staker) computeEpochTransition(currentBlock uint32) (*EpochTransition,
 	if err != nil {
 		return nil, err
 	}
-	transition.ActiveValidators = active
 
 	return transition, nil
 }
@@ -247,7 +242,6 @@ func (s *Staker) applyEpochTransition(transition *EpochTransition) error {
 		if err := s.globalStatsService.ApplyExit(exit.Add(aggExit)); err != nil {
 			return err
 		}
-		delete(transition.ActiveValidators, *transition.ExitValidator)
 	}
 
 	// Apply activations using existing method
@@ -257,15 +251,10 @@ func (s *Staker) applyEpochTransition(transition *EpochTransition) error {
 	}
 
 	for range transition.ActivationCount {
-		address, err := s.activateNextValidation(transition.Block, maxLeaderGroupSize)
-		if err != nil {
-			return err
-		}
-		validator, err := s.Get(*address)
+		_, err := s.activateNextValidation(transition.Block, maxLeaderGroupSize)
 		if err != nil {
 			return err
 		}
-		transition.ActiveValidators[*address] = validator
 	}
 
 	return nil

builtin/staker/protocol.go

@@ -0,0 +1,60 @@
+// 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 (
+	"fmt"
+
+	"github.com/vechain/thor/v2/thor"
+)
+
+type Status struct {
+	Active  bool // indicates if the staker contract is currently active
+	Updates bool // indicates if there are updates to the staker contract
+}
+
+// SyncPOS checks the status of the staker contract and updates its state based on the current block number.
+// It returns a Status object containing the activation status and the current leader group.
+// If the staker contract is not active, it attempts to transition to dPoS on transition blocks.
+// If the staker contract is active, it performs housekeeping on epoch blocks.
+func (s *Staker) SyncPOS(forkConfig *thor.ForkConfig, current uint32) (Status, error) {
+	status := Status{}
+	// still on PoA
+	if forkConfig.HAYABUSA+forkConfig.HAYABUSA_TP > current {
+		return status, nil
+	}
+
+	var err error
+	var activated bool
+
+	// check if the staker contract is active
+	status.Active, err = s.IsPoSActive()
+	if err != nil {
+		return status, err
+	}
+
+	// attempt to transition if we're on a transition block and the staker contract is not active
+	if !status.Active && current%forkConfig.HAYABUSA_TP == 0 {
+		activated, err = s.transition(current)
+		if err != nil {
+			return status, fmt.Errorf("failed to transition to dPoS: %w", err)
+		}
+		if activated {
+			status.Active = true
+			status.Updates = true
+		}
+	}
+
+	// perform housekeeping if the staker contract is active
+	if status.Active && !activated {
+		status.Updates, err = s.Housekeep(current)
+		if err != nil {
+			return status, err
+		}
+	}
+
+	return status, nil
+}

builtin/staker/staker.go

@@ -329,30 +329,9 @@ func (s *Staker) WithdrawStake(validator thor.Address, endorser thor.Address, cu
 	return stake, nil
 }
 
-func (s *Staker) SetOnline(validator thor.Address, blockNum uint32, online bool) (bool, error) {
+func (s *Staker) SetOnline(validator thor.Address, blockNum uint32, online bool) error {
 	logger.Debug("set node online", "validator", validator, "online", online)
-	entry, err := s.validationService.GetValidation(validator)
-	if err != nil {
-		return false, err
-	}
-	hasChanged := entry.OfflineBlock == nil != online
-	if hasChanged {
-		s.setOfflineBlock(validator, online, blockNum, entry)
-		err = s.validationService.SetValidation(validator, entry, false)
-	} else {
-		err = nil
-	}
-	return hasChanged, err
-}
-
-func (s *Staker) setOfflineBlock(validator thor.Address, online bool, blockNum uint32, val *validation.Validation) {
-	if online {
-		logger.Info("clearing offline block", "validator", validator, "online", online)
-		val.OfflineBlock = nil
-	} else {
-		logger.Info("setting offline block", "validator", validator, "online", online, "offline block", blockNum)
-		val.OfflineBlock = &blockNum
-	}
+	return s.validationService.UpdateOfflineBlock(validator, blockNum, online)
 }
 
 func (s *Staker) SetBeneficiary(validator, endorser, beneficiary thor.Address) error {

builtin/staker/staker_test.go

@@ -167,7 +167,7 @@ func (ts *TestSequence) AssertWithdrawable(
 }
 
 func (ts *TestSequence) SetOnline(id thor.Address, blockNum uint32, online bool) *TestSequence {
-	_, err := ts.staker.SetOnline(id, blockNum, online)
+	err := ts.staker.SetOnline(id, blockNum, online)
 	assert.NoError(ts.t, err, "failed to set online status for validator %s: %v", id.String(), err)
 	return ts
 }
@@ -278,13 +278,13 @@ func (ts *TestSequence) ActivateNext(block uint32) *TestSequence {
 }
 
 func (ts *TestSequence) Housekeep(block uint32) *TestSequence {
-	_, _, err := ts.staker.Housekeep(block)
+	_, err := ts.staker.Housekeep(block)
 	assert.NoError(ts.t, err, "failed to perform housekeeping at block %d", block)
 	return ts
 }
 
 func (ts *TestSequence) Transition(block uint32) *TestSequence {
-	_, err := ts.staker.Transition(block)
+	_, err := ts.staker.transition(block)
 	assert.NoError(ts.t, err, "failed to transition at block %d", block)
 	return ts
 }

builtin/staker/transition.go

@@ -11,8 +11,8 @@ import (
 	"github.com/vechain/thor/v2/thor"
 )
 
-// Transition activates the staker contract when sufficient validators are queued
-func (s *Staker) Transition(currentBlock uint32) (bool, error) {
+// transition activates the staker contract when sufficient validators are queued
+func (s *Staker) transition(currentBlock uint32) (bool, error) {
 	if currentBlock%EpochLength.Get() != 0 {
 		return false, nil // No transition needed
 	}

builtin/staker/validation/service.go

@@ -492,6 +492,21 @@ func (s *Service) ActivateValidator(
 	return validatorRenewal, nil
 }
 
+// UpdateOfflineBlock updates the offline block for a validator.
+func (s *Service) UpdateOfflineBlock(validator thor.Address, block uint32, online bool) error {
+	validation, err := s.GetExistingValidation(validator)
+	if err != nil {
+		return err
+	}
+	if online {
+		validation.OfflineBlock = nil
+	} else {
+		validation.OfflineBlock = &block
+	}
+
+	return s.SetValidation(validator, validation, false)
+}
+
 //
 // Repository methods
 //