metablock.go

package block

import (
	"bytes"
	"encoding/hex"
	"errors"
	"fmt"
	"math/big"
	"sync"
	"time"

	"github.com/multiversx/mx-chain-core-go/core"
	"github.com/multiversx/mx-chain-core-go/core/check"
	"github.com/multiversx/mx-chain-core-go/data"
	"github.com/multiversx/mx-chain-core-go/data/block"
	"github.com/multiversx/mx-chain-core-go/data/headerVersionData"
	logger "github.com/multiversx/mx-chain-logger-go"

	epochStartMetaCommmon "github.com/multiversx/mx-chain-go/epochStart/metachain"
	"github.com/multiversx/mx-chain-go/trie"

	"github.com/multiversx/mx-chain-go/common"
	"github.com/multiversx/mx-chain-go/common/holders"
	"github.com/multiversx/mx-chain-go/dataRetriever"
	processOutport "github.com/multiversx/mx-chain-go/outport/process"
	"github.com/multiversx/mx-chain-go/process"
	"github.com/multiversx/mx-chain-go/process/asyncExecution/executionTrack"
	"github.com/multiversx/mx-chain-go/process/block/bootstrapStorage"
	"github.com/multiversx/mx-chain-go/process/block/helpers"
	"github.com/multiversx/mx-chain-go/process/block/processedMb"
	"github.com/multiversx/mx-chain-go/state"
)

const (
	firstHeaderNonce           = uint64(1)
	defaultMaxProposalNonceGap = 10
)

var _ process.BlockProcessor = (*metaProcessor)(nil)

// metaProcessor implements metaProcessor interface, and actually it tries to execute block

// ShardHeaderInfo holds info about a shard header
type ShardHeaderInfo struct {
	Header      data.HeaderHandler
	Hash        []byte
	UsedInBlock bool
}

type epochStartDataWrapper struct {
	Epoch          uint32
	EpochStartData *block.EpochStart
}
type metaProcessor struct {
	*baseProcessor
	scToProtocol                 process.SmartContractToProtocolHandler
	epochStartDataCreator        process.EpochStartDataCreator
	epochEconomics               process.EndOfEpochEconomics
	epochRewardsCreator          process.RewardsCreator
	validatorInfoCreator         process.EpochStartValidatorInfoCreator
	epochSystemSCProcessor       process.EpochStartSystemSCProcessor
	pendingMiniBlocksHandler     process.PendingMiniBlocksHandler
	validatorStatisticsProcessor process.ValidatorStatisticsProcessor
	shardsHeadersNonce           *sync.Map
	shardBlockFinality           uint32
	headersCounter               *headersCounter
	epochStartDataWrapper        *epochStartDataWrapper
	mutEpochStartData            sync.RWMutex
	shardInfoCreateData          process.ShardInfoCreator
}

// NewMetaProcessor creates a new metaProcessor object
func NewMetaProcessor(arguments ArgMetaProcessor) (*metaProcessor, error) {
	base, err := NewBaseProcessor(arguments.ArgBaseProcessor)
	if err != nil {
		return nil, err
	}
	if check.IfNil(arguments.SCToProtocol) {
		return nil, process.ErrNilSCToProtocol
	}
	if check.IfNil(arguments.PendingMiniBlocksHandler) {
		return nil, process.ErrNilPendingMiniBlocksHandler
	}
	if check.IfNil(arguments.EpochStartDataCreator) {
		return nil, process.ErrNilEpochStartDataCreator
	}
	if check.IfNil(arguments.EpochEconomics) {
		return nil, process.ErrNilEpochEconomics
	}
	if check.IfNil(arguments.EpochRewardsCreator) {
		return nil, process.ErrNilRewardsCreator
	}
	if check.IfNil(arguments.EpochValidatorInfoCreator) {
		return nil, process.ErrNilEpochStartValidatorInfoCreator
	}
	if check.IfNil(arguments.ValidatorStatisticsProcessor) {
		return nil, process.ErrNilValidatorStatistics
	}
	if check.IfNil(arguments.EpochSystemSCProcessor) {
		return nil, process.ErrNilEpochStartSystemSCProcessor
	}
	if check.IfNil(arguments.ReceiptsRepository) {
		return nil, process.ErrNilReceiptsRepository
	}
	if check.IfNil(arguments.ShardInfoCreator) {
		return nil, process.ErrNilShardInfoCreator
	}

	mp := metaProcessor{
		baseProcessor:                base,
		headersCounter:               NewHeaderCounter(),
		scToProtocol:                 arguments.SCToProtocol,
		pendingMiniBlocksHandler:     arguments.PendingMiniBlocksHandler,
		epochStartDataCreator:        arguments.EpochStartDataCreator,
		epochEconomics:               arguments.EpochEconomics,
		epochRewardsCreator:          arguments.EpochRewardsCreator,
		validatorStatisticsProcessor: arguments.ValidatorStatisticsProcessor,
		validatorInfoCreator:         arguments.EpochValidatorInfoCreator,
		epochSystemSCProcessor:       arguments.EpochSystemSCProcessor,
		shardInfoCreateData:          arguments.ShardInfoCreator,
		epochStartDataWrapper: &epochStartDataWrapper{
			Epoch:          arguments.EpochStartTrigger.Epoch(),
			EpochStartData: &block.EpochStart{},
		},
	}

	argsTransactionCounter := ArgsTransactionCounter{
		AppStatusHandler: mp.appStatusHandler,
		Hasher:           mp.hasher,
		Marshalizer:      mp.marshalizer,
		ShardID:          core.MetachainShardId,
	}
	mp.txCounter, err = NewTransactionCounter(argsTransactionCounter)
	if err != nil {
		return nil, err
	}

	mp.requestBlockBodyHandler = &mp
	mp.blockProcessor = &mp

	mp.shardBlockFinality = process.BlockFinality

	mp.shardsHeadersNonce = &sync.Map{}

	return &mp, nil
}

func (mp *metaProcessor) isRewardsV2Enabled(headerHandler data.HeaderHandler) bool {
	return mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.StakingV2Flag, headerHandler.GetEpoch())
}

// ProcessBlock processes a block. It returns nil if all ok or the specific error
func (mp *metaProcessor) ProcessBlock(
	headerHandler data.HeaderHandler,
	bodyHandler data.BodyHandler,
	haveTime func() time.Duration,
) error {
	if haveTime == nil {
		return process.ErrNilHaveTimeHandler
	}

	if !mp.processStatusHandler.TrySetBusy("metaProcessor.ProcessBlock") {
		return process.ErrBlockProcessorBusy
	}
	defer mp.processStatusHandler.SetIdle()

	err := mp.checkBlockValidity(headerHandler, bodyHandler)
	if err != nil {
		if errors.Is(err, process.ErrBlockHashDoesNotMatch) {
			log.Debug("requested missing meta header",
				"hash", headerHandler.GetPrevHash(),
				"for shard", headerHandler.GetShardID(),
			)

			go mp.requestHandler.RequestMetaHeader(headerHandler.GetPrevHash())
		}

		return err
	}

	mp.roundNotifier.CheckRound(headerHandler)
	mp.epochNotifier.CheckEpoch(headerHandler)
	mp.requestHandler.SetEpoch(headerHandler.GetEpoch())

	log.Debug("started processing block",
		"epoch", headerHandler.GetEpoch(),
		"shard", headerHandler.GetShardID(),
		"round", headerHandler.GetRound(),
		"nonce", headerHandler.GetNonce())

	header, ok := headerHandler.(*block.MetaBlock)
	if !ok {
		return process.ErrWrongTypeAssertion
	}

	body, ok := bodyHandler.(*block.Body)
	if !ok {
		return process.ErrWrongTypeAssertion
	}

	err = mp.checkHeaderBodyCorrelation(header.GetMiniBlockHeaderHandlers(), body)
	if err != nil {
		return err
	}

	err = mp.checkScheduledMiniBlocksValidity(headerHandler)
	if err != nil {
		return err
	}

	mp.updateMetrics(header)

	defer func() {
		if err != nil {
			mp.RevertCurrentBlock()
		}
	}()

	err = mp.createBlockStarted()
	if err != nil {
		return err
	}

	mp.epochStartTrigger.Update(header.GetRound(), header.GetNonce())
	err = mp.checkEpochCorrectness(header)
	if err != nil {
		return err
	}

	if mp.accountsDB[state.UserAccountsState].JournalLen() != 0 {
		log.Error("metaProcessor.ProcessBlock first entry", "stack", string(mp.accountsDB[state.UserAccountsState].GetStackDebugFirstEntry()))
		return process.ErrAccountStateDirty
	}

	err = mp.blockChainHook.SetCurrentHeader(header)
	if err != nil {
		return err
	}

	err = mp.processIfFirstBlockAfterEpochStart()
	if err != nil {
		return err
	}

	if header.IsStartOfEpochBlock() {
		err = mp.processEpochStartMetaBlock(header, body)
		return err
	}

	mp.txCoordinator.RequestBlockTransactions(body)
	mp.hdrsForCurrBlock.RequestShardHeaders(header)

	if haveTime() < 0 {
		return process.ErrTimeIsOut
	}

	err = mp.txCoordinator.IsDataPreparedForProcessing(haveTime)
	if err != nil {
		return err
	}

	err = mp.hdrsForCurrBlock.WaitForHeadersIfNeeded(haveTime)
	if err != nil {
		return err
	}

	defer func() {
		go mp.checkAndRequestIfShardHeadersMissing()
	}()

	highestNonceHdrs, err := mp.checkShardHeadersValidity(header)
	if err != nil {
		return err
	}

	err = mp.checkShardHeadersFinality(highestNonceHdrs)
	if err != nil {
		return err
	}

	err = mp.verifyCrossShardMiniBlockDstMe(header)
	if err != nil {
		return err
	}

	err = mp.verifyTotalAccumulatedFeesInEpoch(header)
	if err != nil {
		return err
	}

	mbIndex := mp.getIndexOfFirstMiniBlockToBeExecuted(header)
	miniBlocks := body.MiniBlocks[mbIndex:]

	startTime := time.Now()
	err = mp.txCoordinator.ProcessBlockTransaction(header, &block.Body{MiniBlocks: miniBlocks}, haveTime)
	elapsedTime := time.Since(startTime)
	log.Debug("elapsed time to process block transaction",
		"time [s]", elapsedTime,
	)
	if err != nil {
		return err
	}

	err = mp.txCoordinator.VerifyCreatedBlockTransactions(header, &block.Body{MiniBlocks: miniBlocks})
	if err != nil {
		return err
	}

	err = mp.scToProtocol.UpdateProtocol(&block.Body{MiniBlocks: miniBlocks}, header.Nonce)
	if err != nil {
		return err
	}

	err = mp.verifyFees(header)
	if err != nil {
		return err
	}

	if !mp.verifyStateRoot(header.GetRootHash()) {
		err = process.ErrRootStateDoesNotMatch
		return err
	}

	err = mp.verifyValidatorStatisticsRootHash(header)
	if err != nil {
		return err
	}

	err = mp.blockProcessingCutoffHandler.HandleProcessErrorCutoff(header)
	if err != nil {
		return err
	}

	return nil
}

func (mp *metaProcessor) updateMetrics(header data.MetaHeaderHandler) {
	headersPool := mp.dataPool.Headers()
	numShardHeadersFromPool := 0
	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		numShardHeadersFromPool += headersPool.GetNumHeaders(shardID)
	}

	txCounts, rewardCounts, unsignedCounts := mp.txCounter.getPoolCounts(mp.dataPool)
	log.Debug("total txs in pool", "counts", txCounts.String())
	log.Debug("total txs in rewards pool", "counts", rewardCounts.String())
	log.Debug("total txs in unsigned pool", "counts", unsignedCounts.String())

	go getMetricsFromMetaHeader(
		header,
		mp.marshalizer,
		mp.appStatusHandler,
		numShardHeadersFromPool,
		mp.headersCounter.getNumShardMBHeadersTotalProcessed(),
	)
}

func (mp *metaProcessor) processEpochStartMetaBlock(
	header data.MetaHeaderHandler,
	body *block.Body,
) error {
	err := mp.epochStartDataCreator.VerifyEpochStartDataForMetablock(header)
	if err != nil {
		return err
	}

	currentRootHash, err := mp.validatorStatisticsProcessor.RootHash()
	if err != nil {
		return err
	}

	allValidatorsInfo, err := mp.validatorStatisticsProcessor.GetValidatorInfoForRootHash(currentRootHash)
	if err != nil {
		return err
	}

	err = mp.validatorStatisticsProcessor.ProcessRatingsEndOfEpoch(allValidatorsInfo, header.GetEpoch())
	if err != nil {
		return err
	}

	computedEconomics, err := mp.epochEconomics.ComputeEndOfEpochEconomics(header)
	if err != nil {
		return err
	}

	if mp.isRewardsV2Enabled(header) {
		err = mp.epochSystemSCProcessor.ProcessSystemSmartContract(allValidatorsInfo, header)
		if err != nil {
			return err
		}

		err = mp.epochRewardsCreator.VerifyRewardsMiniBlocks(header, allValidatorsInfo, computedEconomics)
		if err != nil {
			return err
		}
	} else {
		err = mp.epochRewardsCreator.VerifyRewardsMiniBlocks(header, allValidatorsInfo, computedEconomics)
		if err != nil {
			return err
		}

		err = mp.epochSystemSCProcessor.ProcessSystemSmartContract(allValidatorsInfo, header)
		if err != nil {
			return err
		}
	}

	err = mp.epochSystemSCProcessor.ProcessDelegationRewards(body.MiniBlocks, mp.epochRewardsCreator.GetLocalTxCache())
	if err != nil {
		return err
	}

	err = mp.validatorInfoCreator.VerifyValidatorInfoMiniBlocks(body.MiniBlocks, allValidatorsInfo)
	if err != nil {
		return err
	}

	err = mp.validatorStatisticsProcessor.ResetValidatorStatisticsAtNewEpoch(allValidatorsInfo)
	if err != nil {
		return err
	}

	err = mp.epochEconomics.VerifyRewardsPerBlock(header, mp.epochRewardsCreator.GetAcceleratorRewards(), computedEconomics)
	if err != nil {
		return err
	}

	err = mp.verifyFees(header)
	if err != nil {
		return err
	}

	if !mp.verifyStateRoot(header.GetRootHash()) {
		err = process.ErrRootStateDoesNotMatch
		return err
	}

	err = mp.verifyValidatorStatisticsRootHash(header)
	if err != nil {
		return err
	}

	mp.saveEpochStartEconomicsMetrics(header)

	return nil
}

