Optimistic signature aggregation by leader

consensus/spos/bls/export_test.go

@@ -269,6 +269,10 @@ func (sr *subroundEndRound) DoEndRoundJobByParticipant(cnsDta *consensus.Message
 	return sr.doEndRoundJobByParticipant(cnsDta)
 }
 
+func (sr *subroundEndRound) DoEndRoundJobByLeader() bool {
+	return sr.doEndRoundJobByLeader()
+}
+
 func (sr *subroundEndRound) HaveConsensusHeaderWithFullInfo(cnsDta *consensus.Message) (bool, data.HeaderHandler) {
 	return sr.haveConsensusHeaderWithFullInfo(cnsDta)
 }
@@ -293,6 +297,14 @@ func (sr *subroundEndRound) IsOutOfTime() bool {
 	return sr.isOutOfTime()
 }
 
+func (sr *subroundEndRound) VerifyNodesOnAggSigVerificationFail() error {
+	return sr.verifyNodesOnAggSigVerificationFail()
+}
+
+func (sr *subroundEndRound) ComputeAggSigOnValidNodes() ([]byte, []byte, error) {
+	return sr.computeAggSigOnValidNodes()
+}
+
 // GetStringValue gets the name of the message type
 func GetStringValue(messageType consensus.MessageType) string {
 	return getStringValue(messageType)

consensus/spos/bls/subroundEndRound.go

@@ -197,6 +197,30 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool {
 		return false
 	}
 
+	currentMultiSigner := sr.MultiSigner()
+	err = currentMultiSigner.SetAggregatedSig(sig)
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.SetAggregatedSig", "error", err.Error())
+		return false
+	}
+
+	err = currentMultiSigner.Verify(sr.GetData(), bitmap)
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.Verify", "error", err.Error())
+
+		err = sr.verifyNodesOnAggSigVerificationFail()
+		if err != nil {
+			log.Debug("doEndRoundJobByLeader.verifyNodesOnAggSigVerificationFail", "error", err.Error())
+			return false
+		}
+
+		bitmap, sig, err = sr.computeAggSigOnValidNodes()
+		if err != nil {
+			log.Debug("doEndRoundJobByLeader.computeAggSigOnValidNodes", "error", err.Error())
+			return false
+		}
+	}
+
 	err = sr.Header.SetPubKeysBitmap(bitmap)
 	if err != nil {
 		log.Debug("doEndRoundJobByLeader.SetPubKeysBitmap", "error", err.Error())
@@ -281,6 +305,76 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool {
 	return true
 }
 
+// TODO:
+//	- slashing for invalid sig shares
+//	- handle sig share verifications concurrently
+func (sr *subroundEndRound) verifyNodesOnAggSigVerificationFail() error {
+	multiSigner := sr.MultiSigner()
+	pubKeys := sr.ConsensusGroup()
+
+	for i, pk := range pubKeys {
+		isJobDone, err := sr.JobDone(pk, SrSignature)
+		if err != nil || !isJobDone {
+			continue
+		}
+
+		sigShare, err := multiSigner.SignatureShare(uint16(i))
+		if err != nil {
+			return err
+		}
+
+		isSuccessfull := true
+		err = multiSigner.VerifySignatureShare(uint16(i), sigShare, sr.GetData(), nil)
+		if err != nil {
+			isSuccessfull = false
+
+			err = sr.SetJobDone(pk, SrSignature, false)
+			if err != nil {
+				return err
+			}
+
+			sr.PeerHonestyHandler().ChangeScore(
+				pk,
+				spos.GetConsensusTopicID(sr.ShardCoordinator()),
+				spos.ValidatorPeerHonestyDecreaseFactor,
+			)
+		}
+
+		log.Trace("verifyNodesOnAggSigVerificationFail: verifying signature share", "public key", pk, "is successfull", isSuccessfull)
+	}
+
+	return nil
+}
+
+func (sr *subroundEndRound) computeAggSigOnValidNodes() ([]byte, []byte, error) {
+	multiSigner := sr.MultiSigner()
+	threshold := sr.Threshold(sr.Current())
+	numValidSigShares := sr.ComputeSize(SrSignature)
+
+	if numValidSigShares < threshold {
+		return nil, nil, fmt.Errorf("%w: number of valid sig shares lower than threshold, numSigShares: %d, threshold: %d",
+			spos.ErrInvalidNumSigShares, numValidSigShares, threshold)
+	}
+
+	bitmap := sr.GenerateBitmap(SrSignature)
+	err := sr.checkSignaturesValidity(bitmap)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sig, err := multiSigner.AggregateSigs(bitmap)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	err = multiSigner.SetAggregatedSig(sig)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return bitmap, sig, nil
+}
+
 func (sr *subroundEndRound) createAndBroadcastHeaderFinalInfo() {
 	cnsMsg := consensus.NewConsensusMessage(
 		sr.GetData(),

consensus/spos/bls/subroundEndRound_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/data"
 	"github.com/ElrondNetwork/elrond-go-core/data/block"
-	"github.com/ElrondNetwork/elrond-go-crypto"
+	crypto "github.com/ElrondNetwork/elrond-go-crypto"
 	"github.com/ElrondNetwork/elrond-go/consensus"
 	"github.com/ElrondNetwork/elrond-go/consensus/mock"
 	"github.com/ElrondNetwork/elrond-go/consensus/spos"
@@ -937,3 +937,241 @@ func TestSubroundEndRound_IsBlockHeaderFinalInfoValidShouldReturnTrue(t *testing
 	isValid := sr.IsBlockHeaderFinalInfoValid(cnsDta)
 	assert.True(t, isValid)
 }
+
+func TestVerifyNodesOnAggSigVerificationFail(t *testing.T) {
+	t.Parallel()
+
+	t.Run("fail to get signature share", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		multiSignerMock := mock.InitMultiSignerMock()
+
+		expectedErr := errors.New("exptected error")
+		multiSignerMock.SignatureShareCalled = func(index uint16) ([]byte, error) {
+			return nil, expectedErr
+		}
+
+		container.SetMultiSigner(multiSignerMock)
+
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+
+		err := sr.VerifyNodesOnAggSigVerificationFail()
+		require.Equal(t, expectedErr, err)
+	})
+
+	t.Run("fail to verify signature share, job done will be set to false", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		multiSignerMock := mock.InitMultiSignerMock()
+
+		expectedErr := errors.New("exptected error")
+		multiSignerMock.SignatureShareCalled = func(index uint16) ([]byte, error) {
+			return nil, nil
+		}
+		multiSignerMock.VerifySignatureShareCalled = func(index uint16, sig, msg, bitmap []byte) error {
+			return expectedErr
+		}
+
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+		container.SetMultiSigner(multiSignerMock)
+
+		err := sr.VerifyNodesOnAggSigVerificationFail()
+		require.Nil(t, err)
+
+		isJobDone, err := sr.JobDone(sr.ConsensusGroup()[0], bls.SrSignature)
+		require.Nil(t, err)
+		require.False(t, isJobDone)
+	})
+
+	t.Run("should work", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		multiSignerMock := mock.InitMultiSignerMock()
+		multiSignerMock.SignatureShareCalled = func(index uint16) ([]byte, error) {
+			return nil, nil
+		}
+		multiSignerMock.VerifySignatureShareCalled = func(index uint16, sig, msg, bitmap []byte) error {
+			return nil
+		}
+		multiSignerMock.VerifyCalled = func(msg, bitmap []byte) error {
+			return nil
+		}
+		container.SetMultiSigner(multiSignerMock)
+
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+		_ = sr.SetJobDone(sr.ConsensusGroup()[1], bls.SrSignature, true)
+
+		err := sr.VerifyNodesOnAggSigVerificationFail()
+		require.Nil(t, err)
+	})
+}
+
+func TestComputeAddSigOnValidNodes(t *testing.T) {
+	t.Parallel()
+
+	t.Run("invalid number of valid sig shares", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		sr.SetThreshold(bls.SrEndRound, 2)
+
+		_, _, err := sr.ComputeAggSigOnValidNodes()
+		require.True(t, errors.Is(err, spos.ErrInvalidNumSigShares))
+	})
+
+	t.Run("fail to created aggregated sig", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		multiSignerMock := mock.InitMultiSignerMock()
+
+		expectedErr := errors.New("exptected error")
+		multiSignerMock.AggregateSigsCalled = func(bitmap []byte) ([]byte, error) {
+			return nil, expectedErr
+		}
+		container.SetMultiSigner(multiSignerMock)
+
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+
+		_, _, err := sr.ComputeAggSigOnValidNodes()
+		require.Equal(t, expectedErr, err)
+	})
+
+	t.Run("fail to set aggregated sig", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		multiSignerMock := mock.InitMultiSignerMock()
+
+		expectedErr := errors.New("exptected error")
+		multiSignerMock.SetAggregatedSigCalled = func(aggSig []byte) error {
+			return expectedErr
+		}
+		container.SetMultiSigner(multiSignerMock)
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+
+		_, _, err := sr.ComputeAggSigOnValidNodes()
+		require.Equal(t, expectedErr, err)
+	})
+
+	t.Run("should work", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+
+		bitmap, sig, err := sr.ComputeAggSigOnValidNodes()
+		require.NotNil(t, bitmap)
+		require.NotNil(t, sig)
+		require.Nil(t, err)
+	})
+}
+
+func TestSubroundEndRound_DoEndRoundJobByLeaderVerificationFail(t *testing.T) {
+	t.Parallel()
+
+	t.Run("not enough valid signature shares", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		multiSignerMock := mock.InitMultiSignerMock()
+		multiSignerMock.SignatureShareCalled = func(index uint16) ([]byte, error) {
+			return nil, nil
+		}
+
+		verifySigShareNumCalls := 0
+		multiSignerMock.VerifySignatureShareCalled = func(index uint16, sig, msg, bitmap []byte) error {
+			if verifySigShareNumCalls == 0 {
+				verifySigShareNumCalls++
+				return errors.New("expected error")
+			}
+
+			verifySigShareNumCalls++
+			return nil
+		}
+
+		verifyFirstCall := true
+		multiSignerMock.VerifyCalled = func(msg, bitmap []byte) error {
+			if verifyFirstCall {
+				verifyFirstCall = false
+				return errors.New("expected error")
+			}
+
+			return nil
+		}
+
+		container.SetMultiSigner(multiSignerMock)
+
+		sr.SetThreshold(bls.SrEndRound, 2)
+
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+		_ = sr.SetJobDone(sr.ConsensusGroup()[1], bls.SrSignature, true)
+
+		sr.Header = &block.Header{}
+
+		r := sr.DoEndRoundJobByLeader()
+		require.False(t, r)
+
+		assert.False(t, verifyFirstCall)
+		assert.Equal(t, 2, verifySigShareNumCalls)
+	})
+
+	t.Run("should work", func(t *testing.T) {
+		t.Parallel()
+
+		container := mock.InitConsensusCore()
+		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+		multiSignerMock := mock.InitMultiSignerMock()
+		multiSignerMock.SignatureShareCalled = func(index uint16) ([]byte, error) {
+			return nil, nil
+		}
+
+		verifySigShareNumCalls := 0
+		multiSignerMock.VerifySignatureShareCalled = func(index uint16, sig, msg, bitmap []byte) error {
+			if verifySigShareNumCalls == 0 {
+				verifySigShareNumCalls++
+				return errors.New("expected error")
+			}
+
+			verifySigShareNumCalls++
+			return nil
+		}
+
+		verifyFirstCall := true
+		multiSignerMock.VerifyCalled = func(msg, bitmap []byte) error {
+			if verifyFirstCall {
+				verifyFirstCall = false
+				return errors.New("expected error")
+			}
+
+			return nil
+		}
+
+		container.SetMultiSigner(multiSignerMock)
+
+		sr.SetThreshold(bls.SrEndRound, 2)
+
+		_ = sr.SetJobDone(sr.ConsensusGroup()[0], bls.SrSignature, true)
+		_ = sr.SetJobDone(sr.ConsensusGroup()[1], bls.SrSignature, true)
+		_ = sr.SetJobDone(sr.ConsensusGroup()[2], bls.SrSignature, true)
+
+		sr.Header = &block.Header{}
+
+		r := sr.DoEndRoundJobByLeader()
+		require.True(t, r)
+
+		assert.False(t, verifyFirstCall)
+		assert.Equal(t, 3, verifySigShareNumCalls)
+	})
+}