Refactor: refactored heartbeat manager

packages/ca/heartbeat/errors.go

+package heartbeat
+
+import (
+	"github.com/iotaledger/goshimmer/packages/errors"
+)
+
+var (
+	ErrSigningFailed = errors.Wrap(errors.New("failed to sign"), "failed to sign")
+)

packages/ca/heartbeat/heartbeat.go

@@ -3,6 +3,8 @@ package heartbeat
 import (
 	"sync"
 
+	"github.com/iotaledger/goshimmer/packages/identity"
+
 	"github.com/iotaledger/goshimmer/packages/stringify"
 
 	"github.com/iotaledger/goshimmer/packages/errors"
@@ -77,6 +79,20 @@ func (heartbeat *Heartbeat) GetSignature() []byte {
 	return heartbeat.signature
 }
 
+func (heartbeat *Heartbeat) Sign(identity *identity.Identity) (err errors.IdentifiableError) {
+	if marshaledHeartbeat, marshalErr := heartbeat.MarshalBinary(); marshalErr == nil {
+		if signature, signingErr := identity.Sign(marshaledHeartbeat); signingErr == nil {
+			heartbeat.SetSignature(signature)
+		} else {
+			err = ErrSigningFailed.Derive(signingErr, "failed to sign heartbeat")
+		}
+	} else {
+		err = marshalErr
+	}
+
+	return
+}
+
 func (heartbeat *Heartbeat) SetSignature(signature []byte) {
 	heartbeat.signatureMutex.Lock()
 	defer heartbeat.signatureMutex.Unlock()

packages/ca/heartbeat/opinion_statement.go

@@ -3,6 +3,8 @@ package heartbeat
 import (
 	"sync"
 
+	"github.com/iotaledger/goshimmer/packages/identity"
+
 	"golang.org/x/crypto/blake2b"
 
 	"github.com/iotaledger/goshimmer/packages/stringify"
@@ -104,6 +106,20 @@ func (opinionStatement *OpinionStatement) SetSignature(signature []byte) {
 	opinionStatement.signature = signature
 }
 
+func (opinionStatement *OpinionStatement) Sign(identity *identity.Identity) (err errors.IdentifiableError) {
+	if marshaledStatement, marshalErr := opinionStatement.MarshalBinary(); marshalErr == nil {
+		if signature, signingErr := identity.Sign(marshaledStatement); signingErr == nil {
+			opinionStatement.SetSignature(signature)
+		} else {
+			err = ErrSigningFailed.Derive(signingErr, "failed to sign opinion statement")
+		}
+	} else {
+		err = marshalErr
+	}
+
+	return
+}
+
 func (opinionStatement *OpinionStatement) GetHash() []byte {
 	opinionStatement.hashMutex.RLock()
 	defer opinionStatement.hashMutex.RUnlock()

packages/ca/heartbeat_manager.go

@@ -40,86 +40,65 @@ func (heartbeatManager *HeartbeatManager) InitialLike(transactionId []byte) {
 	heartbeatManager.initialOpinions[string(transactionId)] = true
 }
 
-func (heartbeatManager *HeartbeatManager) GenerateMainStatement() (result *heartbeat.OpinionStatement, err errors.IdentifiableError) {
-	toggledTransactions := make([]*heartbeat.ToggledTransaction, 0)
-	for transactionId, liked := range heartbeatManager.initialOpinions {
-		if !liked {
-			newToggledTransaction := heartbeat.NewToggledTransaction()
-			newToggledTransaction.SetInitialStatement(true)
-			newToggledTransaction.SetFinalStatement(false)
-			newToggledTransaction.SetTransactionId([]byte(transactionId))
-
-			toggledTransactions = append(toggledTransactions, newToggledTransaction)
+func (heartbeatManager *HeartbeatManager) GenerateHeartbeat() (result *heartbeat.Heartbeat, err errors.IdentifiableError) {
+	if mainStatement, mainStatementErr := heartbeatManager.GenerateMainStatement(); mainStatementErr == nil {
+		generatedHeartbeat := heartbeat.NewHeartbeat()
+		generatedHeartbeat.SetNodeId(heartbeatManager.identity.StringIdentifier)
+		generatedHeartbeat.SetMainStatement(mainStatement)
+		generatedHeartbeat.SetNeighborStatements(nil)
+
+		if signingErr := generatedHeartbeat.Sign(heartbeatManager.identity); signingErr == nil {
+			result = generatedHeartbeat
+		} else {
+			err = signingErr
 		}
+	} else {
+		err = mainStatementErr
 	}
 
+	return
+}
+
+func (heartbeatManager *HeartbeatManager) GenerateMainStatement() (result *heartbeat.OpinionStatement, err errors.IdentifiableError) {
 	mainStatement := heartbeat.NewOpinionStatement()
 	mainStatement.SetNodeId(heartbeatManager.identity.StringIdentifier)
 	mainStatement.SetTime(uint64(time.Now().Unix()))
-	mainStatement.SetToggledTransactions(toggledTransactions)
+	mainStatement.SetToggledTransactions(heartbeatManager.GenerateToggledTransactions())
 
 	if lastAppliedStatement := heartbeatManager.statementChain.lastAppliedStatement; lastAppliedStatement != nil {
 		mainStatement.SetPreviousStatementHash(lastAppliedStatement.GetHash())
 	}
 
-	marshaledStatement, marshalErr := mainStatement.MarshalBinary()
-	if marshalErr != nil {
-		err = marshalErr
-
-		return
-	}
-
-	signature, signingErr := heartbeatManager.identity.Sign(marshaledStatement)
-	if signingErr != nil {
-		err = ErrMalformedHeartbeat.Derive(signingErr.Error())
+	if signingErr := mainStatement.Sign(heartbeatManager.identity); signingErr == nil {
+		result = mainStatement
 
-		return
+		heartbeatManager.ResetInitialOpinions()
+		heartbeatManager.statementChain.lastAppliedStatement = mainStatement
+	} else {
+		err = signingErr
 	}
 
-	mainStatement.SetSignature(signature)
-
-	result = mainStatement
-
-	heartbeatManager.ResetInitialStatements()
-	heartbeatManager.statementChain.lastAppliedStatement = mainStatement
-
 	return
 }
 
-func (heartbeatManager *HeartbeatManager) ResetInitialStatements() {
-	heartbeatManager.initialOpinions = make(map[string]bool)
-}
-
-func (heartbeatManager *HeartbeatManager) GenerateHeartbeat() (result *heartbeat.Heartbeat, err errors.IdentifiableError) {
-	mainStatement, mainStatementErr := heartbeatManager.GenerateMainStatement()
-	if mainStatementErr != nil {
-		err = mainStatementErr
-
-		return
-	}
-
-	generatedHeartbeat := heartbeat.NewHeartbeat()
-	generatedHeartbeat.SetNodeId(heartbeatManager.identity.StringIdentifier)
-	generatedHeartbeat.SetMainStatement(mainStatement)
-	generatedHeartbeat.SetNeighborStatements(nil)
-
-	marshaledHeartbeat, marshalErr := generatedHeartbeat.MarshalBinary()
-	if marshalErr != nil {
-		err = marshalErr
-
-		return
-	}
-	signature, signingErr := heartbeatManager.identity.Sign(marshaledHeartbeat)
-	if signingErr != nil {
-		err = ErrMalformedHeartbeat.Derive(signingErr.Error())
+func (heartbeatManager *HeartbeatManager) GenerateToggledTransactions() []*heartbeat.ToggledTransaction {
+	toggledTransactions := make([]*heartbeat.ToggledTransaction, 0)
+	for transactionId, liked := range heartbeatManager.initialOpinions {
+		if !liked {
+			newToggledTransaction := heartbeat.NewToggledTransaction()
+			newToggledTransaction.SetInitialStatement(true)
+			newToggledTransaction.SetFinalStatement(false)
+			newToggledTransaction.SetTransactionId([]byte(transactionId))
 
-		return
+			toggledTransactions = append(toggledTransactions, newToggledTransaction)
+		}
 	}
-	generatedHeartbeat.SetSignature(signature)
 
-	result = generatedHeartbeat
+	return toggledTransactions
+}
 
-	return
+func (heartbeatManager *HeartbeatManager) ResetInitialOpinions() {
+	heartbeatManager.initialOpinions = make(map[string]bool)
 }
 
 func (heartbeatManager *HeartbeatManager) ApplyHeartbeat(heartbeat *heartbeat.Heartbeat) (err errors.IdentifiableError) {