// SetNumProcessedObj will set the num of processed headers
func (mp *metaProcessor) SetNumProcessedObj(numObj uint64) {
	mp.headersCounter.shardMBHeadersTotalProcessed = numObj
}

func (mp *metaProcessor) checkEpochCorrectness(
	headerHandler data.MetaHeaderHandler,
) error {
	currentBlockHeader := mp.blockChain.GetCurrentBlockHeader()
	if check.IfNil(currentBlockHeader) {
		return nil
	}

	isEpochIncorrect := headerHandler.GetEpoch() != currentBlockHeader.GetEpoch() &&
		mp.epochStartTrigger.Epoch() == currentBlockHeader.GetEpoch()
	if isEpochIncorrect {
		log.Warn("epoch does not match", "currentHeaderEpoch", currentBlockHeader.GetEpoch(), "receivedHeaderEpoch", headerHandler.GetEpoch(), "epochStartTrigger", mp.epochStartTrigger.Epoch())
		return process.ErrEpochDoesNotMatch
	}

	isEpochIncorrect = mp.epochStartTrigger.IsEpochStart() &&
		mp.epochStartTrigger.EpochStartRound() <= headerHandler.GetRound() &&
		headerHandler.GetEpoch() != currentBlockHeader.GetEpoch()+1
	if isEpochIncorrect {
		log.Warn("is epoch start and epoch does not match", "currentHeaderEpoch", currentBlockHeader.GetEpoch(), "receivedHeaderEpoch", headerHandler.GetEpoch(), "epochStartTrigger", mp.epochStartTrigger.Epoch())
		return process.ErrEpochDoesNotMatch
	}

	return nil
}

func (mp *metaProcessor) verifyCrossShardMiniBlockDstMe(metaBlock data.MetaHeaderHandler) error {
	miniBlockShardsHashes, err := mp.getAllMiniBlockDstMeFromShards(metaBlock)
	if err != nil {
		return err
	}

	mapMetaMiniBlockHeaders := make(map[string]struct{}, len(metaBlock.GetMiniBlockHeaderHandlers()))
	for _, miniBlockHeader := range metaBlock.GetMiniBlockHeaderHandlers() {
		mapMetaMiniBlockHeaders[string(miniBlockHeader.GetHash())] = struct{}{}
	}

	for hash := range miniBlockShardsHashes {
		if _, ok := mapMetaMiniBlockHeaders[hash]; !ok {
			return process.ErrCrossShardMBWithoutConfirmationFromMeta
		}
	}

	return nil
}

func (mp *metaProcessor) getAllMiniBlockDstMeFromShards(metaHdr data.MetaHeaderHandler) (map[string][]byte, error) {
	miniBlockShardsHashes := make(map[string][]byte)

	var shardHeaderHandler data.HeaderHandler
	var err error
	for _, shardInfo := range getShardHeadersReferencedByMeta(metaHdr) {
		shardHeaderHandler, err = mp.getHeaderFromHash(metaHdr.IsHeaderV3(), shardInfo.GetHeaderHash(), shardInfo.GetShardID())
		if err != nil {
			return nil, fmt.Errorf("%w : for shardInfo.HeaderHash = %s",
				process.ErrMissingHeader, hex.EncodeToString(shardInfo.GetHeaderHash()))
		}

		shardHeader, ok := shardHeaderHandler.(data.ShardHeaderHandler)
		if !ok {
			return nil, fmt.Errorf("%w : for shardInfo.HeaderHash = %s",
				process.ErrWrongTypeAssertion, hex.EncodeToString(shardInfo.GetHeaderHash()))
		}

		lastCrossNotarizedHeader, _, err := mp.blockTracker.GetLastCrossNotarizedHeader(shardInfo.GetShardID())
		if err != nil {
			return nil, err
		}

		if shardHeader.GetRound() > metaHdr.GetRound() {
			return nil, fmt.Errorf("%w : for shard info with hash = %s",
				process.ErrHigherRoundInBlock, hex.EncodeToString(shardInfo.GetHeaderHash()))
		}

		isGenesisNotarization := metaHdr.GetNonce() == 1

		if isGenesisNotarization && shardHeader.GetRound() != 0 {
			return nil, fmt.Errorf("%w : for shard info with hash = %s",
				process.ErrLowerRoundInBlock, hex.EncodeToString(shardInfo.GetHeaderHash()))
		}
		if isGenesisNotarization && shardHeader.GetNonce() != 0 {
			return nil, fmt.Errorf("%w : for shard info with hash = %s",
				process.ErrLowerNonceInBlock, hex.EncodeToString(shardInfo.GetHeaderHash()))
		}

		if !isGenesisNotarization && shardHeader.GetRound() <= lastCrossNotarizedHeader.GetRound() {
			return nil, fmt.Errorf("%w : for shard info with hash = %s",
				process.ErrLowerRoundInBlock, hex.EncodeToString(shardInfo.GetHeaderHash()))
		}
		if !isGenesisNotarization && shardHeader.GetNonce() <= lastCrossNotarizedHeader.GetNonce() {
			return nil, fmt.Errorf("%w : for shard info with hash = %s",
				process.ErrLowerNonceInBlock, hex.EncodeToString(shardInfo.GetHeaderHash()))
		}

		finalCrossMiniBlockHashes := mp.getFinalCrossMiniBlockHashes(shardHeader)
		for hash := range finalCrossMiniBlockHashes {
			miniBlockShardsHashes[hash] = shardInfo.GetHeaderHash()
		}
	}

	return miniBlockShardsHashes, nil
}

func (mp *metaProcessor) getFinalCrossMiniBlockHashes(headerHandler data.HeaderHandler) map[string]uint32 {
	if !mp.enableEpochsHandler.IsFlagEnabled(common.ScheduledMiniBlocksFlag) {
		return headerHandler.GetMiniBlockHeadersWithDst(mp.shardCoordinator.SelfId())
	}
	return process.GetFinalCrossMiniBlockHashes(headerHandler, mp.shardCoordinator.SelfId())
}

func (mp *metaProcessor) checkAndRequestIfShardHeadersMissing() {
	orderedHdrsPerShard := mp.blockTracker.GetTrackedHeadersForAllShards()

	for i := uint32(0); i < mp.shardCoordinator.NumberOfShards(); i++ {
		err := mp.requestHeadersIfMissing(orderedHdrsPerShard[i], i)
		if err != nil {
			log.Debug("checkAndRequestIfShardHeadersMissing", "error", err.Error())
			continue
		}
	}
}

func (mp *metaProcessor) indexBlock(
	metaBlock data.HeaderHandler,
	headerHash []byte,
	body data.BodyHandler,
	lastMetaBlock data.HeaderHandler,
	notarizedHeadersHashes []string,
	rewardsTxs map[string]data.TransactionHandler,
) {
	if !mp.outportHandler.HasDrivers() {
		return
	}

	log.Debug("preparing to index block", "hash", headerHash, "nonce", metaBlock.GetNonce(), "round", metaBlock.GetRound())
	argSaveBlock, err := mp.outportDataProvider.PrepareOutportSaveBlockData(processOutport.ArgPrepareOutportSaveBlockData{
		HeaderHash:             headerHash,
		Header:                 metaBlock,
		Body:                   body,
		PreviousHeader:         lastMetaBlock,
		RewardsTxs:             rewardsTxs,
		NotarizedHeadersHashes: notarizedHeadersHashes,
		HighestFinalBlockNonce: mp.forkDetector.GetHighestFinalBlockNonce(),
		HighestFinalBlockHash:  mp.forkDetector.GetHighestFinalBlockHash(),
		ScheduledRootHash:      mp.scheduledTxsExecutionHandler.GetScheduledRootHash(),
	})
	if err != nil {
		log.Error("metaProcessor.indexBlock cannot prepare argSaveBlock", "error", err.Error(),
			"hash", headerHash, "nonce", metaBlock.GetNonce(), "round", metaBlock.GetRound())
		return
	}
	err = mp.outportHandler.SaveBlock(argSaveBlock)
	if err != nil {
		log.Error("metaProcessor.outportHandler.SaveBlock cannot save block", "error", err,
			"hash", headerHash, "nonce", metaBlock.GetNonce(), "round", metaBlock.GetRound())
		return
	}

	log.Debug("indexed block", "hash", headerHash, "nonce", metaBlock.GetNonce(), "round", metaBlock.GetRound())

	indexRoundInfo(
		mp.outportHandler,
		mp.nodesCoordinator,
		core.MetachainShardId,
		metaBlock,
		lastMetaBlock,
		argSaveBlock.SignersIndexes,
		mp.enableEpochsHandler,
	)

	if metaBlock.GetNonce() != 1 && !metaBlock.IsStartOfEpochBlock() {
		return
	}

	indexValidatorsRating(mp.outportHandler, mp.validatorStatisticsProcessor, metaBlock)
}

// RestoreBlockIntoPools restores the block into associated pools
func (mp *metaProcessor) RestoreBlockIntoPools(headerHandler data.HeaderHandler, bodyHandler data.BodyHandler) error {
	if check.IfNil(headerHandler) {
		return process.ErrNilMetaBlockHeader
	}

	metaBlock, ok := headerHandler.(*block.MetaBlock)
	if !ok {
		return process.ErrWrongTypeAssertion
	}

	hdrHashes := make([][]byte, len(metaBlock.ShardInfo))
	for i := 0; i < len(metaBlock.ShardInfo); i++ {
		hdrHashes[i] = metaBlock.ShardInfo[i].HeaderHash
	}

	err := mp.pendingMiniBlocksHandler.RevertHeader(metaBlock)
	if err != nil {
		return err
	}

	headersPool := mp.dataPool.Headers()

	for _, hdrHash := range hdrHashes {
		shardHeader, errNotCritical := process.GetShardHeaderFromStorage(hdrHash, mp.marshalizer, mp.store)
		if errNotCritical != nil {
			log.Debug("shard header not found in BlockHeaderUnit",
				"hash", hdrHash,
			)
			continue
		}

		headersPool.AddHeader(hdrHash, shardHeader)

		hdrNonceHashDataUnit := dataRetriever.GetHdrNonceHashDataUnit(shardHeader.GetShardID())
		storer, errNotCritical := mp.store.GetStorer(hdrNonceHashDataUnit)
		if errNotCritical != nil {
			log.Debug("storage unit not found", "unit", hdrNonceHashDataUnit, "error", errNotCritical.Error())
			continue
		}

		nonceToByteSlice := mp.uint64Converter.ToByteSlice(shardHeader.GetNonce())
		errNotCritical = storer.Remove(nonceToByteSlice)
		if errNotCritical != nil {
			log.Debug("ShardHdrNonceHashDataUnit.Remove", "error", errNotCritical.Error())
		}

		mp.headersCounter.subtractRestoredMBHeaders(len(shardHeader.GetMiniBlockHeaderHandlers()))
	}

	mp.restoreBlockBody(headerHandler, bodyHandler)

	mp.blockTracker.RemoveLastNotarizedHeaders()

	return nil
}

func (mp *metaProcessor) updateHeaderForEpochStartIfNeeded(metaHdr *block.MetaBlock) error {
	isEpochStart := mp.epochStartTrigger.IsEpochStart()
	if !isEpochStart {
		return nil
	}
	return mp.updateEpochStartHeader(metaHdr)
}

func (mp *metaProcessor) createBody(metaHdr *block.MetaBlock, haveTime func() bool) (data.BodyHandler, error) {
	isEpochStart := mp.epochStartTrigger.IsEpochStart()
	var body data.BodyHandler
	var err error
	if isEpochStart {
		body, err = mp.createEpochStartBody(metaHdr)
		if err != nil {
			return nil, err
		}
	} else {
		body, err = mp.createBlockBody(metaHdr, haveTime)
		if err != nil {
			return nil, err
		}
	}

	return body, nil
}

// CreateBlock creates the final block and header for the current round
func (mp *metaProcessor) CreateBlock(
	initialHdr data.HeaderHandler,
	haveTime func() bool,
) (data.HeaderHandler, data.BodyHandler, error) {
	if check.IfNil(initialHdr) {
		return nil, nil, process.ErrNilBlockHeader
	}

	metaHdr, ok := initialHdr.(*block.MetaBlock)
	if !ok {
		return nil, nil, process.ErrWrongTypeAssertion
	}

	if !mp.processStatusHandler.TrySetBusy("metaProcessor.CreateBlock") {
		return nil, nil, process.ErrBlockProcessorBusy
	}
	defer mp.processStatusHandler.SetIdle()

	metaHdr.SoftwareVersion = []byte(mp.headerIntegrityVerifier.GetVersion(metaHdr.Epoch, metaHdr.Round))
	mp.epochNotifier.CheckEpoch(metaHdr)

	var body data.BodyHandler

	if mp.accountsDB[state.UserAccountsState].JournalLen() != 0 {
		log.Error("metaProcessor.CreateBlock first entry", "stack", string(mp.accountsDB[state.UserAccountsState].GetStackDebugFirstEntry()))
		return nil, nil, process.ErrAccountStateDirty
	}

	err := mp.processIfFirstBlockAfterEpochStart()
	if err != nil {
		return nil, nil, err
	}

	err = mp.updateHeaderForEpochStartIfNeeded(metaHdr)
	if err != nil {
		return nil, nil, err
	}

	err = mp.blockChainHook.SetCurrentHeader(metaHdr)
	if err != nil {
		return nil, nil, err
	}

	body, err = mp.createBody(metaHdr, haveTime)
	if err != nil {
		return nil, nil, err
	}

	body, err = mp.applyBodyToHeader(metaHdr, body)
	if err != nil {
		return nil, nil, err
	}

	mp.requestHandler.SetEpoch(metaHdr.GetEpoch())

	return metaHdr, body, nil
}

