Removed engine dependency.

api/service/legacysync/syncing.go

@@ -880,12 +880,12 @@ func (ss *StateSync) UpdateBlockAndStatus(block *types.Block, bc core.BlockChain
 			}
 
 			startTime := time.Now()
-			if err := bc.Engine().VerifyHeaderSignature(bc, block.Header(), sig, bitmap); err != nil {
+			if err := chain.Engine().VerifyHeaderSignature(bc, block.Header(), sig, bitmap); err != nil {
 				return errors.Wrapf(err, "verify header signature %v", block.Hash().String())
 			}
 			utils.Logger().Debug().Int64("elapsed time", time.Now().Sub(startTime).Milliseconds()).Msg("[Sync] VerifyHeaderSignature")
 		}
-		err := bc.Engine().VerifyHeader(bc, block.Header(), verifySeal)
+		err := chain.Engine().VerifyHeader(bc, block.Header(), verifySeal)
 		if err == engine.ErrUnknownAncestor {
 			return err
 		} else if err != nil {

api/service/stagedstreamsync/adapter.go

@@ -27,7 +27,6 @@ type syncProtocol interface {
 
 type blockChain interface {
 	engine.ChainReader
-	Engine() engine.Engine
 
 	InsertChain(chain types.Blocks, verifyHeaders bool) (int, error)
 	WriteCommitSig(blockNum uint64, lastCommits []byte) error

api/service/stagedstreamsync/sig_verify.go

@@ -47,10 +47,10 @@ func verifyAndInsertBlock(bc blockChain, block *types.Block, nextBlocks ...*type
 		}
 	}
 
-	if err := bc.Engine().VerifyHeaderSignature(bc, block.Header(), sigBytes, bitmap); err != nil {
+	if err := chain.Engine().VerifyHeaderSignature(bc, block.Header(), sigBytes, bitmap); err != nil {
 		return &sigVerifyErr{err}
 	}
-	if err := bc.Engine().VerifyHeader(bc, block.Header(), true); err != nil {
+	if err := chain.Engine().VerifyHeader(bc, block.Header(), true); err != nil {
 		return errors.Wrap(err, "[VerifyHeader]")
 	}
 	if _, err := bc.InsertChain(types.Blocks{block}, false); err != nil {

api/service/stagedsync/stage_state.go

@@ -250,7 +250,7 @@ func (stg *StageStates) verifyBlockSignatures(bc core.BlockChain, block *types.B
 		}
 
 		startTime := time.Now()
-		if err := bc.Engine().VerifyHeaderSignature(bc, block.Header(), sig, bitmap); err != nil {
+		if err := chain.Engine().VerifyHeaderSignature(bc, block.Header(), sig, bitmap); err != nil {
 			return errors.Wrapf(err, "verify header signature %v", block.Hash().String())
 		}
 		utils.Logger().Debug().

api/service/stagedsync/stagedsync.go

@@ -1052,14 +1052,14 @@ func (ss *StagedSync) UpdateBlockAndStatus(block *types.Block, bc core.BlockChai
 			}
 
 			startTime := time.Now()
-			if err := bc.Engine().VerifyHeaderSignature(bc, block.Header(), sig, bitmap); err != nil {
+			if err := chain.Engine().VerifyHeaderSignature(bc, block.Header(), sig, bitmap); err != nil {
 				return errors.Wrapf(err, "verify header signature %v", block.Hash().String())
 			}
 			utils.Logger().Debug().
 				Int64("elapsed time", time.Now().Sub(startTime).Milliseconds()).
 				Msg("[STAGED_SYNC] VerifyHeaderSignature")
 		}
-		err := bc.Engine().VerifyHeader(bc, block.Header(), verifySeal)
+		err := chain.Engine().VerifyHeader(bc, block.Header(), verifySeal)
 		if err == engine.ErrUnknownAncestor {
 			return err
 		} else if err != nil {

block/header.go

@@ -153,6 +153,11 @@ func (h *Header) IsLastBlockInEpoch() bool {
 	return len(h.ShardState()) > 0
 }
 
+// NumberU64 returns the block number in uint64.
+func (h Header) NumberU64() uint64 {
+	return h.Number().Uint64()
+}
+
 // HeaderRegistry is the taggedrlp type registry for versioned headers.
 var HeaderRegistry = taggedrlp.NewRegistry()
 

cmd/harmony/main.go

@@ -16,7 +16,6 @@ import (
 	"time"
 
 	"github.com/harmony-one/harmony/consensus/quorum"
-	"github.com/harmony-one/harmony/internal/chain"
 	"github.com/harmony-one/harmony/internal/registry"
 	"github.com/harmony-one/harmony/internal/shardchain/tikv_manage"
 	"github.com/harmony-one/harmony/internal/tikv/redis_helper"
@@ -701,11 +700,9 @@ func setupConsensusAndNode(hc harmonyconfig.HarmonyConfig, nodeConfig *nodeconfi
 		chainDBFactory = &shardchain.LDBFactory{RootDir: nodeConfig.DBDir}
 	}
 
-	engine := chain.NewEngine()
-
 	chainConfig := nodeConfig.GetNetworkType().ChainConfig()
 	collection := shardchain.NewCollection(
-		&hc, chainDBFactory, &core.GenesisInitializer{NetworkType: nodeConfig.GetNetworkType()}, engine, &chainConfig,
+		&hc, chainDBFactory, &core.GenesisInitializer{NetworkType: nodeConfig.GetNetworkType()}, &chainConfig,
 	)
 	for shardID, archival := range nodeConfig.ArchiveModes() {
 		if archival {
@@ -740,7 +737,7 @@ func setupConsensusAndNode(hc harmonyconfig.HarmonyConfig, nodeConfig *nodeconfi
 		os.Exit(1)
 	}
 
-	currentNode := node.New(myHost, currentConsensus, engine, collection, blacklist, allowedTxs, localAccounts, nodeConfig.ArchiveModes(), &hc, registry)
+	currentNode := node.New(myHost, currentConsensus, collection, blacklist, allowedTxs, localAccounts, nodeConfig.ArchiveModes(), &hc, registry)
 
 	if hc.Legacy != nil && hc.Legacy.TPBroadcastInvalidTxn != nil {
 		currentNode.BroadcastInvalidTx = *hc.Legacy.TPBroadcastInvalidTxn

consensus/engine/errors.go

@@ -31,13 +31,6 @@ var (
 	// to the current node.
 	ErrFutureBlock = errors.New("block in the future")
 
-	// ErrInvalidNumber is returned if a block's number doesn't equal it's parent's
-	// plus one.
-	ErrInvalidNumber = errors.New("invalid block number")
-
 	// ErrViewIDNotMatch is returned if the current viewID is not equal message's viewID
 	ErrViewIDNotMatch = errors.New("viewID not match")
-
-	// ErrInvalidConsensusMessage is returned is the consensus message received is invalid
-	ErrInvalidConsensusMessage = errors.New("invalid consensus message")
 )

consensus/validator.go

@@ -331,7 +331,7 @@ func (consensus *Consensus) onCommitted(recvMsg *FBFTMessage) {
 			Msg("[OnCommitted] Failed to parse commit sigBytes and bitmap")
 		return
 	}
-	if err := consensus.Blockchain().Engine().VerifyHeaderSignature(consensus.Blockchain(), blockObj.Header(),
+	if err := chain.Engine().VerifyHeaderSignature(consensus.Blockchain(), blockObj.Header(),
 		sigBytes, bitmap); err != nil {
 		consensus.getLogger().Error().
 			Uint64("blockNum", recvMsg.BlockNum).

core/block_validator.go

@@ -26,6 +26,8 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/harmony-one/harmony/block"
+	"github.com/harmony-one/harmony/internal/chain"
+	chain2 "github.com/harmony-one/harmony/internal/chain"
 	"github.com/pkg/errors"
 
 	consensus_engine "github.com/harmony-one/harmony/consensus/engine"
@@ -40,16 +42,14 @@ import (
 //
 // BlockValidator implements validator.
 type BlockValidator struct {
-	config *params.ChainConfig     // Chain configuration options
-	bc     BlockChain              // Canonical blockchain
-	engine consensus_engine.Engine // Consensus engine used for validating
+	config *params.ChainConfig // Chain configuration options
+	bc     BlockChain          // Canonical blockchain
 }
 
 // NewBlockValidator returns a new block validator which is safe for re-use
-func NewBlockValidator(config *params.ChainConfig, blockchain BlockChain, engine consensus_engine.Engine) *BlockValidator {
+func NewBlockValidator(config *params.ChainConfig, blockchain BlockChain) *BlockValidator {
 	validator := &BlockValidator{
 		config: config,
-		engine: engine,
 		bc:     blockchain,
 	}
 	return validator
@@ -131,7 +131,7 @@ func (v *BlockValidator) ValidateHeader(block *types.Block, seal bool) error {
 		return errors.New("block is nil")
 	}
 	if h := block.Header(); h != nil {
-		return v.engine.VerifyHeader(v.bc, h, true)
+		return chain.Engine().VerifyHeader(v.bc, h, true)
 	}
 	return errors.New("header field was nil")
 }
@@ -147,7 +147,7 @@ func (v *BlockValidator) ValidateHeaders(chain []*types.Block) (chan<- struct{},
 		headers[i] = block.Header()
 		seals[i] = true
 	}
-	return v.engine.VerifyHeaders(v.bc, headers, seals)
+	return chain2.Engine().VerifyHeaders(v.bc, headers, seals)
 }
 
 // CalcGasLimit computes the gas limit of the next block after parent. It aims
@@ -249,5 +249,5 @@ func (v *BlockValidator) ValidateCXReceiptsProof(cxp *types.CXReceiptsProof) err
 	// (4) verify blockHeader with seal
 	var commitSig bls.SerializedSignature
 	copy(commitSig[:], cxp.CommitSig)
-	return v.engine.VerifyHeaderSignature(v.bc, cxp.Header, commitSig, cxp.CommitBitmap)
+	return chain.Engine().VerifyHeaderSignature(v.bc, cxp.Header, commitSig, cxp.CommitBitmap)
 }

core/blockchain.go

@@ -126,8 +126,6 @@ type BlockChain interface {
 	GetHeaderByNumber(number uint64) *block.Header
 	// Config retrieves the blockchain's chain configuration.
 	Config() *params.ChainConfig
-	// Engine retrieves the blockchain's consensus engine.
-	Engine() engine.Engine
 	// SubscribeRemovedLogsEvent registers a subscription of RemovedLogsEvent.
 	SubscribeRemovedLogsEvent(ch chan<- RemovedLogsEvent) event.Subscription
 	// SubscribeTraceEvent registers a subscription of ChainEvent.

core/blockchain_impl.go

@@ -49,6 +49,8 @@ import (
 	"github.com/harmony-one/harmony/core/types"
 	"github.com/harmony-one/harmony/core/vm"
 	"github.com/harmony-one/harmony/crypto/bls"
+	"github.com/harmony-one/harmony/internal/chain"
+	chain2 "github.com/harmony-one/harmony/internal/chain"
 	harmonyconfig "github.com/harmony-one/harmony/internal/configs/harmony"
 	"github.com/harmony-one/harmony/internal/params"
 	"github.com/harmony-one/harmony/internal/tikv"
@@ -190,7 +192,6 @@ type BlockChainImpl struct {
 	// procInterrupt must be atomically called
 	procInterrupt int32 // interrupt signaler for block processing
 
-	engine                 consensus_engine.Engine
 	processor              Processor // block processor interface
 	validator              Validator // block and state validator interface
 	vmConfig               vm.Config
@@ -204,25 +205,25 @@ type BlockChainImpl struct {
 // NewBlockChainWithOptions same as NewBlockChain but can accept additional behaviour options.
 func NewBlockChainWithOptions(
 	db ethdb.Database, stateCache state.Database, beaconChain BlockChain, cacheConfig *CacheConfig, chainConfig *params.ChainConfig,
-	engine consensus_engine.Engine, vmConfig vm.Config, options Options,
+	vmConfig vm.Config, options Options,
 ) (*BlockChainImpl, error) {
-	return newBlockChainWithOptions(db, stateCache, beaconChain, cacheConfig, chainConfig, engine, vmConfig, options)
+	return newBlockChainWithOptions(db, stateCache, beaconChain, cacheConfig, chainConfig, vmConfig, options)
 }
 
 // NewBlockChain returns a fully initialised block chain using information
 // available in the database. It initialises the default Ethereum validator and
 // Processor.
 func NewBlockChain(
 	db ethdb.Database, stateCache state.Database, beaconChain BlockChain, cacheConfig *CacheConfig, chainConfig *params.ChainConfig,
-	engine consensus_engine.Engine, vmConfig vm.Config,
+	vmConfig vm.Config,
 ) (*BlockChainImpl, error) {
-	return newBlockChainWithOptions(db, stateCache, beaconChain, cacheConfig, chainConfig, engine, vmConfig, Options{})
+	return newBlockChainWithOptions(db, stateCache, beaconChain, cacheConfig, chainConfig, vmConfig, Options{})
 }
 
 func newBlockChainWithOptions(
 	db ethdb.Database, stateCache state.Database, beaconChain BlockChain,
 	cacheConfig *CacheConfig, chainConfig *params.ChainConfig,
-	engine consensus_engine.Engine, vmConfig vm.Config, options Options) (*BlockChainImpl, error) {
+	vmConfig vm.Config, options Options) (*BlockChainImpl, error) {
 
 	bodyCache, _ := lru.New(bodyCacheLimit)
 	bodyRLPCache, _ := lru.New(bodyCacheLimit)
@@ -266,7 +267,6 @@ func newBlockChainWithOptions(
 		blockAccumulatorCache:         blockAccumulatorCache,
 		leaderPubKeyFromCoinbase:      leaderPubKeyFromCoinbase,
 		blockchainPruner:              newBlockchainPruner(db),
-		engine:                        engine,
 		vmConfig:                      vmConfig,
 		badBlocks:                     badBlocks,
 		pendingSlashes:                slash.Records{},
@@ -275,7 +275,7 @@ func newBlockChainWithOptions(
 	}
 
 	var err error
-	bc.hc, err = NewHeaderChain(db, chainConfig, engine, bc.getProcInterrupt)
+	bc.hc, err = NewHeaderChain(db, chainConfig, bc.getProcInterrupt)
 	if err != nil {
 		return nil, err
 	}
@@ -294,8 +294,8 @@ func newBlockChainWithOptions(
 		beaconChain = bc
 	}
 
-	bc.SetValidator(NewBlockValidator(chainConfig, bc, engine))
-	bc.SetProcessor(NewStateProcessor(chainConfig, bc, beaconChain, engine))
+	bc.SetValidator(NewBlockValidator(chainConfig, bc))
+	bc.SetProcessor(NewStateProcessor(chainConfig, bc, beaconChain))
 
 	// Take ownership of this particular state
 	go bc.update()
@@ -353,7 +353,7 @@ func VerifyCrossLink(blockchain BlockChain, cl types.CrossLink) error {
 	if blockchain.ShardID() != shard.BeaconChainShardID {
 		return errors.New("[VerifyCrossLink] Shard chains should not verify cross links")
 	}
-	engine := blockchain.Engine()
+	engine := chain.Engine()
 
 	if err := engine.VerifyCrossLink(blockchain, cl); err != nil {
 		return errors.Wrap(err, "[VerifyCrossLink]")
@@ -424,7 +424,7 @@ func (bc *BlockChainImpl) ValidateNewBlock(block *types.Block, beaconChain Block
 			Msg("[ValidateNewBlock] Cannot validate header for the new block")
 		return err
 	}
-	if err := bc.Engine().VerifyVRF(
+	if err := chain.Engine().VerifyVRF(
 		bc, block.Header(),
 	); err != nil {
 		utils.Logger().Error().
@@ -436,7 +436,7 @@ func (bc *BlockChainImpl) ValidateNewBlock(block *types.Block, beaconChain Block
 			"[ValidateNewBlock] Cannot verify vrf for the new block",
 		)
 	}
-	err := bc.Engine().VerifyShardState(bc, beaconChain, block.Header())
+	err := chain.Engine().VerifyShardState(bc, beaconChain, block.Header())
 	if err != nil {
 		utils.Logger().Error().
 			Str("blockHash", block.Hash().Hex()).
@@ -1577,7 +1577,7 @@ func (bc *BlockChainImpl) insertChain(chain types.Blocks, verifyHeaders bool) (i
 			seals[i] = true
 		}
 		// Note that VerifyHeaders verifies headers in the chain in parallel
-		abort, results := bc.Engine().VerifyHeaders(bc, headers, seals)
+		abort, results := chain2.Engine().VerifyHeaders(bc, headers, seals)
 		verifyHeadersResults = results
 		defer close(abort)
 	}
@@ -2045,8 +2045,6 @@ func (bc *BlockChainImpl) GetHeaderByNumber(number uint64) *block.Header {
 
 func (bc *BlockChainImpl) Config() *params.ChainConfig { return bc.chainConfig }
 
-func (bc *BlockChainImpl) Engine() consensus_engine.Engine { return bc.engine }
-
 func (bc *BlockChainImpl) SubscribeRemovedLogsEvent(ch chan<- RemovedLogsEvent) event.Subscription {
 	return bc.scope.Track(bc.rmLogsFeed.Subscribe(ch))
 }

core/epochchain.go

@@ -8,8 +8,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/harmony-one/harmony/block"
-	"github.com/harmony-one/harmony/consensus/engine"
-	consensus_engine "github.com/harmony-one/harmony/consensus/engine"
 	"github.com/harmony-one/harmony/core/rawdb"
 	"github.com/harmony-one/harmony/core/types"
 	"github.com/harmony-one/harmony/core/vm"
@@ -29,7 +27,6 @@ type EpochChain struct {
 	db            ethdb.Database // Low level persistent database to store final content in.
 	mu            chan struct{}
 	currentHeader atomic.Value // Current head of the blockchain.
-	engine        consensus_engine.Engine
 	vmConfig      *vm.Config
 
 	headerCache     *lru.Cache // Cache for the most recent block headers
@@ -46,7 +43,7 @@ func cache(size int) *lru.Cache {
 }
 
 func NewEpochChain(db ethdb.Database, chainConfig *params.ChainConfig,
-	engine consensus_engine.Engine, vmConfig vm.Config) (*EpochChain, error) {
+	vmConfig vm.Config) (*EpochChain, error) {
 
 	hash := rawdb.ReadCanonicalHash(db, 0)
 	genesisBlock := rawdb.ReadBlock(db, hash, 0)
@@ -60,7 +57,6 @@ func NewEpochChain(db ethdb.Database, chainConfig *params.ChainConfig,
 		db:            db,
 		mu:            make(chan struct{}, 1),
 		currentHeader: atomic.Value{},
-		engine:        engine,
 		vmConfig:      &vmConfig,
 
 		headerCache:     cache(headerCacheLimit),
@@ -242,10 +238,6 @@ func (bc *EpochChain) Config() *params.ChainConfig {
 	return bc.chainConfig
 }
 
-func (bc *EpochChain) Engine() engine.Engine {
-	return bc.engine
-}
-
 func (bc *EpochChain) ReadShardState(epoch *big.Int) (*shard.State, error) {
 	cacheKey := string(epoch.Bytes())
 	if cached, ok := bc.shardStateCache.Get(cacheKey); ok {

core/epochchain_test.go

@@ -15,7 +15,7 @@ func TestGenesisBlock(t *testing.T) {
 	err := (&core.GenesisInitializer{NetworkType: nodeconfig.Mainnet}).InitChainDB(db, 0)
 	require.NoError(t, err)
 
-	chain, err := core.NewEpochChain(db, nil, nil, vm.Config{})
+	chain, err := core.NewEpochChain(db, nil, vm.Config{})
 	require.NoError(t, err)
 
 	header := chain.GetHeaderByNumber(0)

core/evm.go

@@ -26,7 +26,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/harmony-one/harmony/block"
-	consensus_engine "github.com/harmony-one/harmony/consensus/engine"
 	"github.com/harmony-one/harmony/core/types"
 	"github.com/harmony-one/harmony/core/vm"
 	"github.com/harmony-one/harmony/internal/params"
@@ -39,9 +38,6 @@ import (
 // ChainContext supports retrieving headers and consensus parameters from the
 // current blockchain to be used during transaction processing.
 type ChainContext interface {
-	// Engine retrieves the chain's consensus engine.
-	Engine() consensus_engine.Engine
-
 	// GetHeader returns the hash corresponding to their hash.
 	GetHeader(common.Hash, uint64) *block.Header