Node diver metrics

shared/services/bc-manager.go

@@ -134,6 +134,16 @@ func (m *BeaconClientManager) GetSyncStatus() (beacon.SyncStatus, error) {
 	return result.(beacon.SyncStatus), nil
 }
 
+func (m *BeaconClientManager) GetNodeVersion() (beacon.NodeVersion, error) {
+	result, err := m.runFunction1(func(client beacon.Client) (interface{}, error) {
+		return client.GetNodeVersion()
+	})
+	if err != nil {
+		return beacon.NodeVersion{}, err
+	}
+	return result.(beacon.NodeVersion), nil
+}
+
 // Get the Beacon configuration
 func (m *BeaconClientManager) GetEth2Config() (beacon.Eth2Config, error) {
 	result, err := m.runFunction1(func(client beacon.Client) (interface{}, error) {

shared/services/beacon/client.go

@@ -97,6 +97,10 @@ type AttestationInfo struct {
 	CommitteeIndex  uint64
 }
 
+type NodeVersion struct {
+	Version string
+}
+
 // Beacon client type
 type BeaconClientType int
 
@@ -133,6 +137,7 @@ const (
 type Client interface {
 	GetClientType() (BeaconClientType, error)
 	GetSyncStatus() (SyncStatus, error)
+	GetNodeVersion() (NodeVersion, error)
 	GetEth2Config() (Eth2Config, error)
 	GetEth2DepositContract() (Eth2DepositContract, error)
 	GetAttestations(blockId string) ([]AttestationInfo, bool, error)

shared/services/beacon/client/std-http-client.go

@@ -48,6 +48,7 @@
 	RequestContentType = "application/json"
 
 	RequestSyncStatusPath            = "/eth/v1/node/syncing"
+	RequestNodeVersionPath           = "/eth/v1/node/version"
 	RequestEth2ConfigPath            = "/eth/v1/config/spec"
 	RequestEth2DepositContractMethod = "/eth/v1/config/deposit_contract"
 	RequestGenesisPath               = "/eth/v1/beacon/genesis"
@@ -107,6 +108,17 @@
 
 }
 
+func (c *StandardHttpClient) GetNodeVersion() (beacon.NodeVersion, error) {
+	nodeVersion, err := c.getNodeVersion()
+	if err != nil {
+		return beacon.NodeVersion{}, err
+	}
+
+	return beacon.NodeVersion{
+		Version: nodeVersion.Data.Version,
+	}, nil
+}
+
 // Get the eth2 config
 func (c *StandardHttpClient) GetEth2Config() (beacon.Eth2Config, error) {
 
@@ -572,6 +584,21 @@
 	return syncStatus, nil
 }
 
+func (c *StandardHttpClient) getNodeVersion() (NodeVersionResponse, error) {
+	responseBody, status, err := c.getRequest(RequestNodeVersionPath)
+	if err != nil {
+		return NodeVersionResponse{}, fmt.Errorf("Could not get node sync status: %w", err)
+	}
+	if status != http.StatusOK {
+		return NodeVersionResponse{}, fmt.Errorf("Could not get node sync status: HTTP status %d; response body: '%s'", status, string(responseBody))
+	}
+	var nodeVersion NodeVersionResponse
+	if err := json.Unmarshal(responseBody, &nodeVersion); err != nil {
+		return NodeVersionResponse{}, fmt.Errorf("Could not decode node sync status: %w", err)
+	}
+	return nodeVersion, nil
+}
+
 // Get the eth2 config
 func (c *StandardHttpClient) getEth2Config() (Eth2ConfigResponse, error) {
 	responseBody, status, err := c.getRequest(RequestEth2ConfigPath)

shared/services/beacon/client/types.go

@@ -46,6 +46,13 @@ type SyncStatusResponse struct {
 		SyncDistance uinteger `json:"sync_distance"`
 	} `json:"data"`
 }
+
+type NodeVersionResponse struct {
+	Data struct {
+		Version string `json:"version"`
+	} `json:"data"`
+}
+
 type Eth2ConfigResponse struct {
 	Data struct {
 		SecondsPerSlot               uinteger `json:"SECONDS_PER_SLOT"`

shared/services/config/stadernode-config.go

@@ -324,6 +324,10 @@
 	return cfg.baseStaderBackendUrl[cfg.Network.Value.(config.Network)] + "/merklesForElRewards/proofs/%s"
 }
 
+func (cfg *StaderNodeConfig) GetNodeDiversityApi() string {
+	return cfg.baseStaderBackendUrl[cfg.Network.Value.(config.Network)] + "/nodeDiversity"
+}
+
 func (cfg *StaderNodeConfig) GetTxWatchUrl() string {
 	return cfg.txWatchUrl[cfg.Network.Value.(config.Network)]
 }

shared/services/ec-manager.go

@@ -21,9 +21,12 @@
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"io"
 	"math"
 	"math/big"
+	"net/http"
 	"strings"
 	"time"
 
@@ -520,3 +523,51 @@
 func (p *ExecutionClientManager) isDisconnected(err error) bool {
 	return strings.Contains(err.Error(), "dial tcp")
 }
+
+func (p *ExecutionClientManager) Version() (string, error) {
+	if !p.primaryReady && !p.fallbackReady {
+		return "", fmt.Errorf("EC not ready")
+	}
+
+	var url string
+
+	if p.primaryReady {
+		url = p.primaryEcUrl
+	} else {
+		url = p.primaryEcUrl
+	}
+
+	method := "POST"
+
+	payload := strings.NewReader(`{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":1}`)
+
+	client := &http.Client{}
+	req, err := http.NewRequest(method, url, payload)
+
+	if err != nil {
+		return "", err
+	}
+	req.Header.Add("Content-Type", "application/json")
+
+	res, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+
+	response := struct {
+		Result string `json:"result"`
+	}{}
+
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		return "", err
+	}
+
+	return response.Result, nil
+}

shared/services/wallet/node.go

@@ -22,6 +22,7 @@
 import (
 	"context"
 	"crypto/ecdsa"
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"math/big"
@@ -186,3 +187,29 @@
 	return key, derivationPath, nil
 
 }
+
+// Get the node hex encoding public key
+func (w *Wallet) GetNodePubkey() (string, error) {
+
+	// Check wallet is initialized
+	if !w.IsInitialized() {
+		return "", errors.New("Wallet is not initialized")
+	}
+
+	// Get private key
+	privateKey, _, err := w.getNodePrivateKey()
+	if err != nil {
+		return "", err
+	}
+
+	// Get public key
+	publicKey := privateKey.Public()
+	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
+	if !ok {
+		return "", errors.New("Could not get node public key")
+	}
+
+	publickeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
+
+	return hex.EncodeToString(publickeyBytes), nil
+}

shared/types/stader-backend/node-diversity.go

@@ -0,0 +1,19 @@
+package stader_backend
+
+type NodeDiversityRequest struct {
+	Signature string         `json:"signature"`
+	Message   *NodeDiversity `json:"message"`
+}
+
+type NodeDiversity struct {
+	ExecutionClient string `json:"executionClient"`
+	ConsensusClient string `json:"consensusClient"`
+	NodeAddress     string `json:"nodeAddress"`
+	NodePublicKey   string `json:"nodePublicKey"`
+	Relays          string `json:"relays"`
+}
+
+type NodeDiversityResponseType struct {
+	Success bool   `json:"success"`
+	Error   string `json:"error"`
+}

shared/utils/stader/node-diversity.go

@@ -0,0 +1,37 @@
+package stader
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/stader-labs/stader-node/shared/services"
+	stader_backend "github.com/stader-labs/stader-node/shared/types/stader-backend"
+	"github.com/stader-labs/stader-node/shared/utils/net"
+	"github.com/urfave/cli"
+)
+
+func SendNodeDiversityResponseType(
+	c *cli.Context,
+	request *stader_backend.NodeDiversityRequest,
+) (*stader_backend.NodeDiversityResponseType, error) {
+	config, err := services.GetConfig(c)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := net.MakePostRequest(config.StaderNode.GetNodeDiversityApi(), request)
+	if err != nil {
+		return nil, fmt.Errorf("request to GetNodeDiversityApi %w", err)
+	}
+	defer res.Body.Close()
+
+	var resp stader_backend.NodeDiversityResponseType
+	err = json.NewDecoder(res.Body).Decode(&resp)
+
+	if err != nil {
+		return nil, fmt.Errorf("decode NodeDiversityResponseType %w", err)
+	}
+
+	return &resp, nil
+
+}

stader-cli/service/service.go

@@ -684,8 +684,8 @@ func startService(
 			fmt.Printf("%sWarning: couldn't verify that the validator container can be safely restarted:\n\t%s\n", colorYellow, err.Error())
 			fmt.Println("If you are changing to a different ETH2 client, it may resubmit an attestation you have already submitted.")
 			fmt.Println("This will slash your validator!")
-			fmt.Println("To prevent slashing, you must wait 15 minutes from the time you stopped the clients before starting them again.\n")
-			fmt.Println("**If you did NOT change clients, you can safely ignore this warning.**\n")
+			fmt.Println("To prevent slashing, you must wait 15 minutes from the time you stopped the clients before starting them again.")
+			fmt.Println("**If you did NOT change clients, you can safely ignore this warning.**")
 			if !cliutils.Confirm(fmt.Sprintf("Press y when you understand the above warning, have waited, and are ready to start Stader:%s", colorReset)) {
 				fmt.Println("Cancelled.")
 				return nil