From ee76c0c5f5763616fba5b03b7604b924252ee6f6 Mon Sep 17 00:00:00 2001
From: andicrypt <keepgoing0901@gmail.com>
Date: Mon, 11 Mar 2024 11:34:20 +0700
Subject: [PATCH 1/5] consortium-v2: implement RLP encoding for header extra
 data

---
 consensus/consortium/v2/consortium_test.go    | 120 ++++++++++++++++++
 .../v2/finality/consortium_header.go          |  88 +++++++++++++
 crypto/bls/blst/public_key.go                 |   1 +
 3 files changed, 209 insertions(+)

diff --git a/consensus/consortium/v2/consortium_test.go b/consensus/consortium/v2/consortium_test.go
index 59c10c0c87..8c078f3c47 100644
--- a/consensus/consortium/v2/consortium_test.go
+++ b/consensus/consortium/v2/consortium_test.go
@@ -3,9 +3,11 @@ package v2
 import (
 	"bytes"
 	"crypto/ecdsa"
+	"crypto/rand"
 	"encoding/binary"
 	"errors"
 	"math/big"
+	mrand "math/rand"
 	"testing"
 	"time"
 
@@ -530,6 +532,124 @@ func TestExtraDataDecode(t *testing.T) {
 	}
 }
 
+func mockExtraData(nVal int, bits uint32) *finality.HeaderExtraData {
+	var (
+		vanity                  = make([]byte, finality.ExtraVanity)
+		hasFinalityVote         uint8
+		finalityVotedValidators finality.FinalityVoteBitSet
+		aggregatedFinalityVotes blsCommon.Signature
+		checkpointValidators    = make([]finality.ValidatorWithBlsPub, 0, nVal)
+		seal                    = make([]byte, finality.ExtraSeal)
+	)
+	ret := &finality.HeaderExtraData{}
+
+	hasFinalityVote = uint8(mrand.Intn(2))
+	ret.HasFinalityVote = hasFinalityVote
+
+	if ret.HasFinalityVote == 1 {
+		finalityVotedValidators = finality.FinalityVoteBitSet(mrand.Uint64())
+		ret.FinalityVotedValidators = finalityVotedValidators
+
+		delegated, _ := blst.RandKey()
+		msg := make([]byte, 64)
+		rand.Read(msg)
+		aggregatedFinalityVotes = delegated.Sign(msg)
+		ret.AggregatedFinalityVotes = aggregatedFinalityVotes
+	}
+
+	bits = bits % 7 // ensure bits can be represented by 3-bit integer
+	for i := 0; i < 3; i++ {
+		if bits&(1<<i) != 0 {
+			switch i {
+			case 0:
+				rand.Read(vanity)
+				ret.Vanity = [finality.ExtraVanity]byte(vanity)
+			case 1:
+				for i := 0; i < nVal; i++ {
+					s, _ := blst.RandKey()
+					sk, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
+					addr := crypto.PubkeyToAddress(sk.PublicKey)
+					val := finality.ValidatorWithBlsPub{
+						Address:      addr,
+						BlsPublicKey: s.PublicKey(),
+					}
+					checkpointValidators = append(checkpointValidators, val)
+				}
+				ret.CheckpointValidators = checkpointValidators
+			case 2:
+				rand.Read(seal)
+				ret.Seal = [finality.ExtraSeal]byte(seal)
+			}
+		}
+	}
+	return ret
+}
+
+func TestExtraDataEncodeRLP(t *testing.T) {
+	nVal := 22
+	for i := 0; i < 7; i++ {
+		ext := mockExtraData(nVal, uint32(i))
+		_, err := ext.EncodeRLP()
+		if err != nil {
+			t.Errorf("encode rlp error: %v", err)
+		}
+	}
+}
+
+func TestExtraDataDecodeRLP(t *testing.T) {
+	nVals := 22
+	// loop 64 times, equivalent to 64 combinations of 6 bits
+	for i := 0; i < 7; i++ {
+		ext := mockExtraData(nVals, uint32(i))
+		enc, err := ext.EncodeRLP()
+		if err != nil {
+			t.Errorf("encode rlp error: %v", err)
+		}
+		dec, err := finality.DecodeExtraRLP(enc)
+		if err != nil {
+			t.Errorf("decode rlp error: %v", err)
+		}
+		if !bytes.Equal(dec.Vanity[:], ext.Vanity[:]) {
+			t.Errorf("Mismatched decoded data")
+		}
+		if dec.HasFinalityVote != ext.HasFinalityVote {
+			t.Errorf("Mismatch decoded data")
+		}
+		if dec.FinalityVotedValidators != ext.FinalityVotedValidators {
+			t.Errorf("Mismatch decoded data")
+		}
+		if (dec.AggregatedFinalityVotes != nil && ext.AggregatedFinalityVotes == nil) ||
+			(dec.AggregatedFinalityVotes == nil && ext.AggregatedFinalityVotes != nil) {
+			t.Errorf("Mismatch decoded data")
+		}
+		if dec.AggregatedFinalityVotes != nil &&
+			ext.AggregatedFinalityVotes != nil &&
+			!bytes.Equal(dec.AggregatedFinalityVotes.Marshal(), ext.AggregatedFinalityVotes.Marshal()) {
+			t.Errorf("Mismatch decoded data")
+		}
+		if len(dec.CheckpointValidators) != len(ext.CheckpointValidators) {
+			t.Errorf("Mismatch decoded data")
+		}
+		for i := 0; i < len(ext.CheckpointValidators); i++ {
+			if dec.CheckpointValidators[i].Address.Hex() != ext.CheckpointValidators[i].Address.Hex() {
+				t.Errorf("Mismatch decoded data")
+			}
+			if (dec.CheckpointValidators[i].BlsPublicKey == nil && ext.CheckpointValidators[i].BlsPublicKey != nil) ||
+				(dec.CheckpointValidators[i].BlsPublicKey != nil && ext.CheckpointValidators[i].BlsPublicKey == nil) {
+				t.Errorf("Mismatch decoded data")
+			}
+			if dec.CheckpointValidators[i].BlsPublicKey != nil &&
+				ext.CheckpointValidators[i].BlsPublicKey != nil &&
+				!bytes.Equal(dec.CheckpointValidators[i].BlsPublicKey.Marshal(), ext.CheckpointValidators[i].BlsPublicKey.Marshal()) {
+				t.Errorf("Mismatch decoded data")
+			}
+		}
+		if !bytes.Equal(dec.Seal[:], ext.Seal[:]) {
+			t.Errorf("Mismatch decoded data")
+		}
+	}
+}
+
 func TestVerifyFinalitySignature(t *testing.T) {
 	const numValidator = 3
 	var err error
diff --git a/consensus/consortium/v2/finality/consortium_header.go b/consensus/consortium/v2/finality/consortium_header.go
index e19e85ed15..3602ab0d40 100644
--- a/consensus/consortium/v2/finality/consortium_header.go
+++ b/consensus/consortium/v2/finality/consortium_header.go
@@ -12,6 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto/bls/blst"
 	blsCommon "github.com/ethereum/go-ethereum/crypto/bls/common"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rlp"
 )
 
 const (
@@ -66,6 +67,12 @@ var (
 	// ErrInvalidTargetNumber is returned if the vote contains invalid
 	// target number
 	ErrInvalidTargetNumber = errors.New("invalid target number in vote")
+
+	// ErrNilAggregatedFinalityVotes is returned if the aggregated votes is nil
+	ErrNilAggregatedFinalityVotes = errors.New("aggregated finality votes is nil")
+
+	// ErrNilBlsPublicKey is returned if the bls public key is nil
+	ErrNilBlsPublicKey = errors.New("bls public key is nil")
 )
 
 type ValidatorWithBlsPub struct {
@@ -180,6 +187,87 @@ func (extraData *HeaderExtraData) Encode(isShillin bool) []byte {
 	return rawBytes
 }
 
+type extraDataRLP struct {
+	Vanity                  [ExtraVanity]byte
+	HasFinalityVote         uint8
+	FinalityVotedValidators FinalityVoteBitSet
+	AggregatedFinalityVotes []byte
+	CheckpointValidators    []validatorWithBlsPubRLP
+	Seal                    [ExtraSeal]byte `rlp:"optional"`
+}
+
+type validatorWithBlsPubRLP struct {
+	Address      common.Address
+	BlsPublicKey []byte
+}
+
+func (extraData *HeaderExtraData) EncodeRLP() ([]byte, error) {
+	ext := &extraDataRLP{
+		Vanity:          extraData.Vanity,
+		HasFinalityVote: extraData.HasFinalityVote,
+		Seal:            extraData.Seal,
+	}
+	cp := make([]validatorWithBlsPubRLP, 0)
+	for _, val := range extraData.CheckpointValidators {
+		v := validatorWithBlsPubRLP{
+			Address: val.Address,
+		}
+		if val.BlsPublicKey == nil {
+			return nil, ErrNilBlsPublicKey
+		}
+		v.BlsPublicKey = val.BlsPublicKey.Marshal()
+		cp = append(cp, v)
+	}
+	ext.CheckpointValidators = cp
+	if extraData.HasFinalityVote != 0 && extraData.HasFinalityVote != 1 {
+		return nil, ErrInvalidHasFinalityVote
+	}
+	if extraData.HasFinalityVote == 1 {
+		ext.FinalityVotedValidators = extraData.FinalityVotedValidators
+		if extraData.AggregatedFinalityVotes == nil {
+			return nil, ErrNilAggregatedFinalityVotes
+		}
+		ext.AggregatedFinalityVotes = extraData.AggregatedFinalityVotes.Marshal()
+	}
+	return rlp.EncodeToBytes(ext)
+}
+
+func DecodeExtraRLP(enc []byte) (*HeaderExtraData, error) {
+	var err error
+	dec := &extraDataRLP{}
+	if err := rlp.DecodeBytes(enc, dec); err != nil {
+		return nil, err
+	}
+	ret := &HeaderExtraData{
+		Vanity:          dec.Vanity,
+		HasFinalityVote: dec.HasFinalityVote,
+		Seal:            dec.Seal,
+	}
+	cp := make([]ValidatorWithBlsPub, 0)
+	for _, val := range dec.CheckpointValidators {
+		v := ValidatorWithBlsPub{
+			Address: val.Address,
+		}
+		v.BlsPublicKey, err = blst.PublicKeyFromBytes(val.BlsPublicKey)
+		if err != nil {
+			return nil, err
+		}
+		cp = append(cp, v)
+	}
+	ret.CheckpointValidators = cp
+	if dec.HasFinalityVote != 1 && dec.HasFinalityVote != 0 {
+		return nil, ErrInvalidHasFinalityVote
+	}
+	if dec.HasFinalityVote == 1 {
+		ret.FinalityVotedValidators = dec.FinalityVotedValidators
+		ret.AggregatedFinalityVotes, err = blst.SignatureFromBytes(dec.AggregatedFinalityVotes)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return ret, nil
+}
+
 func DecodeExtra(rawBytes []byte, isShillin bool) (*HeaderExtraData, error) {
 	var (
 		extraData       HeaderExtraData
diff --git a/crypto/bls/blst/public_key.go b/crypto/bls/blst/public_key.go
index f543241057..984b60165e 100644
--- a/crypto/bls/blst/public_key.go
+++ b/crypto/bls/blst/public_key.go
@@ -4,6 +4,7 @@ package blst
 
 import (
 	"fmt"
+
 	"github.com/ethereum/go-ethereum/crypto/bls/common"
 	"github.com/ethereum/go-ethereum/params"
 	lru "github.com/hashicorp/golang-lru"

From 00c57bb5ea0c39010e3f897e7ac06d753aaeab11 Mon Sep 17 00:00:00 2001
From: andicrypt <keepgoing0901@gmail.com>
Date: Tue, 12 Mar 2024 16:46:03 +0700
Subject: [PATCH 2/5] consortium-v2: integrate new RLP encoder/decoder for
 header extra data

---
 consensus/consortium/v2/api.go                |  3 +-
 consensus/consortium/v2/consortium.go         | 33 +++++++++++------
 consensus/consortium/v2/consortium_test.go    | 22 +++++++++---
 .../v2/finality/consortium_header.go          | 35 +++++++++++++++----
 consensus/consortium/v2/snapshot.go           |  4 +--
 crypto/bls/blst/public_key.go                 |  1 -
 monitor/finality_vote.go                      |  2 +-
 7 files changed, 72 insertions(+), 28 deletions(-)

diff --git a/consensus/consortium/v2/api.go b/consensus/consortium/v2/api.go
index a168eeb164..3ac0167e5f 100644
--- a/consensus/consortium/v2/api.go
+++ b/consensus/consortium/v2/api.go
@@ -52,8 +52,7 @@ func (api *consortiumV2Api) GetFinalityVoteAtHash(hash common.Hash) (*finalityVo
 		return nil, consortiumCommon.ErrUnknownBlock
 	}
 
-	isShillin := api.consortium.chainConfig.IsShillin(header.Number)
-	extraData, err := finality.DecodeExtra(header.Extra, isShillin)
+	extraData, err := finality.DecodeExtraV2(header.Extra, api.consortium.chainConfig, header.Number)
 	if err != nil {
 		return nil, err
 	}
diff --git a/consensus/consortium/v2/consortium.go b/consensus/consortium/v2/consortium.go
index 0b91785870..1745260a39 100644
--- a/consensus/consortium/v2/consortium.go
+++ b/consensus/consortium/v2/consortium.go
@@ -359,7 +359,7 @@ func (c *Consortium) verifyCascadingFields(chain consensus.ChainHeaderReader, he
 
 	// Check extra data
 	isShillin := c.chainConfig.IsShillin(header.Number)
-	extraData, err := finality.DecodeExtra(header.Extra, isShillin)
+	extraData, err := finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
 	if err != nil {
 		return err
 	}
@@ -726,7 +726,6 @@ func (c *Consortium) Prepare(chain consensus.ChainHeaderReader, header *types.He
 	// Set the correct difficulty
 	header.Difficulty = CalcDifficulty(snap, coinbase)
 
-	isShillin := c.chainConfig.IsShillin(header.Number)
 	var extraData finality.HeaderExtraData
 
 	if number%c.config.EpochV2 == 0 || c.chainConfig.IsOnConsortiumV2(big.NewInt(int64(number))) {
@@ -741,7 +740,10 @@ func (c *Consortium) Prepare(chain consensus.ChainHeaderReader, header *types.He
 	// not assemble finality vote yet. Let's wait some time for the
 	// finality votes to be broadcasted around the network. The
 	// finality votes are assembled later in Seal function.
-	header.Extra = extraData.Encode(isShillin)
+	header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+	if err != nil {
+		return err
+	}
 
 	// Mix digest is reserved for now, set to empty
 	header.MixDigest = common.Hash{}
@@ -767,9 +769,10 @@ func (c *Consortium) processSystemTransactions(chain consensus.ChainHeaderReader
 	_, _, _, contract := c.readSignerAndContract()
 
 	// If the parent's block includes the finality votes, distribute reward for the voters
-	if c.chainConfig.IsShillin(new(big.Int).Sub(header.Number, common.Big1)) {
+	parentNumber := new(big.Int).Sub(header.Number, common.Big1)
+	if c.chainConfig.IsShillin(parentNumber) {
 		parentHeader := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
-		extraData, err := finality.DecodeExtra(parentHeader.Extra, true)
+		extraData, err := finality.DecodeExtraV2(parentHeader.Extra, c.chainConfig, parentNumber)
 		if err != nil {
 			return err
 		}
@@ -891,7 +894,7 @@ func (c *Consortium) Finalize(chain consensus.ChainHeaderReader, header *types.H
 		if err != nil {
 			return err
 		}
-		extraData, err := finality.DecodeExtra(header.Extra, isShillin)
+		extraData, err := finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
 		if err != nil {
 			return err
 		}
@@ -1097,9 +1100,15 @@ func (c *Consortium) SealHash(header *types.Header) common.Hash {
 		// FinalizeAndAssemble call.
 		copyHeader := types.CopyHeader(header)
 
-		extraData, _ := finality.DecodeExtra(copyHeader.Extra, true)
+		extraData, err := finality.DecodeExtraV2(copyHeader.Extra, c.chainConfig, header.Number)
+		if err != nil {
+			log.Error("Failed to decode header extra data", "err", err)
+		}
 		extraData.HasFinalityVote = 0
-		copyHeader.Extra = extraData.Encode(true)
+		copyHeader.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+		if err != nil {
+			log.Error("Failed to encode header extra data", "err", err)
+		}
 		return calculateSealHash(copyHeader, c.chainConfig.ChainID)
 	} else {
 		return calculateSealHash(header, c.chainConfig.ChainID)
@@ -1263,7 +1272,7 @@ func (c *Consortium) assembleFinalityVote(header *types.Header, snap *Snapshot)
 
 				bitSetCount := len(finalityVotedValidators.Indices())
 				if bitSetCount >= finalityThreshold {
-					extraData, err := finality.DecodeExtra(header.Extra, true)
+					extraData, err := finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
 					if err != nil {
 						// This should not happen
 						log.Error("Failed to decode header extra data", "err", err)
@@ -1272,7 +1281,11 @@ func (c *Consortium) assembleFinalityVote(header *types.Header, snap *Snapshot)
 					extraData.HasFinalityVote = 1
 					extraData.FinalityVotedValidators = finalityVotedValidators
 					extraData.AggregatedFinalityVotes = blst.AggregateSignatures(signatures)
-					header.Extra = extraData.Encode(true)
+					header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+					if err != nil {
+						log.Error("Failed to encode header extra data", "err", err)
+						return
+					}
 				}
 			}
 		}
diff --git a/consensus/consortium/v2/consortium_test.go b/consensus/consortium/v2/consortium_test.go
index 8c078f3c47..fdbdaca4c2 100644
--- a/consensus/consortium/v2/consortium_test.go
+++ b/consensus/consortium/v2/consortium_test.go
@@ -948,6 +948,7 @@ func TestAssembleFinalityVote(t *testing.T) {
 	c := Consortium{
 		chainConfig: &params.ChainConfig{
 			ShillinBlock: big.NewInt(0),
+			TrippBlock:   big.NewInt(100),
 		},
 		votePool: &mock,
 	}
@@ -962,12 +963,15 @@ func TestAssembleFinalityVote(t *testing.T) {
 
 	snap := newSnapshot(nil, nil, nil, 10, common.Hash{}, nil, validators, nil)
 
-	header := types.Header{Number: big.NewInt(5)}
+	header := types.Header{Number: big.NewInt(mrand.Int63n(int64(200)))}
 	extraData := &finality.HeaderExtraData{}
-	header.Extra = extraData.Encode(true)
+	header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+	if err != nil {
+		t.Fatalf("Failed to encode extra data, err: %s", err)
+	}
 	c.assembleFinalityVote(&header, snap)
 
-	extraData, err = finality.DecodeExtra(header.Extra, true)
+	extraData, err = finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
 	if err != nil {
 		t.Fatalf("Failed to decode extra data, err: %s", err)
 	}
@@ -1230,7 +1234,11 @@ func TestKnownBlockReorg(t *testing.T) {
 			bg.SetCoinbase(validatorAddrs[0])
 			bg.SetDifficulty(big.NewInt(7))
 			extra.CheckpointValidators = checkpointValidators
-			bg.SetExtra(extra.Encode(true))
+			enc, err := extra.EncodeV2(&chainConfig, bg.Number())
+			if err != nil {
+				t.Fatalf("Failed to encode header extra data, err: %s", err)
+			}
+			bg.SetExtra(enc)
 		},
 		true,
 		func(i int, bg *core.BlockGen) {
@@ -1322,7 +1330,11 @@ func TestKnownBlockReorg(t *testing.T) {
 				}
 
 				extra.AggregatedFinalityVotes = blst.AggregateSignatures(signatures)
-				bg.SetExtra(extra.Encode(true))
+				enc, err := extra.EncodeV2(&chainConfig, bg.Number())
+				if err != nil {
+					t.Fatalf("Failed to encode header extra data, err: %s", err)
+				}
+				bg.SetExtra(enc)
 			}
 
 			bg.SetDifficulty(big.NewInt(3))
diff --git a/consensus/consortium/v2/finality/consortium_header.go b/consensus/consortium/v2/finality/consortium_header.go
index 3602ab0d40..a4a16d9e8b 100644
--- a/consensus/consortium/v2/finality/consortium_header.go
+++ b/consensus/consortium/v2/finality/consortium_header.go
@@ -6,6 +6,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"errors"
+	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -68,11 +69,11 @@ var (
 	// target number
 	ErrInvalidTargetNumber = errors.New("invalid target number in vote")
 
-	// ErrNilAggregatedFinalityVotes is returned if the aggregated votes is nil
-	ErrNilAggregatedFinalityVotes = errors.New("aggregated finality votes is nil")
+	// ErrInvalidExtraData is returned if the bls public key is nil
+	ErrInvalidExtraData = errors.New("invalid header extra data")
 
-	// ErrNilBlsPublicKey is returned if the bls public key is nil
-	ErrNilBlsPublicKey = errors.New("bls public key is nil")
+	// ErrInvalidArgument  is returned if the chain config is nil
+	ErrInvalidArgument = errors.New("invalid argument")
 )
 
 type ValidatorWithBlsPub struct {
@@ -165,6 +166,26 @@ type HeaderExtraData struct {
 	Seal                    [ExtraSeal]byte       // the sealing block signature
 }
 
+func (extraData *HeaderExtraData) EncodeV2(chainConfig *params.ChainConfig, number *big.Int) ([]byte, error) {
+	if chainConfig == nil || number == nil {
+		return nil, ErrInvalidArgument
+	}
+	if chainConfig.IsTripp(number) {
+		return extraData.EncodeRLP()
+	}
+	return extraData.Encode(chainConfig.IsShillin(number)), nil
+}
+
+func DecodeExtraV2(enc []byte, chainConfig *params.ChainConfig, number *big.Int) (*HeaderExtraData, error) {
+	if chainConfig == nil || number == nil {
+		return nil, ErrInvalidArgument
+	}
+	if chainConfig.IsTripp(number) {
+		return DecodeExtraRLP(enc)
+	}
+	return DecodeExtra(enc, chainConfig.IsShillin(number))
+}
+
 func (extraData *HeaderExtraData) Encode(isShillin bool) []byte {
 	var rawBytes []byte
 
@@ -193,7 +214,7 @@ type extraDataRLP struct {
 	FinalityVotedValidators FinalityVoteBitSet
 	AggregatedFinalityVotes []byte
 	CheckpointValidators    []validatorWithBlsPubRLP
-	Seal                    [ExtraSeal]byte `rlp:"optional"`
+	Seal                    [ExtraSeal]byte
 }
 
 type validatorWithBlsPubRLP struct {
@@ -213,7 +234,7 @@ func (extraData *HeaderExtraData) EncodeRLP() ([]byte, error) {
 			Address: val.Address,
 		}
 		if val.BlsPublicKey == nil {
-			return nil, ErrNilBlsPublicKey
+			return nil, ErrInvalidExtraData
 		}
 		v.BlsPublicKey = val.BlsPublicKey.Marshal()
 		cp = append(cp, v)
@@ -225,7 +246,7 @@ func (extraData *HeaderExtraData) EncodeRLP() ([]byte, error) {
 	if extraData.HasFinalityVote == 1 {
 		ext.FinalityVotedValidators = extraData.FinalityVotedValidators
 		if extraData.AggregatedFinalityVotes == nil {
-			return nil, ErrNilAggregatedFinalityVotes
+			return nil, ErrInvalidExtraData
 		}
 		ext.AggregatedFinalityVotes = extraData.AggregatedFinalityVotes.Marshal()
 	}
diff --git a/consensus/consortium/v2/snapshot.go b/consensus/consortium/v2/snapshot.go
index 5931f0713a..1e586fb604 100644
--- a/consensus/consortium/v2/snapshot.go
+++ b/consensus/consortium/v2/snapshot.go
@@ -205,7 +205,7 @@ func (s *Snapshot) apply(headers []*types.Header, chain consensus.ChainHeaderRea
 		snap.Recents[number] = validator
 
 		if chain.Config().IsShillin(header.Number) {
-			extraData, err := finality.DecodeExtra(header.Extra, true)
+			extraData, err := finality.DecodeExtraV2(header.Extra, chain.Config(), header.Number)
 			if err != nil {
 				return nil, err
 			}
@@ -240,7 +240,7 @@ func (s *Snapshot) apply(headers []*types.Header, chain consensus.ChainHeaderRea
 			} else {
 				isShillin := chain.Config().IsShillin(checkpointHeader.Number)
 				// Get validator set from headers and use that for new validator set
-				extraData, err := finality.DecodeExtra(checkpointHeader.Extra, isShillin)
+				extraData, err := finality.DecodeExtraV2(checkpointHeader.Extra, chain.Config(), checkpointHeader.Number)
 				if err != nil {
 					return nil, err
 				}
diff --git a/crypto/bls/blst/public_key.go b/crypto/bls/blst/public_key.go
index 984b60165e..f543241057 100644
--- a/crypto/bls/blst/public_key.go
+++ b/crypto/bls/blst/public_key.go
@@ -4,7 +4,6 @@ package blst
 
 import (
 	"fmt"
-
 	"github.com/ethereum/go-ethereum/crypto/bls/common"
 	"github.com/ethereum/go-ethereum/params"
 	lru "github.com/hashicorp/golang-lru"
diff --git a/monitor/finality_vote.go b/monitor/finality_vote.go
index 6edd7af64a..c833f1bc10 100644
--- a/monitor/finality_vote.go
+++ b/monitor/finality_vote.go
@@ -64,7 +64,7 @@ func prettyPrintAddress(addresses []common.Address) string {
 }
 
 func (monitor *FinalityVoteMonitor) CheckFinalityVote(block *types.Block) error {
-	extraData, err := finality.DecodeExtra(block.Extra(), true)
+	extraData, err := finality.DecodeExtraV2(block.Extra(), monitor.chain.Config(), block.Number())
 	// This should not happen because the block has been verified
 	if err != nil {
 		log.Error("Unexpected error when decode extradata", "err", err)

From fb5c83e96f33ff6ea571b616b2e089142319999e Mon Sep 17 00:00:00 2001
From: andicrypt <keepgoing0901@gmail.com>
Date: Thu, 14 Mar 2024 17:17:45 +0700
Subject: [PATCH 3/5] consortium-v2: optimize extra data rlp encoding

---
 consensus/consortium/v2/consortium_test.go    | 153 +++++++++---
 .../v2/finality/consortium_header.go          | 218 ++++++++++--------
 2 files changed, 237 insertions(+), 134 deletions(-)

diff --git a/consensus/consortium/v2/consortium_test.go b/consensus/consortium/v2/consortium_test.go
index fdbdaca4c2..c4dba90f75 100644
--- a/consensus/consortium/v2/consortium_test.go
+++ b/consensus/consortium/v2/consortium_test.go
@@ -7,7 +7,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"math/big"
-	mrand "math/rand"
 	"testing"
 	"time"
 
@@ -534,36 +533,27 @@ func TestExtraDataDecode(t *testing.T) {
 
 func mockExtraData(nVal int, bits uint32) *finality.HeaderExtraData {
 	var (
-		vanity                  = make([]byte, finality.ExtraVanity)
-		hasFinalityVote         uint8
 		finalityVotedValidators finality.FinalityVoteBitSet
 		aggregatedFinalityVotes blsCommon.Signature
-		checkpointValidators    = make([]finality.ValidatorWithBlsPub, 0, nVal)
+		checkpointValidators    []finality.ValidatorWithBlsPub
 		seal                    = make([]byte, finality.ExtraSeal)
+		ret                     = &finality.HeaderExtraData{}
 	)
-	ret := &finality.HeaderExtraData{}
-
-	hasFinalityVote = uint8(mrand.Intn(2))
-	ret.HasFinalityVote = hasFinalityVote
-
-	if ret.HasFinalityVote == 1 {
-		finalityVotedValidators = finality.FinalityVoteBitSet(mrand.Uint64())
-		ret.FinalityVotedValidators = finalityVotedValidators
-
-		delegated, _ := blst.RandKey()
-		msg := make([]byte, 64)
-		rand.Read(msg)
-		aggregatedFinalityVotes = delegated.Sign(msg)
-		ret.AggregatedFinalityVotes = aggregatedFinalityVotes
-	}
 
 	bits = bits % 7 // ensure bits can be represented by 3-bit integer
 	for i := 0; i < 3; i++ {
 		if bits&(1<<i) != 0 {
 			switch i {
 			case 0:
-				rand.Read(vanity)
-				ret.Vanity = [finality.ExtraVanity]byte(vanity)
+				ret.HasFinalityVote = 1
+				finalityVotedValidators = finality.FinalityVoteBitSet(uint64(8))
+				ret.FinalityVotedValidators = finalityVotedValidators
+
+				delegated, _ := blst.RandKey()
+				msg := make([]byte, 64)
+				rand.Read(msg)
+				aggregatedFinalityVotes = delegated.Sign(msg)
+				ret.AggregatedFinalityVotes = aggregatedFinalityVotes
 			case 1:
 				for i := 0; i < nVal; i++ {
 					s, _ := blst.RandKey()
@@ -577,6 +567,8 @@ func mockExtraData(nVal int, bits uint32) *finality.HeaderExtraData {
 				}
 				ret.CheckpointValidators = checkpointValidators
 			case 2:
+				// Even seal does not get assigned a random value, seal
+				// is still be zero-filled byte array of size ExtraSeal
 				rand.Read(seal)
 				ret.Seal = [finality.ExtraSeal]byte(seal)
 			}
@@ -589,10 +581,13 @@ func TestExtraDataEncodeRLP(t *testing.T) {
 	nVal := 22
 	for i := 0; i < 7; i++ {
 		ext := mockExtraData(nVal, uint32(i))
-		_, err := ext.EncodeRLP()
+		enc, err := ext.EncodeRLP()
 		if err != nil {
 			t.Errorf("encode rlp error: %v", err)
 		}
+		if len(enc) < finality.ExtraSeal {
+			t.Error("encode rlp error: invalid length of encoded data")
+		}
 	}
 }
 
@@ -612,9 +607,6 @@ func TestExtraDataDecodeRLP(t *testing.T) {
 		if !bytes.Equal(dec.Vanity[:], ext.Vanity[:]) {
 			t.Errorf("Mismatched decoded data")
 		}
-		if dec.HasFinalityVote != ext.HasFinalityVote {
-			t.Errorf("Mismatch decoded data")
-		}
 		if dec.FinalityVotedValidators != ext.FinalityVotedValidators {
 			t.Errorf("Mismatch decoded data")
 		}
@@ -910,6 +902,106 @@ func (votePool *mockVotePool) FetchVoteByBlockHash(hash common.Hash) []*types.Vo
 	return votePool.vote
 }
 
+func TestAssembleFinalityVoteV2(t *testing.T) {
+	nVoted := 9
+	var err error
+	secretKeys := make([]blsCommon.SecretKey, 10)
+	for i := 0; i < len(secretKeys); i++ {
+		secretKeys[i], err = blst.RandKey()
+		if err != nil {
+			t.Fatalf("Failed to generate secret key, err: %s", err)
+		}
+	}
+
+	voteData := types.VoteData{
+		TargetNumber: 4,
+		TargetHash:   common.Hash{0x1},
+	}
+	digest := voteData.Hash()
+
+	signatures := make([]blsCommon.Signature, 10)
+	for i := 0; i < len(signatures); i++ {
+		signatures[i] = secretKeys[i].Sign(digest[:])
+	}
+
+	var votes []*types.VoteEnvelope
+	for i := 0; i < 10; i++ {
+		votes = append(votes, &types.VoteEnvelope{
+			RawVoteEnvelope: types.RawVoteEnvelope{
+				PublicKey: types.BLSPublicKey(secretKeys[i].PublicKey().Marshal()),
+				Signature: types.BLSSignature(signatures[i].Marshal()),
+				Data:      &voteData,
+			},
+		})
+	}
+
+	c := Consortium{
+		chainConfig: &params.ChainConfig{
+			ShillinBlock: big.NewInt(0),
+			TrippBlock:   big.NewInt(10),
+		},
+		votePool: &mockVotePool{
+			vote: votes,
+		},
+	}
+
+	var validators []finality.ValidatorWithBlsPub
+	for i := 0; i < nVoted; i++ {
+		validators = append(validators, finality.ValidatorWithBlsPub{
+			Address:      common.BigToAddress(big.NewInt(int64(i))),
+			BlsPublicKey: secretKeys[i].PublicKey(),
+		})
+	}
+
+	snap := newSnapshot(nil, nil, nil, 10, common.Hash{}, nil, validators, nil)
+
+	// iterate through 3 blocks (ranging from 9-12, which corresponds to Tripp hardfork, at block 10)
+	// to ensure the reliability of the rlp switch after Tripp hardfork.
+	for i := 9; i < 12; i++ {
+		header := types.Header{Number: big.NewInt(int64(i))}
+		extraData := &finality.HeaderExtraData{}
+		header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
+		if err != nil {
+			t.Fatalf("Failed to encode rlp extra data, err: %s", err)
+		}
+	
+		c.assembleFinalityVote(&header, snap)
+	
+		extraData, err = finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
+		if err != nil {
+			t.Fatalf("Failed to decode extra data, err: %s", err)
+		}
+	
+		if extraData.HasFinalityVote != 1 {
+			t.Fatal("Missing finality vote in header")
+		}
+	
+		bitSet := finality.FinalityVoteBitSet(0)
+		for i := 0; i < nVoted; i++ {
+			bitSet.SetBit(i)
+		}
+	
+		if uint64(bitSet) != uint64(extraData.FinalityVotedValidators) {
+			t.Fatalf(
+				"Mismatch voted validator, expect %d have %d",
+				uint64(bitSet),
+				uint64(extraData.FinalityVotedValidators),
+			)
+		}
+	
+		var includedSignatures []blsCommon.Signature
+		for i := 0; i < nVoted; i++ {
+			includedSignatures = append(includedSignatures, signatures[i])
+		}
+	
+		aggregatedSignature := blst.AggregateSignatures(includedSignatures)
+	
+		if !bytes.Equal(aggregatedSignature.Marshal(), extraData.AggregatedFinalityVotes.Marshal()) {
+			t.Fatal("Mismatch signature")
+		}
+	}
+}
+
 func TestAssembleFinalityVote(t *testing.T) {
 	var err error
 	secretKeys := make([]blsCommon.SecretKey, 10)
@@ -948,7 +1040,6 @@ func TestAssembleFinalityVote(t *testing.T) {
 	c := Consortium{
 		chainConfig: &params.ChainConfig{
 			ShillinBlock: big.NewInt(0),
-			TrippBlock:   big.NewInt(100),
 		},
 		votePool: &mock,
 	}
@@ -963,15 +1054,13 @@ func TestAssembleFinalityVote(t *testing.T) {
 
 	snap := newSnapshot(nil, nil, nil, 10, common.Hash{}, nil, validators, nil)
 
-	header := types.Header{Number: big.NewInt(mrand.Int63n(int64(200)))}
+	header := types.Header{Number: big.NewInt(5)}
 	extraData := &finality.HeaderExtraData{}
-	header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
-	if err != nil {
-		t.Fatalf("Failed to encode extra data, err: %s", err)
-	}
+	header.Extra = extraData.Encode(true)
+
 	c.assembleFinalityVote(&header, snap)
 
-	extraData, err = finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
+	extraData, err = finality.DecodeExtra(header.Extra, true)
 	if err != nil {
 		t.Fatalf("Failed to decode extra data, err: %s", err)
 	}
diff --git a/consensus/consortium/v2/finality/consortium_header.go b/consensus/consortium/v2/finality/consortium_header.go
index a4a16d9e8b..9bb4640ebf 100644
--- a/consensus/consortium/v2/finality/consortium_header.go
+++ b/consensus/consortium/v2/finality/consortium_header.go
@@ -72,8 +72,10 @@ var (
 	// ErrInvalidExtraData is returned if the bls public key is nil
 	ErrInvalidExtraData = errors.New("invalid header extra data")
 
-	// ErrInvalidArgument  is returned if the chain config is nil
+	// ErrInvalidArgument is returned if the chain config is nil
 	ErrInvalidArgument = errors.New("invalid argument")
+
+	ErrInvalidEncodedExtraData = errors.New("invalid encoded extra data")
 )
 
 type ValidatorWithBlsPub struct {
@@ -166,26 +168,6 @@ type HeaderExtraData struct {
 	Seal                    [ExtraSeal]byte       // the sealing block signature
 }
 
-func (extraData *HeaderExtraData) EncodeV2(chainConfig *params.ChainConfig, number *big.Int) ([]byte, error) {
-	if chainConfig == nil || number == nil {
-		return nil, ErrInvalidArgument
-	}
-	if chainConfig.IsTripp(number) {
-		return extraData.EncodeRLP()
-	}
-	return extraData.Encode(chainConfig.IsShillin(number)), nil
-}
-
-func DecodeExtraV2(enc []byte, chainConfig *params.ChainConfig, number *big.Int) (*HeaderExtraData, error) {
-	if chainConfig == nil || number == nil {
-		return nil, ErrInvalidArgument
-	}
-	if chainConfig.IsTripp(number) {
-		return DecodeExtraRLP(enc)
-	}
-	return DecodeExtra(enc, chainConfig.IsShillin(number))
-}
-
 func (extraData *HeaderExtraData) Encode(isShillin bool) []byte {
 	var rawBytes []byte
 
@@ -208,87 +190,6 @@ func (extraData *HeaderExtraData) Encode(isShillin bool) []byte {
 	return rawBytes
 }
 
-type extraDataRLP struct {
-	Vanity                  [ExtraVanity]byte
-	HasFinalityVote         uint8
-	FinalityVotedValidators FinalityVoteBitSet
-	AggregatedFinalityVotes []byte
-	CheckpointValidators    []validatorWithBlsPubRLP
-	Seal                    [ExtraSeal]byte
-}
-
-type validatorWithBlsPubRLP struct {
-	Address      common.Address
-	BlsPublicKey []byte
-}
-
-func (extraData *HeaderExtraData) EncodeRLP() ([]byte, error) {
-	ext := &extraDataRLP{
-		Vanity:          extraData.Vanity,
-		HasFinalityVote: extraData.HasFinalityVote,
-		Seal:            extraData.Seal,
-	}
-	cp := make([]validatorWithBlsPubRLP, 0)
-	for _, val := range extraData.CheckpointValidators {
-		v := validatorWithBlsPubRLP{
-			Address: val.Address,
-		}
-		if val.BlsPublicKey == nil {
-			return nil, ErrInvalidExtraData
-		}
-		v.BlsPublicKey = val.BlsPublicKey.Marshal()
-		cp = append(cp, v)
-	}
-	ext.CheckpointValidators = cp
-	if extraData.HasFinalityVote != 0 && extraData.HasFinalityVote != 1 {
-		return nil, ErrInvalidHasFinalityVote
-	}
-	if extraData.HasFinalityVote == 1 {
-		ext.FinalityVotedValidators = extraData.FinalityVotedValidators
-		if extraData.AggregatedFinalityVotes == nil {
-			return nil, ErrInvalidExtraData
-		}
-		ext.AggregatedFinalityVotes = extraData.AggregatedFinalityVotes.Marshal()
-	}
-	return rlp.EncodeToBytes(ext)
-}
-
-func DecodeExtraRLP(enc []byte) (*HeaderExtraData, error) {
-	var err error
-	dec := &extraDataRLP{}
-	if err := rlp.DecodeBytes(enc, dec); err != nil {
-		return nil, err
-	}
-	ret := &HeaderExtraData{
-		Vanity:          dec.Vanity,
-		HasFinalityVote: dec.HasFinalityVote,
-		Seal:            dec.Seal,
-	}
-	cp := make([]ValidatorWithBlsPub, 0)
-	for _, val := range dec.CheckpointValidators {
-		v := ValidatorWithBlsPub{
-			Address: val.Address,
-		}
-		v.BlsPublicKey, err = blst.PublicKeyFromBytes(val.BlsPublicKey)
-		if err != nil {
-			return nil, err
-		}
-		cp = append(cp, v)
-	}
-	ret.CheckpointValidators = cp
-	if dec.HasFinalityVote != 1 && dec.HasFinalityVote != 0 {
-		return nil, ErrInvalidHasFinalityVote
-	}
-	if dec.HasFinalityVote == 1 {
-		ret.FinalityVotedValidators = dec.FinalityVotedValidators
-		ret.AggregatedFinalityVotes, err = blst.SignatureFromBytes(dec.AggregatedFinalityVotes)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return ret, nil
-}
-
 func DecodeExtra(rawBytes []byte, isShillin bool) (*HeaderExtraData, error) {
 	var (
 		extraData       HeaderExtraData
@@ -357,6 +258,119 @@ func DecodeExtra(rawBytes []byte, isShillin bool) (*HeaderExtraData, error) {
 	return &extraData, nil
 }
 
+// extraDataRLP excludes vanity, hasFinalityVotes because vanity is not used in
+// Consortium and filled with zero by default; whereas hasFinalityVotes can be determined
+// by AggregatedFinalityVotes and FinalityVotedValidators. On the other hand, seal is 
+// appended manually, enabling encodeSigHeader easily to exclude Seal before signing process
+type extraDataRLP struct {
+	FinalityVotedValidators FinalityVoteBitSet
+	AggregatedFinalityVotes []byte
+	CheckpointValidators    []validatorWithBlsPubRLP
+}
+
+type validatorWithBlsPubRLP struct {
+	Address      common.Address
+	BlsPublicKey []byte
+}
+
+// EncodeRLP computes rlp-based encoding for HeaderExtraData before
+// appending Seal manually, enabling encodeSigHeader easily to exclude
+// Seal before signing process.
+func (extraData *HeaderExtraData) EncodeRLP() ([]byte, error) {
+	var ext = &extraDataRLP{}
+	if extraData.HasFinalityVote != 0 && extraData.HasFinalityVote != 1 {
+		return nil, ErrInvalidHasFinalityVote
+	}
+	if extraData.HasFinalityVote == 1 {
+		if extraData.AggregatedFinalityVotes == nil || len(extraData.FinalityVotedValidators.Indices()) == 0 {
+			return nil, ErrInvalidExtraData
+		}
+		ext.FinalityVotedValidators = extraData.FinalityVotedValidators
+		ext.AggregatedFinalityVotes = extraData.AggregatedFinalityVotes.Marshal()
+	}
+
+	cp := make([]validatorWithBlsPubRLP, len(extraData.CheckpointValidators))
+	for i, val := range extraData.CheckpointValidators {
+		if val.BlsPublicKey == nil {
+			return nil, ErrInvalidExtraData
+		}
+		cp[i] = validatorWithBlsPubRLP{
+			Address:      val.Address,
+			BlsPublicKey: val.BlsPublicKey.Marshal(),
+		}
+	}
+	ext.CheckpointValidators = cp
+
+	enc, err := rlp.EncodeToBytes(ext)
+	if err != nil {
+		return nil, err
+	}
+	// Seal is appended at the end of the raw bytes data
+	rawBytes := append(enc, extraData.Seal[:]...)
+	return rawBytes, nil
+}
+
+// DecodeExtraRLP decodes HeaderExtraData from bytes. It is necessary to exclude
+// the last ExtraSeal bytes before rlp-decoding, as Seal is not rlp encoded.
+func DecodeExtraRLP(enc []byte) (*HeaderExtraData, error) {
+	var (
+		err error
+		dec = &extraDataRLP{}
+		ret = &HeaderExtraData{}
+	)
+	if len(enc) < ExtraSeal {
+		return nil, ErrInvalidEncodedExtraData
+	}
+	// Exclude the seal before rlp decoding.
+	if err := rlp.DecodeBytes(enc[:len(enc)-ExtraSeal], dec); err != nil {
+		return nil, err
+	}
+	cp := make([]ValidatorWithBlsPub, len(dec.CheckpointValidators))
+	for i, val := range dec.CheckpointValidators {
+		blsPublicKey, err := blst.PublicKeyFromBytes(val.BlsPublicKey)
+		if err != nil {
+			return nil, err
+		}
+		cp[i] = ValidatorWithBlsPub{
+			Address:      val.Address,
+			BlsPublicKey: blsPublicKey,
+		}
+	}
+	ret.CheckpointValidators = cp
+	if len(dec.AggregatedFinalityVotes) != 0 && len(dec.FinalityVotedValidators.Indices()) != 0 {
+		ret.HasFinalityVote = 1
+		ret.FinalityVotedValidators = dec.FinalityVotedValidators
+		ret.AggregatedFinalityVotes, err = blst.SignatureFromBytes(dec.AggregatedFinalityVotes)
+		if err != nil {
+			return nil, err
+		}
+	}
+	copy(ret.Seal[:], enc[len(enc)-ExtraSeal:])
+	return ret, nil
+}
+
+// After Tripp, HeaderExtraData switches to use RLP encoding method
+func (extraData *HeaderExtraData) EncodeV2(chainConfig *params.ChainConfig, number *big.Int) ([]byte, error) {
+	if chainConfig == nil || number == nil {
+		return nil, ErrInvalidArgument
+	}
+	if chainConfig.IsTripp(number) {
+		return extraData.EncodeRLP()
+	}
+	return extraData.Encode(chainConfig.IsShillin(number)), nil
+}
+
+// After Tripp, HeaderExtraData switches to use RLP decoding method
+func DecodeExtraV2(enc []byte, chainConfig *params.ChainConfig, number *big.Int) (*HeaderExtraData, error) {
+	if chainConfig == nil || number == nil {
+		return nil, ErrInvalidArgument
+	}
+	if chainConfig.IsTripp(number) {
+		return DecodeExtraRLP(enc)
+	}
+	return DecodeExtra(enc, chainConfig.IsShillin(number))
+}
+
 // ParseCheckpointData retrieves the list of validator addresses and finality voter's public keys
 // at the checkpoint block
 func ParseCheckpointData(checkpointData []byte, isShillin bool) ([]ValidatorWithBlsPub, error) {

From 13bc6090b476d010f1dc930c29404364ba95c913 Mon Sep 17 00:00:00 2001
From: andicrypt <keepgoing0901@gmail.com>
Date: Tue, 19 Mar 2024 16:25:20 +0700
Subject: [PATCH 4/5] consortium-v2: benchmark for new rlp encoding

---
 consensus/consortium/v2/consortium_test.go | 49 ++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/consensus/consortium/v2/consortium_test.go b/consensus/consortium/v2/consortium_test.go
index c4dba90f75..64662f5f12 100644
--- a/consensus/consortium/v2/consortium_test.go
+++ b/consensus/consortium/v2/consortium_test.go
@@ -7,6 +7,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"math/big"
+	"strconv"
 	"testing"
 	"time"
 
@@ -642,6 +643,54 @@ func TestExtraDataDecodeRLP(t *testing.T) {
 	}
 }
 
+func TestEncodedSize(t *testing.T) {
+	nVal := 22
+	for i := 0; i < 7; i++ {
+		ext := mockExtraData(nVal, uint32(i))
+		old := ext.Encode(true)
+		new, _ := ext.EncodeRLP()
+		t.Logf("binary: %v, original: %v; new: %v", strconv.FormatInt(int64(i), 2), len(old), len(new))
+	}
+}
+
+func BenchmarkEncodeRLP(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ext.EncodeRLP()
+	}
+}
+
+func BenchmarkEncode(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ext.Encode(true)
+	}
+}
+
+func BenchmarkDecodeRLP(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	dec, _ := ext.EncodeRLP()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		finality.DecodeExtraRLP(dec)
+	}
+}
+
+func BenchmarkDecode(b *testing.B) {
+	nVal := 22
+	ext := mockExtraData(nVal, 7)
+	dec := ext.Encode(true)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		finality.DecodeExtra(dec, true)
+	}
+}
+
 func TestVerifyFinalitySignature(t *testing.T) {
 	const numValidator = 3
 	var err error

From 13f9be0a26dd3fffbfd196ec7d738295e179ee61 Mon Sep 17 00:00:00 2001
From: Bui Quang Minh <minh.bui@skymavis.com>
Date: Wed, 20 Mar 2024 14:29:30 +0700
Subject: [PATCH 5/5] consortium-v2: clean up unit test

---
 consensus/consortium/v2/consortium_test.go | 139 +++------------------
 1 file changed, 19 insertions(+), 120 deletions(-)

diff --git a/consensus/consortium/v2/consortium_test.go b/consensus/consortium/v2/consortium_test.go
index 64662f5f12..fe345a4918 100644
--- a/consensus/consortium/v2/consortium_test.go
+++ b/consensus/consortium/v2/consortium_test.go
@@ -6,8 +6,8 @@ import (
 	"crypto/rand"
 	"encoding/binary"
 	"errors"
+	"io"
 	"math/big"
-	"strconv"
 	"testing"
 	"time"
 
@@ -590,6 +590,13 @@ func TestExtraDataEncodeRLP(t *testing.T) {
 			t.Error("encode rlp error: invalid length of encoded data")
 		}
 	}
+
+	var extraData finality.HeaderExtraData
+	extraData.HasFinalityVote = 2
+	_, err := extraData.EncodeRLP()
+	if !errors.Is(err, finality.ErrInvalidHasFinalityVote) {
+		t.Fatalf("Expect error: %s, got: %s", finality.ErrInvalidHasFinalityVote, err)
+	}
 }
 
 func TestExtraDataDecodeRLP(t *testing.T) {
@@ -641,15 +648,16 @@ func TestExtraDataDecodeRLP(t *testing.T) {
 			t.Errorf("Mismatch decoded data")
 		}
 	}
-}
 
-func TestEncodedSize(t *testing.T) {
-	nVal := 22
-	for i := 0; i < 7; i++ {
-		ext := mockExtraData(nVal, uint32(i))
-		old := ext.Encode(true)
-		new, _ := ext.EncodeRLP()
-		t.Logf("binary: %v, original: %v; new: %v", strconv.FormatInt(int64(i), 2), len(old), len(new))
+	_, err := finality.DecodeExtraRLP([]byte{})
+	if !errors.Is(err, finality.ErrInvalidEncodedExtraData) {
+		t.Fatalf("Expect error: %s, got: %s", finality.ErrInvalidEncodedExtraData, err)
+	}
+
+	encodedData := [finality.ExtraSeal]byte{}
+	_, err = finality.DecodeExtraRLP(encodedData[:])
+	if !errors.Is(err, io.EOF) {
+		t.Fatalf("Expect error: %s, got: %s", io.EOF, err)
 	}
 }
 
@@ -951,106 +959,6 @@ func (votePool *mockVotePool) FetchVoteByBlockHash(hash common.Hash) []*types.Vo
 	return votePool.vote
 }
 
-func TestAssembleFinalityVoteV2(t *testing.T) {
-	nVoted := 9
-	var err error
-	secretKeys := make([]blsCommon.SecretKey, 10)
-	for i := 0; i < len(secretKeys); i++ {
-		secretKeys[i], err = blst.RandKey()
-		if err != nil {
-			t.Fatalf("Failed to generate secret key, err: %s", err)
-		}
-	}
-
-	voteData := types.VoteData{
-		TargetNumber: 4,
-		TargetHash:   common.Hash{0x1},
-	}
-	digest := voteData.Hash()
-
-	signatures := make([]blsCommon.Signature, 10)
-	for i := 0; i < len(signatures); i++ {
-		signatures[i] = secretKeys[i].Sign(digest[:])
-	}
-
-	var votes []*types.VoteEnvelope
-	for i := 0; i < 10; i++ {
-		votes = append(votes, &types.VoteEnvelope{
-			RawVoteEnvelope: types.RawVoteEnvelope{
-				PublicKey: types.BLSPublicKey(secretKeys[i].PublicKey().Marshal()),
-				Signature: types.BLSSignature(signatures[i].Marshal()),
-				Data:      &voteData,
-			},
-		})
-	}
-
-	c := Consortium{
-		chainConfig: &params.ChainConfig{
-			ShillinBlock: big.NewInt(0),
-			TrippBlock:   big.NewInt(10),
-		},
-		votePool: &mockVotePool{
-			vote: votes,
-		},
-	}
-
-	var validators []finality.ValidatorWithBlsPub
-	for i := 0; i < nVoted; i++ {
-		validators = append(validators, finality.ValidatorWithBlsPub{
-			Address:      common.BigToAddress(big.NewInt(int64(i))),
-			BlsPublicKey: secretKeys[i].PublicKey(),
-		})
-	}
-
-	snap := newSnapshot(nil, nil, nil, 10, common.Hash{}, nil, validators, nil)
-
-	// iterate through 3 blocks (ranging from 9-12, which corresponds to Tripp hardfork, at block 10)
-	// to ensure the reliability of the rlp switch after Tripp hardfork.
-	for i := 9; i < 12; i++ {
-		header := types.Header{Number: big.NewInt(int64(i))}
-		extraData := &finality.HeaderExtraData{}
-		header.Extra, err = extraData.EncodeV2(c.chainConfig, header.Number)
-		if err != nil {
-			t.Fatalf("Failed to encode rlp extra data, err: %s", err)
-		}
-	
-		c.assembleFinalityVote(&header, snap)
-	
-		extraData, err = finality.DecodeExtraV2(header.Extra, c.chainConfig, header.Number)
-		if err != nil {
-			t.Fatalf("Failed to decode extra data, err: %s", err)
-		}
-	
-		if extraData.HasFinalityVote != 1 {
-			t.Fatal("Missing finality vote in header")
-		}
-	
-		bitSet := finality.FinalityVoteBitSet(0)
-		for i := 0; i < nVoted; i++ {
-			bitSet.SetBit(i)
-		}
-	
-		if uint64(bitSet) != uint64(extraData.FinalityVotedValidators) {
-			t.Fatalf(
-				"Mismatch voted validator, expect %d have %d",
-				uint64(bitSet),
-				uint64(extraData.FinalityVotedValidators),
-			)
-		}
-	
-		var includedSignatures []blsCommon.Signature
-		for i := 0; i < nVoted; i++ {
-			includedSignatures = append(includedSignatures, signatures[i])
-		}
-	
-		aggregatedSignature := blst.AggregateSignatures(includedSignatures)
-	
-		if !bytes.Equal(aggregatedSignature.Marshal(), extraData.AggregatedFinalityVotes.Marshal()) {
-			t.Fatal("Mismatch signature")
-		}
-	}
-}
-
 func TestAssembleFinalityVote(t *testing.T) {
 	var err error
 	secretKeys := make([]blsCommon.SecretKey, 10)
@@ -1106,7 +1014,6 @@ func TestAssembleFinalityVote(t *testing.T) {
 	header := types.Header{Number: big.NewInt(5)}
 	extraData := &finality.HeaderExtraData{}
 	header.Extra = extraData.Encode(true)
-
 	c.assembleFinalityVote(&header, snap)
 
 	extraData, err = finality.DecodeExtra(header.Extra, true)
@@ -1372,11 +1279,7 @@ func TestKnownBlockReorg(t *testing.T) {
 			bg.SetCoinbase(validatorAddrs[0])
 			bg.SetDifficulty(big.NewInt(7))
 			extra.CheckpointValidators = checkpointValidators
-			enc, err := extra.EncodeV2(&chainConfig, bg.Number())
-			if err != nil {
-				t.Fatalf("Failed to encode header extra data, err: %s", err)
-			}
-			bg.SetExtra(enc)
+			bg.SetExtra(extra.Encode(true))
 		},
 		true,
 		func(i int, bg *core.BlockGen) {
@@ -1468,11 +1371,7 @@ func TestKnownBlockReorg(t *testing.T) {
 				}
 
 				extra.AggregatedFinalityVotes = blst.AggregateSignatures(signatures)
-				enc, err := extra.EncodeV2(&chainConfig, bg.Number())
-				if err != nil {
-					t.Fatalf("Failed to encode header extra data, err: %s", err)
-				}
-				bg.SetExtra(enc)
+				bg.SetExtra(extra.Encode(true))
 			}
 
 			bg.SetDifficulty(big.NewInt(3))