refactor block remote validation code

core/block_validator.go

@@ -94,6 +94,13 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
  }
  return nil
  },
+ func() error {
+ if v.remoteValidator != nil && !v.remoteValidator.AncestorVerified(block.Header()) {
+ return fmt.Errorf("%w, number: %s, hash: %s", ErrAncestorHasNotBeenVerified, block.Number(), block.Hash())
+ }
+
+ return nil
+ },
  }
  validateRes := make(chan error, len(validateFuns))
  for _, f := range validateFuns {

core/blockchain.go

@@ -2092,15 +2092,6 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, er
  }()
 
  for ; block != nil && err == nil || err == ErrKnownBlock; block, err = it.next() {
- if bc.validator.RemoteVerifyManager() != nil {
- for !bc.Validator().RemoteVerifyManager().AncestorVerified(block.Header()) {
- if bc.insertStopped() {
- break
- }
- log.Info("block ancestor has not been verified", "number", block.Number(), "hash", block.Hash())
- time.Sleep(100 * time.Millisecond)
- }
- }
  // If the chain is terminating, stop processing blocks
  if bc.insertStopped() {
  log.Debug("Abort during block processing")

core/error.go

@@ -35,6 +35,9 @@ var (
  // ErrDiffLayerNotFound is returned when diff layer not found.
  ErrDiffLayerNotFound = errors.New("diff layer not found")
 
+ // ErrDiffLayerNotFound is returned when block - 11 has not been verified by the remote verifier.
+ ErrAncestorHasNotBeenVerified = errors.New("block ancestor has not been verified")
+
  // ErrCurrentBlockNotFound is returned when current block not found.
  ErrCurrentBlockNotFound = errors.New("current block not found")
 

core/remote_state_verifier.go

@@ -4,6 +4,7 @@ import (
  "fmt"
  "math/big"
  "math/rand"
+ "sync"
  "time"
 
  lru "github.com/hashicorp/golang-lru"
@@ -40,6 +41,7 @@ var (
 
 type remoteVerifyManager struct {
  bc *BlockChain
+ taskLock sync.RWMutex
  tasks map[common.Hash]*verifyTask
  peers verifyPeers
  verifiedCache *lru.Cache
@@ -109,14 +111,17 @@ func (vm *remoteVerifyManager) mainLoop() {
  vm.NewBlockVerifyTask(h.Block.Header())
  case hash := <-vm.verifyCh:
  vm.cacheBlockVerified(hash)
+ vm.taskLock.Lock()
  if task, ok := vm.tasks[hash]; ok {
  delete(vm.tasks, hash)
  verifyTaskCounter.Dec(1)
  verifyTaskSucceedMeter.Mark(1)
  verifyTaskExecutionTimer.Update(time.Since(task.startAt))
  close(task.terminalCh)
  }
+ vm.taskLock.Unlock()
  case <-pruneTicker.C:
+ vm.taskLock.Lock()
  for hash, task := range vm.tasks {
  if vm.bc.CurrentHeader().Number.Cmp(task.blockHeader.Number) == 1 &&
  vm.bc.CurrentHeader().Number.Uint64()-task.blockHeader.Number.Uint64() > pruneHeightDiff {
@@ -126,16 +131,21 @@ func (vm *remoteVerifyManager) mainLoop() {
  close(task.terminalCh)
  }
  }
+ vm.taskLock.Unlock()
  case message := <-vm.messageCh:
+ vm.taskLock.RLock()
  if vt, ok := vm.tasks[message.verifyResult.BlockHash]; ok {
  vt.messageCh <- message
  }
+ vm.taskLock.RUnlock()
 
  // System stopped
  case <-vm.bc.quit:
+ vm.taskLock.RLock()
  for _, task := range vm.tasks {
  close(task.terminalCh)
  }
+ vm.taskLock.RUnlock()
  return
  case <-vm.chainHeadSub.Err():
  return
@@ -156,7 +166,10 @@ func (vm *remoteVerifyManager) NewBlockVerifyTask(header *types.Header) {
  return
  }
  // if there already has a verify task for this block, skip.
- if _, ok := vm.tasks[hash]; ok {
+ vm.taskLock.RLock()
+ _, ok := vm.tasks[hash]
+ vm.taskLock.RUnlock()
+ if ok {
  return
  }
 
@@ -184,7 +197,9 @@ func (vm *remoteVerifyManager) NewBlockVerifyTask(header *types.Header) {
  return
  }
  verifyTask := NewVerifyTask(diffHash, header, vm.peers, vm.verifyCh, vm.allowInsecure)
+ vm.taskLock.Lock()
  vm.tasks[hash] = verifyTask
+ vm.taskLock.Unlock()
  verifyTaskCounter.Inc(1)
  }(header.Hash())
  header = vm.bc.GetHeaderByHash(header.ParentHash)
@@ -208,7 +223,16 @@ func (vm *remoteVerifyManager) AncestorVerified(header *types.Header) bool {
  }
 
  hash := header.Hash()
- _, exist := vm.verifiedCache.Get(hash)
+
+ // Check if the task is complete
+ vm.taskLock.RLock()
+ task, exist := vm.tasks[hash]
+ vm.taskLock.RUnlock()
+ if exist {
+ <-task.terminalCh
+ }
+
+ _, exist = vm.verifiedCache.Get(hash)
  return exist
 }
 

eth/downloader/downloader.go

@@ -27,6 +27,7 @@ import (
 
  "github.com/ethereum/go-ethereum"
  "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
  "github.com/ethereum/go-ethereum/core/rawdb"
  "github.com/ethereum/go-ethereum/core/state/snapshot"
  "github.com/ethereum/go-ethereum/core/types"
@@ -1812,6 +1813,9 @@ func (d *Downloader) importBlockResults(results []*fetchResult) error {
  // of the blocks delivered from the downloader, and the indexing will be off.
  log.Debug("Downloaded item processing failed on sidechain import", "index", index, "err", err)
  }
+ if errors.Is(err, core.ErrAncestorHasNotBeenVerified) {
+ return err
+ }
  return fmt.Errorf("%w: %v", errInvalidChain, err)
  }
  return nil