func (mp *metaProcessor) isPreviousBlockEpochStart() (uint32, bool) {
	blockHeader := mp.blockChain.GetCurrentBlockHeader()
	if check.IfNil(blockHeader) {
		blockHeader = mp.blockChain.GetGenesisHeader()
	}

	return blockHeader.GetEpoch(), blockHeader.IsStartOfEpochBlock()
}

func (mp *metaProcessor) processIfFirstBlockAfterEpochStart() error {
	epoch, isPreviousEpochStart := mp.isPreviousBlockEpochStart()
	if !isPreviousEpochStart {
		return nil
	}

	nodesForcedToStay, err := mp.validatorStatisticsProcessor.SaveNodesCoordinatorUpdates(epoch)
	if err != nil {
		return err
	}

	err = mp.epochSystemSCProcessor.ToggleUnStakeUnBond(nodesForcedToStay)
	if err != nil {
		return err
	}

	return nil
}

func (mp *metaProcessor) updateEpochStartHeader(metaHdr *block.MetaBlock) error {
	sw := core.NewStopWatch()
	sw.Start("createEpochStartForMetablock")
	defer func() {
		sw.Stop("createEpochStartForMetablock")
		log.Debug("epochStartHeaderDataCreation", sw.GetMeasurements()...)
	}()

	epochStart, err := mp.epochStartDataCreator.CreateEpochStartData()
	if err != nil {
		return err
	}

	metaHdr.EpochStart = *epochStart

	totalAccumulatedFeesInEpoch := big.NewInt(0)
	totalDevFeesInEpoch := big.NewInt(0)
	currentHeader := mp.blockChain.GetCurrentBlockHeader()
	if !check.IfNil(currentHeader) && !currentHeader.IsStartOfEpochBlock() {
		prevMetaHdr, ok := currentHeader.(*block.MetaBlock)
		if !ok {
			return process.ErrWrongTypeAssertion
		}
		totalAccumulatedFeesInEpoch = big.NewInt(0).Set(prevMetaHdr.AccumulatedFeesInEpoch)
		totalDevFeesInEpoch = big.NewInt(0).Set(prevMetaHdr.DevFeesInEpoch)
	}

	metaHdr.AccumulatedFeesInEpoch.Set(totalAccumulatedFeesInEpoch)
	metaHdr.DevFeesInEpoch.Set(totalDevFeesInEpoch)
	economicsData, err := mp.epochEconomics.ComputeEndOfEpochEconomics(metaHdr)
	if err != nil {
		return err
	}

	metaHdr.EpochStart.Economics = *economicsData

	mp.saveEpochStartEconomicsMetrics(metaHdr)

	return nil
}

func (mp *metaProcessor) createEpochStartBody(metaBlock *block.MetaBlock) (data.BodyHandler, error) {
	err := mp.createBlockStarted()
	if err != nil {
		return nil, err
	}

	log.Debug("started creating epoch start block body",
		"epoch", metaBlock.GetEpoch(),
		"round", metaBlock.GetRound(),
		"nonce", metaBlock.GetNonce(),
	)

	return mp.processEpochStartMiniBlocks(metaBlock, &metaBlock.EpochStart.Economics)
}

func (mp *metaProcessor) processEpochStartMiniBlocks(
	metaBlock data.MetaHeaderHandler,
	computedEconomics *block.Economics,
) (*block.Body, error) {

	epochToUse := epochStartMetaCommmon.GetEpochToUseEpochStartData(metaBlock)

	currentRootHash, err := mp.validatorStatisticsProcessor.RootHash()
	if err != nil {
		return nil, err
	}

	allValidatorsInfo, err := mp.validatorStatisticsProcessor.GetValidatorInfoForRootHash(currentRootHash)
	if err != nil {
		return nil, err
	}

	err = mp.validatorStatisticsProcessor.ProcessRatingsEndOfEpoch(allValidatorsInfo, epochToUse)
	if err != nil {
		return nil, err
	}

	rewardMiniBlocks, err := mp.createRewardsMiniBlocksAndProcessSystemSCs(metaBlock, allValidatorsInfo, computedEconomics)
	if err != nil {
		return nil, err
	}

	computedEconomics.RewardsForProtocolSustainability.Set(mp.epochRewardsCreator.GetAcceleratorRewards())

	err = mp.epochSystemSCProcessor.ProcessDelegationRewards(rewardMiniBlocks, mp.epochRewardsCreator.GetLocalTxCache())
	if err != nil {
		return nil, err
	}

	validatorMiniBlocks, err := mp.validatorInfoCreator.CreateValidatorInfoMiniBlocks(allValidatorsInfo)
	if err != nil {
		return nil, err
	}

	err = mp.validatorStatisticsProcessor.ResetValidatorStatisticsAtNewEpoch(allValidatorsInfo)
	if err != nil {
		return nil, err
	}

	finalMiniBlocks := make([]*block.MiniBlock, 0)
	finalMiniBlocks = append(finalMiniBlocks, rewardMiniBlocks...)
	finalMiniBlocks = append(finalMiniBlocks, validatorMiniBlocks...)

	return &block.Body{MiniBlocks: finalMiniBlocks}, nil
}

func (mp *metaProcessor) createRewardsMiniBlocksAndProcessSystemSCs(
	metaBlock data.MetaHeaderHandler,
	allValidatorsInfo state.ShardValidatorsInfoMapHandler,
	computedEconomics *block.Economics,
) (block.MiniBlockSlice, error) {

	var rewardMiniBlocks block.MiniBlockSlice
	var err error
	if mp.isRewardsV2Enabled(metaBlock) {
		err = mp.epochSystemSCProcessor.ProcessSystemSmartContract(allValidatorsInfo, metaBlock)
		if err != nil {
			return nil, err
		}

		rewardMiniBlocks, err = mp.createRewardsMiniBlocks(metaBlock, allValidatorsInfo, computedEconomics)
		if err != nil {
			return nil, err
		}
	} else {
		rewardMiniBlocks, err = mp.createRewardsMiniBlocks(metaBlock, allValidatorsInfo, computedEconomics)
		if err != nil {
			return nil, err
		}

		err = mp.epochSystemSCProcessor.ProcessSystemSmartContract(allValidatorsInfo, metaBlock)
		if err != nil {
			return nil, err
		}
	}

	return rewardMiniBlocks, nil
}

func (mp *metaProcessor) createRewardsMiniBlocks(
	metaHeader data.MetaHeaderHandler,
	allValidatorsInfo state.ShardValidatorsInfoMapHandler,
	computedEconomics *block.Economics,
) (block.MiniBlockSlice, error) {
	if !metaHeader.IsHeaderV3() {
		return mp.epochRewardsCreator.CreateRewardsMiniBlocks(metaHeader, allValidatorsInfo, computedEconomics)
	}

	prevBlockExecutionResult := mp.blockChain.GetLastExecutionResult()
	if check.IfNil(prevBlockExecutionResult) {
		return nil, fmt.Errorf("%w for blockchain.GetLastExecutionResult", process.ErrNilBaseExecutionResult)
	}

	prevMetaExecResult, ok := prevBlockExecutionResult.(data.MetaExecutionResultHandler)
	if !ok {
		return nil, fmt.Errorf("%w to MetaExecutionResultHandler", process.ErrWrongTypeAssertion)
	}

	return mp.epochRewardsCreator.CreateRewardsMiniBlocksV3(metaHeader, allValidatorsInfo, computedEconomics, prevMetaExecResult)
}

// createBlockBody creates block body of metachain
func (mp *metaProcessor) createBlockBody(metaBlock data.HeaderHandler, haveTime func() bool) (data.BodyHandler, error) {
	err := mp.createBlockStarted()
	if err != nil {
		return nil, err
	}

	mp.blockSizeThrottler.ComputeCurrentMaxSize()

	log.Debug("started creating meta block body",
		"epoch", metaBlock.GetEpoch(),
		"round", metaBlock.GetRound(),
		"nonce", metaBlock.GetNonce(),
	)

	randomness := helpers.ComputeRandomnessForTxSorting(metaBlock, mp.enableEpochsHandler)
	miniBlocks, err := mp.createMiniBlocks(haveTime, randomness)
	if err != nil {
		return nil, err
	}

	err = mp.scToProtocol.UpdateProtocol(miniBlocks, metaBlock.GetNonce())
	if err != nil {
		return nil, err
	}

	return miniBlocks, nil
}

func (mp *metaProcessor) createMiniBlocks(
	haveTime func() bool,
	randomness []byte,
) (*block.Body, error) {
	var miniBlocks block.MiniBlockSlice

	if mp.enableEpochsHandler.IsFlagEnabled(common.ScheduledMiniBlocksFlag) {
		miniBlocks = mp.scheduledTxsExecutionHandler.GetScheduledMiniBlocks()
		mp.txCoordinator.AddTxsFromMiniBlocks(miniBlocks)
		// TODO: in case we add metachain originating scheduled miniBlocks, we need to add the invalid txs here, same as for shard processor
	}

	if !haveTime() {
		log.Debug("metaProcessor.createMiniBlocks", "error", process.ErrTimeIsOut)

		interMBs := mp.txCoordinator.CreatePostProcessMiniBlocks()
		if len(interMBs) > 0 {
			miniBlocks = append(miniBlocks, interMBs...)
		}

		log.Debug("creating mini blocks has been finished", "num miniblocks", len(miniBlocks))
		return &block.Body{MiniBlocks: miniBlocks}, nil
	}

	mbsToMe, numTxs, numShardHeaders, err := mp.createAndProcessCrossMiniBlocksDstMe(haveTime)
	if err != nil {
		log.Debug("createAndProcessCrossMiniBlocksDstMe", "error", err.Error())
	}

	if len(mbsToMe) > 0 {
		miniBlocks = append(miniBlocks, mbsToMe...)

		log.Debug("processed miniblocks and txs with destination in self shard",
			"num miniblocks", len(mbsToMe),
			"num txs", numTxs,
			"num shard headers", numShardHeaders,
		)
	}

	err = mp.recreateTrieIfNeeded()
	if err != nil {
		return nil, err
	}

	mbsFromMe := mp.txCoordinator.CreateMbsAndProcessTransactionsFromMe(haveTime, randomness)
	if len(mbsFromMe) > 0 {
		miniBlocks = append(miniBlocks, mbsFromMe...)

		numTxs = 0
		for _, mb := range mbsFromMe {
			numTxs += uint32(len(mb.TxHashes))
		}

		log.Debug("processed miniblocks and txs from self shard",
			"num miniblocks", len(mbsFromMe),
			"num txs", numTxs,
		)
	}

	log.Debug("creating mini blocks has been finished",
		"miniblocks created", len(miniBlocks),
	)

	return &block.Body{MiniBlocks: miniBlocks}, nil
}

func (mp *metaProcessor) isGenesisShardBlockAndFirstMeta(shardHdrNonce uint64) bool {
	return shardHdrNonce == mp.genesisNonce && check.IfNil(mp.blockChain.GetCurrentBlockHeader())
}

// full verification through metachain header
func (mp *metaProcessor) createAndProcessCrossMiniBlocksDstMe(
	haveTime func() bool,
) (block.MiniBlockSlice, uint32, uint32, error) {

	var miniBlocks block.MiniBlockSlice
	txsAdded := uint32(0)
	hdrsAdded := uint32(0)

	sw := core.NewStopWatch()
	sw.Start("ComputeLongestShardsChainsFromLastNotarized")
	orderedHdrs, orderedHdrsHashes, _, err := mp.blockTracker.ComputeLongestShardsChainsFromLastNotarized()
	sw.Stop("ComputeLongestShardsChainsFromLastNotarized")
	log.Debug("measurements ComputeLongestShardsChainsFromLastNotarized", sw.GetMeasurements()...)
	if err != nil {
		return nil, 0, 0, err
	}

	log.Debug("shard headers ordered",
		"num shard headers", len(orderedHdrs),
	)

	lastShardHdr, err := mp.getLastCrossNotarizedShardHdrsAndAddToCurrentBlock()
	if err != nil {
		return nil, 0, 0, err
	}

	maxShardHeadersFromSameShard := core.MaxUint32(
		process.MinShardHeadersFromSameShardInOneMetaBlock,
		process.MaxShardHeadersAllowedInOneMetaBlock/mp.shardCoordinator.NumberOfShards(),
	)
	maxShardHeadersAllowedInOneMetaBlock := maxShardHeadersFromSameShard * mp.shardCoordinator.NumberOfShards()
	hdrsAddedForShard := make(map[uint32]uint32)
	haveAdditionalTimeFalse := func() bool {
		return false
	}

	for i := 0; i < len(orderedHdrs); i++ {
		if !haveTime() {
			log.Debug("time is up after putting cross txs with destination to current shard",
				"num txs", txsAdded,
			)
			break
		}

		if hdrsAdded >= maxShardHeadersAllowedInOneMetaBlock {
			log.Debug("maximum shard headers allowed to be included in one meta block has been reached",
				"shard headers added", hdrsAdded,
			)
			break
		}

		currShardHdr := orderedHdrs[i]
		if currShardHdr.GetNonce() > lastShardHdr[currShardHdr.GetShardID()].GetNonce()+1 {
			log.Trace("skip searching",
				"shard", currShardHdr.GetShardID(),
				"last shard hdr nonce", lastShardHdr[currShardHdr.GetShardID()].GetNonce(),
				"curr shard hdr nonce", currShardHdr.GetNonce())
			continue
		}

		if hdrsAddedForShard[currShardHdr.GetShardID()] >= maxShardHeadersFromSameShard {
			log.Trace("maximum shard headers from same shard allowed to be included in one meta block has been reached",
				"shard", currShardHdr.GetShardID(),
				"shard headers added", hdrsAddedForShard[currShardHdr.GetShardID()],
			)
			continue
		}

		shouldCheckProof := mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.AndromedaFlag, currShardHdr.GetEpoch())
		if shouldCheckProof {
			hasProofForHdr := mp.proofsPool.HasProof(currShardHdr.GetShardID(), orderedHdrsHashes[i])
			if !hasProofForHdr {
				log.Trace("no proof for shard header",
					"shard", currShardHdr.GetShardID(),
					"hash", logger.DisplayByteSlice(orderedHdrsHashes[i]),
				)
				continue
			}
		}

		if len(currShardHdr.GetMiniBlockHeadersWithDst(mp.shardCoordinator.SelfId())) == 0 {
			mp.hdrsForCurrBlock.AddHeaderUsedInBlock(string(orderedHdrsHashes[i]), currShardHdr)
			hdrsAdded++
			hdrsAddedForShard[currShardHdr.GetShardID()]++
			lastShardHdr[currShardHdr.GetShardID()] = currShardHdr
			continue
		}

		snapshot := mp.accountsDB[state.UserAccountsState].JournalLen()
		currMBProcessed, currTxsAdded, hdrProcessFinished, createErr := mp.txCoordinator.CreateMbsAndProcessCrossShardTransactionsDstMe(
			currShardHdr,
			nil,
			haveTime,
			haveAdditionalTimeFalse,
			false)

		if createErr != nil {
			return nil, 0, 0, createErr
		}

		if !hdrProcessFinished {
			log.Debug("shard header cannot be fully processed",
				"round", currShardHdr.GetRound(),
				"nonce", currShardHdr.GetNonce(),
				"hash", orderedHdrsHashes[i])

			// shard header must be processed completely
			errAccountState := mp.accountsDB[state.UserAccountsState].RevertToSnapshot(snapshot)
			if errAccountState != nil {
				// TODO: evaluate if reloading the trie from disk might solve the problem
				log.Warn("accounts.RevertToSnapshot", "error", errAccountState.Error())
			}
			continue
		}

		// all txs processed, add to processed miniblocks
		miniBlocks = append(miniBlocks, currMBProcessed...)
		txsAdded += currTxsAdded

		mp.hdrsForCurrBlock.AddHeaderUsedInBlock(string(orderedHdrsHashes[i]), currShardHdr)
		hdrsAdded++
		hdrsAddedForShard[currShardHdr.GetShardID()]++

		lastShardHdr[currShardHdr.GetShardID()] = currShardHdr
	}

	go mp.requestShardHeadersIfNeeded(hdrsAddedForShard, lastShardHdr)

	return miniBlocks, txsAdded, hdrsAdded, nil
}

