[blockchain] add ValidateBlock() to fullsync check

Author: dustinxie

blockchain/block/block.go

@@ -6,6 +6,7 @@
 package block
 
 import (
+	"context"
 	"time"
 
 	"github.com/ethereum/go-ethereum/core/types"
@@ -20,6 +21,8 @@ import (
 	"github.com/iotexproject/iotex-core/v2/pkg/log"
 )
 
+type BlockValidator func(context.Context, *Block) error
+
 // Block defines the struct of block
 type Block struct {
 	Header

blockchain/blockchain.go

@@ -206,6 +206,12 @@ func NewBlockchain(cfg Config, g genesis.Genesis, dao blockdao.BlockDAO, bbf Blo
 	if chain.dao == nil {
 		log.L().Panic("blockdao is nil")
 	}
+	chain.dao.SetBlockValidator(func(ctx context.Context, blk *block.Block) error {
+		if chain.blockValidator == nil {
+			return nil
+		}
+		return chain.blockValidator.Validate(ctx, blk)
+	})
 	chain.lifecycle.Add(chain.dao)
 	chain.lifecycle.Add(chain.pubSubManager)
 

blockchain/blockdao/blockdao.go

@@ -42,6 +42,7 @@ type (
 		BlockStore
 		GetBlob(hash.Hash256) (*types.BlobTxSidecar, string, error)
 		GetBlobsByHeight(uint64) ([]*types.BlobTxSidecar, []string, error)
+		SetBlockValidator(block.BlockValidator)
 	}
 
 	BlockStore interface {
@@ -65,6 +66,7 @@ type (
 		blockStore   BlockStore
 		blobStore    BlobStore
 		indexers     []BlockIndexer
+		validator    block.BlockValidator
 		timerFactory *prometheustimer.TimerFactory
 		lifecycle    lifecycle.Lifecycle
 		headerCache  cache.LRUCache
@@ -126,6 +128,10 @@ func NewBlockDAOWithIndexersAndCache(blkStore BlockStore, indexers []BlockIndexe
 	return blockDAO
 }
 
+func (dao *blockDAO) SetBlockValidator(v block.BlockValidator) {
+	dao.validator = v
+}
+
 // Start starts block DAO and initiates the top height if it doesn't exist
 func (dao *blockDAO) Start(ctx context.Context) error {
 	err := dao.lifecycle.OnStart(ctx)
@@ -142,8 +148,13 @@ func (dao *blockDAO) Start(ctx context.Context) error {
 }
 
 func (dao *blockDAO) checkIndexers(ctx context.Context) error {
-	checker := NewBlockIndexerChecker(dao)
+	var checker *BlockIndexerChecker
 	for i, indexer := range dao.indexers {
+		if _, ok := indexer.(BlockIndexerStateDBWriter); ok {
+			checker = NewBlockIndexerChecker(dao, dao.validator)
+		} else {
+			checker = NewBlockIndexerChecker(dao, nil)
+		}
 		if err := checker.CheckIndexer(ctx, indexer, 0, func(height uint64) {
 			if height%5000 == 0 {
 				log.L().Info(

blockchain/blockdao/blockindexer.go

@@ -34,15 +34,25 @@ type (
 		StartHeight() uint64
 	}
 
+	BlockIndexerStateDBWriter interface {
+		BlockIndexer
+		// StateDBWriter indicates this indexer writes to state DB
+		StateDBWriter()
+	}
+
 	// BlockIndexerChecker defines a checker of block indexer
 	BlockIndexerChecker struct {
-		dao BlockDAO
+		dao       BlockDAO
+		validator block.BlockValidator
 	}
 )
 
 // NewBlockIndexerChecker creates a new block indexer checker
-func NewBlockIndexerChecker(dao BlockDAO) *BlockIndexerChecker {
-	return &BlockIndexerChecker{dao: dao}
+func NewBlockIndexerChecker(dao BlockDAO, v block.BlockValidator) *BlockIndexerChecker {
+	return &BlockIndexerChecker{
+		dao:       dao,
+		validator: v,
+	}
 }
 
 // CheckIndexer checks a block indexer against block dao
@@ -115,18 +125,24 @@ func (bic *BlockIndexerChecker) CheckIndexer(ctx context.Context, indexer BlockI
 			bcCtx.Tip.Hash = g.Hash()
 			bcCtx.Tip.Timestamp = time.Unix(g.Timestamp, 0)
 		}
+		checkCtx := protocol.WithFeatureCtx(protocol.WithBlockCtx(
+			protocol.WithBlockchainCtx(ctx, bcCtx),
+			protocol.BlockCtx{
+				BlockHeight:    i,
+				BlockTimeStamp: blk.Timestamp(),
+				Producer:       producer,
+				GasLimit:       g.BlockGasLimitByHeight(i),
+				BaseFee:        blk.BaseFee(),
+				ExcessBlobGas:  blk.ExcessBlobGas(),
+			},
+		))
+		if bic.validator != nil {
+			if err := bic.validator(checkCtx, blk); err != nil {
+				return err
+			}
+		}
 		for {
-			if err = indexer.PutBlock(protocol.WithFeatureCtx(protocol.WithBlockCtx(
-				protocol.WithBlockchainCtx(ctx, bcCtx),
-				protocol.BlockCtx{
-					BlockHeight:    i,
-					BlockTimeStamp: blk.Timestamp(),
-					Producer:       producer,
-					GasLimit:       g.BlockGasLimitByHeight(i),
-					BaseFee:        blk.BaseFee(),
-					ExcessBlobGas:  blk.ExcessBlobGas(),
-				},
-			)), blk); err == nil {
+			if err = indexer.PutBlock(checkCtx, blk); err == nil {
 				break
 			}
 			if i < g.HawaiiBlockHeight && errors.Cause(err) == block.ErrDeltaStateMismatch {

blockchain/blockdao/blockindexer_test.go

@@ -49,7 +49,7 @@ func TestCheckIndexer(t *testing.T) {
 			ctrl := gomock.NewController(t)
 			defer ctrl.Finish()
 			mockDao := mock_blockdao.NewMockBlockDAO(ctrl)
-			checker := NewBlockIndexerChecker(mockDao)
+			checker := NewBlockIndexerChecker(mockDao, nil)
 			indexer := mock_blockdao.NewMockBlockIndexer(ctrl)
 
 			putBlocks := make([]*block.Block, 0)
@@ -121,7 +121,7 @@ func TestCheckIndexerWithStart(t *testing.T) {
 			ctrl := gomock.NewController(t)
 			defer ctrl.Finish()
 			mockDao := mock_blockdao.NewMockBlockDAO(ctrl)
-			checker := NewBlockIndexerChecker(mockDao)
+			checker := NewBlockIndexerChecker(mockDao, nil)
 			indexer := mock_blockdao.NewMockBlockIndexerWithStart(ctrl)
 
 			putBlocks := make([]*block.Block, 0)
@@ -179,7 +179,7 @@ func TestBlockIndexerChecker_CheckIndexer(t *testing.T) {
 	ctx := context.Background()
 	store := mock_blockdao.NewMockBlockDAO(ctrl)
 	dao := &blockDAO{blockStore: store}
-	bic := NewBlockIndexerChecker(dao)
+	bic := NewBlockIndexerChecker(dao, nil)
 	indexer := mock_blockdao.NewMockBlockIndexer(ctrl)
 
 	t.Run("WithoutBlockchainContext", func(t *testing.T) {

blockindex/sync_indexers.go

@@ -12,6 +12,10 @@ import (
 	"github.com/iotexproject/iotex-core/v2/blockchain/blockdao"
 )
 
+var (
+	_ blockdao.BlockIndexerStateDBWriter = (*SyncIndexers)(nil)
+)
+
 // SyncIndexers is a special index that includes multiple indexes,
 // which stay in sync when blocks are added.
 type SyncIndexers struct {
@@ -26,6 +30,8 @@ func NewSyncIndexers(indexers ...blockdao.BlockIndexer) *SyncIndexers {
 	return &SyncIndexers{indexers: indexers}
 }
 
+func (ig *SyncIndexers) StateDBWriter() {}
+
 // Start starts the indexer group
 func (ig *SyncIndexers) Start(ctx context.Context) error {
 	for _, indexer := range ig.indexers {