put difflayer into verifyManage cache when node restart

core/block_validator.go

@@ -41,17 +41,21 @@ type BlockValidator struct {
 }
 
 // NewBlockValidator returns a new block validator which is safe for re-use
-func NewBlockValidator(config *params.ChainConfig, blockchain *BlockChain, engine consensus.Engine, mode VerifyMode, peers verifyPeers) *BlockValidator {
+func NewBlockValidator(config *params.ChainConfig, blockchain *BlockChain, engine consensus.Engine, mode VerifyMode, peers verifyPeers) (*BlockValidator, error) {
 	validator := &BlockValidator{
 		config: config,
 		engine: engine,
 		bc:     blockchain,
 	}
 	if mode.NeedRemoteVerify() {
-		validator.remoteValidator = NewVerifyManager(blockchain, peers, mode == InsecureVerify)
+		remoteValidator, err := NewVerifyManager(blockchain, peers, mode == InsecureVerify)
+		if err != nil {
+			return nil, err
+		}
+		validator.remoteValidator = remoteValidator
 		go validator.remoteValidator.mainLoop()
 	}
-	return validator
+	return validator, nil
 }
 
 // ValidateBody validates the given block's uncles and verifies the block

core/blockchain.go

@@ -164,7 +164,7 @@ var defaultCacheConfig = &CacheConfig{
 	SnapshotWait:   true,
 }
 
-type BlockChainOption func(*BlockChain) *BlockChain
+type BlockChainOption func(*BlockChain) (*BlockChain, error)
 
 // BlockChain represents the canonical chain given a database with a genesis
 // block. The Blockchain manages chain imports, reverts, chain reorganisations.
@@ -198,16 +198,16 @@ type BlockChain struct {
 	txLookupLimit uint64
 	triesInMemory uint64
 
-	hc            *HeaderChain
-	rmLogsFeed    event.Feed
-	chainFeed     event.Feed
-	chainSideFeed event.Feed
-	chainHeadFeed event.Feed
+	hc             *HeaderChain
+	rmLogsFeed     event.Feed
+	chainFeed      event.Feed
+	chainSideFeed  event.Feed
+	chainHeadFeed  event.Feed
 	chainBlockFeed event.Feed
-	logsFeed      event.Feed
-	blockProcFeed event.Feed
-	scope         event.SubscriptionScope
-	genesisBlock  *types.Block
+	logsFeed       event.Feed
+	blockProcFeed  event.Feed
+	scope          event.SubscriptionScope
+	genesisBlock   *types.Block
 
 	chainmu sync.RWMutex // blockchain insertion lock
 
@@ -451,7 +451,10 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, chainConfig *par
 	}
 	// do options before start any routine
 	for _, option := range options {
-		bc = option(bc)
+		bc, err = option(bc)
+		if err != nil {
+			return nil, err
+		}
 	}
 	// Take ownership of this particular state
 	go bc.update()
@@ -525,7 +528,6 @@ func (bc *BlockChain) cacheDiffLayer(diffLayer *types.DiffLayer, sorted bool) {
 		bc.diffLayerCache.RemoveOldest()
 	}
 
-	//json.MarshalIndent()
 	bc.diffLayerCache.Add(diffLayer.BlockHash, diffLayer)
 	if cached, ok := bc.diffLayerChanCache.Get(diffLayer.BlockHash); ok {
 		diffLayerCh := cached.(chan struct{})
@@ -3145,27 +3147,31 @@ func (bc *BlockChain) SubscribeBlockProcessingEvent(ch chan<- bool) event.Subscr
 }
 
 // Options
-func EnableLightProcessor(bc *BlockChain) *BlockChain {
+func EnableLightProcessor(bc *BlockChain) (*BlockChain, error) {
 	bc.processor = NewLightStateProcessor(bc.Config(), bc, bc.engine)
-	return bc
+	return bc, nil
 }
 
-func EnablePipelineCommit(bc *BlockChain) *BlockChain {
+func EnablePipelineCommit(bc *BlockChain) (*BlockChain, error) {
 	bc.pipeCommit = true
-	return bc
+	return bc, nil
 }
 
 func EnablePersistDiff(limit uint64) BlockChainOption {
-	return func(chain *BlockChain) *BlockChain {
+	return func(chain *BlockChain) (*BlockChain, error) {
 		chain.diffLayerFreezerBlockLimit = limit
-		return chain
+		return chain, nil
 	}
 }
 
 func EnableBlockValidator(chainConfig *params.ChainConfig, engine consensus.Engine, mode VerifyMode, peers verifyPeers) BlockChainOption {
-	return func(bc *BlockChain) *BlockChain {
-		bc.validator = NewBlockValidator(chainConfig, bc, engine, mode, peers)
-		return bc
+	return func(bc *BlockChain) (*BlockChain, error) {
+		validator, err := NewBlockValidator(chainConfig, bc, engine, mode, peers)
+		if err != nil {
+			return bc, err
+		}
+		bc.validator = validator
+		return bc, nil
 	}
 }
 
@@ -3289,7 +3295,6 @@ func (bc *BlockChain) GenerateDiffLayer(blockHash common.Hash) (*types.DiffLayer
 	if diffLayer != nil {
 		diffLayer.BlockHash = blockHash
 		diffLayer.Number = block.NumberU64()
-
 		bc.cacheDiffLayer(diffLayer, true)
 	}
 

core/blockchain_diff_test.go

@@ -499,8 +499,8 @@ func newTwoForkedBlockchains(len1, len2 int) (chain1 *BlockChain, chain2 *BlockC
 		Config: params.TestChainConfig,
 		Alloc:  GenesisAlloc{testAddr: {Balance: big.NewInt(100000000000000000)}},
 	}).MustCommit(db1)
-
-	chain1, _ = NewBlockChain(db1, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil, EnablePersistDiff(860000))
+	engine1 := ethash.NewFaker()
+	chain1, _ = NewBlockChain(db1, nil, params.TestChainConfig, engine1, vm.Config{}, nil, nil, EnablePersistDiff(860000), EnableBlockValidator(params.TestChainConfig, engine1, 0, nil))
 	generator1 := func(i int, block *BlockGen) {
 		// The chain maker doesn't have access to a chain, so the difficulty will be
 		// lets unset (nil). Set it here to the correct value.
@@ -555,7 +555,8 @@ func newTwoForkedBlockchains(len1, len2 int) (chain1 *BlockChain, chain2 *BlockC
 		Config: params.TestChainConfig,
 		Alloc:  GenesisAlloc{testAddr: {Balance: big.NewInt(100000000000000000)}},
 	}).MustCommit(db2)
-	chain2, _ = NewBlockChain(db2, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil, EnablePersistDiff(860000))
+	engine2 := ethash.NewFaker()
+	chain2, _ = NewBlockChain(db2, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil, EnablePersistDiff(860000), EnableBlockValidator(params.TestChainConfig, engine2, 0, nil))
 	generator2 := func(i int, block *BlockGen) {
 		// The chain maker doesn't have access to a chain, so the difficulty will be
 		// lets unset (nil). Set it here to the correct value.
@@ -659,7 +660,7 @@ func newBlockChainWithCliqueEngine(blocks int) *BlockChain {
 	copy(genspec.ExtraData[32:], testAddr[:])
 	genesis := genspec.MustCommit(db)
 
-	chain, _ := NewBlockChain(db, nil, params.AllCliqueProtocolChanges, engine, vm.Config{}, nil, nil)
+	chain, _ := NewBlockChain(db, nil, params.AllCliqueProtocolChanges, engine, vm.Config{}, nil, nil, EnableBlockValidator(params.AllCliqueProtocolChanges, engine, 0 /*LocalVerify*/, nil))
 	generator := func(i int, block *BlockGen) {
 		// The chain maker doesn't have access to a chain, so the difficulty will be
 		// lets unset (nil). Set it here to the correct value.

core/blockchain_test.go

@@ -252,7 +252,7 @@ func TestBlockImportVerification(t *testing.T) {
 	}
 	defer processor.Stop()
 	// Start fork from current height
-	processor = EnablePipelineCommit(processor)
+	processor, _ = EnablePipelineCommit(processor)
 	testInvalidStateRootBlockImport(t, processor, length, 10, true)
 }
 

core/error.go

@@ -35,6 +35,9 @@ var (
 	// ErrDiffLayerNotFound is returned when diff layer not found.
 	ErrDiffLayerNotFound = errors.New("diff layer not found")
 
+	// ErrCurrentBlockNotFound is returned when current block not found.
+	ErrCurrentBlockNotFound = errors.New("current block not found")
+
 	// ErrKnownBadBlock is return when the block is a known bad block
 	ErrKnownBadBlock = errors.New("already known bad block")
 )

core/remote_state_verifier.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"fmt"
+	"math/big"
 	"math/rand"
 	"time"
 
@@ -45,16 +46,35 @@ type remoteVerifyManager struct {
 	allowInsecure bool
 
 	// Subscription
-	chainBlockCh  chan ChainHeadEvent
+	chainBlockCh chan ChainHeadEvent
 	chainHeadSub event.Subscription
 
 	// Channels
 	verifyCh  chan common.Hash
 	messageCh chan verifyMessage
 }
 
-func NewVerifyManager(blockchain *BlockChain, peers verifyPeers, allowInsecure bool) *remoteVerifyManager {
+func NewVerifyManager(blockchain *BlockChain, peers verifyPeers, allowInsecure bool) (*remoteVerifyManager, error) {
 	verifiedCache, _ := lru.New(verifiedCacheSize)
+	block := blockchain.CurrentBlock()
+	if block == nil {
+		return nil, ErrCurrentBlockNotFound
+	}
+	number := block.Number()
+	for i := maxForkHeight; i >= 0; i-- {
+		if new(big.Int).Sub(number, big.NewInt(int64(i))).Cmp(common.Big0) <= 0 {
+			continue
+		}
+		oldBlock := blockchain.GetBlockByNumber(number.Uint64() - uint64(i))
+		if oldBlock == nil {
+			return nil, fmt.Errorf("block is nil, number: %d", number)
+		}
+		_, err := blockchain.GenerateDiffLayer(oldBlock.Hash())
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	vm := &remoteVerifyManager{
 		bc:            blockchain,
 		tasks:         make(map[common.Hash]*verifyTask),
@@ -63,11 +83,11 @@ func NewVerifyManager(blockchain *BlockChain, peers verifyPeers, allowInsecure b
 		allowInsecure: allowInsecure,
 
 		chainBlockCh: make(chan ChainHeadEvent, chainHeadChanSize),
-		verifyCh:    make(chan common.Hash, maxForkHeight),
-		messageCh:   make(chan verifyMessage),
+		verifyCh:     make(chan common.Hash, maxForkHeight),
+		messageCh:    make(chan verifyMessage),
 	}
 	vm.chainHeadSub = blockchain.SubscribeChainBlockEvent(vm.chainBlockCh)
-	return vm
+	return vm, nil
 }
 
 func (vm *remoteVerifyManager) mainLoop() {
@@ -219,7 +239,7 @@ type verifyTask struct {
 	candidatePeers verifyPeers
 	badPeers       map[string]struct{}
 	startAt        time.Time
-	allowInsecure bool
+	allowInsecure  bool
 
 	messageCh  chan verifyMessage
 	terminalCh chan struct{}
@@ -288,7 +308,7 @@ func (vt *verifyTask) sendVerifyRequest(n int) {
 	}
 	// if has not valid peer, log warning.
 	if len(validPeers) == 0 {
-		log.Warn("there is no valid peer for block", vt.blockHeader.Number)
+		log.Warn("there is no valid peer for block", "number", vt.blockHeader.Number)
 		return
 	}