(no commit message provided)

crypto/mpc/mpc.go

@@ -0,0 +1,97 @@
+package mpc
+
+import (
+	"errors"
+	"fmt"
+	"github.com/onsonr/hway/crypto/core/curves"
+	"github.com/onsonr/hway/crypto/core/protocol"
+	"github.com/onsonr/hway/crypto/kss"
+	"github.com/onsonr/hway/crypto/signatures/ecdsa"
+	"github.com/onsonr/hway/crypto/tecdsa/dklsv1"
+)
+
+// GenerateKss generates both keyshares
+func GenerateKss() (kss.Set, error) {
+	defaultCurve := curves.K256()
+	bob := dklsv1.NewBobDkg(defaultCurve, protocol.Version1)
+	alice := dklsv1.NewAliceDkg(defaultCurve, protocol.Version1)
+	err := RunProtocol(bob, alice)
+	if err != nil {
+		return nil, err
+	}
+	aliceRes, err := alice.Result(protocol.Version1)
+	if err != nil {
+		return nil, err
+	}
+	bobRes, err := bob.Result(protocol.Version1)
+	if err != nil {
+		return nil, err
+	}
+	return kss.NewKeyshareSet(aliceRes, bobRes)
+}
+
+// RunProtocol runs the keyshare protocol between two parties
+func RunProtocol(firstParty protocol.Iterator, secondParty protocol.Iterator) error {
+	var (
+		message *protocol.Message
+		aErr    error
+		bErr    error
+	)
+
+	for aErr != protocol.ErrProtocolFinished || bErr != protocol.ErrProtocolFinished {
+		// Crank each protocol forward one iteration
+		message, bErr = firstParty.Next(message)
+		if bErr != nil && bErr != protocol.ErrProtocolFinished {
+			return errors.Join(fmt.Errorf("validator failed to process mpc message"), bErr)
+		}
+
+		message, aErr = secondParty.Next(message)
+		if aErr != nil && aErr != protocol.ErrProtocolFinished {
+			return errors.Join(fmt.Errorf("user failed to process mpc message"), aErr)
+		}
+	}
+	if aErr == protocol.ErrProtocolFinished && bErr == protocol.ErrProtocolFinished {
+		return nil
+	}
+	if aErr != nil {
+		return fmt.Errorf("validator keyshare failed: %v", aErr)
+	}
+	if bErr != nil {
+		return fmt.Errorf("user keyshare failed: %v", bErr)
+	}
+	return nil
+}
+
+// RunSignProtocol runs the generic dkls protocol using the kss.SignFuncVal and kss.SignFuncUser
+func RunSignProtocol(valSignFunc kss.SignFuncVal, userSignFunc kss.SignFuncUser) ([]byte, error) {
+	err := RunProtocol(valSignFunc, userSignFunc)
+	if err != nil {
+		return nil, errors.Join(err, fmt.Errorf("failed to get validator sign function"))
+	}
+	resultMessage, err := userSignFunc.Result(protocol.Version1)
+	if err != nil {
+		return nil, errors.Join(fmt.Errorf("error Getting User Sign Result"), err)
+	}
+	sig, err := dklsv1.DecodeSignature(resultMessage)
+	if err != nil {
+		return nil, errors.Join(fmt.Errorf("error Decoding Signature"), err)
+	}
+	return ecdsa.SerializeSecp256k1Signature(sig)
+}
+
+// RunRefreshProtocol runs the generic dkls protocol using the kss.RefreshFuncVal and kss.RefreshFuncUser
+func RunRefreshProtocol(valRefreshFunc kss.RefreshFuncVal, userRefreshFunc kss.RefreshFuncUser) (kss.Set, error) {
+  err := RunProtocol(valRefreshFunc, userRefreshFunc)
+  if err != nil {
+    return nil, err
+  }
+	valRes, err := valRefreshFunc.Result(protocol.Version1)
+	if err != nil {
+		return nil, err
+	}
+	userRes, err := userRefreshFunc.Result(protocol.Version1)
+	if err != nil {
+		return nil, err
+	}
+	return kss.NewKeyshareSet(valRes, userRes)
+}