Improved inactivity time synchronization

pkg/tbtc/heartbeat.go

@@ -14,17 +14,23 @@ import (
 )
 
 const (
-	// heartbeatProposalValidityBlocks determines the wallet heartbeat proposal
-	// validity time expressed in blocks. In other words, this is the worst-case
-	// time for a wallet heartbeat during which the wallet is busy and cannot
-	// take another actions. The value of 300 blocks is roughly 1 hour, assuming
-	// 12 seconds per block.
-	heartbeatProposalValidityBlocks = 300
+	// heartbeatTotalProposalValidityBlocks determines the total wallet
+	// heartbeat proposal validity time expressed in blocks. In other words,
+	// this is the worst-case time for a wallet heartbeat during which the
+	// wallet is busy and cannot take another actions. It includes the total
+	// duration need to perform both both signing the heartbeat message and
+	// optionally notifying about operator inactivity if the heartbeat failed.
+	// The value of 600 blocks is roughly 2 hours, assuming 12 seconds per block.
+	heartbeatTotalProposalValidityBlocks = 600
+	// heartbeatInactivityNotificationValidityBlocks determines the duration
+	// that needs to be preserved for the optional notification about operator
+	// inactivity that follows a failed heartbeat signing.
+	heartbeatInactivityNotificationValidityBlocks = 300
 	// heartbeatRequestTimeoutSafetyMarginBlocks determines the duration of the
-	// safety margin that must be preserved between the signing timeout
-	// and the timeout of the entire heartbeat action. This safety
-	// margin prevents against the case where signing completes too late and
-	// another action has been already requested by the coordinator.
+	// safety margin that must be preserved between the timeout of operator
+	// inactivity notification and the timeout of the entire heartbeat action.
+	// This safety margin prevents against the case where signing completes too
+	// late and another action has been already requested by the coordinator.
 	// The value of 25 blocks is roughly 5 minutes, assuming 12 seconds per block.
 	heartbeatRequestTimeoutSafetyMarginBlocks = 25
 	// heartbeatSigningMinimumActiveOperators determines the minimum number of
@@ -44,7 +50,7 @@ func (hp *HeartbeatProposal) ActionType() WalletActionType {
 }
 
 func (hp *HeartbeatProposal) ValidityBlocks() uint64 {
-	return heartbeatProposalValidityBlocks
+	return heartbeatTotalProposalValidityBlocks
 }
 
 // heartbeatSigningExecutor is an interface meant to decouple the specific
@@ -136,19 +142,19 @@ func (ha *heartbeatAction) execute() error {
 	messageToSign := new(big.Int).SetBytes(messageBytes[:])
 
 	// Just in case. This should never happen.
-	if ha.expiryBlock < heartbeatRequestTimeoutSafetyMarginBlocks {
+	if ha.expiryBlock < heartbeatInactivityNotificationValidityBlocks {
 		return fmt.Errorf("invalid proposal expiry block")
 	}
 
-	heartbeatCtx, cancelHeartbeatCtx := withCancelOnBlock(
+	heartbeatSigningCtx, cancelHeartbeatSigningCtx := withCancelOnBlock(
 		context.Background(),
-		ha.expiryBlock-heartbeatRequestTimeoutSafetyMarginBlocks,
+		ha.expiryBlock-heartbeatInactivityNotificationValidityBlocks,
 		ha.waitForBlockFn,
 	)
-	defer cancelHeartbeatCtx()
+	defer cancelHeartbeatSigningCtx()
 
-	signature, activeOperatorsCount, signingEndBlock, err := ha.signingExecutor.sign(
-		heartbeatCtx,
+	signature, activeOperatorsCount, _, err := ha.signingExecutor.sign(
+		heartbeatSigningCtx,
 		messageToSign,
 		ha.startBlock,
 	)
@@ -192,17 +198,24 @@ func (ha *heartbeatAction) execute() error {
 		return nil
 	}
 
+	heartbeatInactivityCtx, cancelHeartbeatInactivityCtx := withCancelOnBlock(
+		context.Background(),
+		ha.expiryBlock-heartbeatRequestTimeoutSafetyMarginBlocks,
+		ha.waitForBlockFn,
+	)
+	defer cancelHeartbeatInactivityCtx()
+
 	// The value of consecutive heartbeat failures exceeds the threshold.
 	// Proceed with operator inactivity notification.
 	err = ha.inactivityClaimExecutor.claimInactivity(
+		heartbeatInactivityCtx,
 		// Leave the list of inactive operators empty even if some operators
 		// were inactive during signing heartbeat. The inactive operators could
 		// simply be in the process of unstaking and therefore should not be
 		// punished.
 		[]group.MemberIndex{},
 		true,
 		messageToSign,
-		signingEndBlock,
 	)
 	if err != nil {
 		return fmt.Errorf(

pkg/tbtc/heartbeat_test.go

@@ -22,7 +22,7 @@ func TestHeartbeatAction_HappyPath(t *testing.T) {
 	}
 
 	startBlock := uint64(10)
-	expiryBlock := startBlock + heartbeatProposalValidityBlocks
+	expiryBlock := startBlock + heartbeatTotalProposalValidityBlocks
 
 	proposal := &HeartbeatProposal{
 		Message: [16]byte{
@@ -90,7 +90,7 @@ func TestHeartbeatAction_SigningError(t *testing.T) {
 	}
 
 	startBlock := uint64(10)
-	expiryBlock := startBlock + heartbeatProposalValidityBlocks
+	expiryBlock := startBlock + heartbeatTotalProposalValidityBlocks
 
 	proposal := &HeartbeatProposal{
 		Message: [16]byte{

pkg/tbtc/inactivity.go

@@ -24,10 +24,7 @@ const (
 	// that is used to calculate the submission delay period that should be respected
 	// by the given member to avoid all members submitting the same inactivity claim
 	// at the same time.
-	inactivityClaimSubmissionDelayStepBlocks = 3
-	// inactivityClaimMaximumSubmissionBlocks determines the maximum block
-	// duration of inactivity claim submission procedure.
-	inactivityClaimMaximumSubmissionBlocks = 60
+	inactivityClaimSubmissionDelayStepBlocks = 2
 )
 
 // errInactivityClaimExecutorBusy is an error returned when the inactivity claim
@@ -70,10 +67,10 @@ func newInactivityClaimExecutor(
 }
 
 func (ice *inactivityClaimExecutor) claimInactivity(
+	parentCtx context.Context,
 	inactiveMembersIndexes []group.MemberIndex,
 	heartbeatFailed bool,
 	sessionID *big.Int,
-	startBlock uint64,
 ) error {
 	if lockAcquired := ice.lock.TryAcquire(1); !lockAcquired {
 		return errInactivityClaimExecutorBusy
@@ -88,12 +85,9 @@ func (ice *inactivityClaimExecutor) claimInactivity(
 		return fmt.Errorf("cannot marshal wallet public key: [%v]", err)
 	}
 
-	timeoutBlock := startBlock + inactivityClaimMaximumSubmissionBlocks
-
 	execLogger := logger.With(
 		zap.String("wallet", fmt.Sprintf("0x%x", walletPublicKeyBytes)),
-		zap.Uint64("inactivityClaimStartBlock", startBlock),
-		zap.Uint64("inactivityClaimTimeoutBlock", timeoutBlock),
+		zap.String("sessionID", fmt.Sprintf("0x%x", sessionID)),
 	)
 
 	walletRegistryData, err := ice.chain.GetWallet(walletPublicKeyHash)
@@ -135,11 +129,7 @@ func (ice *inactivityClaimExecutor) claimInactivity(
 				signer.signingGroupMemberIndex,
 			)
 
-			ctx, cancelCtx := withCancelOnBlock(
-				context.Background(),
-				timeoutBlock,
-				ice.waitForBlockFn,
-			)
+			ctx, cancelCtx := context.WithCancel(parentCtx)
 			defer cancelCtx()
 
 			subscription := ice.chain.OnInactivityClaimed(