fix: expose key share in frost

internal/app/broker.go

@@ -26,7 +26,15 @@ func Broker() {
 	ethRPC := ethereum.New()
 	pos.New(ethRPC)
 
+	//frostService := frost.New()
+
+	//scheduler := scheduler.New(
+	//	scheduler.WithFrostEvents(frostService),
+	//)
+
 	server.New(
 		websocket.WithWebsocket(),
 	)
+
+	//scheduler.Start()
 }

internal/config/model.go

@@ -34,10 +34,16 @@ type EthLog struct {
 	Events   []Event                  `yaml:"events"`
 }
 
+// Frost struct represent all task detail of its plugin.
+type Frost struct {
+	Schedule time.Duration `yaml:"schedule"`
+}
+
 // Plugins struct holds all applications plugin configs.
 type Plugins struct {
 	EthLog      *EthLog  `yaml:"logs"`
 	Uniswap     *Uniswap `yaml:"uniswap"`
+	Frost       *Frost   `yaml:"frost"`
 	Correctness []string `yaml:"correctness"`
 }
 

internal/consts/channels.go

@@ -7,4 +7,5 @@ const (
 	ChannelPriceReport       Channels = "unchained:price_report"
 	ChannelEventLog          Channels = "unchained:event_log"
 	ChannelCorrectnessReport Channels = "unchained:correctness_report"
+	ChannelFrostSignerList   Channels = "unchained:frost_signer_list"
 )

internal/consts/opcodes.go

@@ -23,4 +23,6 @@ const (
 
 	OpCodeCorrectnessReport          OpCode = 10
 	OpCodeCorrectnessReportBroadcast OpCode = 11
+
+	OpCodeSendSignerList OpCode = 12
 )

internal/crypto/frost/identity.go

@@ -40,6 +40,7 @@ func (s *DistributedSigner) Update(msg *dkg.Round1Data) ([]*dkg.Round2Data, erro
 	return round2Data, nil
 }
 
