dbft: Implement block verification callback. Close #65

Author: chenquanyu

consensus/dbft/block.go

@@ -119,3 +119,14 @@ func (b *Block) Verify(pub crypto.PublicKey, sign []byte) error {
 func (b *Block) Hash() util.Uint256 {
 	return WorkerSealHash(b.header).Uint256()
 }
+
+// Convert dbft.Blcok to types.Block
+func (b *Block) ToEthBlock() *types.Block {
+	res := types.NewBlockWithHeader(b.header)
+	// Uncles are always nil in dBFT-like consensus.
+	res = res.WithBody(b.transactions, nil)
+	if b.withdrawals != nil {
+		res = res.WithWithdrawals(b.withdrawals)
+	}
+	return res
+}

consensus/dbft/chainreader.go

@@ -4,6 +4,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/event"
 )
@@ -15,6 +16,7 @@ type ChainHeaderReader interface {
 	SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription
 	HasBlock(hash common.Hash, number uint64) bool
 	GetBlockByNumber(uint64) *types.Block
+	VerifyBlock(block *types.Block) (*state.StateDB, types.Receipts, error)
 }
 
 // ChainHeaderWriter is a Blockchain API abstraction needed for proper blockQueue

consensus/dbft/dbft.go

@@ -550,6 +550,30 @@ func New(config *params.DBFTConfig, _ ethdb.Database) (*DBFT, error) {
 
 			return nil
 		}),
+		dbft.WithVerifyBlock(func(b block.Block) bool {
+			dbftBlock := b.(*Block)
+			parent := c.chain.CurrentBlock()
+			if parent.Number.Cmp(dbftBlock.header.Number) >= 0 {
+				log.Warn("proposed block has already outdated",
+					"current block number", parent.Number.Uint64(),
+					"proposed block number", dbftBlock.header.Number)
+				return false
+			}
+			if c.lastTimestamp > dbftBlock.header.Time {
+				log.Warn("proposed block has small timestamp",
+					"ts", dbftBlock.header.Time,
+					"last", c.lastTimestamp)
+				return false
+			}
+			ethBlock := dbftBlock.ToEthBlock()
+			_, _, err := c.chain.VerifyBlock(ethBlock)
+			if err != nil {
+				log.Warn("proposed block verification failed",
+					"err", err.Error())
+				return false
+			}
+			return true
+		}),
 		dbft.WithBroadcast(func(p payload.ConsensusPayload) {
 			if err := p.(*Payload).Sign(c.dbft.Priv.(*Signer)); err != nil {
 				log.Warn("can't sign consensus payload", "error", err)

core/blockchain.go

@@ -2451,3 +2451,60 @@ func (bc *BlockChain) SetTrieFlushInterval(interval time.Duration) {
 func (bc *BlockChain) GetTrieFlushInterval() time.Duration {
 	return time.Duration(bc.flushInterval.Load())
 }
+
+// ProcessState processes the state changes according to the Ethereum rules by running
+// the transaction messages using the statedb and applying any rewards to both
+// the processor (coinbase) and any included uncles. It doesn't persist any data.
+func (bc *BlockChain) ProcessState(block *types.Block) (*state.StateDB, types.Receipts, []*types.Log, uint64, error) {
+	parent := bc.GetBlockByHash(block.ParentHash())
+	if parent == nil {
+		err := fmt.Errorf("failed to retrieve parent by hash to process block, %s: %v, %s: %s", "parent number", block.NumberU64()-1,
+			"parent hash", block.ParentHash().String())
+		log.Error(err.Error())
+		parent = bc.GetBlockByNumber(block.NumberU64() - 1)
+		if parent == nil {
+			err = fmt.Errorf("failed to retrieve canonical parent by number to process block, %s: %v, %s: %s", "parent number", block.NumberU64()-1,
+				"parent hash", block.ParentHash().String())
+			log.Error(err.Error())
+			return nil, nil, nil, 0, err
+		}
+	}
+	statedb, err := bc.StateAt(parent.Root())
+	if err != nil {
+		err = fmt.Errorf("failed to retrieve state at %s: %w", parent.Root(), err)
+		log.Error(err.Error())
+		return nil, nil, nil, 0, err
+	}
+
+	receipts, logs, usedGas, err := bc.processor.Process(block, statedb, bc.vmConfig)
+	if err != nil {
+		err = fmt.Errorf("failed to process block: %w", err)
+		log.Error(err.Error())
+		return nil, nil, nil, 0, err
+	}
+	return statedb, receipts, logs, usedGas, nil
+}
+
+// VerifyBlock checks block state
+func (bc *BlockChain) VerifyBlock(block *types.Block) (*state.StateDB, types.Receipts, error) {
+	err := bc.validator.ValidateBody(block)
+	if err != nil {
+		err = fmt.Errorf("failed to validate body: %w", err)
+		log.Error(err.Error())
+		return nil, nil, err
+	}
+
+	statedb, receipts, _, usedGas, err := bc.ProcessState(block)
+	if err != nil {
+		err = fmt.Errorf("failed to process block state: %w", err)
+		log.Error(err.Error())
+		return nil, nil, err
+	}
+
+	if err := bc.validator.ValidateState(block, statedb, receipts, usedGas); err != nil {
+		err = fmt.Errorf("failed to verify state: %w", err)
+		log.Error(err.Error())
+		return nil, nil, err
+	}
+	return statedb, receipts, nil
+}