lint

cli/initiator/reshare.go

@@ -2,6 +2,7 @@ package initiator
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
 
@@ -45,7 +46,11 @@ var StartReshare = &cobra.Command{
 		if err != nil {
 			return err
 		}
-		defer logger.Sync()
+		defer func() {
+			if err := cli_utils.Sync(logger); err != nil {
+				log.Printf("Failed to sync logger: %v", err)
+			}
+		}()
 		logger.Info("🪛 Initiator`s", zap.String("Version", cmd.Version))
 		opMap, err := cli_utils.LoadOperators(logger)
 		if err != nil {

pkgs/dkg/drand.go

@@ -426,7 +426,9 @@ func (o *LocalOwner) Process(st *wire.SignedTransport, incOperators []*spec.Oper
 					Data:       byts,
 					Version:    o.version,
 				}
-				o.Broadcast(trsp)
+				if err := o.Broadcast(trsp); err != nil {
+					return fmt.Errorf("failed to broadcast ReshareKyberMessage message: %w", err)
+				}
 			}
 		}
 	case wire.ReshareKyberMessageType:

pkgs/dkg/drand_test.go

@@ -6,14 +6,14 @@ import (
 	"sort"
 	"testing"
 
+	"github.com/bloxapp/ssv-dkg/pkgs/crypto"
+	wire2 "github.com/bloxapp/ssv-dkg/pkgs/wire"
+	"github.com/bloxapp/ssv/utils/rsaencryption"
 	kyber_bls "github.com/drand/kyber-bls12381"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
 
-	"github.com/bloxapp/ssv-dkg/pkgs/crypto"
-	wire2 "github.com/bloxapp/ssv-dkg/pkgs/wire"
-	"github.com/bloxapp/ssv/utils/rsaencryption"
 	spec "github.com/ssvlabs/dkg-spec"
 	spec_crypto "github.com/ssvlabs/dkg-spec/crypto"
 )