func (mp *metaProcessor) requestShardHeadersIfNeeded(
	hdrsAddedForShard map[uint32]uint32,
	lastShardHdr map[uint32]data.HeaderHandler,
) {
	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		log.Debug("shard headers added",
			"shard", shardID,
			"num", hdrsAddedForShard[shardID],
			"highest nonce", lastShardHdr[shardID].GetNonce())

		lastShardHdrRound := lastShardHdr[shardID].GetRound()
		roundTooOld := mp.roundHandler.Index() > int64(lastShardHdrRound+mp.getMaxRoundsWithoutBlockReceived(lastShardHdrRound))
		shouldRequestCrossHeaders := hdrsAddedForShard[shardID] == 0 && roundTooOld
		if shouldRequestCrossHeaders {
			fromNonce := lastShardHdr[shardID].GetNonce() + 1
			toNonce := fromNonce + uint64(mp.shardBlockFinality)
			for nonce := fromNonce; nonce <= toNonce; nonce++ {
				mp.addHeaderIntoTrackerPool(nonce, shardID)
				mp.requestHandler.RequestShardHeaderByNonce(shardID, nonce)
				mp.requestProofIfNeeded(nonce, shardID, lastShardHdr[shardID].GetEpoch())
			}
		}
	}
}

// CommitBlock commits the block in the blockchain if everything was checked successfully
func (mp *metaProcessor) CommitBlock(
	headerHandler data.HeaderHandler,
	bodyHandler data.BodyHandler,
) error {
	err := checkForNils(headerHandler, bodyHandler)
	if err != nil {
		return err
	}

	prevBlockHeader := mp.blockChain.GetCurrentBlockHeader()
	prevBlockHeaderHash := mp.blockChain.GetCurrentBlockHeaderHash()

	if !headerHandler.IsHeaderV3() {
		if !mp.processStatusHandler.TrySetBusy("metaProcessor.CommitBlock") {
			return process.ErrBlockProcessorBusy
		}
		defer func() {
			if err != nil {
				mp.RevertCurrentBlock()
			}
			mp.processStatusHandler.SetIdle()
		}()
	} else {
		defer func() {
			if err != nil {
				mp.RevertHeaderV3OnCommit(headerHandler)
				_ = mp.blockChain.SetCurrentBlockHeader(prevBlockHeader)
				mp.blockChain.SetCurrentBlockHeaderHash(prevBlockHeaderHash)
			}
		}()
	}

	log.Debug("started committing block",
		"epoch", headerHandler.GetEpoch(),
		"shard", headerHandler.GetShardID(),
		"round", headerHandler.GetRound(),
		"nonce", headerHandler.GetNonce(),
	)

	err = mp.checkBlockValidity(headerHandler, bodyHandler)
	if err != nil {
		return err
	}

	mp.store.SetEpochForPutOperation(headerHandler.GetEpoch())

	header, ok := headerHandler.(data.MetaHeaderHandler)
	if !ok {
		err = process.ErrWrongTypeAssertion
		return err
	}

	marshalizedHeader, err := mp.marshalizer.Marshal(header)
	if err != nil {
		return err
	}

	body, ok := bodyHandler.(*block.Body)
	if !ok {
		err = process.ErrWrongTypeAssertion
		return err
	}

	// must be called before commitEpochStart
	rewardsTxs := mp.getRewardsTxs(header, body)

	err = mp.commitEpochStart(header, body)
	if err != nil {
		return err
	}
	if header.IsStartOfEpochBlock() {
		mp.epochStartDataWrapper = &epochStartDataWrapper{
			Epoch:          header.GetEpoch(),
			EpochStartData: &block.EpochStart{},
		}
	}
	headerHash := mp.hasher.Compute(string(marshalizedHeader))
	mp.saveMetaHeader(header, headerHash, marshalizedHeader)
	mp.saveBody(body, header, headerHash)

	if !headerHandler.IsHeaderV3() {
		// TODO commit state on ProcessBlockProposal for meta and header v3
		err = mp.commitState(headerHandler)
		if err != nil {
			return err
		}
	}

	mp.validatorStatisticsProcessor.DisplayRatings(header.GetEpoch())

	err = mp.saveLastNotarizedHeader(header)
	if err != nil {
		return err
	}

	err = mp.pendingMiniBlocksHandler.AddProcessedHeader(header)
	if err != nil {
		return err
	}

	log.Info("meta block has been committed successfully",
		"epoch", headerHandler.GetEpoch(),
		"shard", headerHandler.GetShardID(),
		"round", headerHandler.GetRound(),
		"nonce", headerHandler.GetNonce(),
		"hash", headerHash)
	mp.setNonceOfFirstCommittedBlock(headerHandler.GetNonce())
	mp.updateLastCommittedInDebugger(headerHandler.GetRound())

	err = mp.computeOwnShardStuckIfNeeded(headerHandler)
	if err != nil {
		return err
	}

	mp.updateGasConsumptionLimitsIfNeeded()

	errNotCritical := mp.checkSentSignaturesAtCommitTime(headerHandler)
	if errNotCritical != nil {
		log.Debug("checkSentSignaturesBeforeCommitting", "error", errNotCritical.Error())
	}

	notarizedHeadersHashes, errNotCritical := mp.updateCrossShardInfo(header)
	if errNotCritical != nil {
		log.Debug("updateCrossShardInfo", "error", errNotCritical.Error())
	}

	errNotCritical = mp.forkDetector.AddHeader(header, headerHash, process.BHProcessed, nil, nil)
	if errNotCritical != nil {
		log.Debug("forkDetector.AddHeader", "error", errNotCritical.Error())
	}

	currentHeader, currentHeaderHash := getLastSelfNotarizedHeaderByItself(mp.blockChain)
	mp.blockTracker.AddSelfNotarizedHeader(mp.shardCoordinator.SelfId(), currentHeader, currentHeaderHash)

	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		lastSelfNotarizedHeader, lastSelfNotarizedHeaderHash := mp.getLastSelfNotarizedHeaderByShard(header, shardID)
		mp.blockTracker.AddSelfNotarizedHeader(shardID, lastSelfNotarizedHeader, lastSelfNotarizedHeaderHash)
	}

	go mp.historyRepo.OnNotarizedBlocks(mp.shardCoordinator.SelfId(), []data.HeaderHandler{currentHeader}, [][]byte{currentHeaderHash})

	log.Debug("highest final meta block",
		"nonce", mp.forkDetector.GetHighestFinalBlockNonce(),
	)

	finalMetaBlock, finalMetaBlockHash := mp.computeFinalMetaBlock(header, headerHash)
	mp.updateState(finalMetaBlock, finalMetaBlockHash)

	rootHash := mp.getLastExecutedRootHash(header)

	err = mp.setCurrentBlockInfo(header, headerHash, rootHash)
	if err != nil {
		return err
	}

	mp.blockChain.SetCurrentBlockHeaderHash(headerHash)

	lastExecutionResultHeader, err := mp.getLastExecutionResultHeader(header)
	if err != nil {
		return err
	}

	if !check.IfNil(finalMetaBlock) && finalMetaBlock.IsStartOfEpochBlock() {
		mp.blockTracker.CleanupInvalidCrossHeaders(header.GetEpoch(), header.GetRound())
	}

	err = mp.cleanExecutionResultsFromTracker(header)
	if err != nil {
		return err
	}

	// TODO: Should be sent also validatorInfoTxs alongside rewardsTxs -> mp.validatorInfoCreator.GetValidatorInfoTxs(body) ?
	mp.indexBlock(header, headerHash, body, finalMetaBlock, notarizedHeadersHashes, rewardsTxs)
	mp.recordBlockInHistory(headerHash, headerHandler, bodyHandler)

	err = mp.OnExecutedBlock(lastExecutionResultHeader, rootHash)
	if err != nil {
		return err
	}

	highestFinalBlockNonce := mp.forkDetector.GetHighestFinalBlockNonce()
	saveMetricsForCommitMetachainBlock(mp.appStatusHandler, header, headerHash, mp.nodesCoordinator, highestFinalBlockNonce, mp.managedPeersHolder)

	headersPool := mp.dataPool.Headers()
	numShardHeadersFromPool := 0
	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		numShardHeadersFromPool += headersPool.GetNumHeaders(shardID)
	}

	go func() {
		mp.txCounter.headerExecuted(header)
		mp.headersCounter.displayLogInfo(
			mp.txCounter,
			header,
			body,
			headerHash,
			numShardHeadersFromPool,
			mp.blockTracker,
			mp.dataPool,
		)
	}()

	headerInfo := bootstrapStorage.BootstrapHeaderInfo{
		ShardId: header.GetShardID(),
		Epoch:   header.GetEpoch(),
		Nonce:   header.GetNonce(),
		Hash:    headerHash,
	}

	nodesCoordinatorKey := mp.nodesCoordinator.GetSavedStateKey()
	epochStartKey := mp.epochStartTrigger.GetSavedStateKey()

	args := bootStorerDataArgs{
		headerInfo:                 headerInfo,
		round:                      header.GetRound(),
		lastSelfNotarizedHeaders:   mp.getLastSelfNotarizedHeaders(),
		nodesCoordinatorConfigKey:  nodesCoordinatorKey,
		epochStartTriggerConfigKey: epochStartKey,
		pendingMiniBlocks:          mp.getPendingMiniBlocks(),
		highestFinalBlockNonce:     highestFinalBlockNonce,
	}

	// TODO adjust this method if needed for Supernova
	mp.prepareDataForBootStorer(args)

	mp.blockSizeThrottler.Succeed(header.GetRound())

	mp.displayPoolsInfo()

	err = mp.saveExecutedData(header)
	if err != nil {
		return err
	}

	errNotCritical = mp.removeTxsFromPools(headerHash, header, body)
	if errNotCritical != nil {
		log.Debug("removeTxsFromPools", "error", errNotCritical.Error())
	}

	errNotCritical = mp.cleanPostProcessCache(header)
	if errNotCritical != nil {
		log.Debug("cleanPostProcessCache", "error", errNotCritical.Error())
	}

	mp.cleanupPools(headerHandler)

	mp.blockProcessingCutoffHandler.HandlePauseCutoff(header)

	if header.IsHeaderV3() && header.IsStartOfEpochBlock() {
		mp.saveEpochStartEconomicsMetrics(header)
	}

	return nil
}

func (mp *metaProcessor) computeFinalMetaBlock(metaBlock data.MetaHeaderHandler, metaBlockHash []byte) (data.MetaHeaderHandler, []byte) {
	lastHeader := mp.blockChain.GetCurrentBlockHeader()
	lastMetaBlock, ok := lastHeader.(data.MetaHeaderHandler)
	if !ok {
		if metaBlock.GetNonce() == firstHeaderNonce {
			log.Debug("metaBlock.CommitBlock - nil current block header, this is expected at genesis time")
		} else {
			log.Error("metaBlock.CommitBlock - nil current block header, last current header should have not been nil")
		}
	}
	lastMetaBlockHash := mp.blockChain.GetCurrentBlockHeaderHash()
	if mp.lastRestartNonce == 0 {
		mp.lastRestartNonce = metaBlock.GetNonce()
	}

	finalMetaBlock := lastMetaBlock
	finalMetaBlockHash := lastMetaBlockHash
	isBlockAfterAndromedaFlag := !check.IfNil(finalMetaBlock) &&
		mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.AndromedaFlag, finalMetaBlock.GetEpoch())
	if isBlockAfterAndromedaFlag {
		// for the first block we need to update both the state of the previous one and for current
		if common.IsEpochChangeBlockForFlagActivation(metaBlock, mp.enableEpochsHandler, common.AndromedaFlag) {
			mp.updateState(lastMetaBlock, lastMetaBlockHash)
		}

		finalMetaBlock = metaBlock
		finalMetaBlockHash = metaBlockHash
	}

	return finalMetaBlock, finalMetaBlockHash
}