+// Finalize function will confirm the identity key about other parties updates.
 func (s *DistributedSigner) Finalize(msg *dkg.Round2Data) error {
 	if msg.ReceiverIdentifier.Equal(s.currentParticipant.Identifier) == 0 {
 		return nil
@@ -51,8 +52,6 @@ func (s *DistributedSigner) Finalize(msg *dkg.Round2Data) error {
 		return nil
 	}
 
-	// This will, for each participant, return their secret key (which is a share of the global secret signing key),
-	// the corresponding verification key, and the global public key.
 	participantsSecretKey, _, groupPublicKeyGeneratedInDKG, err := s.currentParticipant.Finalize(
 		s.accumulatedMessages,
 		s.ackMessages,
@@ -90,7 +89,5 @@ func NewIdentity(id int, signerCount int, minSigningCount int) (*dkg.Round1Data,
 		panic("this is just a test, and it failed")
 	}
 
-	// signer.accumulatedMessages = append(signer.accumulatedMessages, round1Data)
-
 	return round1Data, &signer
 }

internal/crypto/frost/signer.go

@@ -2,7 +2,6 @@ package frost
 
 import (
 	"errors"
-
 	"github.com/TimeleapLabs/unchained/internal/consts"
 	"github.com/TimeleapLabs/unchained/internal/utils"
 	"github.com/bytemare/frost"
@@ -16,17 +15,18 @@ type MessageSigner struct {
 	participant *frost.Participant
 }
 
-func (s *MessageSigner) Confirm(commitment *frost.Commitment) error {
+// Confirm function will set other parties confirms.
+func (s *MessageSigner) Confirm(commitment *frost.Commitment) (*frost.SignatureShare, error) {
 	s.commitments = append(s.commitments, commitment)
 
 	if len(s.commitments.Participants()) < s.partySize {
-		return nil
+		return nil, nil
 	}
 
 	signatureShare, err := s.participant.Sign(s.data, s.commitments)
 	if err != nil {
 		utils.Logger.With("err", err).Error("cant sign message")
-		return consts.ErrCantSign
+		return nil, consts.ErrCantSign
 	}
 
 	if !s.participant.VerifySignatureShare(
@@ -36,12 +36,19 @@ func (s *MessageSigner) Confirm(commitment *frost.Commitment) error {
 		s.commitments,
 		s.data,
 	) {
-		return consts.ErrCantVerify
+		return nil, consts.ErrCantVerify
 	}
 
-	return nil
+	return signatureShare, nil
+}
+
+func (s *MessageSigner) AggregateSignatures(signatureShares []*frost.SignatureShare) ([]byte, error) {
+	signature := s.participant.Aggregate(s.commitments, s.data, signatureShares)
+
+	return signature.Encode(), nil
 }
 
+// NewSigner create a new signing state for a message.
 func (s *DistributedSigner) NewSigner(data []byte) (*MessageSigner, *frost.Commitment, error) {
 	if s.finalParticipant == nil {
 		return nil, nil, consts.ErrSignerIsNotReady

internal/model/bls.go

@@ -4,6 +4,8 @@ import (
 	sia "github.com/pouya-eghbali/go-sia/v2/pkg"
 )
 
+type Signers []Signer
+
 type Signer struct {
 	Name           string
 	EvmAddress     string
@@ -34,6 +36,25 @@ func (s *Signature) FromSia(sia sia.Sia) *Signature {
 	return s
 }
 
+func (s Signers) Sia() sia.Sia {
+	return new(sia.ArraySia[Signer]).
+		AddArray8(s, func(s *sia.ArraySia[Signer], item Signer) {
+			s.EmbedBytes(item.Sia().Bytes())
+		})
+}
+
+//func (s Signers) FromBytes(payload []byte) Signers {
+//	signers := Signers{}
+//
+//	siaArray := sia.ArraySia[Signer]{
+//		sia.NewFromBytes(payload),
+//	}
+//
+//	ReadArray8(func(s *sia.ArraySia[Signer]) Signer {
+//		signers = append(signers, Signer)
+//	})
+//}
+
 func (s *Signer) Sia() sia.Sia {
 	return sia.New().
 		AddString8(s.Name).

internal/scheduler/frost.go

@@ -0,0 +1,27 @@
+package scheduler
+
+import (
+	"github.com/TimeleapLabs/unchained/internal/service/frost"
+)
+
+// FrostSync is a scheduler for syncing signer of Frost and keep task's dependencies.
+type FrostSync struct {
+	frostService frost.Service
+}
+
+// Run will trigger by the scheduler and process the Frost sync.
+func (e *FrostSync) Run() {
+	err := e.frostService.PushSigners()
+	if err != nil {
+		panic(err)
+	}
+}
+
+// NewFrostSync will create a new FrostSync task.
+func NewFrostSync(frostService frost.Service) *FrostSync {
+	e := FrostSync{
+		frostService: frostService,
+	}
+
+	return &e
+}

internal/scheduler/scheduler.go

@@ -4,6 +4,8 @@ import (
 	"os"
 	"time"
 
+	"github.com/TimeleapLabs/unchained/internal/service/frost"
+
 	"github.com/TimeleapLabs/unchained/internal/utils"
 
 	"github.com/TimeleapLabs/unchained/internal/config"
@@ -66,6 +68,16 @@ func WithUniswapEvents(uniswapService uniswapService.Service) func(s *Scheduler)
 	}
 }
 
+// WithFrostEvents adds frost sync event task to the scheduler.
+func WithFrostEvents(frostService frost.Service) func(s *Scheduler) {
+	return func(s *Scheduler) {
+		if config.App.Plugins.Frost == nil {
+			return
+		}
+		s.AddTask(config.App.Plugins.Frost.Schedule, NewFrostSync(frostService))
+	}
+}
+
 // AddTask adds a new task to the scheduler.
 func (s *Scheduler) AddTask(duration time.Duration, task Task) {
 	utils.Logger.

internal/service/frost/frost.go

@@ -0,0 +1,14 @@
+package frost
+
+type Service interface {
+	PushSigners() error
+}
+
+type service struct {
+	reserveSigners []bool
+	currentSigners []bool
+}
+
+func New() Service {
+	return &service{}
+}

internal/service/frost/sync.go

@@ -0,0 +1,40 @@
+package frost
+
+import (
+	"encoding/json"
+	"github.com/TimeleapLabs/unchained/internal/transport/server/pubsub"
+
+	"github.com/TimeleapLabs/unchained/internal/consts"
+	"github.com/TimeleapLabs/unchained/internal/model"
+	"github.com/TimeleapLabs/unchained/internal/transport/server/websocket/store"
+	"github.com/TimeleapLabs/unchained/internal/utils"
+	"github.com/gorilla/websocket"
+)
+
+// PushSigners starts calculating of Frost signers by sending signers list to the Broker.
+func (s *service) PushSigners() error {
+	signers := []model.Signer{}
+	store.Signers.Range(func(_ *websocket.Conn, value model.Signer) bool {
+		signers = append(signers, value)
+		return true
+	})
+
+	signersBytes, err := json.Marshal(signers)
+	if err != nil {
+		utils.Logger.With("Error", err).Error("Cant marshal signers list")
+		return consts.ErrInternalError
+	}
+
+	pubsub.Publish(consts.ChannelFrostSignerList, consts.OpCodeSendSignerList, signersBytes)
+
+	return nil
+}
+
+// SyncSigners Get list of signers and check power of voting them and generate a new list (if there is difference) of signers which have power.
+func (s *service) SyncSigners(signers []model.Signer) error {
+	// TODO: get power of list items and delete no power ones.
+
+	// TODO: check the final list with previous one, and replace it if it have difference
+
+	return nil
+}

internal/transport/client/client.go

@@ -44,6 +44,8 @@ func NewRPC(handler handler.Handler) {
 				case consts.OpCodeCorrectnessReportBroadcast:
 					handler.CorrectnessReport(ctx, payload[1:])
 
+				case consts.OpCodeSendSignerList:
+					handler.InitFrostSigner(ctx, payload[1:])
 				default:
 					utils.Logger.
 						With("Code", payload[0]).

internal/transport/client/handler/frost.go

@@ -0,0 +1,16 @@
+package handler
+
+import (
+	"context"
+)
+
+func (h *consumer) InitFrostSigner(ctx context.Context, message []byte) {
+	// packet := new([]model.Signer).FromBytes(message)
+
+}
+
+func (w worker) InitFrostSigner(ctx context.Context, message []byte) {
+	//packet := new(model.Signers).FromBytes(message)
+	//TODO implement me
+	panic("implement me")
+}

internal/transport/client/handler/handler.go

@@ -9,4 +9,6 @@ type Handler interface {
 	CorrectnessReport(ctx context.Context, message []byte)
 	EventLog(ctx context.Context, message []byte)
 	PriceReport(ctx context.Context, message []byte)
+
+	InitFrostSigner(ctx context.Context, message []byte)
 }