Remove totalEffectiveStake calculation from state manager

Author: jshufro

rocketpool/node/collectors/node-collector.go

@@ -266,7 +266,6 @@ func (collector *NodeCollector) Collect(channel chan<- prometheus.Metric) {
 	rewardsInterval := state.NetworkDetails.IntervalDuration
 	inflationInterval := state.NetworkDetails.RPLInflationIntervalRate
 	totalRplSupply := state.NetworkDetails.RPLTotalSupply
-	totalEffectiveStake := collector.stateLocker.GetTotalEffectiveRPLStake()
 	nodeOperatorRewardsPercent := eth.WeiToEth(state.NetworkDetails.NodeOperatorRewardsPercent)
 	previousIntervalTotalNodeWeight := big.NewInt(0)
 	ethBalance := eth.WeiToEth(nd.BalanceETH)
@@ -280,9 +279,6 @@ func (collector *NodeCollector) Collect(channel chan<- prometheus.Metric) {
 	var beaconHead beacon.BeaconHead
 	unclaimedEthRewards := float64(0)
 	unclaimedRplRewards := float64(0)
-	if totalEffectiveStake == nil {
-		return
-	}
 
 	// Get the cumulative claimed and unclaimed RPL rewards
 	wg.Go(func() error {
@@ -531,7 +527,7 @@ func (collector *NodeCollector) Collect(channel chan<- prometheus.Metric) {
 	 * period we don't attempt an estimate and simply use 0.
 	 */
 	estimatedRewards := float64(0)
-	if totalEffectiveStake.Cmp(big.NewInt(0)) == 1 && nodeWeight.Cmp(big.NewInt(0)) == 1 && state.NetworkDetails.RewardIndex > 0 {
+	if nodeWeight.Cmp(big.NewInt(0)) == 1 && state.NetworkDetails.RewardIndex > 0 {
 
 		nodeWeightSum := big.NewInt(0).Add(nodeWeight, previousIntervalTotalNodeWeight)
 

rocketpool/node/collectors/rpl-collector.go

@@ -18,6 +18,7 @@ type RplCollector struct {
 	totalValueStaked *prometheus.Desc
 
 	// The total effective amount of RPL staked on the network
+	// Obsolete, but still populated so the dashboard can show it.
 	totalEffectiveStaked *prometheus.Desc
 
 	// The date and time of the next RPL rewards checkpoint
@@ -81,20 +82,18 @@ func (collector *RplCollector) Collect(channel chan<- prometheus.Metric) {
 
 	rplPriceFloat := eth.WeiToEth(state.NetworkDetails.RplPrice)
 	totalValueStakedFloat := eth.WeiToEth(state.NetworkDetails.TotalRPLStake)
-	totalEffectiveStake := collector.stateLocker.GetTotalEffectiveRPLStake()
 	lastCheckpoint := state.NetworkDetails.IntervalStart
 	rewardsInterval := state.NetworkDetails.IntervalDuration
 	nextRewardsTime := float64(lastCheckpoint.Add(rewardsInterval).Unix()) * 1000
-	if totalEffectiveStake == nil {
-		return
-	}
 
 	channel <- prometheus.MustNewConstMetric(
 		collector.rplPrice, prometheus.GaugeValue, rplPriceFloat)
 	channel <- prometheus.MustNewConstMetric(
 		collector.totalValueStaked, prometheus.GaugeValue, totalValueStakedFloat)
+	// All staked RPL is effective RPL, but this metric is on the dashboard so we
+	// should keep populating it for now.
 	channel <- prometheus.MustNewConstMetric(
-		collector.totalEffectiveStaked, prometheus.GaugeValue, eth.WeiToEth(totalEffectiveStake))
+		collector.totalEffectiveStaked, prometheus.GaugeValue, totalValueStakedFloat)
 	channel <- prometheus.MustNewConstMetric(
 		collector.checkpointTime, prometheus.GaugeValue, nextRewardsTime)
 }

rocketpool/node/collectors/state-locker.go

@@ -1,15 +1,13 @@
 package collectors
 
 import (
-	"math/big"
 	"sync"
 
 	"github.com/rocket-pool/smartnode/shared/services/state"
 )
 
 type StateLocker struct {
-	state               *state.NetworkState
-	totalEffectiveStake *big.Int
+	state *state.NetworkState
 
 	// Internal fields
 	lock *sync.Mutex
@@ -21,23 +19,14 @@ func NewStateLocker() *StateLocker {
 	}
 }
 
-func (l *StateLocker) UpdateState(state *state.NetworkState, totalEffectiveStake *big.Int) {
+func (l *StateLocker) UpdateState(state *state.NetworkState) {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	l.state = state
-	if totalEffectiveStake != nil {
-		l.totalEffectiveStake = totalEffectiveStake
-	}
 }
 
 func (l *StateLocker) GetState() *state.NetworkState {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	return l.state
 }
-
-func (l *StateLocker) GetTotalEffectiveRPLStake() *big.Int {
-	l.lock.Lock()
-	defer l.lock.Unlock()
-	return l.totalEffectiveStake
-}

rocketpool/node/node.go

@@ -27,7 +27,6 @@ import (
 // Config
 var tasksInterval, _ = time.ParseDuration("5m")
 var taskCooldown, _ = time.ParseDuration("10s")
-var totalEffectiveStakeCooldown, _ = time.ParseDuration("1h")
 
 const (
 	MaxConcurrentEth1Requests = 200
@@ -172,9 +171,6 @@ func run(c *cli.Context) error {
 	wg := new(sync.WaitGroup)
 	wg.Add(2)
 
-	// Timestamp for caching total effective RPL stake
-	lastTotalEffectiveStakeTime := time.Unix(0, 0)
-
 	// Run task loop
 	go func() {
 		// we assume clients are synced on startup so that we don't send unnecessary alerts
@@ -213,18 +209,13 @@ func run(c *cli.Context) error {
 			}
 
 			// Update the network state
-			updateTotalEffectiveStake := false
-			if time.Since(lastTotalEffectiveStakeTime) > totalEffectiveStakeCooldown {
-				updateTotalEffectiveStake = true
-				lastTotalEffectiveStakeTime = time.Now() // Even if the call below errors out, this will prevent contant errors related to this flag
-			}
-			state, totalEffectiveStake, err := updateNetworkState(m, &updateLog, nodeAccount.Address, updateTotalEffectiveStake)
+			state, err := updateNetworkState(m, &updateLog, nodeAccount.Address)
 			if err != nil {
 				errorLog.Println(err)
 				time.Sleep(taskCooldown)
 				continue
 			}
-			stateLocker.UpdateState(state, totalEffectiveStake)
+			stateLocker.UpdateState(state)
 
 			// Manage the fee recipient for the node
 			if err := manageFeeRecipient.run(state); err != nil {
@@ -382,13 +373,13 @@ func removeLegacyFeeRecipientFiles(c *cli.Context) error {
 }
 
 // Update the latest network state at each cycle
-func updateNetworkState(m *state.NetworkStateManager, log *log.ColorLogger, nodeAddress common.Address, calculateTotalEffectiveStake bool) (*state.NetworkState, *big.Int, error) {
+func updateNetworkState(m *state.NetworkStateManager, log *log.ColorLogger, nodeAddress common.Address) (*state.NetworkState, error) {
 	// Get the state of the network
-	state, totalEffectiveStake, err := m.GetHeadStateForNode(nodeAddress, calculateTotalEffectiveStake)
+	state, err := m.GetHeadStateForNode(nodeAddress)
 	if err != nil {
-		return nil, nil, fmt.Errorf("error updating network state: %w", err)
+		return nil, fmt.Errorf("error updating network state: %w", err)
 	}
-	return state, totalEffectiveStake, nil
+	return state, nil
 }
 
 // Checks if the user-inputted priorityFee is greater than the oracle based maxFee

shared/services/state/manager.go

@@ -3,7 +3,6 @@ package state
 import (
 	"context"
 	"fmt"
-	"math/big"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -65,21 +64,21 @@ func (m *NetworkStateManager) GetHeadState() (*NetworkState, error) {
 	if err != nil {
 		return nil, fmt.Errorf("error getting latest Beacon slot: %w", err)
 	}
-	return m.getState(targetSlot)
+	return m.createNetworkState(targetSlot)
 }
 
 // Get the state of the network for a single node using the latest Execution layer block, along with the total effective RPL stake for the network
-func (m *NetworkStateManager) GetHeadStateForNode(nodeAddress common.Address, calculateTotalEffectiveStake bool) (*NetworkState, *big.Int, error) {
+func (m *NetworkStateManager) GetHeadStateForNode(nodeAddress common.Address) (*NetworkState, error) {
 	targetSlot, err := m.getHeadSlot()
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting latest Beacon slot: %w", err)
+		return nil, fmt.Errorf("error getting latest Beacon slot: %w", err)
 	}
-	return m.getStateForNode(nodeAddress, targetSlot, calculateTotalEffectiveStake)
+	return m.createNetworkStateForNode(targetSlot, nodeAddress)
 }
 
 // Get the state of the network at the provided Beacon slot
 func (m *NetworkStateManager) GetStateForSlot(slotNumber uint64) (*NetworkState, error) {
-	return m.getState(slotNumber)
+	return m.createNetworkState(slotNumber)
 }
 
 // Gets the latest valid block
@@ -144,24 +143,6 @@ func (m *NetworkStateManager) getLatestProposedBeaconBlock(targetSlot uint64) (b
 	}
 }
 
-// Get the state of the network at the provided Beacon slot
-func (m *NetworkStateManager) getState(slotNumber uint64) (*NetworkState, error) {
-	state, err := m.createNetworkState(slotNumber)
-	if err != nil {
-		return nil, err
-	}
-	return state, nil
-}
-
-// Get the state of the network for a specific node only at the provided Beacon slot
-func (m *NetworkStateManager) getStateForNode(nodeAddress common.Address, slotNumber uint64, calculateTotalEffectiveStake bool) (*NetworkState, *big.Int, error) {
-	state, totalEffectiveStake, err := m.createNetworkStateForNode(slotNumber, nodeAddress, calculateTotalEffectiveStake)
-	if err != nil {
-		return nil, nil, err
-	}
-	return state, totalEffectiveStake, nil
-}
-
 // Logs a line if the logger is specified
 func (m *NetworkStateManager) logLine(format string, v ...interface{}) {
 	if m.log != nil {

shared/services/state/network-state.go

@@ -281,20 +281,16 @@ func (m *NetworkStateManager) createNetworkState(slotNumber uint64) (*NetworkSta
 }
 
 // Creates a snapshot of the Rocket Pool network, but only for a single node
-// Also gets the total effective RPL stake of the network for convenience since this is required by several node routines
-func (m *NetworkStateManager) createNetworkStateForNode(slotNumber uint64, nodeAddress common.Address, calculateTotalEffectiveStake bool) (*NetworkState, *big.Int, error) {
+func (m *NetworkStateManager) createNetworkStateForNode(slotNumber uint64, nodeAddress common.Address) (*NetworkState, error) {
 	steps := 5
-	if calculateTotalEffectiveStake {
-		steps++
-	}
 
 	// Get the execution block for the given slot
 	beaconBlock, exists, err := m.bc.GetBeaconBlock(fmt.Sprintf("%d", slotNumber))
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting Beacon block for slot %d: %w", slotNumber, err)
+		return nil, fmt.Errorf("error getting Beacon block for slot %d: %w", slotNumber, err)
 	}
 	if !exists {
-		return nil, nil, fmt.Errorf("slot %d did not have a Beacon block", slotNumber)
+		return nil, fmt.Errorf("slot %d did not have a Beacon block", slotNumber)
 	}
 
 	// Get the corresponding block on the EL
@@ -305,7 +301,7 @@ func (m *NetworkStateManager) createNetworkStateForNode(slotNumber uint64, nodeA
 
 	beaconConfig, err := m.getBeaconConfig()
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting Beacon config: %w", err)
+		return nil, fmt.Errorf("error getting Beacon config: %w", err)
 	}
 
 	// Create the state wrapper
@@ -324,26 +320,26 @@ func (m *NetworkStateManager) createNetworkStateForNode(slotNumber uint64, nodeA
 	// Network contracts and details
 	contracts, err := rpstate.NewNetworkContracts(m.rp, m.multicaller, m.balanceBatcher, opts)
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting network contracts: %w", err)
+		return nil, fmt.Errorf("error getting network contracts: %w", err)
 	}
 	state.NetworkDetails, err = rpstate.NewNetworkDetails(m.rp, contracts)
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting network details: %w", err)
+		return nil, fmt.Errorf("error getting network details: %w", err)
 	}
 	m.logLine("1/%d - Retrieved network details (%s so far)", steps, time.Since(start))
 
 	// Node details
 	nodeDetails, err := rpstate.GetNativeNodeDetails(m.rp, contracts, nodeAddress)
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting node details: %w", err)
+		return nil, fmt.Errorf("error getting node details: %w", err)
 	}
 	state.NodeDetails = []rpstate.NativeNodeDetails{nodeDetails}
 	m.logLine("2/%d - Retrieved node details (%s so far)", steps, time.Since(start))
 
 	// Minipool details
 	state.MinipoolDetails, err = rpstate.GetNodeNativeMinipoolDetails(m.rp, contracts, nodeAddress)
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting all minipool details: %w", err)
+		return nil, fmt.Errorf("error getting all minipool details: %w", err)
 	}
 	m.logLine("3/%d - Retrieved minipool details (%s so far)", steps, time.Since(start))
 
@@ -377,22 +373,13 @@ func (m *NetworkStateManager) createNetworkStateForNode(slotNumber uint64, nodeA
 
 	// Get the total network effective RPL stake
 	currentStep := 4
-	var totalEffectiveStake *big.Int
-	if calculateTotalEffectiveStake {
-		totalEffectiveStake, err = rpstate.GetTotalEffectiveRplStake(m.rp, contracts)
-		if err != nil {
-			return nil, nil, fmt.Errorf("error calculating total effective RPL stake for the network: %w", err)
-		}
-		m.logLine("%d/%d - Calculated total effective stake (total time: %s)", currentStep, steps, time.Since(start))
-		currentStep++
-	}
 
 	// Get the validator stats from Beacon
 	statusMap, err := m.bc.GetValidatorStatuses(pubkeys, &beacon.ValidatorStatusOptions{
 		Slot: &slotNumber,
 	})
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	state.ValidatorDetails = statusMap
 	m.logLine("%d/%d - Retrieved validator details (total time: %s)", currentStep, steps, time.Since(start))
@@ -412,7 +399,7 @@ func (m *NetworkStateManager) createNetworkStateForNode(slotNumber uint64, nodeA
 	}
 	err = rpstate.CalculateCompleteMinipoolShares(m.rp, contracts, mpds, beaconBalances)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	state.ValidatorDetails = statusMap
 	m.logLine("%d/%d - Calculated complete node and user balance shares (total time: %s)", currentStep, steps, time.Since(start))
@@ -421,12 +408,12 @@ func (m *NetworkStateManager) createNetworkStateForNode(slotNumber uint64, nodeA
 	// Get the protocol DAO proposals
 	state.ProtocolDaoProposalDetails, err = rpstate.GetAllProtocolDaoProposalDetails(m.rp, contracts)
 	if err != nil {
-		return nil, nil, fmt.Errorf("error getting Protocol DAO proposal details: %w", err)
+		return nil, fmt.Errorf("error getting Protocol DAO proposal details: %w", err)
 	}
 	m.logLine("%d/%d - Retrieved Protocol DAO proposals (total time: %s)", currentStep, steps, time.Since(start))
 	currentStep++
 
-	return state, totalEffectiveStake, nil
+	return state, nil
 }
 
 func (s *NetworkState) GetStakedRplValueInEthAndPercentOfBorrowedEth(eligibleBorrowedEth *big.Int, nodeStake *big.Int) (*big.Int, *big.Int) {