func (mp *metaProcessor) updateCrossShardInfo(metaHeader data.MetaHeaderHandler) ([]string, error) {
	notarizedHeadersHashes := make([]string, 0)
	for _, shardData := range getShardHeadersReferencedByMeta(metaHeader) {
		header, err := mp.getHeaderFromHash(metaHeader.IsHeaderV3(), shardData.GetHeaderHash(), shardData.GetShardID())
		if err != nil {
			return nil, fmt.Errorf("%w : updateCrossShardInfo shardHeaderHash = %s",
				err, logger.DisplayByteSlice(shardData.GetHeaderHash()))
		}

		shardHeader, ok := header.(data.ShardHeaderHandler)
		if !ok {
			return nil, process.ErrWrongTypeAssertion
		}

		mp.updateShardHeadersNonce(shardHeader.GetShardID(), shardHeader.GetNonce())

		marshalizedShardHeader, err := mp.marshalizer.Marshal(shardHeader)
		if err != nil {
			return nil, err
		}

		notarizedHeadersHashes = append(notarizedHeadersHashes, hex.EncodeToString(shardData.GetHeaderHash()))

		mp.saveShardHeader(shardHeader, shardData.GetHeaderHash(), marshalizedShardHeader)
	}

	mp.saveMetricCrossCheckBlockHeight()

	return notarizedHeadersHashes, nil
}

func (mp *metaProcessor) displayPoolsInfo() {
	headersPool := mp.dataPool.Headers()
	miniBlocksPool := mp.dataPool.MiniBlocks()

	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		log.Trace("pools info",
			"shard", shardID,
			"num headers", headersPool.GetNumHeaders(shardID))
	}

	log.Trace("pools info",
		"shard", core.MetachainShardId,
		"num headers", headersPool.GetNumHeaders(core.MetachainShardId))

	// numShardsToKeepHeaders represents the total number of shards for which meta node would keep tracking headers
	// (in this case this number is equal with: number of shards + metachain (self shard))
	numShardsToKeepHeaders := int(mp.shardCoordinator.NumberOfShards()) + 1
	capacity := headersPool.MaxSize() * numShardsToKeepHeaders
	log.Debug("pools info",
		"total headers", headersPool.Len(),
		"headers pool capacity", capacity,
		"total miniblocks", miniBlocksPool.Len(),
		"miniblocks pool capacity", miniBlocksPool.MaxSize(),
	)

	mp.displayMiniBlocksPool()
}

func (mp *metaProcessor) getRootHashAndValidatorRootHash(metaBlock data.MetaHeaderHandler) ([]byte, []byte, error) {
	if !metaBlock.IsHeaderV3() {
		return metaBlock.GetRootHash(), metaBlock.GetValidatorStatsRootHash(), nil
	}

	execResults := metaBlock.GetLastExecutionResultHandler()
	baseMetaExecRes, ok := execResults.(data.LastMetaExecutionResultHandler)
	if !ok {
		return nil, nil, process.ErrWrongTypeAssertion
	}
	execRes := baseMetaExecRes.GetExecutionResultHandler()

	return execRes.GetRootHash(), execRes.GetValidatorStatsRootHash(), nil
}

func (mp *metaProcessor) updateState(metaBlock data.MetaHeaderHandler, metaBlockHash []byte) {
	if check.IfNil(metaBlock) {
		log.Debug("updateState nil header")
		return
	}

	rootHash, validatorRootHash, err := mp.getRootHashAndValidatorRootHash(metaBlock)
	if err != nil {
		log.Warn("could not get root hashes from meta header", "error", err.Error())
		return
	}

	mp.validatorStatisticsProcessor.SetLastFinalizedRootHash(validatorRootHash)

	prevMetaBlockHash := metaBlock.GetPrevHash()
	prevMetaBlock, errNotCritical := process.GetMetaHeader(
		prevMetaBlockHash,
		mp.dataPool.Headers(),
		mp.marshalizer,
		mp.store,
	)
	if errNotCritical != nil {
		log.Debug("could not get meta header from storage")
		return
	}

	if metaBlock.IsStartOfEpochBlock() {
		prevBlockRootHash, _, err := mp.getRootHashAndValidatorRootHash(prevMetaBlock)
		if err != nil {
			log.Warn("could not get root hashes from meta header", "error", err.Error())
			return
		}

		log.Debug("trie snapshot",
			"rootHash", rootHash,
			"prevRootHash", prevBlockRootHash,
			"validatorStatsRootHash", validatorRootHash)
		mp.accountsDB[state.UserAccountsState].SnapshotState(rootHash, metaBlock.GetEpoch())
		mp.accountsDB[state.PeerAccountsState].SnapshotState(validatorRootHash, metaBlock.GetEpoch())
		go func() {
			err := mp.commitTrieEpochRootHashIfNeeded(metaBlock, rootHash)
			if err != nil {
				log.Warn("couldn't commit trie checkpoint", "epoch", metaBlock.GetEpoch(), "error", err)
			}
		}()
	}

	if !metaBlock.IsHeaderV3() {
		mp.updateStateStorage(
			metaBlock.GetNonce(),
			metaBlock.GetRootHash(),
			prevMetaBlock.GetRootHash(),
			mp.accountsDB[state.UserAccountsState],
		)

		mp.updateStateStorage(
			metaBlock.GetNonce(),
			metaBlock.GetValidatorStatsRootHash(),
			prevMetaBlock.GetValidatorStatsRootHash(),
			mp.accountsDB[state.PeerAccountsState],
		)
	}

	// for header v3, trie prnning is triggered in async mode from headers executor

	outportFinalizedHeaderHash := metaBlockHash
	if !common.IsFlagEnabledAfterEpochsStartBlock(metaBlock, mp.enableEpochsHandler, common.AndromedaFlag) {
		outportFinalizedHeaderHash = metaBlock.GetPrevHash()
	}
	mp.setFinalizedHeaderHashInIndexer(outportFinalizedHeaderHash)

	mp.blockChain.SetFinalBlockInfo(metaBlock.GetNonce(), metaBlockHash, rootHash)
}

func (mp *metaProcessor) pruneTrieHeaderV3(
	metaBlock data.HeaderHandler,
) {
	accountsDb := mp.accountsDB[state.UserAccountsState]
	peerAccountsDb := mp.accountsDB[state.PeerAccountsState]
	if !accountsDb.IsPruningEnabled() && !peerAccountsDb.IsPruningEnabled() {
		return
	}

	prevMetaBlockHash := metaBlock.GetPrevHash()
	execResults := metaBlock.GetExecutionResultsHandlers()
	for i := range execResults {
		currentExecRes, ok := execResults[i].(data.BaseMetaExecutionResultHandler)
		if !ok {
			log.Warn("failed to assert current execution result for pruning",
				"index", i,
				"currentExecResType", fmt.Sprintf("%T", execResults[i]))
			continue
		}
		prevExecRes, err := mp.getPreviousExecutionResult(i, execResults, prevMetaBlockHash)
		if err != nil {
			log.Warn("failed to get previous execution result for pruning",
				"err", err,
				"index", i,
				"currentExecResHeaderHash", currentExecRes.GetHeaderHash())
			continue
		}

		currentRootHash := currentExecRes.GetRootHash()
		prevRootHash := prevExecRes.GetRootHash()
		log.Trace("pruneUserTrieHeaderV3",
			"currentRootHash", currentRootHash,
			"prevRootHash", prevRootHash,
		)

		mp.updateStateStorage(
			currentExecRes.GetHeaderNonce(),
			currentRootHash,
			prevRootHash,
			accountsDb,
		)

		currentValidatorRootHash := currentExecRes.GetValidatorStatsRootHash()
		prevValidatorRootHash := prevExecRes.GetValidatorStatsRootHash()
		log.Trace("prunePeerTrieHeaderV3",
			"currentValidatorRootHash", currentValidatorRootHash,
			"prevValidatorRootHash", prevValidatorRootHash,
		)

		mp.updateStateStorage(
			currentExecRes.GetHeaderNonce(),
			currentValidatorRootHash,
			prevValidatorRootHash,
			peerAccountsDb,
		)
	}
}

func (mp *metaProcessor) resetPruning() {
	accountsDb := mp.accountsDB[state.UserAccountsState]
	if accountsDb.IsPruningEnabled() {
		accountsDb.ResetPruning()
	}

	peerAccountsDb := mp.accountsDB[state.PeerAccountsState]
	if peerAccountsDb.IsPruningEnabled() {
		peerAccountsDb.ResetPruning()
	}
}

func (mp *metaProcessor) cancelPruneForDismissedExecutionResults(batches []executionTrack.DismissedBatch) {
	accountsDb := mp.accountsDB[state.UserAccountsState]
	peerAccountsDb := mp.accountsDB[state.PeerAccountsState]
	userPruningEnabled := accountsDb.IsPruningEnabled()
	peerPruningEnabled := peerAccountsDb.IsPruningEnabled()
	if !userPruningEnabled && !peerPruningEnabled {
		return
	}

	for _, batch := range batches {
		mp.cancelPruneForDismissedBatch(accountsDb, peerAccountsDb, batch, userPruningEnabled, peerPruningEnabled)
	}
}

func (mp *metaProcessor) cancelPruneForDismissedBatch(
	accountsDb state.AccountsAdapter,
	peerAccountsDb state.AccountsAdapter,
	batch executionTrack.DismissedBatch,
	userPruningEnabled bool,
	peerPruningEnabled bool,
) {
	if batch.AnchorResult == nil {
		return
	}

	prevUserRootHash := batch.AnchorResult.GetRootHash()
	prevValidatorRootHash := mp.extractValidatorStatsRootHash(batch.AnchorResult, peerPruningEnabled, "anchor")

	for _, result := range batch.Results {
		currentUserRootHash := result.GetRootHash()
		currentValidatorRootHash := mp.extractValidatorStatsRootHash(result, peerPruningEnabled, "result")

		if userPruningEnabled {
			cancelPruneForRootHashTransition(accountsDb, prevUserRootHash, currentUserRootHash)
		}
		if peerPruningEnabled {
			cancelPruneForRootHashTransition(peerAccountsDb, prevValidatorRootHash, currentValidatorRootHash)
		}

		prevUserRootHash = currentUserRootHash
		prevValidatorRootHash = currentValidatorRootHash
	}
}

func (mp *metaProcessor) extractValidatorStatsRootHash(
	result data.BaseExecutionResultHandler,
	peerPruningEnabled bool,
	context string,
) []byte {
	metaResult, ok := result.(data.BaseMetaExecutionResultHandler)
	if ok {
		return metaResult.GetValidatorStatsRootHash()
	}
	if peerPruningEnabled {
		log.Warn("cancelPruneForDismissedExecutionResults: " + context + " does not implement BaseMetaExecutionResultHandler")
	}
	return nil
}

func (mp *metaProcessor) getPreviousExecutionResult(
	index int,
	executionResultsHandlers []data.BaseExecutionResultHandler,
	prevMetaBlockHash []byte,
) (data.BaseMetaExecutionResultHandler, error) {
	if index > 0 {
		metaExecRes, ok := executionResultsHandlers[index-1].(data.BaseMetaExecutionResultHandler)
		if !ok {
			return nil, process.ErrWrongTypeAssertion
		}
		return metaExecRes, nil
	}

	prevMetaBlock, err := process.GetMetaHeader(prevMetaBlockHash, mp.dataPool.Headers(), mp.marshalizer, mp.store)
	if err != nil {
		return nil, err
	}

	if prevMetaBlock.IsHeaderV3() {
		lastExecRes := prevMetaBlock.GetLastExecutionResultHandler()
		if check.IfNil(lastExecRes) {
			return nil, fmt.Errorf("previous meta block has nil last execution result")
		}

		lastMetaExecRes, ok := lastExecRes.(data.LastMetaExecutionResultHandler)
		if !ok {
			return nil, process.ErrWrongTypeAssertion
		}

		return lastMetaExecRes.GetExecutionResultHandler(), nil
	}

	lastExecRes, err := common.CreateLastExecutionResultFromPrevHeader(prevMetaBlock, prevMetaBlockHash)
	if err != nil {
		return nil, err
	}

	lastMetaExecRes, ok := lastExecRes.(data.LastMetaExecutionResultHandler)
	if !ok {
		return nil, process.ErrWrongTypeAssertion
	}

	return lastMetaExecRes.GetExecutionResultHandler(), nil
}

func (mp *metaProcessor) getLastSelfNotarizedHeaderByShard(
	metaHeader data.MetaHeaderHandler,
	shardID uint32,
) (data.HeaderHandler, []byte) {

	lastNotarizedMetaHeader, lastNotarizedMetaHeaderHash, err := mp.blockTracker.GetLastSelfNotarizedHeader(shardID)
	if err != nil {
		log.Warn("getLastSelfNotarizedHeaderByShard.GetLastSelfNotarizedHeader",
			"shard", shardID,
			"error", err.Error())
		return nil, nil
	}

	maxNotarizedNonce := lastNotarizedMetaHeader.GetNonce()
	for _, shardData := range metaHeader.GetShardInfoHandlers() {
		if shardData.GetShardID() != shardID {
			continue
		}

		header, err := mp.getHeaderFromHash(metaHeader.IsHeaderV3(), shardData.GetHeaderHash(), shardData.GetShardID())
		if err != nil {
			log.Debug("getLastSelfNotarizedHeaderByShard",
				"error", err.Error(),
				"hash", shardData.GetHeaderHash())
			continue
		}

		shardHeader, ok := header.(data.ShardHeaderHandler)
		if !ok {
			log.Debug("getLastSelfNotarizedHeaderByShard",
				"error", process.ErrWrongTypeAssertion,
				"hash", shardData.GetHeaderHash())
			continue
		}

		for _, metaHash := range shardHeader.GetMetaBlockHashes() {
			metaHeader, errGet := process.GetMetaHeader(
				metaHash,
				mp.dataPool.Headers(),
				mp.marshalizer,
				mp.store,
			)
			if errGet != nil {
				log.Debug("getLastSelfNotarizedHeaderByShard.GetMetaHeader", "error", errGet.Error())
				continue
			}

			if metaHeader.GetNonce() > maxNotarizedNonce {
				maxNotarizedNonce = metaHeader.GetNonce()
				lastNotarizedMetaHeader = metaHeader
				lastNotarizedMetaHeaderHash = metaHash
			}
		}
	}

	if lastNotarizedMetaHeader != nil {
		log.Debug("last notarized meta header in shard",
			"shard", shardID,
			"epoch", lastNotarizedMetaHeader.GetEpoch(),
			"round", lastNotarizedMetaHeader.GetRound(),
			"nonce", lastNotarizedMetaHeader.GetNonce(),
			"hash", lastNotarizedMetaHeaderHash,
		)
	}

	return lastNotarizedMetaHeader, lastNotarizedMetaHeaderHash
}

