Renaming qibft to qbft for consistency

Author: jbhurat

cmd/utils/flags.go

@@ -2191,7 +2191,7 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readOnly bool, useExist bool)
 		}
 		istanbulConfig.ProposerPolicy = istanbul.NewProposerPolicy(istanbul.ProposerPolicyId(config.Istanbul.ProposerPolicy))
 		istanbulConfig.Ceil2Nby3Block = config.Istanbul.Ceil2Nby3Block
-		istanbulConfig.QibftBlock = config.Istanbul.QibftBlock
+		istanbulConfig.QbftBlock = config.Istanbul.QbftBlock
 		engine = istanbulBackend.New(istanbulConfig, stack.GetNodeKey(), chainDb)
 	} else if config.IsQuorum {
 		// for Raft

consensus/istanbul/backend.go

@@ -71,14 +71,14 @@ type Backend interface {
 	// ParentValidators returns the validator set of the given proposal's parent block
 	ParentValidators(proposal Proposal) ValidatorSet
 
-	// HasBadBlock returns whether the block with the hash is a bad block
+	// HasBadProposal returns whether the block with the hash is a bad block
 	HasBadProposal(hash common.Hash) bool
 
 	Close() error
 
-	// IsQIBFTConsensus checks qibftBlock fork block and returns if it should be enabled
-	IsQIBFTConsensus() bool
+	// IsQBFTConsensus checks qbftBlock fork block and returns if it should be enabled
+	IsQBFTConsensus() bool
 
-	// StartQBFTConsensus stops existing legacy ibft consensus and starts the new qibft consensus
-	StartQIBFTConsensus() error
+	// StartQBFTConsensus stops existing legacy ibft consensus and starts the new qbft consensus
+	StartQBFTConsensus() error
 }

consensus/istanbul/backend/api.go

@@ -83,7 +83,7 @@ func (api *API) signers(header *types.Header) (*BlockSigners, error) {
 		return nil, err
 	}
 
-	committers, err := api.istanbul.Signers(header, api.istanbul.IsQIBFTConsensusForHeader(header))
+	committers, err := api.istanbul.Signers(header, api.istanbul.IsQBFTConsensusForHeader(header))
 	if err != nil {
 		return nil, err
 	}

consensus/istanbul/backend/backend.go

@@ -27,8 +27,8 @@ import (
 	"github.com/ethereum/go-ethereum/consensus/istanbul"
 	istanbulCore "github.com/ethereum/go-ethereum/consensus/istanbul/core"
 	"github.com/ethereum/go-ethereum/consensus/istanbul/validator"
-	qibftCore "github.com/ethereum/go-ethereum/consensus/qibft/core"
-	qibftMessage "github.com/ethereum/go-ethereum/consensus/qibft/message"
+	qbftCore "github.com/ethereum/go-ethereum/consensus/qbft/core"
+	qbftMessage "github.com/ethereum/go-ethereum/consensus/qbft/message"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -102,7 +102,7 @@ type backend struct {
 	recentMessages *lru.ARCCache // the cache of peer's messages
 	knownMessages  *lru.ARCCache // the cache of self messages
 
-	qibftConsensusEnabled bool // qibft consensus
+	qbftConsensusEnabled bool // qbft consensus
 }
 
 // zekun: HACK
@@ -163,10 +163,10 @@ func (sb *backend) Gossip(valSet istanbul.ValidatorSet, code uint64, payload []b
 			sb.recentMessages.Add(addr, m)
 
 			var outboundCode uint64 = istanbulMsg
-			if _, ok := qibftMessage.MessageCodes()[code]; ok {
+			if _, ok := qbftMessage.MessageCodes()[code]; ok {
 				outboundCode = code
 			}
-			if sb.IsQIBFTConsensus() {
+			if sb.IsQBFTConsensus() {
 				go p.SendQbftConsensus(outboundCode, payload)
 			} else {
 				go p.SendConsensus(outboundCode, payload)
@@ -188,7 +188,7 @@ func (sb *backend) Commit(proposal istanbul.Proposal, seals [][]byte, round *big
 	h := block.Header()
 
 	// Append Round Number and seals into extra-data of qbft consensus
-	if sb.IsQIBFTConsensus() {
+	if sb.IsQBFTConsensus() {
 		err := writeQBFTCommittedSeals(h, seals)
 		if err != nil {
 			return err
@@ -353,63 +353,63 @@ func (sb *backend) Close() error {
 	return nil
 }
 
-// IsQIBFTConsensus returns whether qbft consensus should be used
-func (sb *backend) IsQIBFTConsensus() bool {
-	// If qibftBlock is not defined in genesis, then use legacy ibft
-	if sb.qibftConsensusEnabled {
+// IsQBFTConsensus returns whether qbft consensus should be used
+func (sb *backend) IsQBFTConsensus() bool {
+	// If qbftBlock is not defined in genesis, then use legacy ibft
+	if sb.qbftConsensusEnabled {
 		return true
 	}
 	if sb.chain != nil {
-		return sb.IsQIBFTConsensusForHeader(sb.chain.CurrentHeader())
+		return sb.IsQBFTConsensusForHeader(sb.chain.CurrentHeader())
 	}
 	return false
 }
 
-// IsQIBFTConsensusForHeader checks if qbft consensus is enabled for the block height identified by the given header
-func (sb *backend) IsQIBFTConsensusForHeader(header *types.Header) bool {
-	// If qibftBlock is not defined in genesis, then use legacy ibft
-	if sb.config.QibftBlock == nil {
+// IsQBFTConsensusForHeader checks if qbft consensus is enabled for the block height identified by the given header
+func (sb *backend) IsQBFTConsensusForHeader(header *types.Header) bool {
+	// If qbftBlock is not defined in genesis, then use legacy ibft
+	if sb.config.QbftBlock == nil {
 		return false
 	}
-	if sb.config.QibftBlock.Uint64() == 0 {
+	if sb.config.QbftBlock.Uint64() == 0 {
 		return true
 	}
 
-	if sb.chain != nil && header.Number.Cmp(sb.config.QibftBlock) >= 0 {
+	if sb.chain != nil && header.Number.Cmp(sb.config.QbftBlock) >= 0 {
 		return true
 	}
 	return false
 }
 
-// qbftBlockNumber returns the qibftBlock fork block number
+// qbftBlockNumber returns the qbftBlock fork block number
 func (sb *backend) qbftBlockNumber() uint64 {
-	if sb.config.QibftBlock == nil {
+	if sb.config.QbftBlock == nil {
 		return 0
 	}
-	return sb.config.QibftBlock.Uint64()
+	return sb.config.QbftBlock.Uint64()
 }
 
-// StartQBFTConsensus stops existing legacy ibft consensus and starts the new qibft consensus
-func (sb *backend) StartQIBFTConsensus() error {
-	sb.logger.Trace("Starting QIBFT Consensus")
+// StartQBFTConsensus stops existing legacy ibft consensus and starts the new qbft consensus
+func (sb *backend) StartQBFTConsensus() error {
+	sb.logger.Trace("Starting QBFT Consensus")
 	if err := sb.Stop(); err != nil {
 		return err
 	}
 	sb.logger.Trace("Stopped legacy IBFT consensus")
 	sb.coreMu.Lock()
 	defer sb.coreMu.Unlock()
-	// Set the core to qibft
-	sb.core = qibftCore.New(sb, sb.config)
+	// Set the core to qbft
+	sb.core = qbftCore.New(sb, sb.config)
 
-	sb.logger.Trace("Starting qibft")
+	sb.logger.Trace("Starting qbft")
 	sb.config.ProposerPolicy.Use(istanbul.ValidatorSortByByteFunc)
 	if err := sb.core.Start(); err != nil {
 		return err
 	}
 
-	sb.logger.Trace("Started qibft consensus")
+	sb.logger.Trace("Started qbft consensus")
 	sb.coreStarted = true
-	sb.qibftConsensusEnabled = true
+	sb.qbftConsensusEnabled = true
 
 	return nil
 }

consensus/istanbul/backend/backend_test.go

@@ -185,20 +185,20 @@ func TestGetProposer(t *testing.T) {
 	}
 }
 
-func TestIsQIBFTConsensus(t *testing.T) {
-	// Uses Istanbul DefaultConfig which has qibftBlock set to 0
+func TestIsQBFTConsensus(t *testing.T) {
+	// Uses Istanbul DefaultConfig which has qbftBlock set to 0
 	chain, engine := newLegacyBlockChain(1)
 
-	qibftConsensus := engine.IsQIBFTConsensus()
-	if qibftConsensus {
-		t.Errorf("IsQIBFTConsensus() should return false")
+	qbftConsensus := engine.IsQBFTConsensus()
+	if qbftConsensus {
+		t.Errorf("IsQBFTConsensus() should return false")
 	}
 
-	// Set the value of qibftBlock to 1
-	engine.config.QibftBlock = big.NewInt(1)
-	qibftConsensus = engine.IsQIBFTConsensus()
-	if qibftConsensus {
-		t.Errorf("IsQIBFTConsensus() should return false")
+	// Set the value of qbftBlock to 1
+	engine.config.QbftBlock = big.NewInt(1)
+	qbftConsensus = engine.IsQBFTConsensus()
+	if qbftConsensus {
+		t.Errorf("IsQBFTConsensus() should return false")
 	}
 
 	// Create an insert a new block into the chain.
@@ -208,9 +208,9 @@ func TestIsQIBFTConsensus(t *testing.T) {
 		t.Errorf("Error inserting block: %v", err)
 	}
 
-	qibftConsensus = engine.IsQIBFTConsensus()
-	if !qibftConsensus {
-		t.Errorf("IsQIBFTConsensus() should return true after block insertion")
+	qbftConsensus = engine.IsQBFTConsensus()
+	if !qbftConsensus {
+		t.Errorf("IsQBFTConsensus() should return true after block insertion")
 	}
 }
 

consensus/istanbul/backend/engine.go

@@ -29,7 +29,7 @@ import (
 	"github.com/ethereum/go-ethereum/consensus/istanbul"
 	istanbulCore "github.com/ethereum/go-ethereum/consensus/istanbul/core"
 	"github.com/ethereum/go-ethereum/consensus/istanbul/validator"
-	qibftCore "github.com/ethereum/go-ethereum/consensus/qibft/core"
+	qbftCore "github.com/ethereum/go-ethereum/consensus/qbft/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
@@ -102,7 +102,7 @@ var (
 // block, which may be different from the header's coinbase if a consensus
 // engine is based on signatures.
 func (sb *backend) Author(header *types.Header) (common.Address, error) {
-	if sb.IsQIBFTConsensus() {
+	if sb.IsQBFTConsensus() {
 		return ecrecoverFromCoinbase(header)
 	}
 	return ecrecoverFromSignedHeader(header)
@@ -120,7 +120,7 @@ func (sb *backend) Signers(header *types.Header, isQbft bool) ([]common.Address,
 			return []common.Address{}, err
 		}
 		committedSeal = extra.CommittedSeal
-		proposalSeal = qibftCore.PrepareCommittedSeal(header, extra.Round)
+		proposalSeal = qbftCore.PrepareCommittedSeal(header, extra.Round)
 	} else {
 		extra, err := types.ExtractIstanbulExtra(header)
 		if err != nil {
@@ -178,7 +178,7 @@ func (sb *backend) verifyHeader(chain consensus.ChainHeaderReader, header *types
 	}
 
 	// Ensure that the extra data format is satisfied
-	if sb.IsQIBFTConsensus() {
+	if sb.IsQBFTConsensus() {
 		if _, err := types.ExtractQbftExtra(header); err != nil {
 			return errInvalidExtraDataFormat
 		}
@@ -328,7 +328,7 @@ func (sb *backend) verifyCommittedSeals(chain consensus.ChainHeaderReader, heade
 	}
 
 	var committedSeal [][]byte
-	if sb.IsQIBFTConsensus() {
+	if sb.IsQBFTConsensus() {
 		extra, err := types.ExtractQbftExtra(header)
 		if err != nil {
 			return err
@@ -350,7 +350,7 @@ func (sb *backend) verifyCommittedSeals(chain consensus.ChainHeaderReader, heade
 	validators := snap.ValSet.Copy()
 	// Check whether the committed seals are generated by parent's validators
 	validSeal := 0
-	committers, err := sb.Signers(header, sb.IsQIBFTConsensus())
+	committers, err := sb.Signers(header, sb.IsQBFTConsensus())
 	if err != nil {
 		return err
 	}
@@ -389,8 +389,8 @@ func (sb *backend) VerifySeal(chain consensus.ChainHeaderReader, header *types.H
 // Prepare initializes the consensus fields of a block header according to the
 // rules of a particular engine. The changes are executed inline.
 func (sb *backend) Prepare(chain consensus.ChainHeaderReader, header *types.Header) error {
-	// Check if QiBFT Consensus is used, call the QbftPrepare() is that is the case
-	if sb.IsQIBFTConsensus() {
+	// Check if QBFT Consensus is used, call the QbftPrepare() is that is the case
+	if sb.IsQBFTConsensus() {
 		return sb.QbftPrepare(chain, header)
 	}
 	// unused fields, force to set to empty
@@ -606,7 +606,7 @@ func (sb *backend) Seal(chain consensus.ChainHeaderReader, block *types.Block, r
 // update timestamp and signature of the block based on its number of transactions
 func (sb *backend) updateBlock(parent *types.Header, block *types.Block) (*types.Block, error) {
 	header := block.Header()
-	if sb.IsQIBFTConsensus() {
+	if sb.IsQBFTConsensus() {
 		header.Coinbase = sb.address
 	} else {
 		// sign the hash
@@ -653,9 +653,9 @@ func (sb *backend) Start(chain consensus.ChainHeaderReader, currentBlock func()
 	sb.currentBlock = currentBlock
 	sb.hasBadBlock = hasBadBlock
 
-	// Check if qibft Consensus needs to be used after chain is set
-	if sb.IsQIBFTConsensus() {
-		sb.core = qibftCore.New(sb, sb.config)
+	// Check if qbft Consensus needs to be used after chain is set
+	if sb.IsQBFTConsensus() {
+		sb.core = qbftCore.New(sb, sb.config)
 		sb.logger.Trace("Setting ProposerPolicy sorter to ValidatorSortByByteFunc and sort")
 		sb.config.ProposerPolicy.Use(istanbul.ValidatorSortByByteFunc)
 	} else {
@@ -668,9 +668,9 @@ func (sb *backend) Start(chain consensus.ChainHeaderReader, currentBlock func()
 
 	sb.coreStarted = true
 
-	if sb.IsQIBFTConsensus() {
-		sb.logger.Trace("Started qibft consensus")
-		sb.qibftConsensusEnabled = true
+	if sb.IsQBFTConsensus() {
+		sb.logger.Trace("Started qbft consensus")
+		sb.qbftConsensusEnabled = true
 	}
 
 	return nil
@@ -688,8 +688,8 @@ func (sb *backend) Stop() error {
 	}
 	sb.coreStarted = false
 
-	if sb.IsQIBFTConsensus() {
-		sb.qibftConsensusEnabled = false
+	if sb.IsQBFTConsensus() {
+		sb.qbftConsensusEnabled = false
 	}
 
 	return nil
@@ -724,7 +724,7 @@ func (sb *backend) snapshot(chain consensus.ChainHeaderReader, number uint64, ha
 			}
 			// Get the validators from genesis to create a snapshot
 			var validators []common.Address
-			if sb.IsQIBFTConsensus() {
+			if sb.IsQBFTConsensus() {
 				qbftExtra, err := types.ExtractQbftExtra(genesis)
 				if err != nil {
 					return nil, err
@@ -768,7 +768,7 @@ func (sb *backend) snapshot(chain consensus.ChainHeaderReader, number uint64, ha
 	for i := 0; i < len(headers)/2; i++ {
 		headers[i], headers[len(headers)-1-i] = headers[len(headers)-1-i], headers[i]
 	}
-	snap, err := snap.apply(headers, sb.IsQIBFTConsensus(), sb.qbftBlockNumber())
+	snap, err := snap.apply(headers, sb.IsQBFTConsensus(), sb.qbftBlockNumber())
 	if err != nil {
 		return nil, err
 	}
@@ -808,10 +808,10 @@ func sigHash(header *types.Header, isQbftConsensus bool) (hash common.Hash) {
 
 // SealHash returns the hash of a block prior to it being sealed.
 func (sb *backend) SealHash(header *types.Header) common.Hash {
-	if sb.IsQIBFTConsensus() {
+	if sb.IsQBFTConsensus() {
 		header.Coinbase = sb.address
 	}
-	return sigHash(header, sb.IsQIBFTConsensus())
+	return sigHash(header, sb.IsQBFTConsensus())
 }
 
 // ecrecoverFromCoinbase extracts the Ethereum account address from coinbase.

consensus/istanbul/backend/engine_test.go

@@ -46,8 +46,8 @@ func newBlockChain(n int) (*core.BlockChain, *backend) {
 	config := istanbul.DefaultConfig
 	// Use the first key as private key
 	b, _ := New(config, nodeKeys[0], memDB).(*backend)
-	// set the qibft consensus enabled to true
-	b.qibftConsensusEnabled = true
+	// set the qbft consensus enabled to true
+	b.qbftConsensusEnabled = true
 	genesis.MustCommit(memDB)
 	blockchain, err := core.NewBlockChain(memDB, nil, genesis.Config, b, vm.Config{}, nil, nil)
 	if err != nil {
@@ -85,7 +85,7 @@ func newLegacyBlockChain(n int) (*core.BlockChain, *backend) {
 	// Use the first key as private key
 	b, _ := New(config, nodeKeys[0], memDB).(*backend)
 
-	config.QibftBlock = nil
+	config.QbftBlock = nil
 
 	genesis.MustCommit(memDB)
 	blockchain, err := core.NewBlockChain(memDB, nil, genesis.Config, b, vm.Config{}, nil, nil)
@@ -210,7 +210,7 @@ func makeBlockWithoutSeal(chain *core.BlockChain, engine *backend, parent *types
 
 func TestLegacyPrepare(t *testing.T) {
 	chain, engine := newBlockChain(1)
-	chain.Config().Istanbul.QibftBlock = nil
+	chain.Config().Istanbul.QbftBlock = nil
 	header := makeHeader(chain.Genesis(), engine.config)
 	err := engine.Prepare(chain, header)
 	if err != nil {