TODOs

config/config.go

@@ -49,7 +49,6 @@ type ProofsPoolConfig struct {
 }
 
 // ExecutionResultInclusionEstimatorConfig will map the EIE configuration - supplied at construction, read-only thereafter.
-// TODO add also max estimated block gas capacity
 type ExecutionResultInclusionEstimatorConfig struct {
 	SafetyMargin       uint64
 	MaxResultsPerBlock uint64

consensus/broadcast/shardChainMessenger.go

@@ -180,7 +180,6 @@ func (scm *shardChainMessenger) prepareDataToBroadcast(
 		return nil, err
 	}
 
-	// TODO: check if miniblocks and txs are set in a deterministic way (check if there are map iterations that can generate non-deterministic results)
 	metaMiniBlocks, metaTransactions := scm.extractMetaMiniBlocksAndTransactions(miniBlocks, transactions)
 
 	dtb := &dataToBroadcast{

epochStart/metachain/economics.go

@@ -42,6 +42,7 @@ type economics struct {
 	marshalizer           marshal.Marshalizer
 	hasher                hashing.Hasher
 	store                 dataRetriever.StorageService
+	headers               dataRetriever.HeadersPool
 	shardCoordinator      sharding.Coordinator
 	rewardsHandler        process.RewardsHandler
 	roundTime             process.RoundTimeDurationHandler
@@ -60,6 +61,7 @@ type ArgsNewEpochEconomics struct {
 	Marshalizer           marshal.Marshalizer
 	Hasher                hashing.Hasher
 	Store                 dataRetriever.StorageService
+	Headers               dataRetriever.HeadersPool
 	ShardCoordinator      sharding.Coordinator
 	RewardsHandler        process.RewardsHandler
 	RoundTime             process.RoundTimeDurationHandler
@@ -84,6 +86,9 @@ func NewEndOfEpochEconomicsDataCreator(args ArgsNewEpochEconomics) (*economics,
 	if check.IfNil(args.Store) {
 		return nil, epochStart.ErrNilStorage
 	}
+	if check.IfNil(args.Headers) {
+		return nil, epochStart.ErrNilHeadersDataPool
+	}
 	if check.IfNil(args.ShardCoordinator) {
 		return nil, epochStart.ErrNilShardCoordinator
 	}
@@ -110,6 +115,7 @@ func NewEndOfEpochEconomicsDataCreator(args ArgsNewEpochEconomics) (*economics,
 		marshalizer:           args.Marshalizer,
 		hasher:                args.Hasher,
 		store:                 args.Store,
+		headers:               args.Headers,
 		shardCoordinator:      args.ShardCoordinator,
 		rewardsHandler:        args.RewardsHandler,
 		roundTime:             args.RoundTime,
@@ -655,7 +661,7 @@ func (e *economics) startNoncePerShardFromEpochStart(epoch uint32) (map[uint32]u
 		return mapShardIdNonce, previousEpochStartMeta, nil
 	}
 
-	prevEpochMetaNonce, err := getPrevEpochMetaStartNonceForEconomics(previousEpochStartMeta)
+	prevEpochMetaNonce, err := e.getPrevEpochMetaStartNonceForEconomics(previousEpochStartMeta)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -667,17 +673,30 @@ func (e *economics) startNoncePerShardFromEpochStart(epoch uint32) (map[uint32]u
 	return mapShardIdNonce, previousEpochStartMeta, nil
 }
 
-func getPrevEpochMetaStartNonceForEconomics(previousEpochStartMeta data.MetaHeaderHandler) (uint64, error) {
+func (e *economics) getPrevEpochMetaStartNonceForEconomics(previousEpochStartMeta data.MetaHeaderHandler) (uint64, error) {
 	if !previousEpochStartMeta.IsHeaderV3() {
 		return previousEpochStartMeta.GetNonce(), nil
 	}
-	// todo: extract the epoch change proposal execution result here
-	lastNotarizedResult, err := common.GetLastBaseExecutionResultHandler(previousEpochStartMeta)
-	if err != nil {
-		return 0, err
+
+	for _, execResult := range previousEpochStartMeta.GetExecutionResultsHandlers() {
+		hdr, err := process.GetMetaHeader(
+			execResult.GetHeaderHash(),
+			e.headers,
+			e.marshalizer,
+			e.store,
+		)
+		if err != nil {
+			return 0, err
+		}
+
+		if hdr.IsEpochChangeProposed() {
+			return hdr.GetNonce(), nil
+		}
 	}
 
-	return lastNotarizedResult.GetHeaderNonce(), nil
+	log.Debug("getPrevEpochMetaStartNonceForEconomics could not find epoch change proposed header")
+
+	return 0, epochStart.ErrMissingHeader
 }
 
 func (e *economics) maxPossibleNotarizedBlocks(currentRound uint64, prev data.MetaHeaderHandler) uint64 {

epochStart/metachain/economics_test.go

@@ -12,6 +12,7 @@ import (
 	"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-go/testscommon/pool"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -39,6 +40,7 @@ func createMockEpochEconomicsArguments() ArgsNewEpochEconomics {
 		Hasher:                &hashingMocks.HasherMock{},
 		Marshalizer:           &mock.MarshalizerMock{},
 		Store:                 createMetaStore(),
+		Headers:               &pool.HeadersPoolStub{},
 		ShardCoordinator:      shardCoordinator,
 		RewardsHandler:        &mock.RewardsHandlerStub{},
 		RoundTime:             &mock.RoundTimeDurationHandler{},
@@ -83,6 +85,17 @@ func TestEpochEconomics_NewEndOfEpochEconomicsDataCreatorNilStore(t *testing.T)
 	require.Equal(t, epochStart.ErrNilStorage, err)
 }
 
+func TestEpochEconomics_NewEndOfEpochEconomicsDataCreatorNilHeadersPool(t *testing.T) {
+	t.Parallel()
+
+	arguments := createMockEpochEconomicsArguments()
+	arguments.Headers = nil
+
+	esd, err := NewEndOfEpochEconomicsDataCreator(arguments)
+	require.Nil(t, esd)
+	require.Equal(t, epochStart.ErrNilHeadersDataPool, err)
+}
+
 func TestEpochEconomics_NewEndOfEpochEconomicsDataCreatorNilShardCoordinator(t *testing.T) {
 	t.Parallel()
 
@@ -2459,6 +2472,21 @@ func TestEconomics_createEconomicsV3Args(t *testing.T) {
 				DevFeesInEpoch:         big.NewInt(300),
 			},
 		},
+		ExecutionResults: []*block.MetaExecutionResult{
+			{
+				ExecutionResult: &block.BaseMetaExecutionResult{
+					BaseExecutionResult: &block.BaseExecutionResult{
+						HeaderHash:  []byte("some hash"),
+						HeaderEpoch: 2,
+						HeaderNonce: 3,
+						RootHash:    []byte("some root hash"),
+					},
+					ValidatorStatsRootHash: []byte("validator stats root hash"),
+					AccumulatedFeesInEpoch: big.NewInt(1000),
+					DevFeesInEpoch:         big.NewInt(300),
+				},
+			},
+		},
 	}
 
 	t.Run("nil meta block", func(t *testing.T) {
@@ -2561,6 +2589,14 @@ func TestEconomics_createEconomicsV3Args(t *testing.T) {
 				},
 			},
 		}
+		arguments.Headers = &pool.HeadersPoolStub{
+			GetHeaderByHashCalled: func(hash []byte) (data.HeaderHandler, error) {
+				return &block.MetaBlockV3{
+					EpochChangeProposed: true,
+					Nonce:               metaBlockCopy.ExecutionResults[0].GetHeaderNonce(),
+				}, nil
+			},
+		}
 
 		economicsCreator, _ := NewEndOfEpochEconomicsDataCreator(arguments)
 		res, err := economicsCreator.createEconomicsV3Args(&metaBlockCopy, metaExecRes, epochStartDta)
@@ -3048,6 +3084,7 @@ func getArguments() ArgsNewEpochEconomics {
 		Marshalizer:           &mock.MarshalizerMock{},
 		Hasher:                &hashingMocks.HasherMock{},
 		Store:                 &storageStubs.ChainStorerStub{},
+		Headers:               &pool.HeadersPoolStub{},
 		ShardCoordinator:      mock.NewMultipleShardsCoordinatorMock(),
 		RewardsHandler:        &mock.RewardsHandlerStub{},
 		RoundTime:             &mock.RoundTimeDurationHandler{},

epochStart/metachain/epochStartData.go

@@ -418,7 +418,6 @@ func (e *epochStartData) computePendingMiniBlockList(
 
 	epochStartIdentifier := core.EpochStartIdentifier(prevEpoch)
 
-	// TODO: analyse error handling here
 	previousEpochStartMeta, _ := process.GetMetaHeaderFromStorage([]byte(epochStartIdentifier), e.marshalizer, e.store)
 
 	allPending := make([]block.MiniBlockHeader, 0)

errors/errors.go

@@ -616,3 +616,6 @@ var ErrNilTrieLeavesRetriever = errors.New("nil trie leaves retriever")
 
 // ErrNilAOTSelector signals that a nil AOT selector has been provided
 var ErrNilAOTSelector = errors.New("nil AOT selector")
+
+// ErrNilTransactionProcessor signals that a nil transaction processor has been provided
+var ErrNilTransactionProcessor = errors.New("nil transaction processor")

factory/api/apiResolverFactory.go

@@ -250,6 +250,8 @@ func CreateApiResolver(args *ApiResolverArgs) (facade.ApiResolver, error) {
 		EnableEpochsHandler:      args.CoreComponents.EnableEpochsHandler(),
 		EnableRoundsHandler:      args.CoreComponents.EnableRoundsHandler(),
 		TxVersionChecker:         args.CoreComponents.TxVersionChecker(),
+		ChainHandler:             args.DataComponents.Blockchain(),
+		TxProcessor:              args.ProcessComponents.TransactionProcessor(),
 	}
 	apiTransactionProcessor, err := transactionAPI.NewAPITransactionProcessor(argsAPITransactionProc)
 	if err != nil {

factory/interface.go

@@ -329,6 +329,7 @@ type ProcessComponentsHolder interface {
 	EpochSystemSCProcessor() process.EpochStartSystemSCProcessor
 	BlockchainHook() process.BlockChainHookWithAccountsAdapter
 	AOTSelector() process.AOTTransactionSelector
+	TransactionProcessor() process.TransactionProcessor
 	IsInterfaceNil() bool
 }
 

factory/mock/processComponentsStub.go

@@ -62,6 +62,7 @@ type ProcessComponentsMock struct {
 	EpochSystemSCProcessorInternal       process.EpochStartSystemSCProcessor
 	BlockchainHookField                  process.BlockChainHookWithAccountsAdapter
 	AOTSelectorField                     process.AOTTransactionSelector
+	TransactionProcessorField            process.TransactionProcessor
 }
 
 // Create -
@@ -309,6 +310,11 @@ func (pcm *ProcessComponentsMock) AOTSelector() process.AOTTransactionSelector {
 	return pcm.AOTSelectorField
 }
 
+// TransactionProcessor -
+func (pcm *ProcessComponentsMock) TransactionProcessor() process.TransactionProcessor {
+	return pcm.TransactionProcessorField
+}
+
 // IsInterfaceNil -
 func (pcm *ProcessComponentsMock) IsInterfaceNil() bool {
 	return pcm == nil

factory/processing/blockProcessorCreator.go

@@ -59,6 +59,7 @@ type blockProcessorAndVmFactories struct {
 	vmFactoryForProcessing process.VirtualMachinesContainerFactory
 	epochSystemSCProcessor process.EpochStartSystemSCProcessor
 	aotSelector            process.AOTTransactionSelector
+	transactionProcessor   process.TransactionProcessor
 }
 
 func (pcf *processComponentsFactory) newBlockProcessor(
@@ -604,10 +605,14 @@ func (pcf *processComponentsFactory) newShardBlockProcessor(
 		return nil, err
 	}
 
+	maxBlockGasCapacity := pcf.coreData.EconomicsData().MaxGasLimitPerBlock(pcf.bootstrapComponents.ShardCoordinator().SelfId())
+	overestimationFactor := pcf.coreData.EconomicsData().BlockCapacityOverestimationFactor()
+	maxBlockGasCapacity = maxBlockGasCapacity * overestimationFactor / 100
 	inclusionEstimator, err := estimator.NewExecutionResultInclusionEstimator(
 		pcf.config.ExecutionResultInclusionEstimator,
 		pcf.coreData.RoundHandler(),
 		execResSizeComputationHandler,
+		maxBlockGasCapacity,
 	)
 	if err != nil {
 		return nil, err
@@ -688,6 +693,7 @@ func (pcf *processComponentsFactory) newShardBlockProcessor(
 		vmFactoryForProcessing: vmFactory,
 		epochSystemSCProcessor: factoryDisabled.NewDisabledEpochStartSystemSC(),
 		aotSelector:            aotSelector,
+		transactionProcessor:   transactionProcessor,
 	}
 
 	pcf.stakingDataProviderAPI = factoryDisabled.NewDisabledStakingDataProvider()
@@ -1042,6 +1048,7 @@ func (pcf *processComponentsFactory) newMetaBlockProcessor(
 		Marshalizer:           pcf.coreData.InternalMarshalizer(),
 		Hasher:                pcf.coreData.Hasher(),
 		Store:                 pcf.data.StorageService(),
+		Headers:               pcf.data.Datapool().Headers(),
 		ShardCoordinator:      pcf.bootstrapComponents.ShardCoordinator(),
 		RewardsHandler:        pcf.coreData.EconomicsData(),
 		RoundTime:             pcf.coreData.RoundHandler(),
@@ -1186,10 +1193,14 @@ func (pcf *processComponentsFactory) newMetaBlockProcessor(
 		return nil, err
 	}
 
+	maxBlockGasCapacity := pcf.coreData.EconomicsData().MaxGasLimitPerBlock(pcf.bootstrapComponents.ShardCoordinator().SelfId())
+	overestimationFactor := pcf.coreData.EconomicsData().BlockCapacityOverestimationFactor()
+	maxBlockGasCapacity = maxBlockGasCapacity * overestimationFactor / 100
 	inclusionEstimator, err := estimator.NewExecutionResultInclusionEstimator(
 		pcf.config.ExecutionResultInclusionEstimator,
 		pcf.coreData.RoundHandler(),
 		execResSizeComputationHandler,
+		maxBlockGasCapacity,
 	)
 	if err != nil {
 		return nil, err
@@ -1379,6 +1390,7 @@ func (pcf *processComponentsFactory) newMetaBlockProcessor(
 		vmFactoryForProcessing: vmFactory,
 		epochSystemSCProcessor: epochStartSystemSCProcessor,
 		aotSelector:            aotSelector,
+		transactionProcessor:   transactionProcessor,
 	}
 
 	return blockProcessorComponents, nil

factory/processing/processComponents.go

@@ -144,6 +144,7 @@ type processComponents struct {
 	interceptedDataVerifierFactory   process.InterceptedDataVerifierFactory
 	epochStartTriggerHanlder         epochStart.TriggerHandler
 	aotSelector                      process.AOTTransactionSelector
+	transactionProcessor             process.TransactionProcessor
 }
 
 // ProcessComponentsFactoryArgs holds the arguments needed to create a process components factory
@@ -840,6 +841,7 @@ func (pcf *processComponentsFactory) Create() (*processComponents, error) {
 		interceptedDataVerifierFactory:   pcf.interceptedDataVerifierFactory,
 		epochStartTriggerHanlder:         epochStartTrigger,
 		aotSelector:                      blockProcessorComponents.aotSelector,
+		transactionProcessor:             blockProcessorComponents.transactionProcessor,
 	}, nil
 }
 

factory/processing/processComponentsHandler.go

@@ -187,6 +187,9 @@ func (m *managedProcessComponents) CheckSubcomponents() error {
 	if check.IfNil(m.processComponents.aotSelector) {
 		return errors.ErrNilAOTSelector
 	}
+	if check.IfNil(m.processComponents.transactionProcessor) {
+		return errors.ErrNilTransactionProcessor
+	}
 
 	return nil
 }
@@ -735,6 +738,18 @@ func (m *managedProcessComponents) AOTSelector() process.AOTTransactionSelector
 	return m.processComponents.aotSelector
 }
 
+// TransactionProcessor returns the transaction processor
+func (m *managedProcessComponents) TransactionProcessor() process.TransactionProcessor {
+	m.mutProcessComponents.RLock()
+	defer m.mutProcessComponents.RUnlock()
+
+	if m.processComponents == nil {
+		return nil
+	}
+
+	return m.processComponents.transactionProcessor
+}
+
 // IsInterfaceNil returns true if the interface is nil
 func (m *managedProcessComponents) IsInterfaceNil() bool {
 	return m == nil

factory/state/stateComponents.go

@@ -316,7 +316,6 @@ func (scf *stateComponentsFactory) createAccountsAdapters(triesContainer common.
 		return nil, fmt.Errorf("accountsRepository: %w", err)
 	}
 
-	// TODO: this account adapter may be required to be changed as the roothash should be the last execution result roothash
 	accountsAdapterProposal, err := state.NewAccountsDB(argsAPIAccountsDB)
 	if err != nil {
 		return nil, fmt.Errorf("accounts adapter for proposal: %w: %s", errors.ErrAccountsAdapterCreation, err)

integrationTests/mock/processComponentsStub.go

@@ -65,6 +65,7 @@ type ProcessComponentsStub struct {
 	EpochSystemSCProcessorInternal       process.EpochStartSystemSCProcessor
 	BlockchainHookField                  process.BlockChainHookWithAccountsAdapter
 	AOTSelectorField                     process.AOTTransactionSelector
+	TransactionProcessorField            process.TransactionProcessor
 }
 
 // Create -
@@ -321,6 +322,11 @@ func (pcs *ProcessComponentsStub) AOTSelector() process.AOTTransactionSelector {
 	return pcs.AOTSelectorField
 }
 
+// TransactionProcessor -
+func (pcs *ProcessComponentsStub) TransactionProcessor() process.TransactionProcessor {
+	return pcs.TransactionProcessorField
+}
+
 // IsInterfaceNil -
 func (pcs *ProcessComponentsStub) IsInterfaceNil() bool {
 	return pcs == nil

integrationTests/testFullNode.go

@@ -995,6 +995,7 @@ func (tpn *TestFullNode) initBlockProcessor(
 		},
 		tpn.RoundHandler,
 		&testscommon.ExecResSizeComputationStub{},
+		0,
 	)
 	if err != nil {
 		log.LogIfError(err)
@@ -1111,6 +1112,7 @@ func (tpn *TestFullNode) initBlockProcessor(
 			Marshalizer:           TestMarshalizer,
 			Hasher:                TestHasher,
 			Store:                 tpn.Storage,
+			Headers:               tpn.DataPool.Headers(),
 			ShardCoordinator:      tpn.ShardCoordinator,
 			RewardsHandler:        tpn.EconomicsData,
 			RoundTime:             roundHandler,
@@ -1380,6 +1382,7 @@ func (tpn *TestFullNode) initBlockProcessorWithSync(
 		},
 		tpn.RoundHandler,
 		&testscommon.ExecResSizeComputationStub{},
+		0,
 	)
 	if err != nil {
 		log.LogIfError(err)