feat(zetaclient): Revamp TSS package

cmd/zetaclientd/start.go

@@ -2,9 +2,7 @@
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
-	"io"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -13,11 +11,9 @@
 	"syscall"
 	"time"
 
-	ecdsakeygen "github.com/bnb-chain/tss-lib/ecdsa/keygen"
 	"github.com/cometbft/cometbft/crypto/secp256k1"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/p2p/protocol/ping"
-	maddr "github.com/multiformats/go-multiaddr"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
@@ -35,15 +31,13 @@
 	"github.com/zeta-chain/node/zetaclient/maintenance"
 	"github.com/zeta-chain/node/zetaclient/metrics"
 	"github.com/zeta-chain/node/zetaclient/orchestrator"
 	mc "github.com/zeta-chain/node/zetaclient/tss"
 	"github.com/zeta-chain/node/zetaclient/zetacore"
 )
 
-// todo revamp
+// Start starts zetaclientd process todo revamp
 // https://github.com/zeta-chain/node/issues/3119
 // https://github.com/zeta-chain/node/issues/3112
-var preParams *ecdsakeygen.LocalPreParams
-
 func Start(_ *cobra.Command, _ []string) error {
 	// Prompt for Hotkey, TSS key-share and relayer key passwords
 	titles := []string{"HotKey", "TSS", "Solana Relayer Key"}
@@ -164,12 +158,16 @@
 	}
 	priKey := secp256k1.PrivKey(hotkeyPk.Bytes()[:32])
 
-	// Generate pre Params if not present already
-	peers, err := initPeers(cfg.Peer)
+	tssBootstrapPeers, err := mc.MultiAddressFromString(cfg.Peer)
 	if err != nil {
-		log.Error().Err(err).Msg("peer address error")
+		// this is okay, we still have whitelisted peers to connect to
+		startLogger.Warn().Err(err).Msg("TSS bootstrap peers error")
+	}
+
+	tssPreParams, err := mc.ResolvePreParamsFromPath(cfg.PreParamsPath)
+	if err != nil {
+		return errors.Wrap(err, "unable to resolve TSS pre params. Use `zetaclient tss gen-pre-params`")
 	}
-	initPreParams(cfg.PreParamsPath)
 
 	m, err := metrics.NewMetrics()
 	if err != nil {
@@ -201,9 +199,9 @@
 
 	// Create TSS server
 	tssServer, err := mc.SetupTSSServer(
-		peers,
+		tssBootstrapPeers,
 		priKey,
-		preParams,
+		tssPreParams,
 		appContext.Config(),
 		tssKeyPass,
 		true,
@@ -256,9 +254,9 @@
 
 	// Generate a new TSS if keygen is set and add it into the tss server
 	// If TSS has already been generated, and keygen was successful ; we use the existing TSS
-	err = mc.Generate(ctx, zetacoreClient, tssServer, masterLogger)
+	err = mc.KeygenCeremony(ctx, tssServer, zetacoreClient, masterLogger)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "unable to run tss keygen ceremony")
 	}
 
 	tss, err := mc.New(
@@ -273,9 +271,10 @@
 		return err
 	}
 	if cfg.TestTssKeysign {
-		err = mc.TestTSS(tss.CurrentPubkey, *tss.Server, masterLogger)
-		if err != nil {
-			startLogger.Error().Err(err).Msgf("TestTSS error : %s", tss.CurrentPubkey)
+		if err = mc.TestKeySign(tss.Server, tss.CurrentPubkey, startLogger); err != nil {
+			startLogger.Error().Err(err).
+				Str("tss.public_key", tss.CurrentPubkey).
+				Msg("TSS key-sign failed")
 		}
 	}
 
@@ -409,42 +408,6 @@
 	return nil
 }
 
