Ping multisig

integration_test/health_check_test.go

@@ -0,0 +1,77 @@
+package integration_test
+
+import (
+	"io"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/bloxapp/ssv/logging"
+	"github.com/ethereum/go-ethereum"
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ssvlabs/dkg-spec/testing/stubs"
+	cli_initiator "github.com/ssvlabs/ssv-dkg/cli/initiator"
+)
+
+func TestHealthCheck(t *testing.T) {
+	err := logging.SetGlobalLogger("info", "capital", "console", nil)
+	require.NoError(t, err)
+	version := "test.version"
+	stubClient := &stubs.Client{
+		CallContractF: func(call ethereum.CallMsg) ([]byte, error) {
+			return nil, nil
+		},
+	}
+	servers, _ := createOperators(t, version, stubClient)
+	var ips []string
+	for _, s := range servers {
+		ips = append(ips, s.HttpSrv.URL)
+	}
+	RootCmd := &cobra.Command{
+		Use:   "ssv-dkg",
+		Short: "CLI for running Distributed Key Generation protocol",
+		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+		},
+	}
+	RootCmd.AddCommand(cli_initiator.HealthCheck)
+	RootCmd.Short = "ssv-dkg-test"
+	RootCmd.Version = version
+	cli_initiator.HealthCheck.Version = version
+	t.Run("test 1 operator health check: positive", func(t *testing.T) {
+		rescueStdout := os.Stdout
+		r, w, _ := os.Pipe()
+		os.Stdout = w
+		args := []string{"ping", "--ip", ips[0]}
+		RootCmd.SetArgs(args)
+		err := RootCmd.Execute()
+		require.NoError(t, err)
+		w.Close()
+		out, _ := io.ReadAll(r)
+		os.Stdout = rescueStdout
+		t.Log(string(out))
+		require.True(t, strings.Contains(string(out), "operator online and healthy: multisig ready 👌 and connected to ethereum network"))
+		resetFlags(RootCmd)
+	})
+	t.Run("test 1 operator health check: negative", func(t *testing.T) {
+		servers[0].HttpSrv.Close()
+		rescueStdout := os.Stdout
+		r, w, _ := os.Pipe()
+		os.Stdout = w
+		args := []string{"ping", "--ip", ips[0]}
+		RootCmd.SetArgs(args)
+		err := RootCmd.Execute()
+		require.NoError(t, err)
+		w.Close()
+		out, _ := io.ReadAll(r)
+		os.Stdout = rescueStdout
+		t.Log(string(out))
+		require.True(t, strings.Contains(string(out), "operator not healthy"))
+		require.True(t, strings.Contains(string(out), "connection refused"))
+		resetFlags(RootCmd)
+	})
+	for _, srv := range servers {
+		srv.HttpSrv.Close()
+	}
+}

pkgs/initiator/initiator.go

@@ -17,14 +17,14 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/herumi/bls-eth-go-binary/bls"
 	"github.com/imroc/req/v3"
-	"github.com/ssvlabs/ssv-dkg/pkgs/consts"
-	"github.com/ssvlabs/ssv-dkg/pkgs/crypto"
-	"github.com/ssvlabs/ssv-dkg/pkgs/utils"
-	"github.com/ssvlabs/ssv-dkg/pkgs/wire"
 	"go.uber.org/zap"
 
 	spec "github.com/ssvlabs/dkg-spec"
 	spec_crypto "github.com/ssvlabs/dkg-spec/crypto"
+	"github.com/ssvlabs/ssv-dkg/pkgs/consts"
+	"github.com/ssvlabs/ssv-dkg/pkgs/crypto"
+	"github.com/ssvlabs/ssv-dkg/pkgs/utils"
+	"github.com/ssvlabs/ssv-dkg/pkgs/wire"
 )
 
 type VerifyMessageSignatureFunc func(pub *rsa.PublicKey, msg, sig []byte) error
@@ -718,7 +718,7 @@ func (c *Initiator) Ping(ips []string) error {
 		res := <-resc
 		err := c.processPongMessage(res)
 		if err != nil {
-			c.Logger.Error("😥 Operator not healthy: ", zap.Error(err), zap.String("IP", res.IP))
+			c.Logger.Error("🔴 operator not healthy: ", zap.Error(err), zap.String("IP", res.IP))
 			continue
 		}
 	}
