From e28b550a242633e4393359d0ec0effc78e4a4821 Mon Sep 17 00:00:00 2001 From: Jianrong Date: Thu, 21 Dec 2023 23:34:47 +1100 Subject: [PATCH 1/5] Add a new API to help debug when there are missed rounds --- consensus/XDPoS/XDPoS.go | 10 +++++ consensus/XDPoS/api.go | 7 +++ consensus/XDPoS/engines/engine_v2/engine.go | 2 +- consensus/XDPoS/engines/engine_v2/mining.go | 1 + consensus/XDPoS/engines/engine_v2/utils.go | 49 +++++++++++++++++++++ consensus/XDPoS/utils/types.go | 12 +++++ internal/web3ext/web3ext.go | 5 +++ 7 files changed, 85 insertions(+), 1 deletion(-) diff --git a/consensus/XDPoS/XDPoS.go b/consensus/XDPoS/XDPoS.go index d03f324d4c..c06f3c53ff 100644 --- a/consensus/XDPoS/XDPoS.go +++ b/consensus/XDPoS/XDPoS.go @@ -433,6 +433,16 @@ func (x *XDPoS) GetCurrentEpochSwitchBlock(chain consensus.ChainReader, blockNum } } +func (x *XDPoS) CalculateMissingRounds(chain consensus.ChainReader, hash common.Hash) (*utils.PublicApiMissedRoundsMetadata, error) { + header := chain.GetHeaderByHash(hash) + switch x.config.BlockConsensusVersion(header.Number, header.Extra, ExtraFieldCheck) { + case params.ConsensusEngineVersion2: + return x.EngineV2.CalculateMissingRounds(chain, header) + default: // Default "v1" + return nil, fmt.Errorf("Not supported in the v1 consensus") + } +} + // Same DB across all consensus engines func (x *XDPoS) GetDb() ethdb.Database { return x.db diff --git a/consensus/XDPoS/api.go b/consensus/XDPoS/api.go index 768e8b9a5c..aec4fc4f6c 100644 --- a/consensus/XDPoS/api.go +++ b/consensus/XDPoS/api.go @@ -285,6 +285,13 @@ func (api *API) NetworkInformation() NetworkInformation { return info } +/* +An API exclusively for V2 consensus, designed to assist in troubleshooting miners by identifying who mined during their allocated term. +*/ +func (api *API) GetMissiedRoundsInEpochByBlockHash(hash common.Hash) (*utils.PublicApiMissedRoundsMetadata, error) { + return api.XDPoS.CalculateMissingRounds(api.chain, hash) +} + func calculateSigners(message map[string]SignerTypes, pool map[string]map[common.Hash]utils.PoolObj, masternodes []common.Address) { for name, objs := range pool { var currentSigners []common.Address diff --git a/consensus/XDPoS/engines/engine_v2/engine.go b/consensus/XDPoS/engines/engine_v2/engine.go index 3e7eabd8df..cedeaa2f0b 100644 --- a/consensus/XDPoS/engines/engine_v2/engine.go +++ b/consensus/XDPoS/engines/engine_v2/engine.go @@ -360,7 +360,7 @@ func (x *XDPoS_v2) Prepare(chain consensus.ChainReader, header *types.Header) er } if header.Coinbase != signer { - log.Error("[Prepare] The mined blocker header coinbase address mismatch with waller address", "headerCoinbase", header.Coinbase.Hex(), "WalletAddress", signer.Hex()) + log.Error("[Prepare] The mined blocker header coinbase address mismatch with wallet address", "headerCoinbase", header.Coinbase.Hex(), "WalletAddress", signer.Hex()) return consensus.ErrCoinbaseMismatch } diff --git a/consensus/XDPoS/engines/engine_v2/mining.go b/consensus/XDPoS/engines/engine_v2/mining.go index 69c861acc7..546de844a8 100644 --- a/consensus/XDPoS/engines/engine_v2/mining.go +++ b/consensus/XDPoS/engines/engine_v2/mining.go @@ -50,6 +50,7 @@ func (x *XDPoS_v2) yourturn(chain consensus.ChainReader, round types.Round, pare return false, nil } + // TODO: USE BELOW FOR THE NEW API leaderIndex := uint64(round) % x.config.Epoch % uint64(len(masterNodes)) x.whosTurn = masterNodes[leaderIndex] if x.whosTurn != signer { diff --git a/consensus/XDPoS/engines/engine_v2/utils.go b/consensus/XDPoS/engines/engine_v2/utils.go index 1c3497ad60..395493f7e5 100644 --- a/consensus/XDPoS/engines/engine_v2/utils.go +++ b/consensus/XDPoS/engines/engine_v2/utils.go @@ -163,3 +163,52 @@ func (x *XDPoS_v2) GetSignersFromSnapshot(chain consensus.ChainReader, header *t snap, err := x.getSnapshot(chain, header.Number.Uint64(), false) return snap.NextEpochMasterNodes, err } + +func (x *XDPoS_v2) CalculateMissingRounds(chain consensus.ChainReader, header *types.Header) (*utils.PublicApiMissedRoundsMetadata, error) { + var missedRounds []utils.MissedRoundInfo + switchInfo, err := x.getEpochSwitchInfo(chain, header, header.Hash()) + if err != nil { + return nil, err + } + masternodes := switchInfo.Masternodes + + // Loop through from the epoch switch block to the current "header" block + nextHeader := header + for nextHeader.Number.Cmp(switchInfo.EpochSwitchBlockInfo.Number) > 0 { + parentHeader := chain.GetHeaderByHash(nextHeader.ParentHash) + parentRound, err := x.GetRoundNumber(parentHeader) + if err != nil { + return nil, err + } + currRound, err := x.GetRoundNumber(nextHeader) + if err != nil { + return nil, err + } + // This means there is a missing round incrementation when producing blocks + if parentRound+1 != currRound { + // We need to loop through between parentRound and the currRound to assess which miner did not mine + for i := parentRound; i < currRound; i++ { + leaderIndex := uint64(i) % x.config.Epoch % uint64(len(masternodes)) + whosTerm := masternodes[leaderIndex] + missedRounds = append( + missedRounds, + utils.MissedRoundInfo{ + Round: i, + Miner: whosTerm, + CurrentBlockHash: nextHeader.Hash(), + ParentBlockHash: parentHeader.Hash(), + }, + ) + } + } + // Assign the pointer to the next one + nextHeader = parentHeader + } + missedRoundsMetadata := &utils.PublicApiMissedRoundsMetadata{ + EpochRound: switchInfo.EpochSwitchBlockInfo.Round, + EpochBlockNumber: switchInfo.EpochSwitchBlockInfo.Number, + MissedRounds: missedRounds, + } + + return missedRoundsMetadata, nil +} diff --git a/consensus/XDPoS/utils/types.go b/consensus/XDPoS/utils/types.go index 4f55973cfd..3b60688c36 100644 --- a/consensus/XDPoS/utils/types.go +++ b/consensus/XDPoS/utils/types.go @@ -57,3 +57,15 @@ type PublicApiSnapshot struct { Votes []*clique.Vote `json:"votes"` // List of votes cast in chronological order Tally map[common.Address]clique.Tally `json:"tally"` // Current vote tally to avoid recalculating } + +type MissedRoundInfo struct { + Round types.Round + Miner common.Address + CurrentBlockHash common.Hash + ParentBlockHash common.Hash +} +type PublicApiMissedRoundsMetadata struct { + EpochRound types.Round + EpochBlockNumber *big.Int + MissedRounds []MissedRoundInfo +} diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go index f80b2b6e0a..e479fea342 100644 --- a/internal/web3ext/web3ext.go +++ b/internal/web3ext/web3ext.go @@ -156,6 +156,11 @@ web3._extend({ name: 'getLatestPoolStatus', call: 'XDPoS_getLatestPoolStatus' }), + new web3._extend.Method({ + name: 'GetMissiedRoundsInEpochByBlockHash', + call: 'XDPoS_GetMissiedRoundsInEpochByBlockHash', + params: 1 + }), ], properties: [ new web3._extend.Property({ From 6740545358bafd4a75e6dc5369b1e0c38396648e Mon Sep 17 00:00:00 2001 From: Jianrong Date: Fri, 22 Dec 2023 10:37:32 +1100 Subject: [PATCH 2/5] change the API to be block num based --- consensus/XDPoS/XDPoS.go | 3 +-- consensus/XDPoS/api.go | 28 ++++++++++++--------- consensus/XDPoS/engines/engine_v2/mining.go | 1 - consensus/XDPoS/engines/engine_v2/utils.go | 12 +++++---- consensus/XDPoS/utils/types.go | 2 ++ internal/web3ext/web3ext.go | 7 +++--- 6 files changed, 30 insertions(+), 23 deletions(-) diff --git a/consensus/XDPoS/XDPoS.go b/consensus/XDPoS/XDPoS.go index c06f3c53ff..26cadc3555 100644 --- a/consensus/XDPoS/XDPoS.go +++ b/consensus/XDPoS/XDPoS.go @@ -433,8 +433,7 @@ func (x *XDPoS) GetCurrentEpochSwitchBlock(chain consensus.ChainReader, blockNum } } -func (x *XDPoS) CalculateMissingRounds(chain consensus.ChainReader, hash common.Hash) (*utils.PublicApiMissedRoundsMetadata, error) { - header := chain.GetHeaderByHash(hash) +func (x *XDPoS) CalculateMissingRounds(chain consensus.ChainReader, header *types.Header) (*utils.PublicApiMissedRoundsMetadata, error) { switch x.config.BlockConsensusVersion(header.Number, header.Extra, ExtraFieldCheck) { case params.ConsensusEngineVersion2: return x.EngineV2.CalculateMissingRounds(chain, header) diff --git a/consensus/XDPoS/api.go b/consensus/XDPoS/api.go index aec4fc4f6c..17f939faae 100644 --- a/consensus/XDPoS/api.go +++ b/consensus/XDPoS/api.go @@ -224,16 +224,7 @@ func (api *API) GetV2BlockByHeader(header *types.Header, uncle bool) *V2BlockInf } func (api *API) GetV2BlockByNumber(number *rpc.BlockNumber) *V2BlockInfo { - var header *types.Header - if number == nil || *number == rpc.LatestBlockNumber { - header = api.chain.CurrentHeader() - } else if *number == rpc.CommittedBlockNumber { - hash := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo().Hash - header = api.chain.GetHeaderByHash(hash) - } else { - header = api.chain.GetHeaderByNumber(uint64(number.Int64())) - } - + header := api.getHeaderFromApiBlockNum(number) if header == nil { return &V2BlockInfo{ Number: big.NewInt(number.Int64()), @@ -288,8 +279,21 @@ func (api *API) NetworkInformation() NetworkInformation { /* An API exclusively for V2 consensus, designed to assist in troubleshooting miners by identifying who mined during their allocated term. */ -func (api *API) GetMissiedRoundsInEpochByBlockHash(hash common.Hash) (*utils.PublicApiMissedRoundsMetadata, error) { - return api.XDPoS.CalculateMissingRounds(api.chain, hash) +func (api *API) GetMissiedRoundsInEpochByBlockNum(number *rpc.BlockNumber) (*utils.PublicApiMissedRoundsMetadata, error) { + return api.XDPoS.CalculateMissingRounds(api.chain, api.getHeaderFromApiBlockNum(number)) +} + +func (api *API) getHeaderFromApiBlockNum(number *rpc.BlockNumber) *types.Header { + var header *types.Header + if number == nil || *number == rpc.LatestBlockNumber { + header = api.chain.CurrentHeader() + } else if *number == rpc.CommittedBlockNumber { + hash := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo().Hash + header = api.chain.GetHeaderByHash(hash) + } else { + header = api.chain.GetHeaderByNumber(uint64(number.Int64())) + } + return header } func calculateSigners(message map[string]SignerTypes, pool map[string]map[common.Hash]utils.PoolObj, masternodes []common.Address) { diff --git a/consensus/XDPoS/engines/engine_v2/mining.go b/consensus/XDPoS/engines/engine_v2/mining.go index 546de844a8..69c861acc7 100644 --- a/consensus/XDPoS/engines/engine_v2/mining.go +++ b/consensus/XDPoS/engines/engine_v2/mining.go @@ -50,7 +50,6 @@ func (x *XDPoS_v2) yourturn(chain consensus.ChainReader, round types.Round, pare return false, nil } - // TODO: USE BELOW FOR THE NEW API leaderIndex := uint64(round) % x.config.Epoch % uint64(len(masterNodes)) x.whosTurn = masterNodes[leaderIndex] if x.whosTurn != signer { diff --git a/consensus/XDPoS/engines/engine_v2/utils.go b/consensus/XDPoS/engines/engine_v2/utils.go index 395493f7e5..e54b2b59b0 100644 --- a/consensus/XDPoS/engines/engine_v2/utils.go +++ b/consensus/XDPoS/engines/engine_v2/utils.go @@ -184,19 +184,21 @@ func (x *XDPoS_v2) CalculateMissingRounds(chain consensus.ChainReader, header *t if err != nil { return nil, err } - // This means there is a missing round incrementation when producing blocks + // This indicates that an increment in the round number is missing during the block production process. if parentRound+1 != currRound { - // We need to loop through between parentRound and the currRound to assess which miner did not mine - for i := parentRound; i < currRound; i++ { + // We need to iterate from the parentRound to the currRound to determine which miner did not perform mining. + for i := parentRound + 1; i < currRound; i++ { leaderIndex := uint64(i) % x.config.Epoch % uint64(len(masternodes)) - whosTerm := masternodes[leaderIndex] + whosTurn := masternodes[leaderIndex] missedRounds = append( missedRounds, utils.MissedRoundInfo{ Round: i, - Miner: whosTerm, + Miner: whosTurn, CurrentBlockHash: nextHeader.Hash(), + CurrentBlockNum: nextHeader.Number, ParentBlockHash: parentHeader.Hash(), + ParentBlockNum: parentHeader.Number, }, ) } diff --git a/consensus/XDPoS/utils/types.go b/consensus/XDPoS/utils/types.go index 3b60688c36..4073fb522b 100644 --- a/consensus/XDPoS/utils/types.go +++ b/consensus/XDPoS/utils/types.go @@ -62,7 +62,9 @@ type MissedRoundInfo struct { Round types.Round Miner common.Address CurrentBlockHash common.Hash + CurrentBlockNum *big.Int ParentBlockHash common.Hash + ParentBlockNum *big.Int } type PublicApiMissedRoundsMetadata struct { EpochRound types.Round diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go index e479fea342..e0b0018b78 100644 --- a/internal/web3ext/web3ext.go +++ b/internal/web3ext/web3ext.go @@ -157,9 +157,10 @@ web3._extend({ call: 'XDPoS_getLatestPoolStatus' }), new web3._extend.Method({ - name: 'GetMissiedRoundsInEpochByBlockHash', - call: 'XDPoS_GetMissiedRoundsInEpochByBlockHash', - params: 1 + name: 'GetMissiedRoundsInEpochByBlockNum', + call: 'XDPoS_GetMissiedRoundsInEpochByBlockNum', + params: 1, + inputFormatter: [web3._extend.formatters.inputBlockNumberFormatter] }), ], properties: [ From 14f6b267c4293a3655cdfc0a410ca010b7f82a45 Mon Sep 17 00:00:00 2001 From: Jianrong Date: Thu, 28 Dec 2023 15:12:17 +1100 Subject: [PATCH 3/5] Make getMissiedRoundsInEpochByBlockNum API method lower case --- internal/web3ext/web3ext.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go index e0b0018b78..8cbaf04e19 100644 --- a/internal/web3ext/web3ext.go +++ b/internal/web3ext/web3ext.go @@ -157,8 +157,8 @@ web3._extend({ call: 'XDPoS_getLatestPoolStatus' }), new web3._extend.Method({ - name: 'GetMissiedRoundsInEpochByBlockNum', - call: 'XDPoS_GetMissiedRoundsInEpochByBlockNum', + name: 'getMissiedRoundsInEpochByBlockNum', + call: 'XDPoS_getMissiedRoundsInEpochByBlockNum', params: 1, inputFormatter: [web3._extend.formatters.inputBlockNumberFormatter] }), From e83c0a09540b5f7b2161707b37d9bc85131e5aa9 Mon Sep 17 00:00:00 2001 From: Jianrong Date: Thu, 28 Dec 2023 17:37:30 +1100 Subject: [PATCH 4/5] Add tests to cover the new GetMissiedRoundsInEpochByBlockNum API --- consensus/tests/api_test.go | 1 - consensus/tests/engine_v2_tests/api_test.go | 111 ++++++++++++++++++++ consensus/tests/engine_v2_tests/helper.go | 12 +++ 3 files changed, 123 insertions(+), 1 deletion(-) create mode 100644 consensus/tests/engine_v2_tests/api_test.go diff --git a/consensus/tests/api_test.go b/consensus/tests/api_test.go index 3d6318151c..ed3e0897d0 100644 --- a/consensus/tests/api_test.go +++ b/consensus/tests/api_test.go @@ -18,7 +18,6 @@ var ( ) func TestConfigApi(t *testing.T) { - bc := backends.NewXDCSimulatedBackend(core.GenesisAlloc{ voterAddr: {Balance: new(big.Int).SetUint64(10000000000)}, }, 10000000, params.TestXDPoSMockChainConfig) diff --git a/consensus/tests/engine_v2_tests/api_test.go b/consensus/tests/engine_v2_tests/api_test.go new file mode 100644 index 0000000000..e626281fdc --- /dev/null +++ b/consensus/tests/engine_v2_tests/api_test.go @@ -0,0 +1,111 @@ +package engine_v2_tests + +import ( + "math/big" + "testing" + + "github.com/XinFinOrg/XDPoSChain/consensus/XDPoS" + "github.com/XinFinOrg/XDPoSChain/core/types" + "github.com/XinFinOrg/XDPoSChain/params" + "github.com/XinFinOrg/XDPoSChain/rpc" + "github.com/stretchr/testify/assert" +) + +func TestGetMissiedRoundsInEpochByBlockNumOnlyForV2Consensus(t *testing.T) { + _, bc, _, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) + + engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) + blockNum := rpc.BlockNumber(123) + + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + + assert.EqualError(t, err, "Not supported in the v1 consensus") + assert.Nil(t, data) +} + +func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2(t *testing.T) { + _, bc, cb, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) + + engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) + blockNum := rpc.BlockNumber(cb.NumberU64()) + + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + + assert.Nil(t, err) + assert.Equal(t, types.Round(900), data.EpochRound) + assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber) + assert.Equal(t, 0, len(data.MissedRounds)) + + blockNum = rpc.BlockNumber(1800) + + data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + + assert.Nil(t, err) + assert.Equal(t, types.Round(900), data.EpochRound) + assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber) + assert.Equal(t, 0, len(data.MissedRounds)) + + blockNum = rpc.BlockNumber(1801) + + data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + + assert.Nil(t, err) + assert.Equal(t, types.Round(900), data.EpochRound) + assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber) + assert.Equal(t, 0, len(data.MissedRounds)) +} + +func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2FistEpoch(t *testing.T) { + _, bc, _, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) + + engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) + blockNum := rpc.BlockNumber(901) + + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + + assert.Nil(t, err) + assert.Equal(t, types.Round(1), data.EpochRound) + assert.Equal(t, big.NewInt(901), data.EpochBlockNumber) + assert.Equal(t, 0, len(data.MissedRounds)) +} + +func TestGetMissiedRoundsInEpochByBlockNum(t *testing.T) { + blockchain, bc, currentBlock, signer, signFn := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) + chainConfig := params.TestXDPoSMockChainConfig + engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) + blockCoinBase := signer.Hex() + + startingBlockNum := currentBlock.Number().Int64() + 1 + // Skipped the round + roundNumber := startingBlockNum - chainConfig.XDPoS.V2.SwitchBlock.Int64() + 2 + block := CreateBlock(blockchain, chainConfig, currentBlock, int(startingBlockNum), roundNumber, blockCoinBase, signer, signFn, nil, nil, "b345a8560bd51926803dd17677c9f0751193914a851a4ec13063d6bf50220b53") + err := blockchain.InsertBlock(block) + if err != nil { + t.Fatal(err) + } + + // Update Signer as there is no previous signer assigned + err = UpdateSigner(blockchain) + if err != nil { + t.Fatal(err) + } + + blockNum := rpc.BlockNumber(1803) + + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + + assert.Nil(t, err) + assert.Equal(t, types.Round(900), data.EpochRound) + assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber) + assert.Equal(t, 2, len(data.MissedRounds)) + assert.NotEmpty(t, data.MissedRounds[0].Miner) + assert.Equal(t, data.MissedRounds[0].Round, types.Round(903)) + assert.Equal(t, data.MissedRounds[0].CurrentBlockNum, big.NewInt(1803)) + assert.Equal(t, data.MissedRounds[0].ParentBlockNum, big.NewInt(1802)) + assert.NotEmpty(t, data.MissedRounds[1].Miner) + assert.Equal(t, data.MissedRounds[1].Round, types.Round(904)) + assert.Equal(t, data.MissedRounds[0].CurrentBlockNum, big.NewInt(1803)) + assert.Equal(t, data.MissedRounds[0].ParentBlockNum, big.NewInt(1802)) + + assert.NotEqual(t, data.MissedRounds[0].Miner, data.MissedRounds[1].Miner) +} diff --git a/consensus/tests/engine_v2_tests/helper.go b/consensus/tests/engine_v2_tests/helper.go index 854eebd124..9b86fbcda4 100644 --- a/consensus/tests/engine_v2_tests/helper.go +++ b/consensus/tests/engine_v2_tests/helper.go @@ -545,6 +545,18 @@ func PrepareXDCTestBlockChainWith128Candidates(t *testing.T, numOfBlocks int, ch if err != nil { t.Fatal(err) } + + // First v2 block + if (int64(i) - chainConfig.XDPoS.V2.SwitchBlock.Int64()) == 1 { + lastv1BlockNumber := block.Header().Number.Uint64() - 1 + checkpointBlockNumber := lastv1BlockNumber - lastv1BlockNumber%chainConfig.XDPoS.Epoch + checkpointHeader := blockchain.GetHeaderByNumber(checkpointBlockNumber) + err := engine.EngineV2.Initial(blockchain, checkpointHeader) + if err != nil { + panic(err) + } + } + currentBlock = block } From 8e1f71e86ee3b3cfad572318e8c884544722ab62 Mon Sep 17 00:00:00 2001 From: Jianrong Date: Thu, 28 Dec 2023 23:03:53 +1100 Subject: [PATCH 5/5] Fix the typo missied to missed --- consensus/XDPoS/api.go | 2 +- consensus/tests/engine_v2_tests/api_test.go | 20 ++++++++++---------- internal/web3ext/web3ext.go | 4 ++-- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/consensus/XDPoS/api.go b/consensus/XDPoS/api.go index 17f939faae..a922e57f78 100644 --- a/consensus/XDPoS/api.go +++ b/consensus/XDPoS/api.go @@ -279,7 +279,7 @@ func (api *API) NetworkInformation() NetworkInformation { /* An API exclusively for V2 consensus, designed to assist in troubleshooting miners by identifying who mined during their allocated term. */ -func (api *API) GetMissiedRoundsInEpochByBlockNum(number *rpc.BlockNumber) (*utils.PublicApiMissedRoundsMetadata, error) { +func (api *API) GetMissedRoundsInEpochByBlockNum(number *rpc.BlockNumber) (*utils.PublicApiMissedRoundsMetadata, error) { return api.XDPoS.CalculateMissingRounds(api.chain, api.getHeaderFromApiBlockNum(number)) } diff --git a/consensus/tests/engine_v2_tests/api_test.go b/consensus/tests/engine_v2_tests/api_test.go index e626281fdc..fb99f6f879 100644 --- a/consensus/tests/engine_v2_tests/api_test.go +++ b/consensus/tests/engine_v2_tests/api_test.go @@ -11,25 +11,25 @@ import ( "github.com/stretchr/testify/assert" ) -func TestGetMissiedRoundsInEpochByBlockNumOnlyForV2Consensus(t *testing.T) { +func TestGetMissedRoundsInEpochByBlockNumOnlyForV2Consensus(t *testing.T) { _, bc, _, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) blockNum := rpc.BlockNumber(123) - data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum) assert.EqualError(t, err, "Not supported in the v1 consensus") assert.Nil(t, data) } -func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2(t *testing.T) { +func TestGetMissedRoundsInEpochByBlockNumReturnEmptyForV2(t *testing.T) { _, bc, cb, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) blockNum := rpc.BlockNumber(cb.NumberU64()) - data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum) assert.Nil(t, err) assert.Equal(t, types.Round(900), data.EpochRound) @@ -38,7 +38,7 @@ func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2(t *testing.T) { blockNum = rpc.BlockNumber(1800) - data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum) assert.Nil(t, err) assert.Equal(t, types.Round(900), data.EpochRound) @@ -47,7 +47,7 @@ func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2(t *testing.T) { blockNum = rpc.BlockNumber(1801) - data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum) assert.Nil(t, err) assert.Equal(t, types.Round(900), data.EpochRound) @@ -55,13 +55,13 @@ func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2(t *testing.T) { assert.Equal(t, 0, len(data.MissedRounds)) } -func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2FistEpoch(t *testing.T) { +func TestGetMissedRoundsInEpochByBlockNumReturnEmptyForV2FistEpoch(t *testing.T) { _, bc, _, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) blockNum := rpc.BlockNumber(901) - data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum) assert.Nil(t, err) assert.Equal(t, types.Round(1), data.EpochRound) @@ -69,7 +69,7 @@ func TestGetMissiedRoundsInEpochByBlockNumReturnEmptyForV2FistEpoch(t *testing.T assert.Equal(t, 0, len(data.MissedRounds)) } -func TestGetMissiedRoundsInEpochByBlockNum(t *testing.T) { +func TestGetMissedRoundsInEpochByBlockNum(t *testing.T) { blockchain, bc, currentBlock, signer, signFn := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig) chainConfig := params.TestXDPoSMockChainConfig engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS) @@ -92,7 +92,7 @@ func TestGetMissiedRoundsInEpochByBlockNum(t *testing.T) { blockNum := rpc.BlockNumber(1803) - data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissiedRoundsInEpochByBlockNum(&blockNum) + data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum) assert.Nil(t, err) assert.Equal(t, types.Round(900), data.EpochRound) diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go index 8cbaf04e19..c07cf978c8 100644 --- a/internal/web3ext/web3ext.go +++ b/internal/web3ext/web3ext.go @@ -157,8 +157,8 @@ web3._extend({ call: 'XDPoS_getLatestPoolStatus' }), new web3._extend.Method({ - name: 'getMissiedRoundsInEpochByBlockNum', - call: 'XDPoS_getMissiedRoundsInEpochByBlockNum', + name: 'getMissedRoundsInEpochByBlockNum', + call: 'XDPoS_getMissedRoundsInEpochByBlockNum', params: 1, inputFormatter: [web3._extend.formatters.inputBlockNumberFormatter] }),