// getRewardsTxs must be called before method commitEpoch start because when commit is done rewards txs are removed from pool and saved in storage
func (mp *metaProcessor) getRewardsTxs(header data.MetaHeaderHandler, body *block.Body) (rewardsTx map[string]data.TransactionHandler) {
	if !mp.outportHandler.HasDrivers() {
		return
	}
	if !header.IsStartOfEpochBlock() {
		return
	}

	rewardsTx = mp.epochRewardsCreator.GetRewardsTxs(body)
	return rewardsTx
}

func (mp *metaProcessor) commitEpochStart(header data.MetaHeaderHandler, body *block.Body) error {
	if header.IsStartOfEpochBlock() {
		processedBody, err := mp.prepareEpochStartBodyForTrigger(header, body)
		if err != nil {
			return err
		}

		mp.epochStartTrigger.SetProcessed(header, processedBody)
		mp.epochStartTrigger.SetEpochChangeProposed(false)
		go mp.epochRewardsCreator.SaveBlockDataToStorage(header, processedBody)
		go mp.validatorInfoCreator.SaveBlockDataToStorage(header, processedBody)
	} else {
		if header.IsEpochChangeProposed() {
			mp.epochStartTrigger.SetEpochChangeProposed(true)
		}

		currentHeader := mp.blockChain.GetCurrentBlockHeader()
		if !check.IfNil(currentHeader) && currentHeader.IsStartOfEpochBlock() {
			mp.epochStartTrigger.SetFinalityAttestingRound(header.GetRound())
			mp.nodesCoordinator.ShuffleOutForEpoch(currentHeader.GetEpoch())
		}
	}

	return nil
}

func (mp *metaProcessor) prepareEpochStartBodyForTrigger(header data.MetaHeaderHandler, body *block.Body) (*block.Body, error) {
	if !header.IsHeaderV3() {
		return body, nil
	}

	allMiniBlocks := make([]*block.MiniBlock, 0)
	for _, execResult := range header.GetExecutionResultsHandlers() {
		metaExecRes, castOk := execResult.(data.MetaExecutionResultHandler)
		if !castOk {
			return nil, fmt.Errorf("%w in prepareEpochStartBodyForTrigger for metaExecRes", process.ErrWrongTypeAssertion)
		}

		retrievedObj, found := mp.dataPool.ExecutedMiniBlocks().Get(metaExecRes.GetHeaderHash())
		if !found {
			return nil, fmt.Errorf("%w in prepareEpochStartBodyForTrigger for key: %s", trie.ErrKeyNotFound, hex.EncodeToString(metaExecRes.GetHeaderHash()))
		}

		currMBs, castOk := retrievedObj.([]*block.MiniBlock)
		if !castOk {
			return nil, fmt.Errorf("%w in prepareEpochStartBodyForTrigger for marshalledMbs", process.ErrWrongTypeAssertion)
		}

		allMiniBlocks = append(allMiniBlocks, currMBs...)
	}

	return &block.Body{MiniBlocks: allMiniBlocks}, nil
}

// RevertStateToBlock recreates the state tries to the root hashes indicated by the provided root hash and header
func (mp *metaProcessor) RevertStateToBlock(header data.HeaderHandler, rootHash []byte) error {
	rootHashHolder := holders.NewDefaultRootHashesHolder(rootHash)
	err := mp.accountsDB[state.UserAccountsState].RecreateTrie(rootHashHolder)
	if err != nil {
		log.Debug("recreate trie with error for header",
			"nonce", header.GetNonce(),
			"header root hash", header.GetRootHash(),
			"given root hash", rootHash,
			"error", err.Error(),
		)

		return err
	}

	metaHeader, ok := header.(data.MetaHeaderHandler)
	if !ok {
		return process.ErrWrongTypeAssertion
	}

	err = mp.validatorStatisticsProcessor.RevertPeerState(metaHeader)
	if err != nil {
		log.Debug("revert peer state with error for header",
			"nonce", metaHeader.GetNonce(),
			"validators root hash", metaHeader.GetValidatorStatsRootHash(),
			"error", err.Error(),
		)

		return err
	}

	err = mp.epochStartTrigger.RevertStateToBlock(metaHeader)
	if err != nil {
		log.Debug("revert epoch start trigger for header",
			"nonce", metaHeader.GetNonce(),
			"error", err,
		)
		return err
	}

	return nil
}

func (mp *metaProcessor) updateShardHeadersNonce(key uint32, value uint64) {
	valueStoredI, ok := mp.shardsHeadersNonce.Load(key)
	if !ok {
		mp.shardsHeadersNonce.Store(key, value)
		return
	}

	valueStored, ok := valueStoredI.(uint64)
	if !ok {
		mp.shardsHeadersNonce.Store(key, value)
		return
	}

	if valueStored < value {
		mp.shardsHeadersNonce.Store(key, value)
	}
}

func (mp *metaProcessor) saveMetricCrossCheckBlockHeight() {
	crossCheckBlockHeight := ""
	for i := uint32(0); i < mp.shardCoordinator.NumberOfShards(); i++ {
		heightValue := uint64(0)

		valueStoredI, isValueInMap := mp.shardsHeadersNonce.Load(i)
		if isValueInMap {
			valueStored, ok := valueStoredI.(uint64)
			if ok {
				heightValue = valueStored
			}
		}

		crossCheckBlockHeight += fmt.Sprintf("%d: %d, ", i, heightValue)

		shardedCrossChecksKey := fmt.Sprintf("%s_%d", common.MetricCrossCheckBlockHeight, i)
		mp.appStatusHandler.SetUInt64Value(shardedCrossChecksKey, heightValue)
	}

	mp.appStatusHandler.SetStringValue(common.MetricCrossCheckBlockHeight, crossCheckBlockHeight)
}

func (mp *metaProcessor) saveLastNotarizedHeader(metaHeader data.MetaHeaderHandler) error {
	lastCrossNotarizedHeaderForShard := make(map[uint32]*hashAndHdr, mp.shardCoordinator.NumberOfShards())
	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		lastCrossNotarizedHeader, lastCrossNotarizedHeaderHash, err := mp.blockTracker.GetLastCrossNotarizedHeader(shardID)
		if err != nil {
			return err
		}

		lastCrossNotarizedHeaderForShard[shardID] = &hashAndHdr{hdr: lastCrossNotarizedHeader, hash: lastCrossNotarizedHeaderHash}
	}

	for _, shardData := range getShardHeadersReferencedByMeta(metaHeader) {
		header, err := mp.getHeaderFromHash(metaHeader.IsHeaderV3(), shardData.GetHeaderHash(), shardData.GetShardID())
		if err != nil {
			return fmt.Errorf("%w : saveLastNotarizedHeader shardHeaderHash = %s",
				err, logger.DisplayByteSlice(shardData.GetHeaderHash()))
		}

		shardHeader, ok := header.(data.ShardHeaderHandler)
		if !ok {
			return process.ErrWrongTypeAssertion
		}

		if lastCrossNotarizedHeaderForShard[shardHeader.GetShardID()].hdr.GetNonce() < shardHeader.GetNonce() {
			lastCrossNotarizedHeaderForShard[shardHeader.GetShardID()] = &hashAndHdr{hdr: shardHeader, hash: shardData.GetHeaderHash()}
		}
	}

	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		hdr := lastCrossNotarizedHeaderForShard[shardID].hdr
		hash := lastCrossNotarizedHeaderForShard[shardID].hash
		mp.blockTracker.AddCrossNotarizedHeader(shardID, hdr, hash)
		DisplayLastNotarized(mp.marshalizer, mp.hasher, hdr, shardID)
	}

	return nil
}

func (mp *metaProcessor) getLastCrossNotarizedShardHdrsAndAddToCurrentBlock() (map[uint32]data.HeaderHandler, error) {
	lastCrossNotarizedHeader, err := mp.getLastCrossNotarizedShardHeaders()
	if err != nil {
		return nil, err
	}
	mp.addHeaders(lastCrossNotarizedHeader)

	headers := make(map[uint32]data.HeaderHandler, len(lastCrossNotarizedHeader))
	for k, v := range lastCrossNotarizedHeader {
		headers[k] = v.Header
	}

	return headers, nil
}

func (mp *metaProcessor) getLastCrossNotarizedShardHeaders() (map[uint32]ShardHeaderInfo, error) {
	lastCrossNotarizedHeader := make(map[uint32]ShardHeaderInfo, mp.shardCoordinator.NumberOfShards())
	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		lastCrossNotarizedHeaderForShard, hash, err := mp.blockTracker.GetLastCrossNotarizedHeader(shardID)
		if err != nil {
			return nil, err
		}

		log.Debug("lastCrossNotarizedHeader for shard", "shardID", shardID, "hash", hash)
		usedInBlock := mp.isGenesisShardBlockAndFirstMeta(lastCrossNotarizedHeaderForShard.GetNonce())
		lastCrossNotarizedHeader[shardID] = ShardHeaderInfo{
			Header:      lastCrossNotarizedHeaderForShard,
			Hash:        hash,
			UsedInBlock: usedInBlock,
		}
	}

	return lastCrossNotarizedHeader, nil
}

func (mp *metaProcessor) addHeaders(shardHeadersInfo map[uint32]ShardHeaderInfo) {
	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		shardHdrInfo, ok := shardHeadersInfo[shardID]
		if !ok {
			continue
		}
		mp.addHeader(shardHdrInfo.Hash, shardHdrInfo.Header, shardHdrInfo.UsedInBlock)
	}
}

func (mp *metaProcessor) addHeader(hash []byte, header data.HeaderHandler, usedInBlock bool) {
	if usedInBlock {
		mp.hdrsForCurrBlock.AddHeaderUsedInBlock(string(hash), header)
		return
	}

	mp.hdrsForCurrBlock.AddHeaderNotUsedInBlock(string(hash), header)
}

// check if shard headers were signed and constructed correctly and returns headers which has to be
// checked for finality
func (mp *metaProcessor) checkShardHeadersValidity(metaHdr data.MetaHeaderHandler) (map[uint32]data.HeaderHandler, error) {
	lastCrossNotarizedHeader, err := mp.getLastCrossNotarizedShardHdrsAndAddToCurrentBlock()
	if err != nil {
		return nil, err
	}

	usedShardHdrs, err := mp.sortHeadersForCurrentBlockByNonce(true)
	if err != nil {
		return nil, err
	}
	highestNonceHdrs := make(map[uint32]data.HeaderHandler, len(usedShardHdrs))

	if len(usedShardHdrs) == 0 {
		return highestNonceHdrs, nil
	}

	for shardID, hdrsForShard := range usedShardHdrs {
		for _, shardHdr := range hdrsForShard {
			if !mp.isGenesisShardBlockAndFirstMeta(shardHdr.GetNonce()) {
				err = mp.headerValidator.IsHeaderConstructionValid(shardHdr, lastCrossNotarizedHeader[shardID])
				if err != nil {
					return nil, fmt.Errorf("%w : checkShardHeadersValidity -> isHdrConstructionValid", err)
				}
			}

			lastCrossNotarizedHeader[shardID] = shardHdr
			highestNonceHdrs[shardID] = shardHdr
		}
	}

	for _, shardData := range metaHdr.GetShardInfoHandlers() {
		headerInfo, ok := mp.hdrsForCurrBlock.GetHeaderInfo(string(shardData.GetHeaderHash()))
		if !ok {
			return nil, fmt.Errorf("%w : checkShardHeadersValidity -> hash not found %s ",
				process.ErrHeaderShardDataMismatch, hex.EncodeToString(shardData.GetHeaderHash()))
		}
		actualHdr := headerInfo.GetHeader()
		shardHdr, ok := actualHdr.(data.ShardHeaderHandler)
		if !ok {
			return nil, process.ErrWrongTypeAssertion
		}

		finalMiniBlockHeaders := mp.getFinalMiniBlockHeaders(shardHdr.GetMiniBlockHeaderHandlers())

		if len(shardData.GetShardMiniBlockHeaderHandlers()) != len(finalMiniBlockHeaders) {
			return nil, process.ErrHeaderShardDataMismatch
		}
		if shardData.GetAccumulatedFees().Cmp(shardHdr.GetAccumulatedFees()) != 0 {
			return nil, process.ErrAccumulatedFeesDoNotMatch
		}
		if shardData.GetDeveloperFees().Cmp(shardHdr.GetDeveloperFees()) != 0 {
			return nil, process.ErrDeveloperFeesDoNotMatch
		}
		if mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.AndromedaFlag, shardHdr.GetEpoch()) {
			if shardData.GetEpoch() != shardHdr.GetEpoch() {
				return nil, process.ErrEpochMismatch
			}
		}

		mapMiniBlockHeadersInMetaBlock := make(map[string]struct{})
		for _, shardMiniBlockHdr := range shardData.GetShardMiniBlockHeaderHandlers() {
			mapMiniBlockHeadersInMetaBlock[string(shardMiniBlockHdr.GetHash())] = struct{}{}
		}

		for _, actualMiniBlockHdr := range finalMiniBlockHeaders {
			if _, hashExists := mapMiniBlockHeadersInMetaBlock[string(actualMiniBlockHdr.GetHash())]; !hashExists {
				return nil, process.ErrHeaderShardDataMismatch
			}
		}
	}

	return highestNonceHdrs, nil
}