-func initPeers(peer string) ([]maddr.Multiaddr, error) {
-	var peers []maddr.Multiaddr
-
-	if peer != "" {
-		address, err := maddr.NewMultiaddr(peer)
-		if err != nil {
-			log.Error().Err(err).Msg("NewMultiaddr error")
-			return []maddr.Multiaddr{}, err
-		}
-		peers = append(peers, address)
-	}
-	return peers, nil
-}
-
-func initPreParams(path string) {
-	if path != "" {
-		path = filepath.Clean(path)
-		log.Info().Msgf("pre-params file path %s", path)
-		preParamsFile, err := os.Open(path)
-		if err != nil {
-			log.Error().Err(err).Msg("open pre-params file failed; skip")
-		} else {
-			bz, err := io.ReadAll(preParamsFile)
-			if err != nil {
-				log.Error().Err(err).Msg("read pre-params file failed; skip")
-			} else {
-				err = json.Unmarshal(bz, &preParams)
-				if err != nil {
-					log.Error().Err(err).Msg("unmarshal pre-params file failed; skip and generate new one")
-					preParams = nil // skip reading pre-params; generate new one instead
-				}
-			}
-		}
-	}
-}
-
 // isObserverNode checks whether THIS node is an observer node.
 func isObserverNode(ctx context.Context, client *zetacore.Client) (bool, error) {
 	observers, err := client.GetObserverList(ctx)

zetaclient/chains/bitcoin/signer/signer_keysign_test.go

@@ -148,7 +148,7 @@ func getTSSTX(
 		return "", err
 	}
 
-	sig65B, err := tss.Sign(ctx, witnessHash, 10, 10, 0, "")
+	sig65B, err := tss.Sign(ctx, witnessHash, 10, 10, 0)
 	R := &btcec.ModNScalar{}
 	R.SetBytes((*[32]byte)(sig65B[:32]))
 	S := &btcec.ModNScalar{}

zetaclient/chains/evm/signer/signer.go

@@ -197,7 +197,7 @@ func (signer *Signer) Sign(
 
 	hashBytes := signer.ethSigner.Hash(tx).Bytes()
 
-	sig, err := signer.TSS().Sign(ctx, hashBytes, height, nonce, signer.Chain().ChainId, "")
+	sig, err := signer.TSS().Sign(ctx, hashBytes, height, nonce, signer.Chain().ChainId)
 	if err != nil {
 		return nil, nil, nil, err
 	}

zetaclient/chains/interfaces/interfaces.go

@@ -227,25 +227,11 @@ type EVMJSONRPCClient interface {
 // TSSSigner is the interface for TSS signer
 type TSSSigner interface {
 	Pubkey() []byte
-
-	// Sign signs the data
-	// Note: it specifies optionalPubkey to use a different pubkey than the current pubkey set during keygen
-	// TODO: check if optionalPubkey is needed
-	// https://github.com/zeta-chain/node/issues/2085
-	Sign(
-		ctx context.Context,
-		data []byte,
-		height uint64,
-		nonce uint64,
-		chainID int64,
-		optionalPubkey string,
-	) ([65]byte, error)
-
-	// SignBatch signs the data in batch
-	SignBatch(ctx context.Context, digests [][]byte, height uint64, nonce uint64, chainID int64) ([][65]byte, error)
-
 	EVMAddress() ethcommon.Address
 	EVMAddressList() []ethcommon.Address
 	BTCAddress(chainID int64) (*btcutil.AddressWitnessPubKeyHash, error)
 	PubKeyCompressedBytes() []byte
+
+	Sign(ctx context.Context, data []byte, height, nonce uint64, chainID int64) ([65]byte, error)
+	SignBatch(ctx context.Context, digests [][]byte, height, nonce uint64, chainID int64) ([][65]byte, error)
 }

zetaclient/chains/solana/signer/whitelist.go

@@ -31,7 +31,7 @@ func (signer *Signer) createAndSignMsgWhitelist(
 
 	// sign the message with TSS to get an ECDSA signature.
 	// the produced signature is in the [R || S || V] format where V is 0 or 1.
-	signature, err := signer.TSS().Sign(ctx, msgHash[:], height, nonce, chain.ChainId, "")
+	signature, err := signer.TSS().Sign(ctx, msgHash[:], height, nonce, chain.ChainId)
 	if err != nil {
 		return nil, errors.Wrap(err, "Key-sign failed")
 	}

zetaclient/chains/solana/signer/withdraw.go

@@ -43,7 +43,7 @@ func (signer *Signer) createAndSignMsgWithdraw(
 
 	// sign the message with TSS to get an ECDSA signature.
 	// the produced signature is in the [R || S || V] format where V is 0 or 1.
-	signature, err := signer.TSS().Sign(ctx, msgHash[:], height, nonce, chain.ChainId, "")
+	signature, err := signer.TSS().Sign(ctx, msgHash[:], height, nonce, chain.ChainId)
 	if err != nil {
 		return nil, errors.Wrap(err, "Key-sign failed")
 	}

zetaclient/chains/solana/signer/withdraw_spl.go

@@ -57,7 +57,7 @@ func (signer *Signer) createAndSignMsgWithdrawSPL(
 
 	// sign the message with TSS to get an ECDSA signature.
 	// the produced signature is in the [R || S || V] format where V is 0 or 1.
-	signature, err := signer.TSS().Sign(ctx, msgHash[:], height, nonce, chain.ChainId, "")
+	signature, err := signer.TSS().Sign(ctx, msgHash[:], height, nonce, chain.ChainId)
 	if err != nil {
 		return nil, errors.Wrap(err, "Key-sign failed")
 	}

zetaclient/chains/ton/observer/observer_test.go

@@ -199,7 +199,7 @@ func (ts *testSuite) sign(msg signable) {
 	hash, err := msg.Hash()
 	require.NoError(ts.t, err)
 
-	sig, err := ts.tss.Sign(ts.ctx, hash[:], 0, 0, 0, "")
+	sig, err := ts.tss.Sign(ts.ctx, hash[:], 0, 0, 0)
 	require.NoError(ts.t, err)
 
 	msg.SetSignature(sig)

zetaclient/chains/ton/signer/signer.go

@@ -187,7 +187,7 @@ func (s *Signer) SignMessage(ctx context.Context, msg Signable, zetaHeight, nonc
 	chainID := s.Chain().ChainId
 
 	// sig = [65]byte {R, S, V (recovery ID)}
-	sig, err := s.TSS().Sign(ctx, hash[:], zetaHeight, nonce, chainID, "")
+	sig, err := s.TSS().Sign(ctx, hash[:], zetaHeight, nonce, chainID)
 	if err != nil {
 		return errors.Wrap(err, "unable to sign the message")
 	}

zetaclient/chains/ton/signer/signer_test.go

@@ -201,7 +201,7 @@ func (ts *testSuite) Sign(msg Signable) {
 	hash, err := msg.Hash()
 	require.NoError(ts.t, err)
 
-	sig, err := ts.tss.Sign(ts.ctx, hash[:], 0, 0, 0, "")
+	sig, err := ts.tss.Sign(ts.ctx, hash[:], 0, 0, 0)
 	require.NoError(ts.t, err)
 
 	msg.SetSignature(sig)

zetaclient/testutils/mocks/tss_signer.go

@@ -103,7 +103,7 @@ func (s *TSS) WithPrivKey(privKey *ecdsa.PrivateKey) *TSS {
 }
 
 // Sign uses test key unrelated to any tss key in production
-func (s *TSS) Sign(_ context.Context, data []byte, _ uint64, _ uint64, _ int64, _ string) ([65]byte, error) {
+func (s *TSS) Sign(_ context.Context, data []byte, _ uint64, _ uint64, _ int64) ([65]byte, error) {
 	// return error if tss is paused
 	if s.paused {
 		return [65]byte{}, fmt.Errorf("tss is paused")

zetaclient/tss/config.go

@@ -0,0 +1,55 @@
+package tss
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"github.com/bnb-chain/tss-lib/ecdsa/keygen"
+	"github.com/multiformats/go-multiaddr"
+	"github.com/pkg/errors"
+	tsscommon "gitlab.com/thorchain/tss/go-tss/common"
+)
+
+const (
+	Port    = 6668
+	Version = "0.14.0"
+	Algo    = tsscommon.ECDSA
+)
+
+// MultiAddressFromString parses a string into a slice of addresses (for convenience).
+func MultiAddressFromString(peer string) ([]multiaddr.Multiaddr, error) {
+	if peer == "" {
+		return nil, errors.New("peer is empty")
+	}
+
+	ma, err := multiaddr.NewMultiaddr(peer)
+	if err != nil {
+		return nil, err
+	}
+
+	return []multiaddr.Multiaddr{ma}, nil
+}
+
+// ResolvePreParamsFromPath resolves TSS pre-params from json config by path.
+// Error indicates that the pre-params file is not found or invalid.
+// FYI: pre-params are generated by keygen.GeneratePreParams.
+func ResolvePreParamsFromPath(path string) (*keygen.LocalPreParams, error) {
+	if path == "" {
+		return nil, errors.New("pre-params path is empty")
+	}
+
+	path = filepath.Clean(path)
+
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return nil, errors.Wrapf(err, "unable to read pre-params at %q", path)
+	}
+
+	var pp keygen.LocalPreParams
+	if err = json.Unmarshal(raw, &pp); err != nil {
+		return nil, errors.Wrapf(err, "unable to decode pre-params at %q", path)
+	}
+
+	return &pp, nil
+}

zetaclient/tss/crypto.go

@@ -0,0 +1,80 @@
+package tss
+
+import (
+	"bytes"
+	"encoding/base64"
+	"strings"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/pkg/errors"
+	"gitlab.com/thorchain/tss/go-tss/keysign"
+
+	"github.com/zeta-chain/node/pkg/cosmos"
+)
+
+var (
+	base64Decode       = base64.StdEncoding.Decode
+	base64DecodeString = base64.StdEncoding.DecodeString
+	base64EncodeString = base64.StdEncoding.EncodeToString
+)
+
+// VerifySignature checks that keysign.Signature is valid and origins from expected TSS public key.
+// Also returns signature as [65]byte (R, S, V)
+func VerifySignature(sig keysign.Signature, tssPubKey string, expectedMsgHash []byte) ([65]byte, error) {
+	// Check that msg hash equals msg hash in the signature
+	actualMsgHash, err := base64DecodeString(sig.Msg)
+	switch {
+	case err != nil:
+		return [65]byte{}, errors.Wrap(err, "unable to decode message hash")
+	case !bytes.Equal(expectedMsgHash, actualMsgHash):
+		return [65]byte{}, errors.New("message hash mismatch")
+	}
+
+	// Prepare expected public key
+	expectedPubKey, err := cosmos.GetPubKeyFromBech32(cosmos.Bech32PubKeyTypeAccPub, tssPubKey)
+	if err != nil {
+		return [65]byte{}, errors.Wrap(err, "unable to decode tss pub key from bech32")
+	}
+
+	sigBytes, err := SignatureToBytes(sig)
+	if err != nil {
+		return [65]byte{}, errors.Wrap(err, "unable to convert signature to bytes")
+	}
+
+	// Recover public key from signature
+	actualPubKey, err := crypto.SigToPub(expectedMsgHash, sigBytes[:])
+	if err != nil {
+		return [65]byte{}, errors.Wrap(err, "unable to recover public key from signature")
+	}
+
+	if !bytes.Equal(expectedPubKey.Bytes(), crypto.CompressPubkey(actualPubKey)) {
+		return [65]byte{}, errors.New("public key mismatch")
+	}
+
+	return sigBytes, nil
+}
+
+// SignatureToBytes converts keysign.Signature to [65]byte (R, S, V)
+func SignatureToBytes(input keysign.Signature) (sig [65]byte, err error) {
+	if _, err = base64Decode(sig[:32], []byte(input.R)); err != nil {
+		return sig, errors.Wrap(err, "unable to decode R")
+	}
+
+	if _, err = base64Decode(sig[32:64], []byte(input.S)); err != nil {
+		return sig, errors.Wrap(err, "unable to decode S")
+	}
+
+	if _, err = base64Decode(sig[64:65], []byte(input.RecoveryID)); err != nil {
+		return sig, errors.Wrap(err, "unable to decode RecoveryID (V)")
+	}
+
+	return sig, nil
+}
+
+// combineDigests combines the digests
+func combineDigests(digestList []string) []byte {
+	digestConcat := strings.Join(digestList, "")
+	digestBytes := chainhash.DoubleHashH([]byte(digestConcat))
+	return digestBytes.CloneBytes()
+}