update for move pivot

accounts/abi/bind/backends/simulated.go

@@ -117,7 +117,7 @@ func (b *SimulatedBackend) Commit() {
 		panic(err) // This cannot happen unless the simulator is wrong, fail in that case
 	}
 	stateDB, _ := b.blockchain.State()
-	b.blockchain.WriteBlockWithState(b.pendingBlock, b.pendingReceipts, nil, stateDB, true)
+	b.blockchain.WriteBlockWithState(b.pendingBlock, b.pendingReceipts, nil, stateDB, true, nil)
 	b.rollback()
 }
 

cmd/utils/cmd.go

@@ -126,11 +126,11 @@ func monitorFreeDiskSpace(sigc chan os.Signal, path string, freeDiskSpaceCritica
 			break
 		}
 		if freeSpace < freeDiskSpaceCritical {
-			log.Error("Low disk space. Gracefully shutting down Geth to prevent database corruption.", "available", common.StorageSize(freeSpace))
+			log.Error("Low disk space. Gracefully shutting down PlatON to prevent database corruption.", "available", common.StorageSize(freeSpace))
 			sigc <- syscall.SIGTERM
 			break
 		} else if freeSpace < 2*freeDiskSpaceCritical {
-			log.Warn("Disk space is running low. Geth will shutdown if disk space runs below critical level.", "available", common.StorageSize(freeSpace), "critical_level", common.StorageSize(freeDiskSpaceCritical))
+			log.Warn("Disk space is running low. PlatON will shutdown if disk space runs below critical level.", "available", common.StorageSize(freeSpace), "critical_level", common.StorageSize(freeDiskSpaceCritical))
 		}
 		time.Sleep(60 * time.Second)
 	}

cmd/utils/flags.go

