Add Support for Multisig Wallets

cli/flags/flags.go

@@ -31,10 +31,8 @@ const (
 	serverTLSCertPath = "serverTLSCertPath"
 	serverTLSKeyPath  = "serverTLSKeyPath"
 	proofsFilePath    = "proofsFilePath"
-	ethKeystorePath   = "ethKeystorePath"
-	ethKeystorePass   = "ethKeystorePass"
 	ethEndpointURL    = "ethEndpointURL"
-	signedReshare     = "signedReshare"
+	signatures        = "signatures"
 )
 
 // WithdrawAddressFlag  adds withdraw address flag to the command
@@ -151,27 +149,15 @@ func OperatorIDFlag(c *cobra.Command) {
 func ProofsFilePath(c *cobra.Command) {
 	AddPersistentStringFlag(c, proofsFilePath, "proofs.json", "Path to proofs file", false)
 }
-
-// KeystoreFilePath
-func KeystoreFilePath(c *cobra.Command) {
-	AddPersistentStringFlag(c, ethKeystorePath, "keystore.json", "Path to ethereum keystore json file", false)
-}
-
-// KeystoreFilePass
-func KeystoreFilePass(c *cobra.Command) {
-	AddPersistentStringFlag(c, ethKeystorePass, "", "Password to decrypt ethereum keystore json file", false)
+func SignaturesFlag(c *cobra.Command) {
+	AddPersistentStringFlag(c, signatures, "", "Stringified signature(s) for the resign/reshare message", false)
 }
 
 // EthEndpointURL
 func EthEndpointURL(c *cobra.Command) {
 	AddPersistentStringFlag(c, ethEndpointURL, "http://127.0.0.1:8545", "Ethereum node endpoint URL", false)
 }
 
-// KeystoreFilePath
-func SignedReshareFilePath(c *cobra.Command) {
-	AddPersistentStringFlag(c, ethKeystorePath, "signed_reshare.json", "Path to signed reshare message json file", false)
-}
-
 // AddPersistentStringFlag adds a string flag to the command
 func AddPersistentStringFlag(c *cobra.Command, flag, value, description string, isRequired bool) {
 	req := ""

cli/initiator/initiator.go

@@ -54,7 +54,7 @@ var StartDKG = &cobra.Command{
 		}()
 		logger.Info("🪛 Initiator`s", zap.String("Version", cmd.Version))
 		// Load operators TODO: add more sources.
-		operatorIDs, err := cli_utils.StingSliceToUintArray(cli_utils.OperatorIDs)
+		operatorIDs, err := cli_utils.StringSliceToUintArray(cli_utils.OperatorIDs)
 		if err != nil {
 			logger.Fatal("😥 Failed to load participants: ", zap.Error(err))
 		}

cli/initiator/reshare.go

@@ -3,11 +3,8 @@ package initiator
 import (
 	"fmt"
 	"log"
-	"os"
-	"path/filepath"
 
 	e2m_core "github.com/bloxapp/eth2-key-manager/core"
-	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/spf13/cobra"
 	cli_utils "github.com/ssvlabs/ssv-dkg/cli/utils"
 	"github.com/ssvlabs/ssv-dkg/pkgs/initiator"
@@ -56,11 +53,11 @@ var StartReshare = &cobra.Command{
 		if err != nil {
 			logger.Fatal("😥 Failed to load operators: ", zap.Error(err))
 		}
-		oldOperatorIDs, err := cli_utils.StingSliceToUintArray(cli_utils.OperatorIDs)
+		oldOperatorIDs, err := cli_utils.StringSliceToUintArray(cli_utils.OperatorIDs)
 		if err != nil {
 			logger.Fatal("😥 Failed to load participants: ", zap.Error(err))
 		}
-		newOperatorIDs, err := cli_utils.StingSliceToUintArray(cli_utils.NewOperatorIDs)
+		newOperatorIDs, err := cli_utils.StringSliceToUintArray(cli_utils.NewOperatorIDs)
 		if err != nil {
 			logger.Fatal("😥 Failed to load new participants: ", zap.Error(err))
 		}
@@ -79,21 +76,31 @@ var StartReshare = &cobra.Command{
 		if ethNetwork == "" {
 			logger.Fatal("😥 Cant recognize eth network")
 		}
-		// Open ethereum keystore
-		jsonBytes, err := os.ReadFile(cli_utils.KeystorePath)
+		signatures, err := cli_utils.SignaturesStringToBytes(cli_utils.Signatures)
 		if err != nil {
-			return err
+			logger.Fatal("😥 Failed to load signatures: ", zap.Error(err))
 		}
-		keyStorePassword, err := os.ReadFile(filepath.Clean(cli_utils.KeystorePass))
+		// Contruct the resign message
+		rMsg, err := dkgInitiator.ConstructReshareMessage(
+			oldOperatorIDs,
+			newOperatorIDs,
+			signedProofs[0][0].Proof.ValidatorPubKey,
+			ethNetwork,
+			cli_utils.WithdrawAddress[:],
+			cli_utils.OwnerAddress,
+			cli_utils.Nonce,
+			signedProofs[0],
+		)
 		if err != nil {
-			return fmt.Errorf("😥 Error reading password file: %s", err)
+			logger.Fatal("😥 Failed to construct resign message: ", zap.Error(err))
 		}
-		sk, err := keystore.DecryptKey(jsonBytes, string(keyStorePassword))
-		if err != nil {
-			return err
+		// Append the signatures
+		signedReshare := &wire.SignedReshare{
+			Message:   rMsg,
+			Signature: signatures,
 		}
 		// Start the ceremony
-		depositData, keyShares, proof, err := dkgInitiator.StartResharing(id, oldOperatorIDs, newOperatorIDs, signedProofs[0], sk.PrivateKey, ethNetwork, cli_utils.WithdrawAddress[:], cli_utils.OwnerAddress, cli_utils.Nonce)
+		depositData, keyShares, proof, err := dkgInitiator.StartResharing(id, signedReshare)
 		if err != nil {
 			logger.Fatal("😥 Failed to initiate DKG ceremony: ", zap.Error(err))
 		}

cli/initiator/resigning.go

@@ -5,11 +5,8 @@ import (
 	"encoding/hex"
 	"fmt"
 	"log"
-	"os"
-	"path/filepath"
 
 	e2m_core "github.com/bloxapp/eth2-key-manager/core"
-	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/sourcegraph/conc/pool"
 	"github.com/spf13/cobra"
 	cli_utils "github.com/ssvlabs/ssv-dkg/cli/utils"
@@ -58,7 +55,7 @@ var StartResigning = &cobra.Command{
 		if err != nil {
 			logger.Fatal("😥 Failed to load operators: ", zap.Error(err))
 		}
-		operatorIDs, err := cli_utils.StingSliceToUintArray(cli_utils.OperatorIDs)
+		operatorIDs, err := cli_utils.StringSliceToUintArray(cli_utils.OperatorIDs)
 		if err != nil {
 			logger.Fatal("😥 Failed to load participants: ", zap.Error(err))
 		}
@@ -70,18 +67,9 @@ var StartResigning = &cobra.Command{
 		if err != nil {
 			logger.Fatal("😥 Failed to read proofs json file:", zap.Error(err))
 		}
-		// Open ethereum keystore
-		jsonBytes, err := os.ReadFile(cli_utils.KeystorePath)
+		signatures, err := cli_utils.SignaturesStringToBytes(cli_utils.Signatures)
 		if err != nil {
-			return err
-		}
-		keyStorePassword, err := os.ReadFile(filepath.Clean(cli_utils.KeystorePass))
-		if err != nil {
-			return fmt.Errorf("😥 Error reading password file: %s", err)
-		}
-		sk, err := keystore.DecryptKey(jsonBytes, string(keyStorePassword))
-		if err != nil {
-			return err
+			logger.Fatal("😥 Failed to load signatures: ", zap.Error(err))
 		}
 		// start the ceremony
 		ctx := context.Background()
@@ -97,8 +85,26 @@ var StartResigning = &cobra.Command{
 				// Create a new ID.
 				id := spec.NewID()
 				nonce := cli_utils.Nonce + uint64(i)
+				// Reconstruct the resign message
+				rMsg, err := dkgInitiator.ConstructResignMessage(
+					operatorIDs,
+					arrayOfSignedProofs[i][0].Proof.ValidatorPubKey,
+					ethNetwork,
+					cli_utils.WithdrawAddress[:],
+					cli_utils.OwnerAddress,
+					nonce,
+					arrayOfSignedProofs[i],
+				)
+				if err != nil {
+					return nil, err
+				}
+				// Append the signatures
+				signedResign := &wire.SignedResign{
+					Message:   rMsg,
+					Signature: signatures,
+				}
 				// Perform the resigning ceremony
-				depositData, keyShares, proofs, err := dkgInitiator.StartResigning(id, operatorIDs, arrayOfSignedProofs[i], sk.PrivateKey, ethNetwork, cli_utils.WithdrawAddress.Bytes(), cli_utils.OwnerAddress, nonce)
+				depositData, keyShares, proofs, err := dkgInitiator.StartResigning(id, signedResign)
 				if err != nil {
 					return nil, err
 				}

cli/utils/utils.go

@@ -72,8 +72,7 @@ var (
 var (
 	ProofsFilePath string
 	NewOperatorIDs []string
-	KeystorePath   string
-	KeystorePass   string
+	Signatures     string
 )
 
 // SetViperConfig reads a yaml config file if provided
@@ -200,6 +199,35 @@ func SetVerifyFlags(cmd *cobra.Command) {
 	flags.AddPersistentStringFlag(cmd, "owner", "", "Owner address", true)
 }
 
+func SetGenerateResignMsgFlags(cmd *cobra.Command) {
+	SetBaseFlags(cmd)
+	flags.OperatorsInfoFlag(cmd)
+	flags.OperatorsInfoPathFlag(cmd)
+	flags.OperatorIDsFlag(cmd)
+	flags.OwnerAddressFlag(cmd)
+	flags.NonceFlag(cmd)
+	flags.NetworkFlag(cmd)
+	flags.WithdrawAddressFlag(cmd)
+	flags.ProofsFilePath(cmd)
+	flags.ClientCACertPathFlag(cmd)
+	flags.EthEndpointURL(cmd)
+}
+
+func SetGenerateReshareMsgFlags(cmd *cobra.Command) {
+	SetBaseFlags(cmd)
+	flags.OperatorsInfoFlag(cmd)
+	flags.OperatorsInfoPathFlag(cmd)
+	flags.OperatorIDsFlag(cmd)
+	flags.NewOperatorIDsFlag(cmd)
+	flags.WithdrawAddressFlag(cmd)
+	flags.OwnerAddressFlag(cmd)
+	flags.NonceFlag(cmd)
+	flags.NetworkFlag(cmd)
+	flags.ProofsFilePath(cmd)
+	flags.ClientCACertPathFlag(cmd)
+	flags.EthEndpointURL(cmd)
+}
+
 func SetResigningFlags(cmd *cobra.Command) {
 	SetBaseFlags(cmd)
 	flags.OperatorsInfoFlag(cmd)
@@ -211,8 +239,7 @@ func SetResigningFlags(cmd *cobra.Command) {
 	flags.WithdrawAddressFlag(cmd)
 	flags.ProofsFilePath(cmd)
 	flags.ClientCACertPathFlag(cmd)
-	flags.KeystoreFilePath(cmd)
-	flags.KeystoreFilePass(cmd)
+	flags.SignaturesFlag(cmd)
 	flags.EthEndpointURL(cmd)
 }
 
@@ -228,8 +255,7 @@ func SetReshareFlags(cmd *cobra.Command) {
 	flags.NetworkFlag(cmd)
 	flags.ProofsFilePath(cmd)
 	flags.ClientCACertPathFlag(cmd)
-	flags.KeystoreFilePath(cmd)
-	flags.KeystoreFilePass(cmd)
+	flags.SignaturesFlag(cmd)
 	flags.EthEndpointURL(cmd)
 }
 
@@ -397,10 +423,7 @@ func BindResigningFlags(cmd *cobra.Command) error {
 	if err := viper.BindPFlag("network", cmd.Flags().Lookup("network")); err != nil {
 		return err
 	}
-	if err := viper.BindPFlag("ethKeystorePath", cmd.PersistentFlags().Lookup("ethKeystorePath")); err != nil {
-		return err
-	}
-	if err := viper.BindPFlag("ethKeystorePass", cmd.PersistentFlags().Lookup("ethKeystorePass")); err != nil {
+	if err := viper.BindPFlag("signatures", cmd.PersistentFlags().Lookup("signatures")); err != nil {
 		return err
 	}
 	OperatorIDs = viper.GetStringSlice("operatorIDs")
@@ -453,13 +476,9 @@ func BindResigningFlags(cmd *cobra.Command) error {
 	if err != nil {
 		return fmt.Errorf("😥 Failed to parse owner address: %s", err)
 	}
-	KeystorePath = viper.GetString("ethKeystorePath")
-	if strings.Contains(KeystorePath, "../") {
-		return fmt.Errorf("😥 ethKeystorePath should not contain traversal")
-	}
-	KeystorePass = viper.GetString("ethKeystorePass")
-	if strings.Contains(KeystorePath, "../") {
-		return fmt.Errorf("😥 ethKeystorePass should not contain traversal")
+	Signatures = viper.GetString("signatures")
+	if Signatures == "" {
+		return fmt.Errorf("😥 Failed to get signature flag value")
 	}
 	return nil
 }
@@ -499,10 +518,7 @@ func BindReshareFlags(cmd *cobra.Command) error {
 	if err := viper.BindPFlag("proofsFilePath", cmd.PersistentFlags().Lookup("proofsFilePath")); err != nil {
 		return err
 	}
-	if err := viper.BindPFlag("ethKeystorePath", cmd.PersistentFlags().Lookup("ethKeystorePath")); err != nil {
-		return err
-	}
-	if err := viper.BindPFlag("ethKeystorePass", cmd.PersistentFlags().Lookup("ethKeystorePass")); err != nil {
+	if err := viper.BindPFlag("signatures", cmd.PersistentFlags().Lookup("signatures")); err != nil {
 		return err
 	}
 	OperatorsInfoPath = viper.GetString("operatorsInfoPath")
@@ -559,13 +575,9 @@ func BindReshareFlags(cmd *cobra.Command) error {
 			return fmt.Errorf("😥 clientCACertPath flag should not contain traversal")
 		}
 	}
-	KeystorePath = viper.GetString("ethKeystorePath")
-	if strings.Contains(KeystorePath, "../") {
-		return fmt.Errorf("😥 ethKeystorePath should not contain traversal")
-	}
-	KeystorePass = viper.GetString("ethKeystorePass")
-	if strings.Contains(KeystorePath, "../") {
-		return fmt.Errorf("😥 ethKeystorePass should not contain traversal")
+	Signatures = viper.GetString("signature")
+	if Signatures == "" {
+		return fmt.Errorf("😥 Failed to get signature flag value")
 	}
 	return nil
 }
@@ -678,8 +690,8 @@ func BindVerifyFlags(cmd *cobra.Command) error {
 	return nil
 }
 
-// StingSliceToUintArray converts the string slice to uint64 slice
-func StingSliceToUintArray(flagdata []string) ([]uint64, error) {
+// StringSliceToUintArray converts the string slice to uint64 slice
+func StringSliceToUintArray(flagdata []string) ([]uint64, error) {
 	partsarr := make([]uint64, 0, len(flagdata))
 	for i := 0; i < len(flagdata); i++ {
 		opid, err := strconv.ParseUint(flagdata[i], 10, strconv.IntSize)
@@ -726,6 +738,14 @@ func LoadOperators(logger *zap.Logger) (wire.OperatorsCLI, error) {
 	return operators, nil
 }
 
+func SignaturesStringToBytes(signatures string) ([]byte, error) {
+	sig, err := hex.DecodeString(signatures)
+	if err != nil {
+		return nil, fmt.Errorf("😥 Failed to parse signatures: %s", err)
+	}
+	return sig, nil
+}
+
 func WriteResults(
 	logger *zap.Logger,
 	depositDataArr []*wire.DepositDataCLI,
@@ -937,6 +957,23 @@ func WriteProofs(proofs []*wire.SignedProof, dir string) error {
 	return nil
 }
 
+func WriteMessage(msg interface{}, outputPath string, msgType string) (err error) {
+	switch msgType {
+	case "resign":
+		finalPath := fmt.Sprintf("%s/resign.json", outputPath)
+		err = utils.WriteJSON(finalPath, msg)
+	case "reshare":
+		finalPath := fmt.Sprintf("%s/reshare.json", outputPath)
+		err = utils.WriteJSON(finalPath, msg)
+	default:
+		return fmt.Errorf("unknown message type: %s", msgType)
+	}
+	if err != nil {
+		return fmt.Errorf("failed writing data file: %w, %v", err, msg)
+	}
+	return nil
+}
+
 func createDirIfNotExist(path string) error {
 	if _, err := os.Stat(path); err != nil {
 		if os.IsNotExist(err) {