@@ -144,29 +144,34 @@ func TestDKGInit(t *testing.T) {
 	uid := spec.NewID()
 	exch := map[uint64]*wire2.Transport{}
 
-	err = ts.ForAll(func(o *LocalOwner) error {
+	if err = ts.ForAll(func(o *LocalOwner) error {
 		ts, err := o.Init(uid, init)
 		if err != nil {
 			t.Error(t, err)
 		}
 		exch[o.ID] = ts
 		return nil
-	})
-	require.NoError(t, err)
-	err = ts.ForAll(func(o *LocalOwner) error {
+	}); err != nil {
+		t.Error(err)
+	}
+	if err := ts.ForAll(func(o *LocalOwner) error {
 		return o.Broadcast(exch[o.ID])
-	})
-	require.NoError(t, err)
-	err = ts.ForAll(func(o *LocalOwner) error {
+	}); err != nil {
+		t.Error(err)
+	}
+	if err = ts.ForAll(func(o *LocalOwner) error {
 		<-o.startedDKG
 		return nil
-	})
-
-	require.NoError(t, err)
-	err = ts.ForAll(func(o *LocalOwner) error {
+	}); err != nil {
+		t.Error(err)
+	}
+	if err := ts.ForAll(func(o *LocalOwner) error {
 		<-o.done
 		return nil
-	})
+	}); err != nil {
+		t.Error(err)
+	}
+
 	for _, res := range ts.results {
 		validatorPK, err := spec.RecoverValidatorPKFromResults(res)
 		require.NoError(t, err)

pkgs/initiator/initiator.go

@@ -239,6 +239,7 @@ func (c *Initiator) resignMessageFlowHandling(rMsg *wire.ResignMessage, id [24]b
 func (c *Initiator) messageFlowHandlingReshare(id [24]byte, reshareMsg *wire.ReshareMessage) ([][]byte, error) {
 	c.Logger.Info("phase 1: sending reshare message to all operators")
 	allOps := utils.JoinSets(reshareMsg.SignedReshare.Reshare.OldOperators, reshareMsg.SignedReshare.Reshare.NewOperators)
+	var errs map[uint64]error
 	exchangeMsgs, errs, err := c.SendReshareMsg(id, reshareMsg, allOps)
 	if err != nil {
 		return nil, err
@@ -254,6 +255,10 @@ func (c *Initiator) messageFlowHandlingReshare(id [24]byte, reshareMsg *wire.Res
 	c.Logger.Info("phase 1: ✅ verified operator resharing responses signatures")
 	c.Logger.Info("phase 2: ➡️ sending operator data (exchange messages) required for dkg")
 	kyberMsgs, errs, err := c.SendExchangeMsgs(id, exchangeMsgs, allOps)
+	// check that all new operators and threshold of old operators replied without errors
+	if err := checkThreshold(exchangeMsgs, errs, reshareMsg.SignedReshare.Reshare.OldOperators, reshareMsg.SignedReshare.Reshare.NewOperators, int(reshareMsg.SignedReshare.Reshare.OldT)); err != nil {
+		return nil, err
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -264,6 +269,10 @@ func (c *Initiator) messageFlowHandlingReshare(id [24]byte, reshareMsg *wire.Res
 	c.Logger.Info("phase 2: ✅ verified old operator responses (deal messages) signatures")
 	c.Logger.Info("phase 3: ➡️ sending deal dkg data to new operators")
 	dkgResult, errs, err := c.SendKyberMsgs(id, kyberMsgs, reshareMsg.SignedReshare.Reshare.NewOperators)
+	// check that all new operators and threshold of old operators replied without errors
+	if err := checkThreshold(exchangeMsgs, errs, reshareMsg.SignedReshare.Reshare.OldOperators, reshareMsg.SignedReshare.Reshare.NewOperators, int(reshareMsg.SignedReshare.Reshare.OldT)); err != nil {
+		return nil, err
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -643,13 +652,15 @@ func (c *Initiator) SendKyberMsgs(id [24]byte, kyberDeals map[uint64][]byte, ope
 func (c *Initiator) sendResult(resData *wire.ResultData, operators []*spec.Operator, method string, id [24]byte) error {
 	signedMsgBts, err := c.prepareAndSignMessage(resData, wire.ResultMessageType, id, c.Version)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to prepare message: %w", err)
 	}
 	_, errs := c.SendToAll(method, signedMsgBts, operators)
 	if len(errs) != 0 {
 		var finalErr error
 		for id, err := range errs {
-			errors.Join(finalErr, fmt.Errorf("operator %d, error: %w", id, err))
+			if err := errors.Join(finalErr, fmt.Errorf("operator %d, error: %w", id, err)); err != nil {
+				return fmt.Errorf("failed to join operator errors: %w", err)
+			}
 		}
 		return finalErr
 	}

pkgs/operator/operator.go

@@ -16,7 +16,6 @@ import (
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
-	spec "github.com/ssvlabs/dkg-spec"
 	spec_crypto "github.com/ssvlabs/dkg-spec/crypto"
 )
 
@@ -121,7 +120,10 @@ func RegisterRoutes(s *Server) {
 			}
 			logger.Info("✅ Reshare instance created successfully")
 			writer.WriteHeader(http.StatusOK)
-			writer.Write(b)
+			if _, err := writer.Write(b); err != nil {
+				logger.Error("error writing reshare response: " + err.Error())
+				return
+			}
 		})
 	s.Router.With(rateLimit(s.Logger, routeLimit)).
 		Post("/dkg", func(writer http.ResponseWriter, request *http.Request) {
@@ -254,11 +256,3 @@ func processIncomingRequest(logger *zap.Logger, writer http.ResponseWriter, requ
 	}
 	return signedMsg, nil
 }
-
-func getIDsFromOperatorsArray(ops []*spec.Operator) []uint64 {
-	ids := make([]uint64, 0)
-	for _, op := range ops {
-		ids = append(ids, op.ID)
-	}
-	return ids
-}

pkgs/operator/state.go

@@ -131,6 +131,9 @@ func (s *Switch) CreateInstance(reqID [24]byte, operators []*spec.Operator, mess
 		}
 	case *wire.ReshareMessage:
 		commits, share, err := s.getPublicCommitsAndSecretShare(msg)
+		if err != nil {
+			return nil, nil, err
+		}
 		owner.SecretShare = share
 		resp, err = owner.Reshare(reqID, &msg.SignedReshare.Reshare, commits)
 		if err != nil {