func (mp *metaProcessor) getFinalMiniBlockHeaders(miniBlockHeaderHandlers []data.MiniBlockHeaderHandler) []data.MiniBlockHeaderHandler {
	if !mp.enableEpochsHandler.IsFlagEnabled(common.ScheduledMiniBlocksFlag) {
		return miniBlockHeaderHandlers
	}

	miniBlockHeaders := make([]data.MiniBlockHeaderHandler, 0)
	for _, miniBlockHeader := range miniBlockHeaderHandlers {
		if !miniBlockHeader.IsFinal() {
			log.Debug("metaProcessor.getFinalMiniBlockHeaders: do not check validity for mini block which is not final", "mb hash", miniBlockHeader.GetHash())
			continue
		}

		miniBlockHeaders = append(miniBlockHeaders, miniBlockHeader)
	}

	return miniBlockHeaders
}

// check if shard headers are final by checking if newer headers were constructed upon them
func (mp *metaProcessor) checkShardHeadersFinality(
	highestNonceHdrs map[uint32]data.HeaderHandler,
) error {
	finalityAttestingShardHdrs, err := mp.sortHeadersForCurrentBlockByNonce(false)
	if err != nil {
		return err
	}

	var errFinal error

	for shardId, lastVerifiedHdr := range highestNonceHdrs {
		if check.IfNil(lastVerifiedHdr) {
			return process.ErrNilBlockHeader
		}
		if lastVerifiedHdr.GetShardID() != shardId {
			return process.ErrShardIdMissmatch
		}
		isGenesisShardBlockAndFirstMeta := mp.isGenesisShardBlockAndFirstMeta(lastVerifiedHdr.GetNonce())
		if isGenesisShardBlockAndFirstMeta {
			continue
		}

		isNotarizedBasedOnProofs, errCheckProof := mp.checkShardHeaderFinalityBasedOnProofs(lastVerifiedHdr, shardId)
		if isNotarizedBasedOnProofs {
			if errCheckProof != nil {
				return errCheckProof
			}

			continue
		}

		// verify if there are "K" block after current to make this one final
		nextBlocksVerified := uint32(0)
		for _, shardHdr := range finalityAttestingShardHdrs[shardId] {
			if nextBlocksVerified >= mp.shardBlockFinality {
				break
			}

			// found a header with the next nonce
			if shardHdr.GetNonce() == lastVerifiedHdr.GetNonce()+1 {
				err := mp.headerValidator.IsHeaderConstructionValid(shardHdr, lastVerifiedHdr)
				if err != nil {
					log.Debug("checkShardHeadersFinality -> isHdrConstructionValid",
						"error", err.Error())
					continue
				}

				isNotarizedBasedOnProofs, errCheckProof = mp.checkShardHeaderFinalityBasedOnProofs(shardHdr, shardId)
				if isNotarizedBasedOnProofs {
					if errCheckProof != nil {
						return errCheckProof
					}

					break
				}

				lastVerifiedHdr = shardHdr
				nextBlocksVerified += 1
			}
		}

		if nextBlocksVerified < mp.shardBlockFinality && !isNotarizedBasedOnProofs {
			go mp.requestHandler.RequestShardHeaderByNonce(lastVerifiedHdr.GetShardID(), lastVerifiedHdr.GetNonce())
			go mp.requestHandler.RequestShardHeaderByNonce(lastVerifiedHdr.GetShardID(), lastVerifiedHdr.GetNonce()+1)
			errFinal = process.ErrHeaderNotFinal
		}
	}

	return errFinal
}

func (mp *metaProcessor) checkShardHeaderFinalityBasedOnProofs(shardHdr data.HeaderHandler, shardId uint32) (bool, error) {
	if !mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.AndromedaFlag, shardHdr.GetEpoch()) {
		return false, nil
	}

	headerHash, err := core.CalculateHash(mp.marshalizer, mp.hasher, shardHdr)
	if err != nil {
		return true, err
	}

	if !mp.proofsPool.HasProof(shardId, headerHash) {
		return true, process.ErrHeaderNotFinal
	}

	return true, nil
}

func (mp *metaProcessor) createShardInfo(metaHdr data.MetaHeaderHandler) ([]data.ShardDataHandler, error) {
	var shardInfo []data.ShardDataHandler
	if metaHdr.IsStartOfEpochBlock() {
		return shardInfo, nil
	}

	hdrHashAndInfo := mp.hdrsForCurrBlock.GetHeadersInfoMap()
	headers := make([]data.ShardHeaderHandler, 0, len(hdrHashAndInfo))
	headerHashes := make([][]byte, 0, len(hdrHashAndInfo))
	for hdrHash, headerInfo := range hdrHashAndInfo {
		if !headerInfo.UsedInBlock() {
			continue
		}

		isBlockAfterAndromedaFlag := !check.IfNil(headerInfo.GetHeader()) &&
			mp.enableEpochsHandler.IsFlagEnabledInEpoch(common.AndromedaFlag, headerInfo.GetHeader().GetEpoch()) && headerInfo.GetHeader().GetNonce() >= 1
		hasMissingShardHdrProof := isBlockAfterAndromedaFlag && !mp.proofsPool.HasProof(headerInfo.GetHeader().GetShardID(), []byte(hdrHash))
		if hasMissingShardHdrProof {
			return nil, fmt.Errorf("%w for shard header with hash %s", process.ErrMissingHeaderProof, hex.EncodeToString([]byte(hdrHash)))
		}

		shardHdr, ok := headerInfo.GetHeader().(data.ShardHeaderHandler)
		if !ok {
			return nil, process.ErrWrongTypeAssertion
		}

		headers = append(headers, shardHdr)
		headerHashes = append(headerHashes, []byte(hdrHash))
	}

	shardInfo, err := mp.shardInfoCreateData.CreateShardInfoFromLegacyMeta(metaHdr, headers, headerHashes)
	if err != nil {
		return nil, err
	}

	log.Debug("created shard data", "size", len(shardInfo))
	return shardInfo, nil
}

func (mp *metaProcessor) verifyTotalAccumulatedFeesInEpoch(metaHdr *block.MetaBlock) error {
	computedTotalFees, computedTotalDevFees, err := mp.computeAccumulatedFeesInEpoch(metaHdr)
	if err != nil {
		return err
	}

	if computedTotalFees.Cmp(metaHdr.AccumulatedFeesInEpoch) != 0 {
		return fmt.Errorf("%w, got %v, computed %v", process.ErrAccumulatedFeesInEpochDoNotMatch, metaHdr.AccumulatedFeesInEpoch, computedTotalFees)
	}

	if computedTotalDevFees.Cmp(metaHdr.DevFeesInEpoch) != 0 {
		return fmt.Errorf("%w, got %v, computed %v", process.ErrDevFeesInEpochDoNotMatch, metaHdr.DevFeesInEpoch, computedTotalDevFees)
	}

	return nil
}

func (mp *metaProcessor) getCurrentlyAccumulatedFees(metaHdr data.MetaHeaderHandler) (*big.Int, *big.Int, error) {
	if metaHdr.IsHeaderV3() {
		if metaHdr.IsEpochChangeProposed() {
			return big.NewInt(0), big.NewInt(0), nil
		}

		lastExecResult, err := common.GetLastBaseExecutionResultHandler(metaHdr)
		if err != nil {
			return nil, nil, err
		}

		lastMetaExecResult, ok := lastExecResult.(data.BaseMetaExecutionResultHandler)
		if !ok {
			return nil, nil, process.ErrWrongTypeAssertion
		}

		currentlyAccumulatedFeesInEpoch := big.NewInt(0).Set(lastMetaExecResult.GetAccumulatedFeesInEpoch())
		currentDevFeesInEpoch := big.NewInt(0).Set(lastMetaExecResult.GetDevFeesInEpoch())

		return currentlyAccumulatedFeesInEpoch, currentDevFeesInEpoch, nil
	}

	lastHdr := mp.blockChain.GetCurrentBlockHeader()
	if check.IfNil(lastHdr) {
		return big.NewInt(0), big.NewInt(0), nil
	}

	lastMeta, ok := lastHdr.(*block.MetaBlock)
	if !ok {
		return nil, nil, process.ErrWrongTypeAssertion
	}

	if lastHdr.IsStartOfEpochBlock() {
		return big.NewInt(0), big.NewInt(0), nil
	}
	currentlyAccumulatedFeesInEpoch := big.NewInt(0).Set(lastMeta.AccumulatedFeesInEpoch)
	currentDevFeesInEpoch := big.NewInt(0).Set(lastMeta.DevFeesInEpoch)

	return currentlyAccumulatedFeesInEpoch, currentDevFeesInEpoch, nil
}

func (mp *metaProcessor) getHeaderAccumulatedFees(metaHdr data.MetaHeaderHandler) (*big.Int, *big.Int) {
	if metaHdr.IsHeaderV3() {
		gasAndFees := mp.getGasAndFees()
		return gasAndFees.GetAccumulatedFees(), gasAndFees.GetDeveloperFees()
	}

	return metaHdr.GetAccumulatedFees(), metaHdr.GetDeveloperFees()
}

func (mp *metaProcessor) computeAccumulatedFeesInEpoch(metaHdr data.MetaHeaderHandler) (*big.Int, *big.Int, error) {
	currentlyAccumulatedFeesInEpoch, currentDevFeesInEpoch, err := mp.getCurrentlyAccumulatedFees(metaHdr)
	if err != nil {
		return nil, nil, err
	}

	accumulatedFees, developerFees := mp.getHeaderAccumulatedFees(metaHdr)

	currentlyAccumulatedFeesInEpoch.Add(currentlyAccumulatedFeesInEpoch, accumulatedFees)
	currentDevFeesInEpoch.Add(currentDevFeesInEpoch, developerFees)
	log.Debug("computeAccumulatedFeesInEpoch - meta block fees",
		"meta nonce", metaHdr.GetNonce(),
		"accumulatedFees", accumulatedFees.String(),
		"devFees", developerFees.String(),
		"meta leader fees", core.GetIntTrimmedPercentageOfValue(big.NewInt(0).Sub(accumulatedFees, developerFees), mp.economicsData.LeaderPercentageInEpoch(metaHdr.GetEpoch())).String())

	for _, shardData := range metaHdr.GetShardInfoHandlers() {
		log.Debug("computeAccumulatedFeesInEpoch - adding shard data fees",
			"shardHeader hash", shardData.GetHeaderHash(),
			"shardHeader nonce", shardData.GetNonce(),
			"shardHeader accumulated fees", shardData.GetAccumulatedFees().String(),
			"shardHeader dev fees", shardData.GetDeveloperFees().String(),
			"shardHeader leader fees", core.GetIntTrimmedPercentageOfValue(big.NewInt(0).Sub(shardData.GetAccumulatedFees(), shardData.GetDeveloperFees()), mp.economicsData.LeaderPercentageInEpoch(metaHdr.GetEpoch())).String(),
		)

		currentlyAccumulatedFeesInEpoch.Add(currentlyAccumulatedFeesInEpoch, shardData.GetAccumulatedFees())
		currentDevFeesInEpoch.Add(currentDevFeesInEpoch, shardData.GetDeveloperFees())
	}

	log.Debug("computeAccumulatedFeesInEpoch - fees in epoch",
		"accumulatedFeesInEpoch", currentlyAccumulatedFeesInEpoch.String(),
		"devFeesInEpoch", currentDevFeesInEpoch.String())

	return currentlyAccumulatedFeesInEpoch, currentDevFeesInEpoch, nil
}

// applyBodyToHeader creates a miniblock header list given a block body
func (mp *metaProcessor) applyBodyToHeader(metaHdr data.MetaHeaderHandler, bodyHandler data.BodyHandler) (data.BodyHandler, error) {
	sw := core.NewStopWatch()
	sw.Start("applyBodyToHeader")
	defer func() {
		sw.Stop("applyBodyToHeader")

		log.Debug("measurements", sw.GetMeasurements()...)
	}()

	if check.IfNil(bodyHandler) {
		return nil, process.ErrNilBlockBody
	}

	var err error
	defer func() {
		go mp.checkAndRequestIfShardHeadersMissing()
	}()

	sw.Start("createShardInfo")
	shardInfo, err := mp.createShardInfo(metaHdr)
	sw.Stop("createShardInfo")
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetEpoch(mp.epochStartTrigger.Epoch())
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetShardInfoHandlers(shardInfo)
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetRootHash(mp.getRootHash())
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetTxCount(getTxCount(shardInfo))
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetAccumulatedFees(mp.feeHandler.GetAccumulatedFees())
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetDeveloperFees(mp.feeHandler.GetDeveloperFees())
	if err != nil {
		return nil, err
	}

	accumulatedFees, devFees, err := mp.computeAccumulatedFeesInEpoch(metaHdr)
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetAccumulatedFeesInEpoch(accumulatedFees)
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetDevFeesInEpoch(devFees)
	if err != nil {
		return nil, err
	}

	body, ok := bodyHandler.(*block.Body)
	if !ok {
		err = process.ErrWrongTypeAssertion
		return nil, err
	}

	sw.Start("CreateReceiptsHash")
	receiptsHash, err := mp.txCoordinator.CreateReceiptsHash()
	sw.Stop("CreateReceiptsHash")
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetReceiptsHash(receiptsHash)
	if err != nil {
		return nil, err
	}

	totalTxCount, miniBlockHeaderHandlers, err := mp.createMiniBlockHeaderHandlers(body, make(map[string]*processedMb.ProcessedMiniBlockInfo))
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetMiniBlockHeaderHandlers(miniBlockHeaderHandlers)
	if err != nil {
		return nil, err
	}

	txCount := metaHdr.GetTxCount() + uint32(totalTxCount)
	err = metaHdr.SetTxCount(txCount)
	if err != nil {
		return nil, err
	}

	sw.Start("UpdatePeerState")
	mp.prepareBlockHeaderInternalMapForValidatorProcessor(metaHdr)
	valStatRootHash, err := mp.updatePeerState(metaHdr, mp.hdrsForCurrBlock.GetHeadersMap())
	sw.Stop("UpdatePeerState")
	if err != nil {
		return nil, err
	}

	err = metaHdr.SetValidatorStatsRootHash(valStatRootHash)
	if err != nil {
		return nil, err
	}

	marshalizedBody, err := mp.marshalizer.Marshal(body)
	if err != nil {
		return nil, err
	}

	mp.blockSizeThrottler.Add(metaHdr.GetRound(), uint32(len(marshalizedBody)))

	return body, nil
}

