DKG saga, part 4: On-chain integration for TBTC DKG

pkg/tbtc/deduplicator.go

@@ -2,9 +2,11 @@ package tbtc
 
 import (
 	"encoding/hex"
-	"github.com/keep-network/keep-common/pkg/cache"
 	"math/big"
+	"strconv"
 	"time"
+
+	"github.com/keep-network/keep-common/pkg/cache"
 )
 
 const (
@@ -67,12 +69,16 @@ func (d *deduplicator) notifyDKGStarted(
 // upon the DKG result submission. It returns boolean indicating whether the
 // client should proceed with the actions or ignore the event as a duplicate.
 func (d *deduplicator) notifyDKGResultSubmitted(
-	newDKGResultHash [32]byte,
+	newDKGResultSeed *big.Int,
+	newDKGResultHash DKGChainResultHash,
+	newDKGResultBlock uint64,
 ) bool {
 	d.dkgResultHashCache.Sweep()
 
-	// The cache key is the hexadecimal representation of the hash.
-	cacheKey := hex.EncodeToString(newDKGResultHash[:])
+	cacheKey := newDKGResultSeed.Text(16) +
+		hex.EncodeToString(newDKGResultHash[:]) +
+		strconv.Itoa(int(newDKGResultBlock))
+
 	// If the key is not in the cache, that means the result was not handled
 	// yet and the client should proceed with the execution.
 	if !d.dkgResultHashCache.Has(cacheKey) {

pkg/tbtc/deduplicator_test.go

@@ -2,10 +2,11 @@ package tbtc
 
 import (
 	"encoding/hex"
-	"github.com/keep-network/keep-common/pkg/cache"
 	"math/big"
 	"testing"
 	"time"
+
+	"github.com/keep-network/keep-common/pkg/cache"
 )
 
 const testDKGSeedCachePeriod = 1 * time.Second
@@ -66,29 +67,47 @@ func TestNotifyDKGResultSubmitted(t *testing.T) {
 	var hash2 [32]byte
 	copy(hash2[:], hash2Bytes)
 
-	// Add the first hash.
-	canProcess := deduplicator.notifyDKGResultSubmitted(hash1)
+	// Add the original parameters.
+	canProcess := deduplicator.notifyDKGResultSubmitted(big.NewInt(100), hash1, 500)
+	if !canProcess {
+		t.Fatal("should be allowed to process")
+	}
+
+	// Add with different seed.
+	canProcess = deduplicator.notifyDKGResultSubmitted(big.NewInt(101), hash1, 500)
+	if !canProcess {
+		t.Fatal("should be allowed to process")
+	}
+
+	// Add with different result hash.
+	canProcess = deduplicator.notifyDKGResultSubmitted(big.NewInt(100), hash2, 500)
+	if !canProcess {
+		t.Fatal("should be allowed to process")
+	}
+
+	// Add with different result block.
+	canProcess = deduplicator.notifyDKGResultSubmitted(big.NewInt(100), hash1, 501)
 	if !canProcess {
 		t.Fatal("should be allowed to process")
 	}
 
-	// Add the second hash.
-	canProcess = deduplicator.notifyDKGResultSubmitted(hash2)
+	// Add with all different parameters.
+	canProcess = deduplicator.notifyDKGResultSubmitted(big.NewInt(101), hash2, 501)
 	if !canProcess {
 		t.Fatal("should be allowed to process")
 	}
 
-	// Add the first hash before caching period elapses.
-	canProcess = deduplicator.notifyDKGResultSubmitted(hash1)
+	// Add the original parameters before caching period elapses.
+	canProcess = deduplicator.notifyDKGResultSubmitted(big.NewInt(100), hash1, 500)
 	if canProcess {
 		t.Fatal("should not be allowed to process")
 	}
 
 	// Wait until caching period elapses.
 	time.Sleep(testDKGResultHashCachePeriod)
 
-	// Add the first hash again.
-	canProcess = deduplicator.notifyDKGResultSubmitted(hash1)
+	// Add the original parameters again.
+	canProcess = deduplicator.notifyDKGResultSubmitted(big.NewInt(100), hash1, 500)
 	if !canProcess {
 		t.Fatal("should be allowed to process")
 	}

pkg/tbtc/dkg.go

@@ -30,6 +30,11 @@ const (
 	// respected by the given member to avoid all members approving the same
 	// DKG result at the same time.
 	dkgResultApprovalDelayStepBlocks = 5
+	// dkgResultChallengeConfirmationBlocks determines the block length of
+	// the confirmation period that is preserved after a DKG result challenge
+	// submission. Once the period elapses, the DKG state is checked to confirm
+	// the challenge was accepted successfully.
+	dkgResultChallengeConfirmationBlocks = 20
 )
 
 // dkgExecutor is a component responsible for the full execution of ECDSA
@@ -513,6 +518,8 @@ func (de *dkgExecutor) executeDkgValidation(
 		zap.String("resultHash", fmt.Sprintf("0x%x", resultHash)),
 	)
 
+	dkgLogger.Infof("starting DKG result validation")
+
 	isValid, err := de.chain.IsDKGResultValid(result)
 	if err != nil {
 		dkgLogger.Errorf("cannot validate DKG result: [%v]", err)
@@ -522,15 +529,61 @@ func (de *dkgExecutor) executeDkgValidation(
 	if !isValid {
 		dkgLogger.Infof("DKG result is invalid")
 
-		err = de.chain.ChallengeDKGResult(result)
-		if err != nil {
-			dkgLogger.Errorf("cannot challenge invalid DKG result: [%v]", err)
-			return
-		}
+		i := uint64(0)
 
-		dkgLogger.Infof("challenging invalid DKG result")
+		// Challenges are done along with DKG state confirmations. This is
+		// needed to handle chain reorgs that may wipe out the block holding
+		// the challenge transaction. The state check done upon the confirmation
+		// block makes sure the submitted challenge changed the DKG state
+		// as expected. If the DKG state was not changed, the challenge is
+		// re-submitted.
+		for {
+			i++
 
-		return
+			err = de.chain.ChallengeDKGResult(result)
+			if err != nil {
+				dkgLogger.Errorf(
+					"cannot challenge invalid DKG result: [%v]",
+					err,
+				)
+				return
+			}
+
+			confirmationBlock := submissionBlock +
+				(i * dkgResultChallengeConfirmationBlocks)
+
+			dkgLogger.Infof(
+				"challenging invalid DKG result; waiting for "+
+					"block [%v] to confirm DKG state",
+				confirmationBlock,
+			)
+
+			err := de.waitForBlockFn(context.Background(), confirmationBlock)
+			if err != nil {
+				dkgLogger.Errorf(
+					"error while waiting for challenge confirmation: [%v]",
+					err,
+				)
+				return
+			}
+
+			state, err := de.chain.GetDKGState()
+			if err != nil {
+				dkgLogger.Errorf("cannot check DKG state: [%v]", err)
+				return
+			}
+
+			if state != Challenge {
+				dkgLogger.Infof(
+					"invalid DKG result challenged successfully",
+				)
+				return
+			}
+
+			dkgLogger.Infof(
+				"invalid DKG result still not challenged; retrying",
+			)
+		}
 	}
 
 	dkgLogger.Infof("DKG result is valid")

pkg/tbtc/tbtc.go

@@ -139,20 +139,25 @@ func Initialize(
 	_ = chain.OnDKGResultSubmitted(func(event *DKGResultSubmittedEvent) {
 		go func() {
 			if ok := deduplicator.notifyDKGResultSubmitted(
+				event.Seed,
 				event.ResultHash,
+				event.BlockNumber,
 			); !ok {
 				logger.Warnf(
-					"DKG result with hash [0x%x] and starting "+
-						"block [%v] has been already processed",
+					"Result with hash [0x%x] for DKG with seed [0x%x] "+
+						"and starting block [%v] has been already processed",
 					event.ResultHash,
+					event.Seed,
 					event.BlockNumber,
 				)
 				return
 			}
 
 			logger.Infof(
-				"DKG result with hash [0x%x] submitted at block [%v]",
+				"Result with hash [0x%x] for DKG with seed [0x%x] "+
+					"submitted at block [%v]",
 				event.ResultHash,
+				event.Seed,
 				event.BlockNumber,
 			)