@@ -782,20 +782,30 @@ func (c *Initiator) processPongMessage(res wire.PongResult) error {
 	}
 	pong := &wire.Pong{}
 	if err := pong.UnmarshalSSZ(signedPongMsg.Message.Data); err != nil {
-		return err
+		return fmt.Errorf("🆘 cant unmarshall pong message, probably old version, please upgrade: %w", err)
+
 	}
 	pongBytes, err := signedPongMsg.Message.MarshalSSZ()
 	if err != nil {
-		return err
+		return fmt.Errorf("error marshalling signedPongMsg: %w", err)
 	}
 	pub, err := spec_crypto.ParseRSAPublicKey(pong.PubKey)
 	if err != nil {
-		return err
+		return fmt.Errorf("cant parse RSA public key from pong message: %w", err)
 	}
+	// Check that we got pong with correct pub
 	if err := spec_crypto.VerifyRSA(pub, pongBytes, signedPongMsg.Signature); err != nil {
-		return err
+		return fmt.Errorf("operator sent pong with wrong RSA public key %w", err)
+	}
+	if pong.Multisig {
+		if pong.EthClientConnected {
+			c.Logger.Info("🟢 operator online and healthy: multisig ready 👌 and connected to ethereum network ⛓️", zap.Uint64("ID", pong.ID), zap.String("IP", res.IP), zap.String("Version", string(signedPongMsg.Message.Version)), zap.String("Public key", string(pong.PubKey)))
+		} else {
+			c.Logger.Info("🟢 operator online and healthy: multisig ready 👌 but NOT connected to ethereum network 🚫", zap.Uint64("ID", pong.ID), zap.String("IP", res.IP), zap.String("Version", string(signedPongMsg.Message.Version)), zap.String("Public key", string(pong.PubKey)))
+		}
+	} else {
+		c.Logger.Error("🔴 operator online: but NOT multisig ready", zap.Uint64("ID", pong.ID), zap.String("IP", res.IP), zap.String("Version", string(signedPongMsg.Message.Version)), zap.String("Public key", string(pong.PubKey)))
 	}
-	c.Logger.Info("🍎 operator online and healthy", zap.Uint64("ID", pong.ID), zap.String("IP", res.IP), zap.String("Version", string(signedPongMsg.Message.Version)), zap.String("Public key", string(pong.PubKey)))
 	return nil
 }
 

pkgs/operator/state.go

@@ -2,6 +2,7 @@ package operator
 
 import (
 	"bytes"
+	"context"
 	"crypto/rsa"
 	"encoding/hex"
 	"encoding/json"
@@ -163,9 +164,16 @@ func (s *Switch) MarshallAndSign(msg wire.SSZMarshaller, msgType wire.TransportT
 }
 
 func (s *Switch) Pong() ([]byte, error) {
+	var connected bool
+	latestBlock, err := s.EthClient.BlockNumber(context.Background())
+	if latestBlock > 0 && err == nil {
+		connected = true
+	}
 	pong := &wire.Pong{
-		ID:     s.OperatorID,
-		PubKey: s.PubKeyBytes,
+		ID:                 s.OperatorID,
+		PubKey:             s.PubKeyBytes,
+		Multisig:           true,
+		EthClientConnected: connected,
 	}
 	return s.MarshallAndSign(pong, wire.PongMessageType, s.OperatorID, [24]byte{})
 }

pkgs/wire/types.go

@@ -110,16 +110,11 @@ type Exchange struct {
 	Commits []byte `ssz-max:"2048"`
 }
 
-type Ping struct {
-	// Operators involved in the DKG
-	Operators []*spec.Operator `ssz-max:"13"`
-	// Initiator public key
-	InitiatorPublicKey []byte `ssz-max:"2048"`
-}
-
 type Pong struct {
-	ID     uint64
-	PubKey []byte `ssz-max:"2048"`
+	ID                 uint64
+	PubKey             []byte `ssz-max:"2048"`
+	Multisig           bool
+	EthClientConnected bool
 }
 
 type ResultData struct {