refactor(types): vote extensions support for multiple types

abci/example/kvstore/kvstore.go

@@ -411,8 +411,8 @@ func (app *Application) FinalizeBlock(_ context.Context, req *abci.RequestFinali
 	if app.shouldCommitVerify {
 		vsu := app.getActiveValidatorSetUpdates()
 		qsd := types.QuorumSignData{
-			Block:      makeBlockSignItem(req, btcjson.LLMQType_5_60, vsu.QuorumHash),
-			Extensions: makeVoteExtensionSignItems(req, btcjson.LLMQType_5_60, vsu.QuorumHash),
+			Block:                   makeBlockSignItem(req, btcjson.LLMQType_5_60, vsu.QuorumHash),
+			ThresholdVoteExtensions: makeVoteExtensionSignItems(req, btcjson.LLMQType_5_60, vsu.QuorumHash),
 		}
 		err := app.verifyBlockCommit(qsd, req.Commit)
 		if err != nil {

abci/example/kvstore/verify.go

@@ -10,7 +10,6 @@ import (
 	"github.com/dashpay/tenderdash/crypto"
 	"github.com/dashpay/tenderdash/crypto/encoding"
 	tmbytes "github.com/dashpay/tenderdash/libs/bytes"
-	types1 "github.com/dashpay/tenderdash/proto/tendermint/types"
 	"github.com/dashpay/tenderdash/types"
 )
 
@@ -25,28 +24,11 @@ func (app *Application) verifyBlockCommit(qsd types.QuorumSignData, commit abci.
 		return err
 	}
 	return verifier.Verify(pubKey, types.QuorumSigns{
-		BlockSign:      commit.BlockSignature,
-		ExtensionSigns: makeThresholdVoteExtensions(commit.ThresholdVoteExtensions),
+		BlockSign:               commit.BlockSignature,
+		ThresholdVoteExtensions: types.VoteExtensionsFromProto(commit.ThresholdVoteExtensions...),
 	})
 }
 
-func makeThresholdVoteExtensions(pbVoteExtensions []*types1.VoteExtension) []types.ThresholdExtensionSign {
-	voteExtensions := types.VoteExtensionsFromProto(pbVoteExtensions)
-	var thresholdExtensionSigns []types.ThresholdExtensionSign
-	thresholdVoteExtensions, ok := voteExtensions[types1.VoteExtensionType_THRESHOLD_RECOVER]
-	if !ok {
-		return nil
-	}
-	thresholdExtensionSigns = make([]types.ThresholdExtensionSign, len(thresholdVoteExtensions))
-	for i, voteExtension := range thresholdVoteExtensions {
-		thresholdExtensionSigns[i] = types.ThresholdExtensionSign{
-			Extension:          voteExtension.Extension,
-			ThresholdSignature: voteExtension.Signature,
-		}
-	}
-	return thresholdExtensionSigns
-}
-
 func makeBlockSignItem(
 	req *abci.RequestFinalizeBlock,
 	quorumType btcjson.LLMQType,
@@ -68,23 +50,14 @@ func makeVoteExtensionSignItems(
 	req *abci.RequestFinalizeBlock,
 	quorumType btcjson.LLMQType,
 	quorumHash []byte,
-) map[types1.VoteExtensionType][]crypto.SignItem {
-	items := make(map[types1.VoteExtensionType][]crypto.SignItem)
-	protoExtensionsMap := types1.VoteExtensionsToMap(req.Commit.ThresholdVoteExtensions)
-	for t, exts := range protoExtensionsMap {
-		if items[t] == nil && len(exts) > 0 {
-			items[t] = make([]crypto.SignItem, len(exts))
-		}
-		chainID := req.Block.Header.ChainID
-		for i, ext := range exts {
-			raw := types.VoteExtensionSignBytes(chainID, req.Height, req.Round, ext)
-			reqID, err := types.VoteExtensionRequestID(ext, req.Height, req.Round)
-			if err != nil {
-				panic(fmt.Errorf("vote extension sign items: %w", err))
-			}
+) []crypto.SignItem {
+
+	extensions := types.VoteExtensionsFromProto(req.Commit.ThresholdVoteExtensions...)
+	chainID := req.Block.Header.ChainID
 
-			items[t][i] = crypto.NewSignItem(quorumType, quorumHash, reqID, raw)
-		}
+	items, err := extensions.SignItems(chainID, quorumType, quorumHash, req.Height, req.Round)
+	if err != nil {
+		panic(fmt.Errorf("vote extension sign items: %w", err))
 	}
 	return items
 }

internal/blocksync/reactor_test.go

@@ -239,8 +239,8 @@ func makeNextBlock(ctx context.Context,
 		blockID,
 		&types.CommitSigns{
 			QuorumSigns: types.QuorumSigns{
-				BlockSign:      vote.BlockSignature,
-				ExtensionSigns: types.MakeThresholdExtensionSigns(vote.VoteExtensions),
+				BlockSign:               vote.BlockSignature,
+				ThresholdVoteExtensions: vote.VoteExtensions.Filter(func(ext types.VoteExtensionIf) bool { return ext.IsThresholdRecoverable() }),
 			},
 			QuorumHash: state.Validators.QuorumHash,
 		},

internal/consensus/common_test.go

@@ -157,10 +157,10 @@ func signVote(
 	blockID types.BlockID,
 	quorumType btcjson.LLMQType,
 	quorumHash crypto.QuorumHash) *types.Vote {
-	exts := make(types.VoteExtensions)
+	exts := make(types.VoteExtensions, 0)
 	if voteType == tmproto.PrecommitType && !blockID.IsNil() {
-		exts.Add(tmproto.VoteExtensionType_DEFAULT, tmproto.VoteExtension{
-			Type:      tmproto.VoteExtensionType_DEFAULT,
+		exts.Add(tmproto.VoteExtension{
+			Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
 			Extension: []byte("extension")})
 	}
 	v, err := vs.signVote(ctx, voteType, chainID, blockID, quorumType, quorumHash, exts)
@@ -1111,7 +1111,7 @@ func signDataIsEqual(v1 *types.Vote, v2 *tmproto.Vote) bool {
 	if v1 == nil || v2 == nil {
 		return false
 	}
-	if v1.VoteExtensions.IsSameWithProto(v2.VoteExtensionsToMap()) {
+	if v1.VoteExtensions.IsSameWithProto(v2.VoteExtensions) {
 		return false
 	}
 	return v1.Type == v2.Type &&

internal/consensus/gossiper_test.go

@@ -603,6 +603,6 @@ func (suite *GossiperSuiteTest) signVote(vote *types.Vote) {
 	err := privVal.SignVote(ctx, factory.DefaultTestChainID, suite.valSet.QuorumType, suite.valSet.QuorumHash, protoVote, nil)
 	suite.Require().NoError(err)
 	vote.BlockSignature = protoVote.BlockSignature
-	err = vote.VoteExtensions.CopySignsFromProto(protoVote.VoteExtensionsToMap())
+	err = vote.VoteExtensions.CopySignsFromProto(protoVote.VoteExtensions)
 	suite.Require().NoError(err)
 }

internal/consensus/msgs_test.go

@@ -384,9 +384,10 @@ func TestConsMsgsVectors(t *testing.T) {
 		Round:              0,
 		Type:               tmproto.PrecommitType,
 		BlockID:            bi,
-		VoteExtensions: types.VoteExtensions{
-			tmproto.VoteExtensionType_DEFAULT: []tmproto.VoteExtension{{Extension: []byte("extension")}},
-		},
+		VoteExtensions: types.VoteExtensionsFromProto(&tmproto.VoteExtension{
+			Type:      tmproto.VoteExtensionType_DEFAULT,
+			Extension: []byte("extension"),
+		}),
 	}
 
 	vpb := v.ToProto()

internal/consensus/replay_test.go

@@ -1123,8 +1123,8 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Comm
 					p.BlockID,
 					&types.CommitSigns{
 						QuorumSigns: types.QuorumSigns{
-							BlockSign:      p.BlockSignature,
-							ExtensionSigns: types.MakeThresholdExtensionSigns(p.VoteExtensions),
+							BlockSign:               p.BlockSignature,
+							ThresholdVoteExtensions: p.VoteExtensions,
 						},
 						QuorumHash: crypto.RandQuorumHash(),
 					},

internal/consensus/state_test.go

@@ -2143,7 +2143,7 @@ func TestExtendVote(t *testing.T) {
 
 	voteExtensions := []*abci.ExtendVoteExtension{
 		{
-			Type:      tmproto.VoteExtensionType_DEFAULT,
+			Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
 			Extension: []byte("extension"),
 		},
 	}
@@ -2159,7 +2159,7 @@ func TestExtendVote(t *testing.T) {
 	m.On("ExtendVote", mock.Anything, mock.Anything).Return(&abci.ResponseExtendVote{
 		VoteExtensions: []*abci.ExtendVoteExtension{
 			{
-				Type:      tmproto.VoteExtensionType_DEFAULT,
+				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
 				Extension: []byte("extension"),
 			},
 		},
@@ -2304,7 +2304,7 @@ func TestVerifyVoteExtensionNotCalledOnAbsentPrecommit(t *testing.T) {
 	defer cancel()
 	voteExtensions := []*abci.ExtendVoteExtension{
 		{
-			Type:      tmproto.VoteExtensionType_DEFAULT,
+			Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
 			Extension: []byte("extension"),
 		},
 	}
@@ -2381,7 +2381,7 @@ func TestVerifyVoteExtensionNotCalledOnAbsentPrecommit(t *testing.T) {
 		Round:              round,
 		VoteExtensions: []*abci.ExtendVoteExtension{
 			{
-				Type:      tmproto.VoteExtensionType_DEFAULT,
+				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
 				Extension: []byte("extension"),
 			},
 		},
@@ -2405,8 +2405,8 @@ func TestPrepareProposalReceivesVoteExtensions(t *testing.T) {
 	m.On("ExtendVote", mock.Anything, mock.Anything).Return(&abci.ResponseExtendVote{
 		VoteExtensions: []*abci.ExtendVoteExtension{
 			{
-				Type:      tmproto.VoteExtensionType_DEFAULT,
-				Extension: []byte("extension"),
+				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER_RAW,
+				Extension: crypto.Checksum([]byte("extension-raw")),
 			},
 			{
 				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
@@ -2430,7 +2430,24 @@ func TestPrepareProposalReceivesVoteExtensions(t *testing.T) {
 
 	m.On("PrepareProposal", mock.Anything, mock.Anything).Return(&abci.ResponsePrepareProposal{AppHash: make([]byte, crypto.DefaultAppHashSize)}, nil).Once()
 	m.On("VerifyVoteExtension", mock.Anything, mock.Anything).Return(&abci.ResponseVerifyVoteExtension{Status: abci.ResponseVerifyVoteExtension_ACCEPT}, nil)
-	m.On("FinalizeBlock", mock.Anything, mock.Anything).Return(&abci.ResponseFinalizeBlock{}, nil)
+
+	// no vote extensions are present
+	m.On("FinalizeBlock", mock.Anything, mock.MatchedBy(func(r *abci.RequestFinalizeBlock) bool {
+		return len(r.Commit.ThresholdVoteExtensions) == 0
+	})).Return(&abci.ResponseFinalizeBlock{}, nil)
+
+	// we expect 2 threshold-recovered vote extensions
+	m.On("FinalizeBlock", mock.Anything, mock.MatchedBy(func(r *abci.RequestFinalizeBlock) bool {
+		if len(r.Commit.ThresholdVoteExtensions) != 0 {
+			return false
+		}
+		t.Logf("FinalizeBlock with %d vote extensions", len(r.Commit.ThresholdVoteExtensions))
+
+		vexts := r.Commit.ThresholdVoteExtensions
+
+		return bytes.Equal(vexts[0].Extension, []byte("deterministic")) &&
+			bytes.Equal(vexts[1].Extension, crypto.Checksum([]byte("raw")))
+	})).Return(&abci.ResponseFinalizeBlock{}, nil).Once()
 
 	cs1, vss := makeState(ctx, t, makeStateArgs{config: config, application: m})
 	stateData := cs1.GetStateData()
@@ -2453,21 +2470,22 @@ func TestPrepareProposalReceivesVoteExtensions(t *testing.T) {
 
 	// create a precommit for each validator with the associated vote extension.
 	for _, vs := range vss[1:] {
-		voteExtensions := types.VoteExtensions{
-			tmproto.VoteExtensionType_DEFAULT: []tmproto.VoteExtension{
-				{
-					Type:      tmproto.VoteExtensionType_DEFAULT,
-					Extension: []byte("extension"),
-				},
+		voteExtensions := tmproto.VoteExtensions{
+			{
+				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
+				Extension: []byte("extension"),
 			},
-			tmproto.VoteExtensionType_THRESHOLD_RECOVER: []tmproto.VoteExtension{
-				{
-					Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
-					Extension: []byte("deterministic"),
-				},
+			{
+				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
+				Extension: []byte("deterministic"),
+			},
+			{
+				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER_RAW,
+				Extension: crypto.Checksum([]byte("raw")),
 			},
 		}
-		signAddPrecommitWithExtension(ctx, t, cs1, config.ChainID(), blockID, voteExtensions, vs)
+
+		signAddPrecommitWithExtension(ctx, t, cs1, config.ChainID(), blockID, types.VoteExtensionsFromProto(voteExtensions...), vs)
 	}
 
 	ensurePrevote(t, voteCh, height, round)
@@ -2491,6 +2509,7 @@ func TestPrepareProposalReceivesVoteExtensions(t *testing.T) {
 	// ensure that the proposer received the list of vote extensions from the
 	// previous height.
 	require.Len(t, rpp.LocalLastCommit.ThresholdVoteExtensions, 1)
+	m.AssertExpectations(t)
 }
 
 // 4 vals, 3 Nil Precommits at P0
@@ -3328,7 +3347,7 @@ func mockProposerApplicationCalls(t *testing.T, m *abcimocks.Application, round
 		m.On("ExtendVote", mock.Anything, roundMatcher).
 			Return(&abci.ResponseExtendVote{
 				VoteExtensions: []*abci.ExtendVoteExtension{{
-					Type:      tmproto.VoteExtensionType_DEFAULT,
+					Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
 					Extension: []byte("extension"),
 				}},
 			}, nil).Once()

internal/consensus/types/height_vote_set_test.go

@@ -87,7 +87,7 @@ func makeVoteHR(
 	require.NoError(t, err, "Error signing vote")
 
 	vote.BlockSignature = v.BlockSignature
-	err = vote.VoteExtensions.CopySignsFromProto(v.VoteExtensionsToMap())
+	err = vote.VoteExtensions.CopySignsFromProto(v.VoteExtensions)
 	require.NoError(t, err)
 
 	return vote

internal/consensus/vote_signer_test.go

@@ -39,14 +39,11 @@ func TestVoteSigner_signAddVote(t *testing.T) {
 		PrivValidator: priVals[0],
 		ProTxHash:     proTxHash,
 	}
-	voteExtensions := types.VoteExtensions{
-		tmproto.VoteExtensionType_THRESHOLD_RECOVER: []tmproto.VoteExtension{
-			{
-				Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
-				Extension: tmbytes.MustHexDecode("524F1D03D1D81E94A099042736D40BD9681B867321443FF58A4568E274DBD83B"),
-			},
-		},
-	}
+	voteExtensions := tmproto.VoteExtensions{{
+		Type:      tmproto.VoteExtensionType_THRESHOLD_RECOVER,
+		Extension: tmbytes.MustHexDecode("524F1D03D1D81E94A099042736D40BD9681B867321443FF58A4568E274DBD83B"),
+	}}
+
 	conf := configSetup(t)
 	stateData := StateData{
 		config: conf.Consensus,
@@ -106,7 +103,7 @@ func TestVoteSigner_signAddVote(t *testing.T) {
 		{
 			msgType:        tmproto.PrecommitType,
 			blockID:        blockID,
-			voteExtensions: voteExtensions,
+			voteExtensions: types.VoteExtensionsFromProto(voteExtensions...),
 			mockFn:         mockFn,
 			wantBlockSign:  "B2C484BB07094AAB8EFAB187982F6A8E8172FBEBAE5B6EB6304E527ABAAB7D059D9A43DDDBA82A6D296AF30E67C28D250449A586E9A69C2577057E01FA290BB03C186982D4D45E6016935AD4B9A84EB0911B62A83E457E25CE44DC28516D0E0A",
 		},
@@ -145,7 +142,6 @@ func TestVoteSigner_signAddVote(t *testing.T) {
 			assert.NoError(t, err)
 
 			t.Logf("key: %x", key1.Serialize())
-			t.Logf("%+v", vote.VoteExtensions[tmproto.VoteExtensionType_THRESHOLD_RECOVER])
 		})
 	}
 }

internal/state/execution.go

@@ -615,7 +615,7 @@ func buildLastCommitInfo(block *types.Block, initialHeight int64) abci.CommitInf
 		Round:                   block.LastCommit.Round,
 		QuorumHash:              block.LastCommit.QuorumHash,
 		BlockSignature:          block.LastCommit.ThresholdBlockSignature,
-		ThresholdVoteExtensions: types.ThresholdExtensionSignToProto(block.LastCommit.ThresholdVoteExtensions),
+		ThresholdVoteExtensions: block.LastCommit.ThresholdVoteExtensions.ToProto(),
 	}
 }
 

internal/state/validation_test.go

@@ -328,8 +328,8 @@ func TestValidateBlockCommit(t *testing.T) {
 		require.NoError(t, err, "height %d", height)
 
 		goodVote.BlockSignature, badVote.BlockSignature = g.BlockSignature, b.BlockSignature
-		goodVote.VoteExtensions = types.VoteExtensionsFromProto(g.VoteExtensions)
-		badVote.VoteExtensions = types.VoteExtensionsFromProto(b.VoteExtensions)
+		goodVote.VoteExtensions = types.VoteExtensionsFromProto(g.VoteExtensions...)
+		badVote.VoteExtensions = types.VoteExtensionsFromProto(b.VoteExtensions...)
 
 		thresholdSigns, err := types.NewSignsRecoverer([]*types.Vote{badVote}).Recover()
 		require.NoError(t, err)

internal/store/store_test.go

@@ -53,7 +53,7 @@ func makeTestCommit(state sm.State, height int64, timestamp time.Time) *types.Co
 	_ = privVal.SignVote(context.Background(), "chainID", state.Validators.QuorumType, state.Validators.QuorumHash, g, nil)
 
 	goodVote.BlockSignature = g.BlockSignature
-	goodVote.VoteExtensions = types.VoteExtensionsFromProto(g.VoteExtensions)
+	goodVote.VoteExtensions = types.VoteExtensionsFromProto(g.VoteExtensions...)
 	thresholdSigns, _ := types.NewSignsRecoverer([]*types.Vote{goodVote}).Recover()
 
 	return types.NewCommit(height, 0,

internal/test/factory/commit.go

@@ -39,7 +39,7 @@ func MakeCommit(
 		}
 		vote.BlockSignature = v.BlockSignature
 
-		err = vote.VoteExtensions.CopySignsFromProto(v.VoteExtensionsToMap())
+		err = vote.VoteExtensions.CopySignsFromProto(v.VoteExtensions)
 		if err != nil {
 			return nil, err
 		}

internal/test/factory/vote.go

@@ -40,8 +40,7 @@ func MakeVote(
 
 	v.BlockSignature = vpb.BlockSignature
 
-	err = v.VoteExtensions.CopySignsFromProto(vpb.VoteExtensionsToMap())
-	v.VoteExtensions = types.VoteExtensionsFromProto(vpb.VoteExtensions)
+	err = v.VoteExtensions.CopySignsFromProto(vpb.VoteExtensions)
 	if err != nil {
 
 		return nil, err

privval/dash_core_signer_client.go

@@ -375,15 +375,15 @@ func (sc *DashCoreSignerClient) signVoteExtensions(
 		}
 		return nil
 	}
-	for et, extensions := range protoVote.VoteExtensionsToMap() {
-		for i, ext := range extensions {
-			signItem := quorumSignData.Extensions[et][i]
-			resp, err := sc.quorumSignAndVerify(ctx, quorumType, quorumHash, signItem)
-			if err != nil {
-				return err
-			}
-			ext.Signature = resp.sign
+
+	for i, ext := range quorumSignData.ThresholdVoteExtensions {
+		signItem := ext
+		resp, err := sc.quorumSignAndVerify(ctx, quorumType, quorumHash, signItem)
+		if err != nil {
+			return err
 		}
+
+		protoVote.VoteExtensions[i].Signature = resp.sign
 	}
 	return nil
 }