Uptime tracking api

go.mod

@@ -5,7 +5,7 @@ go 1.22.8
 require (
 	github.com/VictoriaMetrics/fastcache v1.12.1
 	github.com/antithesishq/antithesis-sdk-go v0.3.8
-	github.com/ava-labs/avalanchego v1.11.13-0.20241026214739-acb3d7d102a0
+	github.com/ava-labs/avalanchego v1.11.13-0.20241029131257-e05aa37abaf9
 	github.com/cespare/cp v0.1.0
 	github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233
 	github.com/davecgh/go-spew v1.1.1

go.sum

@@ -60,6 +60,8 @@ github.com/antithesishq/antithesis-sdk-go v0.3.8/go.mod h1:IUpT2DPAKh6i/YhSbt6Gl
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/ava-labs/avalanchego v1.11.13-0.20241026214739-acb3d7d102a0 h1:1T9OnvZP6XZ62EVWlfmrI8rrudyE6bM2Zt51pCHfS5o=
 github.com/ava-labs/avalanchego v1.11.13-0.20241026214739-acb3d7d102a0/go.mod h1:gYlTU42Q4b29hzhUN22yclym5qwB3Si0jh4+LTn7DZM=
+github.com/ava-labs/avalanchego v1.11.13-0.20241029131257-e05aa37abaf9 h1:rX5Xn5WBPppyvvZXp8wwx9dX+4fBY2/XeNIEm18ifzk=
+github.com/ava-labs/avalanchego v1.11.13-0.20241029131257-e05aa37abaf9/go.mod h1:gYlTU42Q4b29hzhUN22yclym5qwB3Si0jh4+LTn7DZM=
 github.com/ava-labs/coreth v0.13.8 h1:f14X3KgwHl9LwzfxlN6S4bbn5VA2rhEsNnHaRLSTo/8=
 github.com/ava-labs/coreth v0.13.8/go.mod h1:t3BSv/eQv0AlDPMfEDCMMoD/jq1RkUsbFzQAFg5qBcE=
 github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=

plugin/evm/api.go

@@ -0,0 +1,38 @@
+// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package evm
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// SnowmanAPI introduces snowman specific functionality to the evm
+type SnowmanAPI struct{ vm *VM }
+
+// GetAcceptedFrontReply defines the reply that will be sent from the
+// GetAcceptedFront API call
+type GetAcceptedFrontReply struct {
+	Hash   common.Hash `json:"hash"`
+	Number *big.Int    `json:"number"`
+}
+
+// GetAcceptedFront returns the last accepted block's hash and height
+func (api *SnowmanAPI) GetAcceptedFront(ctx context.Context) (*GetAcceptedFrontReply, error) {
+	blk := api.vm.blockChain.LastConsensusAcceptedBlock()
+	return &GetAcceptedFrontReply{
+		Hash:   blk.Hash(),
+		Number: blk.Number(),
+	}, nil
+}
+
+// IssueBlock to the chain
+func (api *SnowmanAPI) IssueBlock(ctx context.Context) error {
+	log.Info("Issuing a new block")
+	api.vm.builder.signalTxsReady()
+	return nil
+}

plugin/evm/block.go

@@ -215,7 +215,7 @@ func (b *Block) verify(predicateContext *precompileconfig.PredicateContext, writ
 	// If the chain is still bootstrapping, we can assume that all blocks we are verifying have
 	// been accepted by the network (so the predicate was validated by the network when the
 	// block was originally verified).
-	if b.vm.bootstrapped {
+	if b.vm.bootstrapped.Get() {
 		if err := b.verifyPredicates(predicateContext); err != nil {
 			return fmt.Errorf("failed to verify predicates: %w", err)
 		}

plugin/evm/config.go

@@ -61,7 +61,10 @@ const (
 	// - state sync time: ~6 hrs.
 	defaultStateSyncMinBlocks   = 300_000
 	defaultStateSyncRequestSize = 1024 // the number of key/values to ask peers for per request
-	defaultDBType               = pebbledb.Name
+
+	defaultValidatorsAPIEnabled = true
+
+	defaultDBType = pebbledb.Name
 )
 
 type PBool bool
@@ -91,10 +94,11 @@ type Config struct {
 	AirdropFile string `json:"airdrop"`
 
 	// Subnet EVM APIs
-	SnowmanAPIEnabled bool   `json:"snowman-api-enabled"`
-	AdminAPIEnabled   bool   `json:"admin-api-enabled"`
-	AdminAPIDir       string `json:"admin-api-dir"`
-	WarpAPIEnabled    bool   `json:"warp-api-enabled"`
+	SnowmanAPIEnabled    bool   `json:"snowman-api-enabled"`
+	ValidatorsAPIEnabled bool   `json:"validators-api-enabled"`
+	AdminAPIEnabled      bool   `json:"admin-api-enabled"`
+	AdminAPIDir          string `json:"admin-api-dir"`
+	WarpAPIEnabled       bool   `json:"warp-api-enabled"`
 
 	// EnabledEthAPIs is a list of Ethereum services that should be enabled
 	// If none is specified, then we use the default list [defaultEnabledAPIs]
@@ -296,6 +300,7 @@ func (c *Config) SetDefaults() {
 	c.StateSyncRequestSize = defaultStateSyncRequestSize
 	c.AllowUnprotectedTxHashes = defaultAllowUnprotectedTxHashes
 	c.AcceptedCacheSize = defaultAcceptedCacheSize
+	c.ValidatorsAPIEnabled = defaultValidatorsAPIEnabled
 	c.DatabaseType = defaultDBType
 }
 

plugin/evm/service.go

@@ -4,35 +4,70 @@
 package evm
 
 import (
-	"context"
-	"math/big"
+	"net/http"
+	"time"
 
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
+	"github.com/ava-labs/avalanchego/database"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/utils/set"
 )
 
-// SnowmanAPI introduces snowman specific functionality to the evm
-type SnowmanAPI struct{ vm *VM }
+type ValidatorsAPI struct {
+	vm *VM
+}
+
+type GetCurrentValidatorsRequest struct {
+	NodeIDs []ids.NodeID `json:"nodeIDs"`
+}
 
-// GetAcceptedFrontReply defines the reply that will be sent from the
-// GetAcceptedFront API call
-type GetAcceptedFrontReply struct {
-	Hash   common.Hash `json:"hash"`
-	Number *big.Int    `json:"number"`
+type GetCurrentValidatorsResponse struct {
+	Validators []CurrentValidator `json:"validators"`
 }
 
-// GetAcceptedFront returns the last accepted block's hash and height
-func (api *SnowmanAPI) GetAcceptedFront(ctx context.Context) (*GetAcceptedFrontReply, error) {
-	blk := api.vm.blockChain.LastConsensusAcceptedBlock()
-	return &GetAcceptedFrontReply{
-		Hash:   blk.Hash(),
-		Number: blk.Number(),
-	}, nil
+type CurrentValidator struct {
+	ValidationID ids.ID        `json:"validationID"`
+	NodeID       ids.NodeID    `json:"nodeID"`
+	StartTime    time.Time     `json:"startTime"`
+	IsActive     bool          `json:"isActive"`
+	IsConnected  bool          `json:"isConnected"`
+	Uptime       time.Duration `json:"uptime"`
 }
 
-// IssueBlock to the chain
-func (api *SnowmanAPI) IssueBlock(ctx context.Context) error {
-	log.Info("Issuing a new block")
-	api.vm.builder.signalTxsReady()
+func (api *ValidatorsAPI) GetCurrentValidators(_ *http.Request, args *GetCurrentValidatorsRequest, reply *GetCurrentValidatorsResponse) error {
+	api.vm.ctx.Lock.RLock()
+	defer api.vm.ctx.Lock.RUnlock()
+
+	nodeIDs := set.Of(args.NodeIDs...)
+	if nodeIDs.Len() == 0 {
+		nodeIDs = api.vm.validatorState.GetValidatorIDs()
+	}
+
+	reply.Validators = make([]CurrentValidator, 0, nodeIDs.Len())
+
+	for _, nodeID := range nodeIDs.List() {
+		validator, err := api.vm.validatorState.GetValidator(nodeID)
+		switch {
+		case err == database.ErrNotFound:
+			continue
+		case err != nil:
+			return err
+		}
+
+		isConnected := api.vm.uptimeManager.IsConnected(nodeID)
+
+		uptime, _, err := api.vm.uptimeManager.CalculateUptime(nodeID)
+		if err != nil {
+			return err
+		}
+
+		reply.Validators = append(reply.Validators, CurrentValidator{
+			ValidationID: validator.ValidationID,
+			NodeID:       nodeID,
+			StartTime:    validator.StartTime,
+			IsActive:     validator.IsActive,
+			IsConnected:  isConnected,
+			Uptime:       time.Duration(uptime.Seconds()),
+		})
+	}
 	return nil
 }

plugin/evm/syncervm_test.go

@@ -494,7 +494,7 @@ func testSyncerVM(t *testing.T, vmSetup *syncVMSetup, test syncTest) {
 
 	// check we can transition to [NormalOp] state and continue to process blocks.
 	require.NoError(syncerVM.SetState(context.Background(), snow.NormalOp))
-	require.True(syncerVM.bootstrapped)
+	require.True(syncerVM.bootstrapped.Get())
 
 	// Generate blocks after we have entered normal consensus as well
 	generateAndAcceptBlocks(t, syncerVM, blocksToBuild, func(_ int, gen *core.BlockGen) {

plugin/evm/tx_gossip_test.go

@@ -37,7 +37,7 @@ func TestEthTxGossip(t *testing.T) {
 	require := require.New(t)
 	ctx := context.Background()
 	snowCtx := utils.TestSnowContext()
-	validatorState := &validatorstest.State{}
+	validatorState := utils.NewTestValidatorState()
 	snowCtx.ValidatorState = validatorState
 
 	responseSender := &enginetest.SenderStub{

plugin/evm/uptime/pausable_manager.go

@@ -0,0 +1,156 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package uptime
+
+import (
+	"errors"
+
+	"github.com/ava-labs/subnet-evm/plugin/evm/validators"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/snow/uptime"
+	"github.com/ava-labs/avalanchego/utils/set"
+)
+
+var _ validators.StateCallbackListener = &pausableManager{}
+
+var (
+	errPausedDisconnect = errors.New("paused node cannot be disconnected")
+	errAlreadyPaused    = errors.New("node is already paused")
+	errNotPaused        = errors.New("node is not paused")
+)
+
+type PausableManager interface {
+	uptime.Manager
+	validators.StateCallbackListener
+	IsPaused(nodeID ids.NodeID) bool
+}
+
+type pausableManager struct {
+	uptime.Manager
+	pausedVdrs set.Set[ids.NodeID]
+	// connectedVdrs is a set of nodes that are connected to the manager.
+	// This is used to immediately connect nodes when they are unpaused.
+	connectedVdrs set.Set[ids.NodeID]
+}
+
+// NewPausableManager takes an uptime.Manager and returns a PausableManager
+func NewPausableManager(manager uptime.Manager) PausableManager {
+	return &pausableManager{
+		pausedVdrs:    make(set.Set[ids.NodeID]),
+		connectedVdrs: make(set.Set[ids.NodeID]),
+		Manager:       manager,
+	}
+}
+
+// Connect connects the node with the given ID to the uptime.Manager
+// If the node is paused, it will not be connected
+func (p *pausableManager) Connect(nodeID ids.NodeID) error {
+	p.connectedVdrs.Add(nodeID)
+	if !p.IsPaused(nodeID) && !p.Manager.IsConnected(nodeID) {
+		return p.Manager.Connect(nodeID)
+	}
+	return nil
+}
+
+// Disconnect disconnects the node with the given ID from the uptime.Manager
+// If the node is paused, it will not be disconnected
+// Invariant: we should never have a connected paused node that is disconnecting
+func (p *pausableManager) Disconnect(nodeID ids.NodeID) error {
+	p.connectedVdrs.Remove(nodeID)
+	if p.Manager.IsConnected(nodeID) {
+		if p.IsPaused(nodeID) {
+			// We should never see this case
+			return errPausedDisconnect
+		}
+		return p.Manager.Disconnect(nodeID)
+	}
+	return nil
+}
+
+// StartTracking starts tracking uptime for the nodes with the given IDs
+// If a node is paused, it will not be tracked
+func (p *pausableManager) StartTracking(nodeIDs []ids.NodeID) error {
+	var activeNodeIDs []ids.NodeID
+	for _, nodeID := range nodeIDs {
+		if !p.IsPaused(nodeID) {
+			activeNodeIDs = append(activeNodeIDs, nodeID)
+		}
+	}
+	return p.Manager.StartTracking(activeNodeIDs)
+}
+
+// OnValidatorAdded is called when a validator is added.
+// If the node is inactive, it will be paused.
+func (p *pausableManager) OnValidatorAdded(vID ids.ID, nodeID ids.NodeID, startTime uint64, isActive bool) {
+	if !isActive {
+		err := p.pause(nodeID)
+		if err != nil {
+			log.Error("failed to handle added validator %s: %s", nodeID, err)
+		}
+	}
+}
+
+// OnValidatorRemoved is called when a validator is removed.
+// If the node is already paused, it will be resumed.
+func (p *pausableManager) OnValidatorRemoved(vID ids.ID, nodeID ids.NodeID) {
+	if p.IsPaused(nodeID) {
+		err := p.resume(nodeID)
+		if err != nil {
+			log.Error("failed to handle validator removed %s: %s", nodeID, err)
+		}
+	}
+}
+
+// OnValidatorStatusUpdated is called when the status of a validator is updated.
+// If the node is active, it will be resumed. If the node is inactive, it will be paused.
+func (p *pausableManager) OnValidatorStatusUpdated(vID ids.ID, nodeID ids.NodeID, isActive bool) {
+	var err error
+	if isActive {
+		err = p.resume(nodeID)
+	} else {
+		err = p.pause(nodeID)
+	}
+	if err != nil {
+		log.Error("failed to update status for node %s: %s", nodeID, err)
+	}
+}
+
+// IsPaused returns true if the node with the given ID is paused.
+func (p *pausableManager) IsPaused(nodeID ids.NodeID) bool {
+	return p.pausedVdrs.Contains(nodeID)
+}
+
+// pause pauses uptime tracking for the node with the given ID
+// pause can disconnect the node from the uptime.Manager if it is connected.
+// Returns an error if the node is already paused.
+func (p *pausableManager) pause(nodeID ids.NodeID) error {
+	if p.IsPaused(nodeID) {
+		return errAlreadyPaused
+	}
+	p.pausedVdrs.Add(nodeID)
+	if p.Manager.IsConnected(nodeID) {
+		// If the node is connected, then we need to disconnect it from
+		// manager
+		// This should be fine in case tracking has not started yet since
+		// the inner manager should handle disconnects accordingly
+		return p.Manager.Disconnect(nodeID)
+	}
+	return nil
+}
+
+// resume resumes uptime tracking for the node with the given ID
+// resume can connect the node to the uptime.Manager if it was connected.
+// Returns an error if the node is not paused.
+func (p *pausableManager) resume(nodeID ids.NodeID) error {
+	if !p.IsPaused(nodeID) {
+		return errNotPaused
+	}
+	p.pausedVdrs.Remove(nodeID)
+	if p.connectedVdrs.Contains(nodeID) && !p.Manager.IsConnected(nodeID) {
+		return p.Manager.Connect(nodeID)
+	}
+	return nil
+}