@@ -1353,7 +1353,7 @@ func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) ethapi.Backend
 	} else {
 		backend, err := eth.New(stack, cfg)
 		if err != nil {
-			Fatalf("Failed to register the Ethereum service: %v", err)
+			Fatalf("Failed to register the PlatON service: %v", err)
 		}
 		stack.RegisterAPIs(tracers.APIs(backend.APIBackend))
 		return backend.APIBackend

common/vm/inner_contract.go

@@ -28,6 +28,7 @@ var (
 	DelegateRewardPoolAddr     = common.HexToAddress("0x1000000000000000000000000000000000000006") // The PlatON Precompiled contract addr for delegate reward
 	ValidatorInnerContractAddr = common.HexToAddress("0x2000000000000000000000000000000000000000") // The PlatON Precompiled contract addr for cbft inner
 	VrfInnerContractAddr       = common.HexToAddress("0x3000000000000000000000000000000000000001") // The PlatON Precompiled contract addr for vrf inner
+	BlsVerifyContractAddr      = common.HexToAddress("0x3000000000000000000000000000000000000002") // The PlatON Precompiled contract addr for bls verify
 )
 
 type PrecompiledContractCheck interface {

consensus/bft_mock.go

@@ -165,7 +165,7 @@ func (bm *BftMock) Author(header *types.Header) (common.Address, error) {
 // VerifyHeader checks whether a header conforms to the consensus rules of a
 // given engine. Verifying the seal may be done optionally here, or explicitly
 // via the VerifySeal method.
-func (bm *BftMock) VerifyHeader(chain ChainReader, header *types.Header, seal bool) error {
+func (bm *BftMock) VerifyHeader(chain ChainReader, header *types.Header, async bool) error {
 	if bm.fakeFail == header.Number.Uint64() {
 		return fmt.Errorf("failed verifyHeader on bftMock")
 	}
@@ -287,35 +287,12 @@ func (bm *BftMock) ConsensusNodes() ([]enode.ID, error) {
 	return nil, nil
 }
 
-// ShouldSeal returns whether the current node is out of the block
-func (bm *BftMock) ShouldSeal(curTime time.Time) (bool, error) {
-	return true, nil
-}
-
-// OnBlockSignature received a new block signature
-// Need to verify if the signature is signed by nodeID
-func (bm *BftMock) OnBlockSignature(chain ChainReader, nodeID enode.IDv0, sig *cbfttypes.BlockSignature) error {
-	return nil
-}
-
-// OnNewBlock processes the BFT signatures
-func (bm *BftMock) OnNewBlock(chain ChainReader, block *types.Block) error {
+func (bm *BftMock) ConsensusValidators() []*cbfttypes.ValidateNode {
 	return nil
 }
 
-// OnPong processes the BFT signatures
-func (bm *BftMock) OnPong(nodeID enode.IDv0, netLatency int64) error {
-	return nil
-
-}
-
-// OnBlockSynced sends a signal if a block synced from other peer.
-func (bm *BftMock) OnBlockSynced() {
-
-}
-
-// CheckConsensusNode is a fake interface, no need to implement.
-func (bm *BftMock) CheckConsensusNode(nodeID enode.IDv0) (bool, error) {
+// ShouldSeal returns whether the current node is out of the block
+func (bm *BftMock) ShouldSeal(curTime time.Time) (bool, error) {
 	return true, nil
 }
 
@@ -324,16 +301,6 @@ func (bm *BftMock) IsConsensusNode() bool {
 	return true
 }
 
-// HighestLogicalBlock is a fake interface, no need to implement.
-func (bm *BftMock) HighestLogicalBlock() *types.Block {
-	return nil
-}
-
-// HighestConfirmedBlock is a fake interface, no need to implement.
-func (bm *BftMock) HighestConfirmedBlock() *types.Block {
-	return nil
-}
-
 // GetBlock is a fake interface, no need to implement.
 func (bm *BftMock) GetBlock(hash common.Hash, number uint64) *types.Block {
 	return nil
@@ -364,32 +331,17 @@ func (bm *BftMock) GetBlockByHashAndNum(hash common.Hash, number uint64) *types.
 	return nil
 }
 
-// Status is a fake interface, no need to implement.
-func (bm *BftMock) Status() string {
-	return ""
-}
-
 // CurrentBlock is a fake interface, no need to implement.
 func (bm *BftMock) CurrentBlock() *types.Block {
-	//if len(bm.Blocks) == 0 {
-	//	h := types.Header{Number: big.NewInt(0)}
-	//	return types.NewBlockWithHeader(&h)
-	//}
-	//return bm.Blocks[len(bm.Blocks)-1]
 	return bm.Current
 }
 
 // TracingSwitch is a fake interface, no need to implement.
-func (bm *BftMock) TracingSwitch(flag int8) {
-
-}
+func (bm *BftMock) TracingSwitch(flag int8) {}
 
-func (bm *BftMock) Pause() {
+func (bm *BftMock) Pause() {}
 
-}
-func (bm *BftMock) Resume() {
-
-}
+func (bm *BftMock) Resume() {}
 
 func (bm *BftMock) Syncing() bool {
 	return false

consensus/cbft/cbft.go

@@ -325,7 +325,7 @@ func (cbft *Cbft) ReceiveMessage(msg *ctypes.MsgInfo) error {
 
 	cMsg := msg.Msg.(ctypes.ConsensusMsg)
 	if invalidMsg(cMsg.EpochNum(), cMsg.ViewNum()) {
-		cbft.log.Debug("Invalid msg", "peer", msg.PeerID, "type", reflect.TypeOf(msg.Msg), "msg", msg.Msg.String())
+		cbft.log.Trace("Invalid msg", "peer", msg.PeerID, "type", reflect.TypeOf(msg.Msg), "msg", msg.Msg.String())
 		return nil
 	}
 
@@ -641,7 +641,7 @@ func (cbft *Cbft) Author(header *types.Header) (common.Address, error) {
 	return header.Coinbase, nil
 }
 
-func (cbft *Cbft) VerifyHeader(chain consensus.ChainReader, header *types.Header, seal bool) error {
+func (cbft *Cbft) VerifyHeader(chain consensus.ChainReader, header *types.Header, async bool) error {
 	// Short circuit if the header is known, or its parent not
 	number := header.Number.Uint64()
 	if chain.GetHeader(header.Hash(), number) != nil {
@@ -650,7 +650,12 @@ func (cbft *Cbft) VerifyHeader(chain consensus.ChainReader, header *types.Header
 
 	parent := chain.GetHeader(header.ParentHash, number-1)
 	if parent == nil {
-		parentBlock := cbft.GetBlockWithoutLock(header.ParentHash, number-1)
+		var parentBlock *types.Block
+		if async {
+			parentBlock = cbft.GetBlockWithLock(header.ParentHash, number-1)
+		} else {
+			parentBlock = cbft.GetBlockWithoutLock(header.ParentHash, number-1)
+		}
 		if parentBlock != nil {
 			parent = parentBlock.Header()
 		}
@@ -738,7 +743,7 @@ func (cbft *Cbft) verifyHeaderWorker(chain consensus.ChainReader, headers []*typ
 	if index == 0 {
 		parent = chain.GetHeader(headers[0].ParentHash, headers[0].Number.Uint64()-1)
 		if parent == nil {
-			parentBlock := cbft.GetBlockWithoutLock(headers[0].ParentHash, headers[0].Number.Uint64()-1)
+			parentBlock := cbft.GetBlockWithLock(headers[0].ParentHash, headers[0].Number.Uint64()-1)
 			if parentBlock != nil {
 				parent = parentBlock.Header()
 			}
@@ -1180,6 +1185,16 @@ func (cbft *Cbft) ConsensusNodes() ([]enode.ID, error) {
 	return cbft.validatorPool.ValidatorList(cbft.state.Epoch()), nil
 }
 
+// ConsensusNodes returns to the list of consensus nodes.
+func (cbft *Cbft) ConsensusValidators() []*cbfttypes.ValidateNode {
+	vs := cbft.validatorPool.Validators(cbft.state.Epoch())
+	nodeList := make([]*cbfttypes.ValidateNode, 0)
+	for _, node := range vs.Nodes {
+		nodeList = append(nodeList, node)
+	}
+	return nodeList
+}
+
 // ShouldSeal check if we can seal block.
 func (cbft *Cbft) ShouldSeal(curTime time.Time) (bool, error) {
 	if cbft.isLoading() || !cbft.isStart() || !cbft.running() {
@@ -1312,6 +1327,25 @@ func (cbft *Cbft) GetBlock(hash common.Hash, number uint64) *types.Block {
 	return <-result
 }
 
+// GetBlockWithLock synchronously obtains blocks according to the specified number and hash.
+func (cbft *Cbft) GetBlockWithLock(hash common.Hash, number uint64) *types.Block {
+	result := make(chan *types.Block, 1)
+
+	cbft.asyncCallCh <- func() {
+		block, _ := cbft.blockTree.FindBlockAndQC(hash, number)
+		if block == nil {
+			if eb := cbft.state.FindBlock(hash, number); eb != nil {
+				block = eb
+			} else {
+				cbft.log.Debug("Get block failed", "hash", hash, "number", number)
+			}
+		}
+		result <- block
+	}
+
+	return <-result
+}
+
 // GetBlockWithoutLock returns the block corresponding to the specified number and hash.
 func (cbft *Cbft) GetBlockWithoutLock(hash common.Hash, number uint64) *types.Block {
 	block, _ := cbft.blockTree.FindBlockAndQC(hash, number)

consensus/cbft/sync_process.go

@@ -248,7 +248,7 @@ func (cbft *Cbft) prepareVoteFetchRules(id string, vote *protocols.PrepareVote)
 func (cbft *Cbft) OnGetPrepareBlock(id string, msg *protocols.GetPrepareBlock) error {
 	if msg.Epoch == cbft.state.Epoch() && msg.ViewNumber == cbft.state.ViewNumber() {
 		prepareBlock := cbft.state.PrepareBlockByIndex(msg.BlockIndex)
-		if prepareBlock != nil {
+		if prepareBlock != nil && prepareBlock.Signature.NotEmpty() {
 			cbft.log.Debug("Send PrepareBlock", "peer", id, "prepareBlock", prepareBlock.String())
 			cbft.network.Send(id, prepareBlock)
 		}

consensus/cbft/types/crypto.go

@@ -14,10 +14,10 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the PlatON-Go library. If not, see <http://www.gnu.org/licenses/>.
 
-
 package types
 
 import (
+	"bytes"
 	"fmt"
 	"reflect"
 
@@ -48,6 +48,11 @@ func (sig *Signature) Bytes() []byte {
 	return target
 }
 
+func (sig *Signature) NotEmpty() bool {
+	var a Signature
+	return bytes.Compare(sig.Bytes(), a.Bytes()) != 0
+}
+
 // MarshalText returns the hex representation of a.
 func (sig Signature) MarshalText() ([]byte, error) {
 	return hexutil.Bytes(sig[:]).MarshalText()

consensus/cbft/types/crypto_test.go

@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the PlatON-Go library. If not, see <http://www.gnu.org/licenses/>.
 
-
 package types
 
 import (
@@ -106,3 +105,12 @@ func Test_ViewChangeQC_MaxBlock(t *testing.T) {
 	epoch, viewNumber, blockEpoch, blockViewNumber, blockHash, blockNumber = viewChangeQC.MaxBlock()
 	assert.Equal(t, uint64(0), epoch)
 }
+
+func Test_Signature_NotEmpty(t *testing.T) {
+	var sig Signature
+	assert.False(t, sig.NotEmpty())
+	sig = Signature{byte(0), byte(0), byte(0)}
+	assert.False(t, sig.NotEmpty())
+	sig = Signature{byte(0), byte(0), byte(1)}
+	assert.True(t, sig.NotEmpty())
+}

consensus/cbft/validator/validator.go

@@ -419,6 +419,17 @@ func (vp *ValidatorPool) Update(blockNumber uint64, epoch uint64, eventMux *even
 
 	isValidatorAfter := vp.isValidator(epoch, vp.nodeID)
 
+	if isValidatorBefore || isValidatorAfter {
+		nodes := make(map[enode.ID]struct{})
+		for _, validator := range vp.currentValidators.Nodes {
+			nodes[validator.NodeID] = struct{}{}
+		}
+		eventMux.Post(cbfttypes.UpdateValidatorEvent{Nodes: nodes})
+	}
+
+	removes := make([]*enode.Node, 0)
+	adds := make([]*enode.Node, 0)
+
 	if isValidatorBefore {
 		// If we are still a consensus node, that adding
 		// new validators as consensus peer, and removing
@@ -427,23 +438,24 @@ func (vp *ValidatorPool) Update(blockNumber uint64, epoch uint64, eventMux *even
 		// in the consensus stages. Also we are not needed
 		// to keep connect with old validators.
 		if isValidatorAfter {
-			for nodeID, vnode := range vp.currentValidators.Nodes {
-				if node, _ := vp.prevValidators.FindNodeByID(nodeID); node == nil {
-					eventMux.Post(cbfttypes.AddValidatorEvent{Node: enode.NewV4(vnode.PubKey, nil, 0, 0)})
-					log.Trace("Post AddValidatorEvent", "nodeID", nodeID.String())
+			for nodeID, vnode := range vp.prevValidators.Nodes {
+				if node, _ := vp.currentValidators.FindNodeByID(nodeID); node == nil {
+					removes = append(removes, enode.NewV4(vnode.PubKey, nil, 0, 0))
+					log.Trace("add to RemoveValidatorEvent", "nodeID", nodeID, "isValidatorAfter")
 				}
 			}
 
-			for nodeID, vnode := range vp.prevValidators.Nodes {
-				if node, _ := vp.currentValidators.FindNodeByID(nodeID); node == nil {
-					eventMux.Post(cbfttypes.RemoveValidatorEvent{Node: enode.NewV4(vnode.PubKey, nil, 0, 0)})
-					log.Trace("Post RemoveValidatorEvent", "nodeID", nodeID.String())
+			for nodeID, vnode := range vp.currentValidators.Nodes {
+				if node, _ := vp.prevValidators.FindNodeByID(nodeID); node == nil {
+					adds = append(adds, enode.NewV4(vnode.PubKey, nil, 0, 0))
+					log.Trace("add to AddValidatorEvent", "nodeID", nodeID)
 				}
 			}
+
 		} else {
 			for nodeID, vnode := range vp.prevValidators.Nodes {
-				eventMux.Post(cbfttypes.RemoveValidatorEvent{Node: enode.NewV4(vnode.PubKey, nil, 0, 0)})
-				log.Trace("Post RemoveValidatorEvent", "nodeID", nodeID.String())
+				removes = append(removes, enode.NewV4(vnode.PubKey, nil, 0, 0))
+				log.Trace("add to RemoveValidatorEvent", "nodeID", nodeID)
 			}
 		}
 	} else {
@@ -453,12 +465,19 @@ func (vp *ValidatorPool) Update(blockNumber uint64, epoch uint64, eventMux *even
 		// with other validators in the consensus stages.
 		if isValidatorAfter {
 			for nodeID, vnode := range vp.currentValidators.Nodes {
-				eventMux.Post(cbfttypes.AddValidatorEvent{Node: enode.NewV4(vnode.PubKey, nil, 0, 0)})
-				log.Trace("Post AddValidatorEvent", "nodeID", nodeID.String())
+				adds = append(adds, enode.NewV4(vnode.PubKey, nil, 0, 0))
+				log.Trace("add to  AddValidatorEvent", "nodeID", nodeID)
 			}
 		}
 	}
-
+	if len(removes) > 0 {
+		eventMux.Post(cbfttypes.RemoveValidatorEvent{Nodes: removes})
+		log.Trace("Post RemoveValidatorEvent", "num", len(removes), "isValidatorBefore", isValidatorBefore, "isValidatorAfter", isValidatorAfter)
+	}
+	if len(adds) > 0 {
+		eventMux.Post(cbfttypes.AddValidatorEvent{Nodes: adds})
+		log.Trace("Post AddValidatorEvent", "num", len(adds), "isValidatorBefore", isValidatorBefore, "isValidatorAfter", isValidatorAfter)
+	}
 	return nil
 }
 

consensus/consensus.go

@@ -81,7 +81,7 @@ type Engine interface {
 	// VerifyHeader checks whether a header conforms to the consensus rules of a
 	// given engine. Verifying the seal may be done optionally here, or explicitly
 	// via the VerifySeal method.
-	VerifyHeader(chain ChainReader, header *types.Header, seal bool) error
+	VerifyHeader(chain ChainReader, header *types.Header, async bool) error
 
 	// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
 	// concurrently. The method returns a quit channel to abort the operations and
@@ -180,6 +180,8 @@ type Bft interface {
 	// Returns the current consensus node address list.
 	ConsensusNodes() ([]enode.ID, error)
 
+	ConsensusValidators() []*cbfttypes.ValidateNode
+
 	// Returns whether the current node is out of the block
 	ShouldSeal(curTime time.Time) (bool, error)