func (mp *metaProcessor) prepareBlockHeaderInternalMapForValidatorProcessor(metaHeader data.MetaHeaderHandler) {
	var blockHeader data.HeaderHandler
	var blockHeaderHash []byte
	if metaHeader.IsHeaderV3() {
		blockHeader = mp.blockChain.GetLastExecutedBlockHeader()
		_, blockHeaderHash, _ = mp.blockChain.GetLastExecutedBlockInfo()
	} else {
		blockHeader = mp.blockChain.GetCurrentBlockHeader()
		blockHeaderHash = mp.blockChain.GetCurrentBlockHeaderHash()
	}

	if check.IfNil(blockHeader) {
		blockHeader = mp.blockChain.GetGenesisHeader()
		blockHeaderHash = mp.blockChain.GetGenesisHeaderHash()
	}

	mp.hdrsForCurrBlock.AddHeaderNotUsedInBlock(string(blockHeaderHash), blockHeader)
}

func (mp *metaProcessor) verifyValidatorStatisticsRootHash(header data.MetaHeaderHandler) error {
	mp.prepareBlockHeaderInternalMapForValidatorProcessor(header)
	validatorStatsRH, err := mp.updatePeerState(header, mp.hdrsForCurrBlock.GetHeadersMap())
	if err != nil {
		return err
	}

	if !bytes.Equal(validatorStatsRH, header.GetValidatorStatsRootHash()) {
		log.Debug("validator stats root hash mismatch",
			"computed", validatorStatsRH,
			"received", header.GetValidatorStatsRootHash(),
		)
		return fmt.Errorf("%s, metachain, computed: %s, received: %s, meta header nonce: %d",
			process.ErrValidatorStatsRootHashDoesNotMatch,
			logger.DisplayByteSlice(validatorStatsRH),
			logger.DisplayByteSlice(header.GetValidatorStatsRootHash()),
			header.GetNonce(),
		)
	}

	return nil
}

func (mp *metaProcessor) updatePeerState(
	header data.MetaHeaderHandler,
	cache map[string]data.HeaderHandler,
) ([]byte, error) {
	if !header.IsHeaderV3() {
		return mp.validatorStatisticsProcessor.UpdatePeerState(header, cache)
	}

	lastExecutionResult, err := mp.getLastExecutionResult(header, cache)
	if err != nil {
		return nil, err
	}

	return mp.validatorStatisticsProcessor.UpdatePeerStateV3(header, cache, lastExecutionResult)
}

func (mp *metaProcessor) getLastExecutionResult(
	header data.MetaHeaderHandler,
	cache map[string]data.HeaderHandler,
) (data.MetaExecutionResultHandler, error) {
	prevHdr, err := getPrevHdrFromCache(header, cache)
	if err != nil {
		return nil, err
	}

	if !prevHdr.IsHeaderV3() {
		// We only need these two fields for validatorStatisticsProcessor.UpdatePeerStateV3
		return &block.MetaExecutionResult{
			AccumulatedFees: prevHdr.GetAccumulatedFees(),
			DeveloperFees:   prevHdr.GetDeveloperFees(),
		}, nil
	}

	lastExecutionResult := mp.blockChain.GetLastExecutionResult()
	if check.IfNil(lastExecutionResult) {
		return nil, fmt.Errorf("missing last execution result in blockchain in metaProcessor.getLastExecutionResult")
	}

	metaExecutionResult, castOk := lastExecutionResult.(data.MetaExecutionResultHandler)
	if !castOk {
		return nil, fmt.Errorf("%w in metaProcessor.getLastExecutionResult", process.ErrWrongTypeAssertion)
	}

	return metaExecutionResult, nil
}

func getPrevHdrFromCache(
	header data.MetaHeaderHandler,
	cache map[string]data.HeaderHandler,
) (data.HeaderHandler, error) {
	prevHash := header.GetPrevHash()
	prevHdr, found := cache[string(prevHash)]
	if !found {
		return nil, fmt.Errorf("%w in getPrevHdrFromCache", errNilPreviousHeader)
	}
	return prevHdr, nil
}

// CreateNewHeader creates a new header
func (mp *metaProcessor) CreateNewHeader(round uint64, nonce uint64) (data.HeaderHandler, error) {
	mp.epochStartTrigger.Update(round, nonce)
	epoch := mp.epochStartTrigger.Epoch()

	header := mp.versionedHeaderFactory.Create(epoch, round)
	metaHeader, ok := header.(data.MetaHeaderHandler)
	if !ok {
		return nil, process.ErrWrongTypeAssertion
	}

	if metaHeader.IsHeaderV3() {
		return nil, process.ErrInvalidHeader
	}

	err := metaHeader.SetRound(round)
	if err != nil {
		return nil, err
	}

	mp.roundNotifier.CheckRound(header)
	mp.epochNotifier.CheckEpoch(header)

	err = metaHeader.SetNonce(nonce)
	if err != nil {
		return nil, err
	}

	err = initializeFeesDataMetaHeaderIfNeeded(metaHeader)
	if err != nil {
		return nil, err
	}

	err = mp.setHeaderVersionData(metaHeader)
	if err != nil {
		return nil, err
	}

	return metaHeader, nil
}

func initializeFeesDataMetaHeaderIfNeeded(metaHeader data.MetaHeaderHandler) error {
	if metaHeader.IsHeaderV3() {
		return nil
	}

	err := metaHeader.SetAccumulatedFees(big.NewInt(0))
	if err != nil {
		return err
	}

	err = metaHeader.SetAccumulatedFeesInEpoch(big.NewInt(0))
	if err != nil {
		return err
	}

	err = metaHeader.SetDeveloperFees(big.NewInt(0))
	if err != nil {
		return err
	}

	err = metaHeader.SetDevFeesInEpoch(big.NewInt(0))
	if err != nil {
		return err
	}

	return nil
}

func (mp *metaProcessor) setHeaderVersionData(metaHeader data.MetaHeaderHandler) error {
	if check.IfNil(metaHeader) {
		return process.ErrNilHeaderHandler
	}

	rootHash, err := mp.accountsDB[state.UserAccountsState].RootHash()
	if err != nil {
		return err
	}

	scheduledGasAndFees := mp.scheduledTxsExecutionHandler.GetScheduledGasAndFees()
	additionalVersionData := &headerVersionData.AdditionalData{
		ScheduledRootHash:        rootHash,
		ScheduledAccumulatedFees: scheduledGasAndFees.GetAccumulatedFees(),
		ScheduledDeveloperFees:   scheduledGasAndFees.GetDeveloperFees(),
		ScheduledGasProvided:     scheduledGasAndFees.GetGasProvided(),
		ScheduledGasPenalized:    scheduledGasAndFees.GetGasPenalized(),
		ScheduledGasRefunded:     scheduledGasAndFees.GetGasRefunded(),
	}

	return metaHeader.SetAdditionalData(additionalVersionData)
}

// MarshalizedDataToBroadcast prepares underlying data into a marshalized object according to destination
func (mp *metaProcessor) MarshalizedDataToBroadcast(
	headerHash []byte,
	header data.HeaderHandler,
	bodyHandler data.BodyHandler,
) (map[uint32][]byte, map[string][][]byte, error) {
	if check.IfNil(header) {
		return nil, nil, process.ErrNilMetaBlockHeader
	}
	if check.IfNil(bodyHandler) {
		return nil, nil, process.ErrNilMiniBlocks
	}

	body, ok := bodyHandler.(*block.Body)
	if !ok {
		return nil, nil, process.ErrWrongTypeAssertion
	}

	bodyToBroadcast, miniBlocksMapToBroadcast, err := mp.getFinalMiniBlocks(headerHash, header, body)
	if err != nil {
		return nil, nil, err
	}

	var mrsTxs map[string][][]byte
	if header.IsStartOfEpochBlock() {
		mrsTxs = mp.getAllMarshalledTxs(bodyToBroadcast)
	} else {
		mrsTxs = mp.txCoordinator.CreateMarshalledDataForHeader(header, bodyToBroadcast, miniBlocksMapToBroadcast)
	}

	mrsData := mp.marshalledBodyToBroadcast(bodyToBroadcast)

	return mrsData, mrsTxs, nil
}

func (mp *metaProcessor) getFinalMiniBlocks(headerHash []byte, header data.HeaderHandler, body *block.Body) (*block.Body, map[string]block.MiniBlockSlice, error) {
	if header.IsHeaderV3() {
		return mp.getFinalMiniBlocksFromExecutionResults(header)
	}

	return body,
		map[string]block.MiniBlockSlice{
			string(headerHash): body.MiniBlocks,
		},
		nil
}

func (mp *metaProcessor) getAllMarshalledTxs(body *block.Body) map[string][][]byte {
	allMarshalledTxs := make(map[string][][]byte)

	marshalledRewardsTxs := mp.epochRewardsCreator.CreateMarshalledData(body)
	marshalledValidatorInfoTxs := mp.validatorInfoCreator.CreateMarshalledData(body)

	for topic, marshalledTxs := range marshalledRewardsTxs {
		allMarshalledTxs[topic] = append(allMarshalledTxs[topic], marshalledTxs...)
		log.Trace("metaProcessor.getAllMarshalledTxs", "topic", topic, "num rewards txs", len(marshalledTxs))
	}

	for topic, marshalledTxs := range marshalledValidatorInfoTxs {
		allMarshalledTxs[topic] = append(allMarshalledTxs[topic], marshalledTxs...)
		log.Trace("metaProcessor.getAllMarshalledTxs", "topic", topic, "num validator info txs", len(marshalledTxs))
	}

	return allMarshalledTxs
}

func getTxCount(shardInfo []data.ShardDataHandler) uint32 {
	txs := uint32(0)
	for i := 0; i < len(shardInfo); i++ {
		shardDataHandlers := shardInfo[i].GetShardMiniBlockHeaderHandlers()
		for j := 0; j < len(shardDataHandlers); j++ {
			txs += shardDataHandlers[j].GetTxCount()
		}
	}

	return txs
}

// IsInterfaceNil returns true if there is no value under the interface
func (mp *metaProcessor) IsInterfaceNil() bool {
	return mp == nil
}

// GetBlockBodyFromPool returns block body from pool for a given header
func (mp *metaProcessor) GetBlockBodyFromPool(headerHandler data.HeaderHandler) (data.BodyHandler, error) {
	metaBlock, ok := headerHandler.(data.MetaHeaderHandler)
	if !ok {
		return nil, process.ErrWrongTypeAssertion
	}

	miniBlockHeaderHandlers, err := common.GetMiniBlockHeadersFromExecResult(metaBlock)
	if err != nil {
		return nil, err
	}

	return mp.getBlockBodyFromPool(metaBlock, miniBlockHeaderHandlers)
}

// GetProposedAndExecutedMiniBlockHeaders returns block body from pool with proposed and executed miniblocks
func (mp *metaProcessor) GetProposedAndExecutedMiniBlockHeaders(headerHandler data.HeaderHandler) (data.BodyHandler, error) {
	metaBlock, ok := headerHandler.(data.MetaHeaderHandler)
	if !ok {
		return nil, process.ErrWrongTypeAssertion
	}

	miniBlockHeaderHandlers, err := getProposedAndExecutedMiniBlockHeaders(metaBlock)
	if err != nil {
		return nil, err
	}

	return mp.getBlockBodyFromPool(metaBlock, miniBlockHeaderHandlers)
}

func (mp *metaProcessor) getPendingMiniBlocks() []bootstrapStorage.PendingMiniBlocksInfo {
	pendingMiniBlocksInfo := make([]bootstrapStorage.PendingMiniBlocksInfo, mp.shardCoordinator.NumberOfShards())

	for shardID := uint32(0); shardID < mp.shardCoordinator.NumberOfShards(); shardID++ {
		pendingMiniBlocksInfo[shardID] = bootstrapStorage.PendingMiniBlocksInfo{
			MiniBlocksHashes: mp.pendingMiniBlocksHandler.GetPendingMiniBlocks(shardID),
			ShardID:          shardID,
		}
	}

	return pendingMiniBlocksInfo
}

func (mp *metaProcessor) removeStartOfEpochBlockDataFromPools(
	headerHandler data.HeaderHandler,
	bodyHandler data.BodyHandler,
) error {

	if !headerHandler.IsStartOfEpochBlock() {
		return nil
	}

	metaBlock, ok := headerHandler.(data.MetaHeaderHandler)
	if !ok {
		return process.ErrWrongTypeAssertion
	}

	body, ok := bodyHandler.(*block.Body)
	if !ok {
		return process.ErrWrongTypeAssertion
	}

	mp.epochRewardsCreator.RemoveBlockDataFromPools(metaBlock, body)
	mp.validatorInfoCreator.RemoveBlockDataFromPools(metaBlock, body)

	return nil
}

// Close - closes all underlying components
func (mp *metaProcessor) Close() error {
	return mp.baseProcessor.Close()
}

// DecodeBlockHeader method decodes block header from a given byte array
func (mp *metaProcessor) DecodeBlockHeader(dta []byte) data.HeaderHandler {
	if dta == nil {
		return nil
	}

	metaBlock, err := process.UnmarshalMetaHeader(mp.marshalizer, dta)
	if err != nil {
		log.Debug("DecodeBlockHeader.Unmarshal", "error", err.Error())
		return nil
	}

	return metaBlock
}