mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-06-19 21:31:37 +00:00
db9c3de1dc
* add syncinfo message into pool for process later * add missing file back --------- Co-authored-by: liam.lai <liam.lai@us>
295 lines
10 KiB
Go
295 lines
10 KiB
Go
package engine_v2_tests
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
"testing"
|
|
|
|
"github.com/XinFinOrg/XDPoSChain/common"
|
|
"github.com/XinFinOrg/XDPoSChain/consensus/XDPoS"
|
|
"github.com/XinFinOrg/XDPoSChain/consensus/XDPoS/utils"
|
|
"github.com/XinFinOrg/XDPoSChain/core/types"
|
|
"github.com/XinFinOrg/XDPoSChain/params"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestSyncInfoShouldSuccessfullyUpdateByQC(t *testing.T) {
|
|
// Block 901 is the first v2 block with starting round of 0
|
|
blockchain, _, currentBlock, _, _, _ := PrepareXDCTestBlockChainForV2Engine(t, 905, params.TestXDPoSMockChainConfig, nil)
|
|
engineV2 := blockchain.Engine().(*XDPoS.XDPoS).EngineV2
|
|
|
|
var extraField types.ExtraFields_v2
|
|
err := utils.DecodeBytesExtraFields(currentBlock.Extra(), &extraField)
|
|
if err != nil {
|
|
t.Fatal("Fail to decode extra data", err)
|
|
}
|
|
|
|
timeoutForSign := &types.TimeoutForSign{
|
|
Round: types.Round(2),
|
|
GapNumber: 450,
|
|
}
|
|
|
|
// Sign from acc 1, 2, 3 and voter
|
|
acc1SignedHash := SignHashByPK(acc1Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc2SignedHash := SignHashByPK(acc2Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc3SignedHash := SignHashByPK(acc3Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
voterSignedHash := SignHashByPK(voterKey, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
|
|
var signatures []types.Signature
|
|
signatures = append(signatures, acc1SignedHash, acc2SignedHash, acc3SignedHash, voterSignedHash)
|
|
|
|
syncInfoMsg := &types.SyncInfo{
|
|
HighestQuorumCert: extraField.QuorumCert,
|
|
HighestTimeoutCert: &types.TimeoutCert{
|
|
Round: types.Round(2),
|
|
Signatures: signatures,
|
|
GapNumber: 450,
|
|
},
|
|
}
|
|
|
|
err = engineV2.SyncInfoHandler(blockchain, syncInfoMsg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
round, _, highestQuorumCert, _, _, highestCommitBlock := engineV2.GetPropertiesFaker()
|
|
// QC is parent block's qc, which is pointing at round 4, hence 4 + 1 = 5
|
|
assert.Equal(t, types.Round(5), round)
|
|
assert.Equal(t, extraField.QuorumCert, highestQuorumCert)
|
|
assert.Equal(t, types.Round(2), highestCommitBlock.Round)
|
|
assert.Equal(t, big.NewInt(902), highestCommitBlock.Number)
|
|
}
|
|
|
|
func TestSyncInfoShouldSuccessfullyUpdateByTC(t *testing.T) {
|
|
// Block 901 is the first v2 block with starting round of 0
|
|
blockchain, _, currentBlock, _, _, _ := PrepareXDCTestBlockChainForV2Engine(t, 905, params.TestXDPoSMockChainConfig, nil)
|
|
engineV2 := blockchain.Engine().(*XDPoS.XDPoS).EngineV2
|
|
|
|
var extraField types.ExtraFields_v2
|
|
err := utils.DecodeBytesExtraFields(currentBlock.Extra(), &extraField)
|
|
if err != nil {
|
|
t.Fatal("Fail to decode extra data", err)
|
|
}
|
|
|
|
timeoutForSign := &types.TimeoutForSign{
|
|
Round: types.Round(6),
|
|
GapNumber: 450,
|
|
}
|
|
|
|
// Sign from acc 1, 2, 3 and voter
|
|
acc1SignedHash := SignHashByPK(acc1Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc2SignedHash := SignHashByPK(acc2Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc3SignedHash := SignHashByPK(acc3Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
voterSignedHash := SignHashByPK(voterKey, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
|
|
var signatures []types.Signature
|
|
signatures = append(signatures, acc1SignedHash, acc2SignedHash, acc3SignedHash, voterSignedHash)
|
|
|
|
highestTC := &types.TimeoutCert{
|
|
Round: types.Round(6),
|
|
Signatures: signatures,
|
|
GapNumber: 450,
|
|
}
|
|
|
|
syncInfoMsg := &types.SyncInfo{
|
|
HighestQuorumCert: extraField.QuorumCert,
|
|
HighestTimeoutCert: highestTC,
|
|
}
|
|
|
|
err = engineV2.SyncInfoHandler(blockchain, syncInfoMsg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
round, _, highestQuorumCert, _, _, _ := engineV2.GetPropertiesFaker()
|
|
assert.Equal(t, types.Round(7), round)
|
|
assert.Equal(t, extraField.QuorumCert, highestQuorumCert)
|
|
}
|
|
|
|
func TestSkipVerifySyncInfoIfBothQcTcNotQualified(t *testing.T) {
|
|
blockchain, _, _, _, _, _ := PrepareXDCTestBlockChainForV2Engine(t, 905, params.TestXDPoSMockChainConfig, nil)
|
|
engineV2 := blockchain.Engine().(*XDPoS.XDPoS).EngineV2
|
|
|
|
// Make the Highest QC in syncInfo point to an old block to simulate it's no longer qualified
|
|
parentBlock := blockchain.GetBlockByNumber(903)
|
|
var extraField types.ExtraFields_v2
|
|
err := utils.DecodeBytesExtraFields(parentBlock.Extra(), &extraField)
|
|
if err != nil {
|
|
t.Fatal("Fail to decode extra data", err)
|
|
}
|
|
|
|
highestTC := &types.TimeoutCert{
|
|
Round: types.Round(5),
|
|
Signatures: []types.Signature{},
|
|
}
|
|
|
|
syncInfoMsg := &types.SyncInfo{
|
|
HighestQuorumCert: extraField.QuorumCert,
|
|
HighestTimeoutCert: highestTC,
|
|
}
|
|
|
|
engineV2.SetPropertiesFaker(syncInfoMsg.HighestQuorumCert, syncInfoMsg.HighestTimeoutCert)
|
|
|
|
verified, err := engineV2.VerifySyncInfoMessage(blockchain, syncInfoMsg)
|
|
assert.False(t, verified)
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestVerifySyncInfoIfTCRoundIsAtNextEpoch(t *testing.T) {
|
|
blockchain, _, _, _, _, _ := PrepareXDCTestBlockChainForV2Engine(t, 905, params.TestXDPoSMockChainConfig, nil)
|
|
engineV2 := blockchain.Engine().(*XDPoS.XDPoS).EngineV2
|
|
|
|
// Make the Highest QC in syncInfo point to an old block to simulate it's no longer qualified
|
|
parentBlock := blockchain.GetBlockByNumber(903)
|
|
var extraField types.ExtraFields_v2
|
|
err := utils.DecodeBytesExtraFields(parentBlock.Extra(), &extraField)
|
|
if err != nil {
|
|
t.Fatal("Fail to decode extra data", err)
|
|
}
|
|
|
|
timeoutForSign := &types.TimeoutForSign{
|
|
Round: types.Round(900),
|
|
GapNumber: 450,
|
|
}
|
|
|
|
// Sign from acc 1, 2, 3 and voter
|
|
acc1SignedHash := SignHashByPK(acc1Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc2SignedHash := SignHashByPK(acc2Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc3SignedHash := SignHashByPK(acc3Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
voterSignedHash := SignHashByPK(voterKey, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
|
|
var signatures []types.Signature
|
|
signatures = append(signatures, acc1SignedHash, acc2SignedHash, acc3SignedHash, voterSignedHash)
|
|
|
|
syncInfoTC := &types.TimeoutCert{
|
|
Round: timeoutForSign.Round,
|
|
Signatures: signatures,
|
|
GapNumber: timeoutForSign.GapNumber,
|
|
}
|
|
|
|
syncInfoMsg := &types.SyncInfo{
|
|
HighestQuorumCert: extraField.QuorumCert,
|
|
HighestTimeoutCert: syncInfoTC,
|
|
}
|
|
|
|
verified, err := engineV2.VerifySyncInfoMessage(blockchain, syncInfoMsg)
|
|
assert.True(t, verified)
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
func TestVerifySyncInfoIfTcUseDifferentEpoch(t *testing.T) {
|
|
config := params.TestXDPoSMockChainConfig
|
|
blockchain, _, currentBlock, signer, signFn, _ := PrepareXDCTestBlockChainForV2Engine(t, 1349, config, nil)
|
|
adaptor := blockchain.Engine().(*XDPoS.XDPoS)
|
|
x := adaptor.EngineV2
|
|
|
|
// Insert block 1350
|
|
t.Logf("Inserting block with propose at 1350...")
|
|
blockCoinbaseA := "0xaaa0000000000000000000000000000000001350"
|
|
// NOTE: voterAddr never exist in the Masternode list, but all acc1,2,3 already does
|
|
tx, err := voteTX(37117, 0, signer.String())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
//Get from block validator error message
|
|
merkleRoot := "8a355a8636d1aae24d5a63df0318534e09110891d6ab7bf20587da64725083be"
|
|
header := &types.Header{
|
|
Root: common.HexToHash(merkleRoot),
|
|
Number: big.NewInt(int64(1350)),
|
|
ParentHash: currentBlock.Hash(),
|
|
Coinbase: common.HexToAddress(blockCoinbaseA),
|
|
}
|
|
|
|
header.Extra = generateV2Extra(450, currentBlock, signer, signFn, nil)
|
|
|
|
parentBlock, err := createBlockFromHeader(blockchain, header, []*types.Transaction{tx}, signer, signFn, config)
|
|
assert.Nil(t, err)
|
|
err = blockchain.InsertBlock(parentBlock)
|
|
assert.Nil(t, err)
|
|
// 1350 is a gap block, need to update the snapshot
|
|
err = blockchain.UpdateM1()
|
|
assert.Nil(t, err)
|
|
t.Logf("Inserting block from 1351 to 1799...")
|
|
for i := 1351; i <= 1799; i++ {
|
|
blockCoinbase := fmt.Sprintf("0xaaa000000000000000000000000000000000%4d", i)
|
|
//Get from block validator error message
|
|
header = &types.Header{
|
|
Root: common.HexToHash(merkleRoot),
|
|
Number: big.NewInt(int64(i)),
|
|
ParentHash: parentBlock.Hash(),
|
|
Coinbase: common.HexToAddress(blockCoinbase),
|
|
}
|
|
|
|
header.Extra = generateV2Extra(int64(i)-900, parentBlock, signer, signFn, nil)
|
|
|
|
block, err := createBlockFromHeader(blockchain, header, nil, signer, signFn, config)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = blockchain.InsertBlock(block)
|
|
assert.Nil(t, err)
|
|
parentBlock = block
|
|
}
|
|
t.Logf("build epoch block with new set of masternodes")
|
|
blockCoinbase := fmt.Sprintf("0xaaa0000000000000000000000000000000001800")
|
|
//Get from block validator error message
|
|
header = &types.Header{
|
|
Root: common.HexToHash(merkleRoot),
|
|
Number: big.NewInt(int64(1800)),
|
|
ParentHash: parentBlock.Hash(),
|
|
Coinbase: common.HexToAddress(blockCoinbase),
|
|
}
|
|
|
|
header.Extra = generateV2Extra(900, parentBlock, signer, signFn, nil)
|
|
validators := []byte{}
|
|
|
|
snap, err := x.GetSnapshot(blockchain, parentBlock.Header())
|
|
assert.Nil(t, err)
|
|
|
|
for _, v := range snap.NextEpochCandidates {
|
|
validators = append(validators, v[:]...)
|
|
}
|
|
// set up 1 more masternode to make it difference
|
|
validators = append(validators, voterAddr[:]...)
|
|
header.Validators = validators
|
|
block, err := createBlockFromHeader(blockchain, header, nil, signer, signFn, config)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = blockchain.InsertBlock(block)
|
|
assert.Nil(t, err)
|
|
parentBlock = block
|
|
|
|
var extraField types.ExtraFields_v2
|
|
err = utils.DecodeBytesExtraFields(parentBlock.Extra(), &extraField)
|
|
if err != nil {
|
|
t.Fatal("Fail to decode extra data", err)
|
|
}
|
|
|
|
timeoutForSign := &types.TimeoutForSign{
|
|
Round: types.Round(899),
|
|
GapNumber: 450,
|
|
}
|
|
|
|
// Sign from acc 1, 2, 3 and voter
|
|
acc1SignedHash := SignHashByPK(acc1Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc2SignedHash := SignHashByPK(acc2Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
acc3SignedHash := SignHashByPK(acc3Key, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
voterSignedHash := SignHashByPK(voterKey, types.TimeoutSigHash(timeoutForSign).Bytes())
|
|
|
|
var signatures []types.Signature
|
|
signatures = append(signatures, acc1SignedHash, acc2SignedHash, acc3SignedHash, voterSignedHash)
|
|
|
|
newTC := &types.TimeoutCert{
|
|
Round: timeoutForSign.Round,
|
|
Signatures: signatures,
|
|
GapNumber: timeoutForSign.GapNumber,
|
|
}
|
|
|
|
syncInfoMsg := &types.SyncInfo{
|
|
HighestQuorumCert: extraField.QuorumCert,
|
|
HighestTimeoutCert: newTC,
|
|
}
|
|
|
|
verified, err := x.VerifySyncInfoMessage(blockchain, syncInfoMsg)
|
|
assert.Nil(t, err)
|
|
assert.True(t, verified)
|
|
}
|