tECDSA DKG: Integration with the asynchronous state machine (#3392)

Here we integrate the tECDSA DKG protocol with the async state machine
introduced by #3362. The presented
changes are analogous to the recent changes introduced to the tECDSA signing
protocol by #3379. Long story short, we no longer use a fixed block duration for
protocol's states but move to a global timeout for the entire protocol attempt
and switch states as soon as possible. As result, the time of a single DKG
attempt can be reduced as the protocol is no longer fixed and can adjust to the
slowest participant.

The aforementioned change in the DKG protocol also involves a similar change in
the DKG result publication step. The publication step is now based on the
asynchronous state machine as well. This has two major consequences:
- Firstly, so far, the participants were waiting for at least a group quorum of
DKG result signatures for a fixed block duration and then moved to the result
submission state. Now, all members wait for the actual group size of DKG result
signatures and move to the result submission. This way, we are introducing an
additional health check of group participants at the result publication step
thus we maximize the final number of operating group members. This is based on
the assumption that if DKG went to the publication step, all participants had to
complete the computation step successfully, so they should be still operating
for publication. 
- Secondly, the result submission queue is now time-based. Since the publication
step relies on the async state machine, we can no longer use the block counter
to set the submission eligibility queue. Each member preserves a time delay,
according to its member index, before attempting to submit the DKG result

Last but not least, we were forced to improve the message retransmission
mechanism. As the DKG's TSS round two is computationally expensive, it takes
~100 blocks to complete their computations. The current retransmission strategy
retransmits every message on every new block. On TSS round two, each member
already retransmits messages from the ephemeral key generation state and from
TSS round one. If the TSS round two state takes ~100 blocks, the amount of
messages flying around the network is really huge and often caused network
congestion. Also, the TSS round two state always takes almost all available CPU
so, the situation became even worse. This resulted in a poor DKG success rate.
To improve the situation and lower the number of messages passed through the
network, we introduced a retransmission backoff strategy (#3396). All messages
are now retransmitted at a decreasing rate so older messages are retransmitted
less and less frequently. This allowed us to achieve a good success rate of the
DKG protocol.

Changes presented in this PR were tested on a local environment with three
clients. Performed five DKGs and all were completed with success after
~18 minutes. That means we achieved an improvement as the DKG based on the sync
machine always took ~26 minutes (fixed duration of 125 computation blocks and 5
publication blocks with an average block time of 12 seconds)

Author: pdyraga

pkg/chain/ethereum/tbtc.go

@@ -116,13 +116,11 @@ func (tc *TbtcChain) GetConfig() *tbtc.ChainConfig {
 	groupSize := 100
 	groupQuorum := 90
 	honestThreshold := 51
-	resultPublicationBlockStep := 1
 
 	return &tbtc.ChainConfig{
-		GroupSize:                  groupSize,
-		GroupQuorum:                groupQuorum,
-		HonestThreshold:            honestThreshold,
-		ResultPublicationBlockStep: uint64(resultPublicationBlockStep),
+		GroupSize:       groupSize,
+		GroupQuorum:     groupQuorum,
+		HonestThreshold: honestThreshold,
 	}
 }
 

pkg/internal/interception/interception.go

@@ -59,7 +59,7 @@ func (c *channel) Name() string {
 func (c *channel) Send(
 	ctx context.Context,
 	m net.TaggedMarshaler,
-	strategy ...net.RetransmissionStrategy,
+	retransmissionStrategy ...net.RetransmissionStrategy,
 ) error {
 	altered := c.rules(m)
 	if altered == nil {

pkg/net/libp2p/channel.go

@@ -91,7 +91,7 @@ func (c *channel) Name() string {
 func (c *channel) Send(
 	ctx context.Context,
 	message net.TaggedMarshaler,
-	strategy ...net.RetransmissionStrategy,
+	retransmissionStrategy ...net.RetransmissionStrategy,
 ) error {
 	messageProto, err := c.messageProto(message)
 	if err != nil {
@@ -104,20 +104,20 @@ func (c *channel) Send(
 		return c.publish(messageProto)
 	}
 
-	var selectedStrategy net.RetransmissionStrategy
-	switch len(strategy) {
+	var strategy net.RetransmissionStrategy
+	switch len(retransmissionStrategy) {
 	case 1:
-		selectedStrategy = strategy[0]
+		strategy = retransmissionStrategy[0]
 	default:
-		selectedStrategy = net.StandardRetransmissionStrategy
+		strategy = net.StandardRetransmissionStrategy
 	}
 
 	retransmission.ScheduleRetransmissions(
 		ctx,
 		logger,
 		c.retransmissionTicker,
 		doSend,
-		retransmission.WithStrategy(selectedStrategy),
+		retransmission.WithStrategy(strategy),
 	)
 
 	return doSend()

pkg/net/local/broadcast_channel.go

@@ -43,7 +43,7 @@ func (lc *localChannel) Name() string {
 func (lc *localChannel) Send(
 	ctx context.Context,
 	message net.TaggedMarshaler,
-	strategy ...net.RetransmissionStrategy,
+	retransmissionStrategy ...net.RetransmissionStrategy,
 ) error {
 	bytes, err := message.Marshal()
 	if err != nil {
@@ -71,12 +71,12 @@ func (lc *localChannel) Send(
 		lc.nextSeqno(),
 	)
 
-	var selectedStrategy net.RetransmissionStrategy
-	switch len(strategy) {
+	var strategy net.RetransmissionStrategy
+	switch len(retransmissionStrategy) {
 	case 1:
-		selectedStrategy = strategy[0]
+		strategy = retransmissionStrategy[0]
 	default:
-		selectedStrategy = net.StandardRetransmissionStrategy
+		strategy = net.StandardRetransmissionStrategy
 	}
 
 	retransmission.ScheduleRetransmissions(
@@ -86,7 +86,7 @@ func (lc *localChannel) Send(
 		func() error {
 			return broadcastMessage(lc.name, netMessage)
 		},
-		retransmission.WithStrategy(selectedStrategy),
+		retransmission.WithStrategy(strategy),
 	)
 
 	return broadcastMessage(lc.name, netMessage)

pkg/net/net.go

@@ -2,6 +2,7 @@ package net
 
 import (
 	"context"
+
 	"github.com/keep-network/keep-core/pkg/internal/pb"
 	"github.com/keep-network/keep-core/pkg/operator"
 )
@@ -14,7 +15,7 @@ const (
 	// that retransmit the message with a constant frequency.
 	StandardRetransmissionStrategy RetransmissionStrategy = iota
 	// BackoffRetransmissionStrategy is a retransmission strategy that
-	// retransmit the message with an exponentially increasing delay between
+	// retransmits the message with an exponentially increasing delay between
 	// subsequent retransmissions.
 	BackoffRetransmissionStrategy
 )
@@ -109,13 +110,13 @@ type BroadcastChannel interface {
 	// conform to the marshalling interface. Message will be periodically
 	// retransmitted by the channel for the lifetime of the provided context
 	// according to the default StandardRetransmissionStrategy. Retransmission
-	// strategy can be set through the `strategy` vararg. If the vararg is
-	// given more than one value, the first value is used as the valid
-	// strategy.
+	// strategy can be set through the `retransmissionStrategy` vararg. If the
+	// vararg is given more than one value, the first value is used as the
+	// valid strategy.
 	Send(
 		ctx context.Context,
 		message TaggedMarshaler,
-		strategy ...RetransmissionStrategy,
+		retransmissionStrategy ...RetransmissionStrategy,
 	) error
 	// Recv installs a message handler that will receive messages from the
 	// channel for the entire lifetime of the provided context.

pkg/tbtc/chain.go

@@ -138,9 +138,6 @@ type ChainConfig struct {
 	// HonestThreshold is the minimum number of active participants behaving
 	// according to the protocol needed to generate a signature.
 	HonestThreshold int
-	// ResultPublicationBlockStep is the duration (in blocks) that has to pass
-	// between publication attempts made by individual members.
-	ResultPublicationBlockStep uint64
 }
 
 // DishonestThreshold is the maximum number of misbehaving participants for

pkg/tbtc/chain_test.go

@@ -226,12 +226,10 @@ func ConnectWithKey(
 ) *localChain {
 	blockCounter, _ := local_v1.BlockCounter()
 
-	resultPublicationBlockStep := uint64(3)
 	chainConfig := &ChainConfig{
-		GroupSize:                  groupSize,
-		GroupQuorum:                groupQuorum,
-		HonestThreshold:            honestThreshold,
-		ResultPublicationBlockStep: resultPublicationBlockStep,
+		GroupSize:       groupSize,
+		GroupQuorum:     groupQuorum,
+		HonestThreshold: honestThreshold,
 	}
 
 	return &localChain{