diff --git a/cmd/node/config/economics.toml b/cmd/node/config/economics.toml
index f0bac97a055..83355fad982 100644
--- a/cmd/node/config/economics.toml
+++ b/cmd/node/config/economics.toml
@@ -20,22 +20,31 @@
 
 [RewardsSettings]
     [[RewardsSettings.RewardsConfigByEpoch]]
-    EpochEnable = 0
-    LeaderPercentage = 0.1 #fraction of value 0.1 - 10%
-    DeveloperPercentage = 0.3 #fraction of value 0.3 - 30%
-    ProtocolSustainabilityPercentage = 0.1 #fraction of value 0.1 - 10%
-    ProtocolSustainabilityAddress = "erd1j25xk97yf820rgdp3mj5scavhjkn6tjyn0t63pmv5qyjj7wxlcfqqe2rw5"
-    TopUpGradientPoint = "3000000000000000000000000" # 3MIL eGLD (eligible topUp)
-    TopUpFactor = 0.25 # fraction of value 0.25 - 25%
+        EpochEnable = 0
+        LeaderPercentage = 0.1 #fraction of value 0.1 - 10%
+        DeveloperPercentage = 0.3 #fraction of value 0.3 - 30%
+        ProtocolSustainabilityPercentage = 0.1 #fraction of value 0.1 - 10%
+        ProtocolSustainabilityAddress = "erd1j25xk97yf820rgdp3mj5scavhjkn6tjyn0t63pmv5qyjj7wxlcfqqe2rw5"
+        TopUpGradientPoint = "3000000000000000000000000" # 3MIL eGLD (eligible topUp)
+        TopUpFactor = 0.25 # fraction of value 0.25 - 25%
 
     [[RewardsSettings.RewardsConfigByEpoch]]
-    EpochEnable = 1
-    LeaderPercentage = 0.1 #fraction of value 0.1 - 10%
-    DeveloperPercentage = 0.3 #fraction of value 0.3 - 30%
-    ProtocolSustainabilityPercentage = 0.1 #fraction of value 0.1 - 10%
-    ProtocolSustainabilityAddress = "erd1j25xk97yf820rgdp3mj5scavhjkn6tjyn0t63pmv5qyjj7wxlcfqqe2rw5"
-    TopUpGradientPoint = "2000000000000000000000000" # 2MIL eGLD (eligible topUp)
-    TopUpFactor = 0.5 # fraction of value 0.5 - 50%
+        EpochEnable = 1
+        LeaderPercentage = 0.1 #fraction of value 0.1 - 10%
+        DeveloperPercentage = 0.3 #fraction of value 0.3 - 30%
+        ProtocolSustainabilityPercentage = 0.1 #fraction of value 0.1 - 10%
+        ProtocolSustainabilityAddress = "erd1j25xk97yf820rgdp3mj5scavhjkn6tjyn0t63pmv5qyjj7wxlcfqqe2rw5"
+        TopUpGradientPoint = "2000000000000000000000000" # 2MIL eGLD (eligible topUp)
+        TopUpFactor = 0.5 # fraction of value 0.5 - 50%
+
+    [[RewardsSettings.RewardsConfigByEpoch]]
+        EpochEnable = 2
+        LeaderPercentage = 0.1 #fraction of value 0.1 - 10%
+        DeveloperPercentage = 0.3 #fraction of value 0.3 - 30%
+        ProtocolSustainabilityPercentage = 0.1 #fraction of value 0.1 - 10%
+        ProtocolSustainabilityAddress = "erd1e5cw5pegj9w2zfpzeq94wf3d5tp6g943xuhgnyysdwyr63rlkspqr0u05s"
+        TopUpGradientPoint = "2000000000000000000000000" # 2MIL eGLD (eligible topUp)
+        TopUpFactor = 0.5 # fraction of value 0.5 - 50%
 
 [FeeSettings]
     GasLimitSettings = [
diff --git a/dataRetriever/factory/dataPoolFactory_test.go b/dataRetriever/factory/dataPoolFactory_test.go
index b4896244ad9..bea0d92c415 100644
--- a/dataRetriever/factory/dataPoolFactory_test.go
+++ b/dataRetriever/factory/dataPoolFactory_test.go
@@ -139,7 +139,7 @@ func TestNewDataPoolFromConfig_BadConfigShouldErr(t *testing.T) {
 }
 
 func getGoodArgs() ArgsDataPool {
-	testEconomics := &economicsmocks.EconomicsHandlerStub{
+	testEconomics := &economicsmocks.EconomicsHandlerMock{
 		MinGasPriceCalled: func() uint64 {
 			return 200000000000
 		},
diff --git a/epochStart/bootstrap/process_test.go b/epochStart/bootstrap/process_test.go
index ca3fd78a5b8..1c68bf51756 100644
--- a/epochStart/bootstrap/process_test.go
+++ b/epochStart/bootstrap/process_test.go
@@ -208,7 +208,7 @@ func createMockEpochStartBootstrapArgs(
 			},
 			Requesters: generalCfg.Requesters,
 		},
-		EconomicsData: &economicsmocks.EconomicsHandlerStub{
+		EconomicsData: &economicsmocks.EconomicsHandlerMock{
 			MinGasPriceCalled: func() uint64 {
 				return 1
 			},
diff --git a/epochStart/bootstrap/storageProcess_test.go b/epochStart/bootstrap/storageProcess_test.go
index a59b0d125f2..7478a851405 100644
--- a/epochStart/bootstrap/storageProcess_test.go
+++ b/epochStart/bootstrap/storageProcess_test.go
@@ -88,7 +88,7 @@ func TestStorageEpochStartBootstrap_BootstrapFromGenesis(t *testing.T) {
 	roundDuration := uint64(60000)
 	coreComp, cryptoComp := createComponentsForEpochStart()
 	args := createMockStorageEpochStartBootstrapArgs(coreComp, cryptoComp)
-	args.EconomicsData = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsData = &economicsmocks.EconomicsHandlerMock{
 		MinGasPriceCalled: func() uint64 {
 			return 1
 		},
@@ -112,7 +112,7 @@ func TestStorageEpochStartBootstrap_BootstrapMetablockNotFound(t *testing.T) {
 	roundDuration := uint64(6000)
 	coreComp, cryptoComp := createComponentsForEpochStart()
 	args := createMockStorageEpochStartBootstrapArgs(coreComp, cryptoComp)
-	args.EconomicsData = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsData = &economicsmocks.EconomicsHandlerMock{
 		MinGasPriceCalled: func() uint64 {
 			return 1
 		},
diff --git a/epochStart/bootstrap/syncEpochStartMeta_test.go b/epochStart/bootstrap/syncEpochStartMeta_test.go
index 169b20a656e..c85efc7304c 100644
--- a/epochStart/bootstrap/syncEpochStartMeta_test.go
+++ b/epochStart/bootstrap/syncEpochStartMeta_test.go
@@ -153,7 +153,7 @@ func getEpochStartSyncerArgs() ArgsNewEpochStartMetaSyncer {
 		RequestHandler:   &testscommon.RequestHandlerStub{},
 		Messenger:        &p2pmocks.MessengerStub{},
 		ShardCoordinator: mock.NewMultiShardsCoordinatorMock(2),
-		EconomicsData:    &economicsmocks.EconomicsHandlerStub{},
+		EconomicsData:    &economicsmocks.EconomicsHandlerMock{},
 		WhitelistHandler: &testscommon.WhiteListHandlerStub{},
 		StartInEpochConfig: config.EpochStartConfig{
 			MinNumConnectedPeersToStart:       2,
diff --git a/epochStart/errors.go b/epochStart/errors.go
index ca115e939f4..650c94bfe35 100644
--- a/epochStart/errors.go
+++ b/epochStart/errors.go
@@ -62,9 +62,6 @@ var ErrNilHeaderValidator = errors.New("nil header validator")
 // ErrNilDataPoolsHolder signals that nil data pools holder has been provided
 var ErrNilDataPoolsHolder = errors.New("nil data pools holder")
 
-// ErrNilProtocolSustainabilityAddress signals that a nil protocol sustainability address was provided
-var ErrNilProtocolSustainabilityAddress = errors.New("nil protocol sustainability address")
-
 // ErrNilStorageService signals that a nil storage service has been provided
 var ErrNilStorageService = errors.New("nil storage service")
 
@@ -203,9 +200,6 @@ var ErrNotEnoughNumOfPeersToConsiderBlockValid = errors.New("not enough num of p
 // ErrNilArgumentsParser signals that nil arguments parser was provided
 var ErrNilArgumentsParser = errors.New("nil arguments parsers")
 
-// ErrProtocolSustainabilityAddressInMetachain signals that protocol sustainability address is in metachain which is not allowed
-var ErrProtocolSustainabilityAddressInMetachain = errors.New("protocol sustainability address in metachain")
-
 // ErrNilGenesisTotalSupply signals that nil genesis total supply has been provided
 var ErrNilGenesisTotalSupply = errors.New("nil genesis total supply")
 
diff --git a/epochStart/metachain/baseRewards.go b/epochStart/metachain/baseRewards.go
index b48cd8b7470..691dbb1aa88 100644
--- a/epochStart/metachain/baseRewards.go
+++ b/epochStart/metachain/baseRewards.go
@@ -29,18 +29,18 @@ import (
 
 // BaseRewardsCreatorArgs defines the arguments structure needed to create a base rewards creator
 type BaseRewardsCreatorArgs struct {
-	ShardCoordinator              sharding.Coordinator
-	PubkeyConverter               core.PubkeyConverter
-	RewardsStorage                storage.Storer
-	MiniBlockStorage              storage.Storer
-	Hasher                        hashing.Hasher
-	Marshalizer                   marshal.Marshalizer
-	DataPool                      dataRetriever.PoolsHolder
-	ProtocolSustainabilityAddress string
-	NodesConfigProvider           epochStart.NodesConfigProvider
-	UserAccountsDB                state.AccountsAdapter
-	EnableEpochsHandler           common.EnableEpochsHandler
-	ExecutionOrderHandler         common.TxExecutionOrderHandler
+	ShardCoordinator      sharding.Coordinator
+	PubkeyConverter       core.PubkeyConverter
+	RewardsStorage        storage.Storer
+	MiniBlockStorage      storage.Storer
+	Hasher                hashing.Hasher
+	Marshalizer           marshal.Marshalizer
+	DataPool              dataRetriever.PoolsHolder
+	NodesConfigProvider   epochStart.NodesConfigProvider
+	UserAccountsDB        state.AccountsAdapter
+	EnableEpochsHandler   common.EnableEpochsHandler
+	ExecutionOrderHandler common.TxExecutionOrderHandler
+	RewardsHandler        process.RewardsHandler
 }
 
 type baseRewardsCreator struct {
@@ -49,7 +49,6 @@ type baseRewardsCreator struct {
 	pubkeyConverter                    core.PubkeyConverter
 	rewardsStorage                     storage.Storer
 	miniBlockStorage                   storage.Storer
-	protocolSustainabilityAddress      []byte
 	nodesConfigProvider                epochStart.NodesConfigProvider
 	hasher                             hashing.Hasher
 	marshalizer                        marshal.Marshalizer
@@ -62,6 +61,7 @@ type baseRewardsCreator struct {
 	enableEpochsHandler                common.EnableEpochsHandler
 	mutRewardsData                     sync.RWMutex
 	executionOrderHandler              common.TxExecutionOrderHandler
+	rewardsHandler                     process.RewardsHandler
 }
 
 // NewBaseRewardsCreator will create a new base rewards creator instance
@@ -71,17 +71,6 @@ func NewBaseRewardsCreator(args BaseRewardsCreatorArgs) (*baseRewardsCreator, er
 		return nil, err
 	}
 
-	address, err := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
-	if err != nil {
-		log.Warn("invalid protocol sustainability reward address", "err", err, "provided address", args.ProtocolSustainabilityAddress)
-		return nil, err
-	}
-
-	protocolSustainabilityShardID := args.ShardCoordinator.ComputeId(address)
-	if protocolSustainabilityShardID == core.MetachainShardId {
-		return nil, epochStart.ErrProtocolSustainabilityAddressInMetachain
-	}
-
 	currTxsCache := dataPool.NewCurrentBlockTransactionsPool()
 	brc := &baseRewardsCreator{
 		currTxs:                            currTxsCache,
@@ -92,7 +81,6 @@ func NewBaseRewardsCreator(args BaseRewardsCreatorArgs) (*baseRewardsCreator, er
 		marshalizer:                        args.Marshalizer,
 		miniBlockStorage:                   args.MiniBlockStorage,
 		dataPool:                           args.DataPool,
-		protocolSustainabilityAddress:      address,
 		nodesConfigProvider:                args.NodesConfigProvider,
 		accumulatedRewards:                 big.NewInt(0),
 		protocolSustainabilityValue:        big.NewInt(0),
@@ -100,6 +88,7 @@ func NewBaseRewardsCreator(args BaseRewardsCreatorArgs) (*baseRewardsCreator, er
 		mapBaseRewardsPerBlockPerValidator: make(map[uint32]*big.Int),
 		enableEpochsHandler:                args.EnableEpochsHandler,
 		executionOrderHandler:              args.ExecutionOrderHandler,
+		rewardsHandler:                     args.RewardsHandler,
 	}
 
 	return brc, nil
@@ -299,9 +288,6 @@ func checkBaseArgs(args BaseRewardsCreatorArgs) error {
 	if check.IfNil(args.DataPool) {
 		return epochStart.ErrNilDataPoolsHolder
 	}
-	if len(args.ProtocolSustainabilityAddress) == 0 {
-		return epochStart.ErrNilProtocolSustainabilityAddress
-	}
 	if check.IfNil(args.NodesConfigProvider) {
 		return epochStart.ErrNilNodesConfigProvider
 	}
@@ -322,6 +308,9 @@ func checkBaseArgs(args BaseRewardsCreatorArgs) error {
 	if check.IfNil(args.ExecutionOrderHandler) {
 		return epochStart.ErrNilExecutionOrderHandler
 	}
+	if check.IfNil(args.RewardsHandler) {
+		return epochStart.ErrNilRewardsHandler
+	}
 
 	return nil
 }
@@ -358,16 +347,17 @@ func (brc *baseRewardsCreator) createProtocolSustainabilityRewardTransaction(
 	computedEconomics *block.Economics,
 ) (*rewardTx.RewardTx, uint32, error) {
 
-	shardID := brc.shardCoordinator.ComputeId(brc.protocolSustainabilityAddress)
+	protocolSustainabilityAddressForEpoch := brc.rewardsHandler.ProtocolSustainabilityAddressInEpoch(metaBlock.GetEpoch())
+	protocolSustainabilityShardID := brc.shardCoordinator.ComputeId([]byte(protocolSustainabilityAddressForEpoch))
 	protocolSustainabilityRwdTx := &rewardTx.RewardTx{
 		Round:   metaBlock.GetRound(),
 		Value:   big.NewInt(0).Set(computedEconomics.RewardsForProtocolSustainability),
-		RcvAddr: brc.protocolSustainabilityAddress,
+		RcvAddr: []byte(protocolSustainabilityAddressForEpoch),
 		Epoch:   metaBlock.GetEpoch(),
 	}
 
 	brc.accumulatedRewards.Add(brc.accumulatedRewards, protocolSustainabilityRwdTx.Value)
-	return protocolSustainabilityRwdTx, shardID, nil
+	return protocolSustainabilityRwdTx, protocolSustainabilityShardID, nil
 }
 
 func (brc *baseRewardsCreator) createRewardFromRwdInfo(
diff --git a/epochStart/metachain/baseRewards_test.go b/epochStart/metachain/baseRewards_test.go
index 50aeb42e7ad..2d36f2a2e3a 100644
--- a/epochStart/metachain/baseRewards_test.go
+++ b/epochStart/metachain/baseRewards_test.go
@@ -2,7 +2,6 @@ package metachain
 
 import (
 	"bytes"
-	"encoding/hex"
 	"errors"
 	"fmt"
 	"math/big"
@@ -18,7 +17,6 @@ import (
 	"github.com/multiversx/mx-chain-go/epochStart"
 	"github.com/multiversx/mx-chain-go/epochStart/mock"
 	"github.com/multiversx/mx-chain-go/process"
-	"github.com/multiversx/mx-chain-go/sharding"
 	"github.com/multiversx/mx-chain-go/state/factory"
 	"github.com/multiversx/mx-chain-go/testscommon"
 	txExecOrderStub "github.com/multiversx/mx-chain-go/testscommon/common"
@@ -106,28 +104,6 @@ func TestBaseRewardsCreator_NilMarshalizer(t *testing.T) {
 	assert.Equal(t, epochStart.ErrNilMarshalizer, err)
 }
 
-func TestBaseRewardsCreator_EmptyProtocolSustainabilityAddress(t *testing.T) {
-	t.Parallel()
-
-	args := getBaseRewardsArguments()
-	args.ProtocolSustainabilityAddress = ""
-
-	rwd, err := NewBaseRewardsCreator(args)
-	assert.True(t, check.IfNil(rwd))
-	assert.Equal(t, epochStart.ErrNilProtocolSustainabilityAddress, err)
-}
-
-func TestBaseRewardsCreator_InvalidProtocolSustainabilityAddress(t *testing.T) {
-	t.Parallel()
-
-	args := getBaseRewardsArguments()
-	args.ProtocolSustainabilityAddress = "xyz" // not a hex string
-
-	rwd, err := NewBaseRewardsCreator(args)
-	assert.True(t, check.IfNil(rwd))
-	assert.NotNil(t, err)
-}
-
 func TestBaseRewardsCreator_NilDataPoolHolder(t *testing.T) {
 	t.Parallel()
 
@@ -176,6 +152,18 @@ func TestBaseRewardsCreator_NilEnableEpochsHandler(t *testing.T) {
 	assert.Equal(t, epochStart.ErrNilEnableEpochsHandler, err)
 }
 
+func TestBaseRewardsCreator_NilRewardsHandler(t *testing.T) {
+	t.Parallel()
+
+	args := getBaseRewardsArguments()
+	args.RewardsHandler = nil
+
+	rwd, err := NewBaseRewardsCreator(args)
+
+	assert.True(t, check.IfNil(rwd))
+	assert.Equal(t, epochStart.ErrNilRewardsHandler, err)
+}
+
 func TestBaseRewardsCreator_InvalidEnableEpochsHandler(t *testing.T) {
 	t.Parallel()
 
@@ -210,19 +198,6 @@ func TestBaseRewardsCreator_clean(t *testing.T) {
 	require.NotNil(t, err)
 }
 
-func TestBaseRewardsCreator_ProtocolSustainabilityAddressInMetachainShouldErr(t *testing.T) {
-	t.Parallel()
-
-	args := getBaseRewardsArguments()
-	args.ShardCoordinator, _ = sharding.NewMultiShardCoordinator(2, 0)
-	// wrong configuration of staking system SC address (in metachain) as protocol sustainability address
-	args.ProtocolSustainabilityAddress = hex.EncodeToString([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255})
-
-	rwd, err := NewBaseRewardsCreator(args)
-	assert.True(t, check.IfNil(rwd))
-	assert.Equal(t, epochStart.ErrProtocolSustainabilityAddressInMetachain, err)
-}
-
 func TestBaseRewardsCreator_OkValsShouldWork(t *testing.T) {
 	t.Parallel()
 
@@ -266,7 +241,7 @@ func TestBaseRewardsCreator_addProtocolRewardToMiniblocks(t *testing.T) {
 	require.NotNil(t, rwd)
 
 	initialProtRewardValue := big.NewInt(-100)
-	protRwAddr, _ := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
+	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
 		Value:   big.NewInt(0).Set(initialProtRewardValue),
@@ -1190,15 +1165,28 @@ func getBaseRewardsArguments() BaseRewardsCreatorArgs {
 		return 0
 	}
 
+	rewardsTopUpGradientPoint, _ := big.NewInt(0).SetString("3000000000000000000000000", 10)
+
+	rewardsHandler := &mock.RewardsHandlerStub{
+		RewardsTopUpGradientPointInEpochCalled: func(_ uint32) *big.Int {
+			return rewardsTopUpGradientPoint
+		},
+		RewardsTopUpFactorInEpochCalled: func(_ uint32) float64 {
+			return 0.25
+		},
+		ProtocolSustainabilityAddressInEpochCalled: func(_ uint32) string {
+			return "11"
+		},
+	}
+
 	return BaseRewardsCreatorArgs{
-		ShardCoordinator:              shardCoordinator,
-		PubkeyConverter:               testscommon.NewPubkeyConverterMock(32),
-		RewardsStorage:                mock.NewStorerMock(),
-		MiniBlockStorage:              mock.NewStorerMock(),
-		Hasher:                        &hashingMocks.HasherMock{},
-		Marshalizer:                   &mock.MarshalizerMock{},
-		DataPool:                      dataRetrieverMock.NewPoolsHolderMock(),
-		ProtocolSustainabilityAddress: "11", // string hex => 17 decimal
+		ShardCoordinator: shardCoordinator,
+		PubkeyConverter:  testscommon.NewPubkeyConverterMock(32),
+		RewardsStorage:   mock.NewStorerMock(),
+		MiniBlockStorage: mock.NewStorerMock(),
+		Hasher:           &hashingMocks.HasherMock{},
+		Marshalizer:      &mock.MarshalizerMock{},
+		DataPool:         dataRetrieverMock.NewPoolsHolderMock(),
 		NodesConfigProvider: &shardingMocks.NodesCoordinatorStub{
 			ConsensusGroupSizeCalled: func(shardID uint32) int {
 				if shardID == core.MetachainShardId {
@@ -1210,6 +1198,7 @@ func getBaseRewardsArguments() BaseRewardsCreatorArgs {
 		UserAccountsDB:        userAccountsDB,
 		EnableEpochsHandler:   enableEpochsHandler,
 		ExecutionOrderHandler: &txExecOrderStub.TxExecutionOrderHandlerStub{},
+		RewardsHandler:        rewardsHandler,
 	}
 }
 
diff --git a/epochStart/metachain/economics.go b/epochStart/metachain/economics.go
index 84da7c6384c..2d68a64ce79 100644
--- a/epochStart/metachain/economics.go
+++ b/epochStart/metachain/economics.go
@@ -213,9 +213,9 @@ func (e *economics) printEconomicsData(
 
 	var rewardsForLeaders *big.Int
 	if metaBlock.Epoch > e.stakingV2EnableEpoch {
-		rewardsForLeaders = core.GetIntTrimmedPercentageOfValue(metaBlock.AccumulatedFeesInEpoch, e.rewardsHandler.LeaderPercentage())
+		rewardsForLeaders = core.GetIntTrimmedPercentageOfValue(metaBlock.AccumulatedFeesInEpoch, e.rewardsHandler.LeaderPercentageInEpoch(metaBlock.GetEpoch()))
 	} else {
-		rewardsForLeaders = core.GetApproximatePercentageOfValue(metaBlock.AccumulatedFeesInEpoch, e.rewardsHandler.LeaderPercentage())
+		rewardsForLeaders = core.GetApproximatePercentageOfValue(metaBlock.AccumulatedFeesInEpoch, e.rewardsHandler.LeaderPercentageInEpoch(metaBlock.GetEpoch()))
 	}
 
 	maxSupplyLength := len(prevEpochEconomics.TotalSupply.String())
@@ -243,7 +243,7 @@ func (e *economics) printEconomicsData(
 		e.newDisplayLine("reward per block", "(8)",
 			e.alignRight(rwdPerBlock.String(), maxSupplyLength)),
 		e.newDisplayLine("percent for protocol sustainability", "(9)",
-			e.alignRight(fmt.Sprintf("%.6f", e.rewardsHandler.ProtocolSustainabilityPercentage()), maxSupplyLength)),
+			e.alignRight(fmt.Sprintf("%.6f", e.rewardsHandler.ProtocolSustainabilityPercentageInEpoch(metaBlock.GetEpoch())), maxSupplyLength)),
 		e.newDisplayLine("reward for protocol sustainability", "(4 * 9)",
 			e.alignRight(rewardsForProtocolSustainability.String(), maxSupplyLength)),
 	}
@@ -272,10 +272,10 @@ func (e *economics) newDisplayLine(values ...string) *display.LineData {
 // compute the rewards for protocol sustainability - percentage from total rewards
 func (e *economics) computeRewardsForProtocolSustainability(totalRewards *big.Int, epoch uint32) *big.Int {
 	if epoch > e.stakingV2EnableEpoch {
-		return core.GetIntTrimmedPercentageOfValue(totalRewards, e.rewardsHandler.ProtocolSustainabilityPercentage())
+		return core.GetIntTrimmedPercentageOfValue(totalRewards, e.rewardsHandler.ProtocolSustainabilityPercentageInEpoch(epoch))
 	}
 
-	return core.GetApproximatePercentageOfValue(totalRewards, e.rewardsHandler.ProtocolSustainabilityPercentage())
+	return core.GetApproximatePercentageOfValue(totalRewards, e.rewardsHandler.ProtocolSustainabilityPercentageInEpoch(epoch))
 }
 
 // adjustment for rewards given for each proposed block taking protocol sustainability rewards into consideration
@@ -309,9 +309,9 @@ func (e *economics) adjustRewardsPerBlockWithLeaderPercentage(
 	var rewardsForLeaders *big.Int
 	if epoch > e.stakingV2EnableEpoch {
 		accumulatedFeesForValidators.Sub(accumulatedFeesForValidators, developerFees)
-		rewardsForLeaders = core.GetIntTrimmedPercentageOfValue(accumulatedFeesForValidators, e.rewardsHandler.LeaderPercentage())
+		rewardsForLeaders = core.GetIntTrimmedPercentageOfValue(accumulatedFeesForValidators, e.rewardsHandler.LeaderPercentageInEpoch(epoch))
 	} else {
-		rewardsForLeaders = core.GetApproximatePercentageOfValue(accumulatedFeesForValidators, e.rewardsHandler.LeaderPercentage())
+		rewardsForLeaders = core.GetApproximatePercentageOfValue(accumulatedFeesForValidators, e.rewardsHandler.LeaderPercentageInEpoch(epoch))
 	}
 
 	averageLeaderRewardPerBlock := big.NewInt(0).Div(rewardsForLeaders, big.NewInt(0).SetUint64(blocksInEpoch))
diff --git a/epochStart/metachain/economics_test.go b/epochStart/metachain/economics_test.go
index d5417c73206..f36a77721e6 100644
--- a/epochStart/metachain/economics_test.go
+++ b/epochStart/metachain/economics_test.go
@@ -207,7 +207,7 @@ func TestEconomics_ComputeRewardsForProtocolSustainability(t *testing.T) {
 	totalRewards := big.NewInt(0).SetUint64(123456)
 	args := getArguments()
 	args.RewardsHandler = &mock.RewardsHandlerStub{
-		ProtocolSustainabilityPercentageCalled: func() float64 {
+		ProtocolSustainabilityPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
 	}
@@ -357,7 +357,7 @@ func TestEconomics_ComputeEndOfEpochEconomics(t *testing.T) {
 	leaderPercentage := 0.1
 	args := getArguments()
 	args.RewardsHandler = &mock.RewardsHandlerStub{
-		LeaderPercentageCalled: func() float64 {
+		LeaderPercentageInEpochCalled: func(epoch uint32) float64 {
 			return leaderPercentage
 		},
 	}
@@ -413,10 +413,10 @@ func TestEconomics_VerifyRewardsPerBlock_DifferentHitRates(t *testing.T) {
 		MaxInflationRateCalled: func(_ uint32) float64 {
 			return 0.1
 		},
-		ProtocolSustainabilityAddressCalled: func() string {
+		ProtocolSustainabilityAddressInEpochCalled: func(epoch uint32) string {
 			return commAddress
 		},
-		ProtocolSustainabilityPercentageCalled: func() float64 {
+		ProtocolSustainabilityPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
 	}
@@ -527,13 +527,13 @@ func TestEconomics_VerifyRewardsPerBlock_DifferentFees(t *testing.T) {
 		MaxInflationRateCalled: func(_ uint32) float64 {
 			return 0.1
 		},
-		ProtocolSustainabilityAddressCalled: func() string {
+		ProtocolSustainabilityAddressInEpochCalled: func(epoch uint32) string {
 			return commAddress
 		},
-		ProtocolSustainabilityPercentageCalled: func() float64 {
+		ProtocolSustainabilityPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
-		LeaderPercentageCalled: func() float64 {
+		LeaderPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
 	}
@@ -683,7 +683,7 @@ func TestEconomics_VerifyRewardsPerBlock_DifferentFees(t *testing.T) {
 			adjustedRwdPerBlock := big.NewInt(0).Sub(big.NewInt(maxRewardPerBlock), commRewardPerBlock)
 			feesForValidators := big.NewInt(0).Sub(tt.accFeesInEpoch, tt.devFeesInEpoch)
 
-			feesForProposers := core.GetApproximatePercentageOfValue(feesForValidators, args.RewardsHandler.LeaderPercentage())
+			feesForProposers := core.GetApproximatePercentageOfValue(feesForValidators, args.RewardsHandler.LeaderPercentageInEpoch(0))
 
 			accFeeRewardPerBlock := big.NewInt(0).Div(feesForProposers, big.NewInt(totalBlocksInEpoch))
 			adjustedRwdPerBlock = big.NewInt(0).Sub(adjustedRwdPerBlock, accFeeRewardPerBlock)
@@ -744,13 +744,13 @@ func TestEconomics_VerifyRewardsPerBlock_MoreFeesThanInflation(t *testing.T) {
 		MaxInflationRateCalled: func(_ uint32) float64 {
 			return 0.1
 		},
-		ProtocolSustainabilityAddressCalled: func() string {
+		ProtocolSustainabilityAddressInEpochCalled: func(epoch uint32) string {
 			return commAddress
 		},
-		ProtocolSustainabilityPercentageCalled: func() float64 {
+		ProtocolSustainabilityPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
-		LeaderPercentageCalled: func() float64 {
+		LeaderPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
 	}
@@ -881,7 +881,7 @@ func TestEconomics_VerifyRewardsPerBlock_MoreFeesThanInflation(t *testing.T) {
 			adjustedRwdPerBlock := big.NewInt(0).Sub(big.NewInt(currentMaxBaseRewardPerBlock), commRewardPerBlock)
 			feesForValidators := big.NewInt(0).Sub(tt.accFeesInEpoch, tt.devFeesInEpoch)
 
-			feesForProposers := core.GetApproximatePercentageOfValue(feesForValidators, args.RewardsHandler.LeaderPercentage())
+			feesForProposers := core.GetApproximatePercentageOfValue(feesForValidators, args.RewardsHandler.LeaderPercentageInEpoch(0))
 
 			accFeeRewardPerBlock := big.NewInt(0).Div(feesForProposers, big.NewInt(totalBlocksInEpoch))
 			adjustedRwdPerBlock = big.NewInt(0).Sub(adjustedRwdPerBlock, accFeeRewardPerBlock)
@@ -942,13 +942,13 @@ func TestEconomics_VerifyRewardsPerBlock_InflationZero(t *testing.T) {
 		MaxInflationRateCalled: func(_ uint32) float64 {
 			return 0.0
 		},
-		ProtocolSustainabilityAddressCalled: func() string {
+		ProtocolSustainabilityAddressInEpochCalled: func(epoch uint32) string {
 			return commAddress
 		},
-		ProtocolSustainabilityPercentageCalled: func() float64 {
+		ProtocolSustainabilityPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
-		LeaderPercentageCalled: func() float64 {
+		LeaderPercentageInEpochCalled: func(epoch uint32) float64 {
 			return 0.1
 		},
 	}
@@ -1064,7 +1064,7 @@ func TestEconomics_VerifyRewardsPerBlock_InflationZero(t *testing.T) {
 			adjustedRwdPerBlock := big.NewInt(0).Sub(totalRewardsToBeDistributedPerBlock, commRewardPerBlock)
 			feesForValidators := big.NewInt(0).Sub(tt.accFeesInEpoch, tt.devFeesInEpoch)
 
-			feesForProposers := core.GetApproximatePercentageOfValue(feesForValidators, args.RewardsHandler.LeaderPercentage())
+			feesForProposers := core.GetApproximatePercentageOfValue(feesForValidators, args.RewardsHandler.LeaderPercentageInEpoch(0))
 
 			accFeeRewardPerBlock := big.NewInt(0).Div(feesForProposers, big.NewInt(totalBlocksInEpoch))
 			adjustedRwdPerBlock = big.NewInt(0).Sub(adjustedRwdPerBlock, accFeeRewardPerBlock)
@@ -1585,19 +1585,19 @@ func createArgsForComputeEndOfEpochEconomics(
 		MaxInflationRateCalled: func(_ uint32) float64 {
 			return 0.1
 		},
-		ProtocolSustainabilityAddressCalled: func() string {
+		ProtocolSustainabilityAddressInEpochCalled: func(_ uint32) string {
 			return commAddress
 		},
-		ProtocolSustainabilityPercentageCalled: func() float64 {
+		ProtocolSustainabilityPercentageInEpochCalled: func(_ uint32) float64 {
 			return 0.1
 		},
-		LeaderPercentageCalled: func() float64 {
+		LeaderPercentageInEpochCalled: func(_ uint32) float64 {
 			return 0.1
 		},
-		RewardsTopUpFactorCalled: func() float64 {
+		RewardsTopUpFactorInEpochCalled: func(_ uint32) float64 {
 			return 0.25
 		},
-		RewardsTopUpGradientPointCalled: func() *big.Int {
+		RewardsTopUpGradientPointInEpochCalled: func(_ uint32) *big.Int {
 			return big.NewInt(0).Div(args.GenesisTotalSupply, big.NewInt(10))
 		},
 	}
@@ -1670,11 +1670,11 @@ func verifyEconomicsBlock(
 	rewardsForLeader := big.NewInt(0).Sub(input.accumulatedFeesInEpoch, input.devFeesInEpoch)
 	var expectedProtocolSustainabilityRewards *big.Int
 	if stakingV2 {
-		rewardsForLeader = core.GetIntTrimmedPercentageOfValue(rewardsForLeader, rewardsHandler.LeaderPercentage())
-		expectedProtocolSustainabilityRewards = core.GetIntTrimmedPercentageOfValue(expectedTotalRewardsToBeDistributed, rewardsHandler.ProtocolSustainabilityPercentage())
+		rewardsForLeader = core.GetIntTrimmedPercentageOfValue(rewardsForLeader, rewardsHandler.LeaderPercentageInEpoch(0))
+		expectedProtocolSustainabilityRewards = core.GetIntTrimmedPercentageOfValue(expectedTotalRewardsToBeDistributed, rewardsHandler.ProtocolSustainabilityPercentageInEpoch(0))
 	} else {
-		rewardsForLeader = core.GetApproximatePercentageOfValue(rewardsForLeader, rewardsHandler.LeaderPercentage())
-		expectedProtocolSustainabilityRewards = core.GetApproximatePercentageOfValue(expectedTotalRewardsToBeDistributed, rewardsHandler.ProtocolSustainabilityPercentage())
+		rewardsForLeader = core.GetApproximatePercentageOfValue(rewardsForLeader, rewardsHandler.LeaderPercentageInEpoch(0))
+		expectedProtocolSustainabilityRewards = core.GetApproximatePercentageOfValue(expectedTotalRewardsToBeDistributed, rewardsHandler.ProtocolSustainabilityPercentageInEpoch(0))
 	}
 	rewardsForLeaderPerBlock := big.NewInt(0).Div(rewardsForLeader, big.NewInt(totalBlocksPerEpoch))
 	adjustedRewardsPerBlock.Sub(adjustedRewardsPerBlock, rewardsForLeaderPerBlock)
diff --git a/epochStart/metachain/rewardsCreatorProxy.go b/epochStart/metachain/rewardsCreatorProxy.go
index 0e770c69629..728c70df324 100644
--- a/epochStart/metachain/rewardsCreatorProxy.go
+++ b/epochStart/metachain/rewardsCreatorProxy.go
@@ -26,7 +26,6 @@ type RewardsCreatorProxyArgs struct {
 	BaseRewardsCreatorArgs
 	StakingDataProvider   epochStart.StakingDataProvider
 	EconomicsDataProvider epochStart.EpochEconomicsDataProvider
-	RewardsHandler        process.RewardsHandler
 }
 
 type rewardsCreatorProxy struct {
diff --git a/epochStart/metachain/rewardsCreatorProxy_test.go b/epochStart/metachain/rewardsCreatorProxy_test.go
index e41730d34f1..638801522d9 100644
--- a/epochStart/metachain/rewardsCreatorProxy_test.go
+++ b/epochStart/metachain/rewardsCreatorProxy_test.go
@@ -16,7 +16,6 @@ import (
 	"github.com/multiversx/mx-chain-go/epochStart/mock"
 	"github.com/multiversx/mx-chain-go/state"
 	"github.com/multiversx/mx-chain-go/testscommon"
-	"github.com/multiversx/mx-chain-go/testscommon/economicsmocks"
 	"github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock"
 	"github.com/multiversx/mx-chain-go/testscommon/hashingMocks"
 	"github.com/multiversx/mx-chain-go/testscommon/stakingcommon"
@@ -369,22 +368,10 @@ func createDefaultBlockBody() *block.Body {
 }
 
 func createDefaultRewardsCreatorProxyArgs() RewardsCreatorProxyArgs {
-	rewardsTopUpGradientPoint, _ := big.NewInt(0).SetString("3000000000000000000000000", 10)
-
-	rewardsHandler := &economicsmocks.EconomicsHandlerStub{
-		RewardsTopUpGradientPointCalled: func() *big.Int {
-			return rewardsTopUpGradientPoint
-		},
-		RewardsTopUpFactorCalled: func() float64 {
-			return 0.25
-		},
-	}
-
 	return RewardsCreatorProxyArgs{
 		BaseRewardsCreatorArgs: getBaseRewardsArguments(),
 		StakingDataProvider:    &stakingcommon.StakingDataProviderStub{},
 		EconomicsDataProvider:  NewEpochEconomicsStatistics(),
-		RewardsHandler:         rewardsHandler,
 	}
 }
 
diff --git a/epochStart/metachain/rewardsV2.go b/epochStart/metachain/rewardsV2.go
index ddfc05abcfe..ac7b5074cc1 100644
--- a/epochStart/metachain/rewardsV2.go
+++ b/epochStart/metachain/rewardsV2.go
@@ -107,7 +107,7 @@ func (rc *rewardsCreatorV2) CreateRewardsMiniBlocks(
 		return nil, err
 	}
 
-	nodesRewardInfo, dustFromRewardsPerNode := rc.computeRewardsPerNode(validatorsInfo)
+	nodesRewardInfo, dustFromRewardsPerNode := rc.computeRewardsPerNode(validatorsInfo, metaBlock.GetEpoch())
 	log.Debug("arithmetic difference from dust rewards per node", "value", dustFromRewardsPerNode)
 
 	dust, err := rc.addValidatorRewardsToMiniBlocks(metaBlock, miniBlocks, nodesRewardInfo)
@@ -264,6 +264,7 @@ func (rc *rewardsCreatorV2) IsInterfaceNil() bool {
 
 func (rc *rewardsCreatorV2) computeRewardsPerNode(
 	validatorsInfo state.ShardValidatorsInfoMapHandler,
+	epoch uint32,
 ) (map[uint32][]*nodeRewardsData, *big.Int) {
 
 	var baseRewardsPerBlock *big.Int
@@ -274,7 +275,7 @@ func (rc *rewardsCreatorV2) computeRewardsPerNode(
 	totalStakeEligible := rc.stakingDataProvider.GetTotalStakeEligibleNodes()
 	totalTopUpEligible := rc.stakingDataProvider.GetTotalTopUpStakeEligibleNodes()
 	remainingToBeDistributed := rc.economicsDataProvider.RewardsToBeDistributedForBlocks()
-	topUpRewards := rc.computeTopUpRewards(remainingToBeDistributed, totalTopUpEligible)
+	topUpRewards := rc.computeTopUpRewards(remainingToBeDistributed, totalTopUpEligible, epoch)
 	baseRewards := big.NewInt(0).Sub(remainingToBeDistributed, topUpRewards)
 	nbBlocks := big.NewInt(int64(rc.economicsDataProvider.NumberOfBlocks()))
 	if nbBlocks.Cmp(zero) <= 0 {
@@ -379,7 +380,7 @@ func (rc *rewardsCreatorV2) computeTopUpRewardsPerNode(
 // x is the cumulative top-up stake value for eligible nodes
 // p is the cumulative eligible stake where rewards per day reach 1/2 of k (includes topUp for the eligible nodes)
 // pi is the mathematical constant pi = 3.1415...
-func (rc *rewardsCreatorV2) computeTopUpRewards(totalToDistribute *big.Int, totalTopUpEligible *big.Int) *big.Int {
+func (rc *rewardsCreatorV2) computeTopUpRewards(totalToDistribute *big.Int, totalTopUpEligible *big.Int, epoch uint32) *big.Int {
 	if totalToDistribute.Cmp(zero) <= 0 || totalTopUpEligible.Cmp(zero) <= 0 {
 		return big.NewInt(0)
 	}
@@ -388,15 +389,15 @@ func (rc *rewardsCreatorV2) computeTopUpRewards(totalToDistribute *big.Int, tota
 	log.Debug("computeTopUpRewards", "totalTopUpEligible", totalTopUpEligible.String())
 
 	// k = c * economics.TotalToDistribute, c = top-up reward factor (constant)
-	k := core.GetIntTrimmedPercentageOfValue(totalToDistribute, rc.rewardsHandler.RewardsTopUpFactor())
-	log.Debug("computeTopUpRewards", "topUpFactor", rc.rewardsHandler.RewardsTopUpFactor())
+	k := core.GetIntTrimmedPercentageOfValue(totalToDistribute, rc.rewardsHandler.RewardsTopUpFactorInEpoch(epoch))
+	log.Debug("computeTopUpRewards", "topUpFactor", rc.rewardsHandler.RewardsTopUpFactorInEpoch(epoch))
 	log.Debug("computeTopUpRewards", "k", k.String())
 
 	// p is the cumulative eligible stake where rewards per day reach 1/2 of k (constant)
 	// x/p - argument for atan
 	totalTopUpEligibleFloat := big.NewFloat(0).SetInt(totalTopUpEligible)
-	topUpGradientPointFloat := big.NewFloat(0).SetInt(rc.rewardsHandler.RewardsTopUpGradientPoint())
-	log.Debug("computeTopUpRewards", "topUpGradientPoint", rc.rewardsHandler.RewardsTopUpGradientPoint().String())
+	topUpGradientPointFloat := big.NewFloat(0).SetInt(rc.rewardsHandler.RewardsTopUpGradientPointInEpoch(epoch))
+	log.Debug("computeTopUpRewards", "topUpGradientPoint", rc.rewardsHandler.RewardsTopUpGradientPointInEpoch(epoch).String())
 
 	floatArg, _ := big.NewFloat(0).Quo(totalTopUpEligibleFloat, topUpGradientPointFloat).Float64()
 	log.Debug("computeTopUpRewards", "x/p", floatArg)
diff --git a/epochStart/metachain/rewardsV2_test.go b/epochStart/metachain/rewardsV2_test.go
index 7abea51dea3..c024613ac25 100644
--- a/epochStart/metachain/rewardsV2_test.go
+++ b/epochStart/metachain/rewardsV2_test.go
@@ -199,7 +199,7 @@ func TestRewardsCreatorV2_adjustProtocolSustainabilityRewardsPositiveValue(t *te
 	require.NotNil(t, rwd)
 
 	initialProtRewardValue := big.NewInt(1000000)
-	protRwAddr, _ := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
+	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
 		Value:   big.NewInt(0).Set(initialProtRewardValue),
@@ -230,7 +230,7 @@ func TestRewardsCreatorV2_adjustProtocolSustainabilityRewardsNegValueNotAccepted
 	require.NotNil(t, rwd)
 
 	initialProtRewardValue := big.NewInt(10)
-	protRwAddr, _ := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
+	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
 		Value:   big.NewInt(0).Set(initialProtRewardValue),
@@ -262,7 +262,7 @@ func TestRewardsCreatorV2_adjustProtocolSustainabilityRewardsInitialNegativeValu
 	require.NotNil(t, rwd)
 
 	initialProtRewardValue := big.NewInt(-100)
-	protRwAddr, _ := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
+	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
 		Value:   big.NewInt(0).Set(initialProtRewardValue),
@@ -539,7 +539,7 @@ func TestNewRewardsCreatorV2_computeTopUpRewardsZeroTopup(t *testing.T) {
 	totalToDistribute, _ := big.NewInt(-1).SetString("3000000000000000000000", 10)
 	totalTopUpEligible := big.NewInt(0)
 
-	topUpRewards := rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible)
+	topUpRewards := rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible, 0)
 	require.NotNil(t, topUpRewards)
 	require.Equal(t, big.NewInt(0), topUpRewards)
 }
@@ -555,7 +555,7 @@ func TestNewRewardsCreatorV2_computeTopUpRewardsNegativeToDistribute(t *testing.
 	totalToDistribute := big.NewInt(-1)
 	totalTopUpEligible := big.NewInt(10000)
 
-	topUpRewards := rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible)
+	topUpRewards := rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible, 0)
 	require.NotNil(t, topUpRewards)
 	require.Equal(t, big.NewInt(0), topUpRewards)
 }
@@ -569,27 +569,27 @@ func TestNewRewardsCreatorV2_computeTopUpRewards(t *testing.T) {
 	require.NotNil(t, rwd)
 
 	totalToDistribute, _ := big.NewInt(0).SetString("3000000000000000000000", 10)
-	topUpRewardsLimit := core.GetApproximatePercentageOfValue(totalToDistribute, rwd.rewardsHandler.RewardsTopUpFactor())
+	topUpRewardsLimit := core.GetApproximatePercentageOfValue(totalToDistribute, rwd.rewardsHandler.RewardsTopUpFactorInEpoch(0))
 
 	totalTopUpEligible, _ := big.NewInt(0).SetString("2000000000000000000000000", 10)
-	topUpRewards := rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible)
+	topUpRewards := rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible, 0)
 	require.NotNil(t, topUpRewards)
 	require.True(t, topUpRewards.Cmp(topUpRewardsLimit) < 0)
 
 	totalTopUpEligible, _ = big.NewInt(0).SetString("3000000000000000000000000", 10)
-	topUpRewards = rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible)
+	topUpRewards = rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible, 0)
 
 	require.NotNil(t, topUpRewards)
 	require.Equal(t, topUpRewards, big.NewInt(0).Div(topUpRewardsLimit, big.NewInt(2)))
 
 	totalTopUpEligible, _ = big.NewInt(0).SetString("3500000000000000000000000", 10)
-	topUpRewards = rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible)
+	topUpRewards = rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible, 0)
 
 	require.NotNil(t, topUpRewards)
 	require.True(t, topUpRewards.Cmp(big.NewInt(0).Div(topUpRewardsLimit, big.NewInt(2))) > 0)
 
 	totalTopUpEligible, _ = big.NewInt(0).SetString("9000000000000000000000000000000", 10)
-	topUpRewards = rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible)
+	topUpRewards = rwd.computeTopUpRewards(totalToDistribute, totalTopUpEligible, 0)
 
 	require.NotNil(t, topUpRewards)
 	require.True(t, topUpRewards.Cmp(big.NewInt(0).Div(topUpRewardsLimit, big.NewInt(2))) > 0)
@@ -769,7 +769,7 @@ func TestNewRewardsCreatorV2_computeRewardsPerNode(t *testing.T) {
 	require.Nil(t, err)
 	require.NotNil(t, rwd)
 
-	nodesRewardInfo, accumulatedDust := rwd.computeRewardsPerNode(vInfo)
+	nodesRewardInfo, accumulatedDust := rwd.computeRewardsPerNode(vInfo, 0)
 
 	// dust should be really small, checking against  baseRewards/1mil
 	limit := core.GetApproximatePercentageOfValue(rewardsForBlocks, 0.000001)
@@ -1063,7 +1063,7 @@ func TestNewRewardsCreatorV35_computeRewardsPer3200NodesWithDifferentTopups(t *t
 			}
 
 			rwd, _ := NewRewardsCreatorV2(setupResult.RewardsCreatorArgsV2)
-			nodesRewardInfo, _ = rwd.computeRewardsPerNode(vInfo)
+			nodesRewardInfo, _ = rwd.computeRewardsPerNode(vInfo, 0)
 
 			currentRewardInfo := nodesRewardInfo[0][0]
 
@@ -1170,7 +1170,7 @@ func TestNewRewardsCreatorV2_computeRewardsPer3200NodesWithDifferentTopups(t *te
 			}
 
 			rwd, _ := NewRewardsCreatorV2(setupResult.RewardsCreatorArgsV2)
-			nodesRewardInfo, _ = rwd.computeRewardsPerNode(vInfo)
+			nodesRewardInfo, _ = rwd.computeRewardsPerNode(vInfo, 0)
 
 			currentRewardInfo := nodesRewardInfo[0][0]
 
@@ -1292,7 +1292,7 @@ func computeRewardsAndDust(nbEligiblePerShard uint32, args SetupRewardsResult, t
 	rwd, _ := NewRewardsCreatorV2(args.RewardsCreatorArgsV2)
 
 	var dust *big.Int
-	nodesRewardInfo, dust = rwd.computeRewardsPerNode(vInfo)
+	nodesRewardInfo, dust = rwd.computeRewardsPerNode(vInfo, 0)
 	return nodesRewardInfo, dust
 }
 
@@ -1766,11 +1766,11 @@ func getRewardsCreatorV2Arguments() RewardsCreatorArgsV2 {
 	rewardsTopUpGradientPoint, _ := big.NewInt(0).SetString("3000000000000000000000000", 10)
 	topUpRewardFactor := 0.25
 
-	rewardsHandler := &economicsmocks.EconomicsHandlerStub{
-		RewardsTopUpGradientPointCalled: func() *big.Int {
+	rewardsHandler := &economicsmocks.EconomicsHandlerMock{
+		RewardsTopUpGradientPointInEpochCalled: func(_ uint32) *big.Int {
 			return big.NewInt(0).Set(rewardsTopUpGradientPoint)
 		},
-		RewardsTopUpFactorCalled: func() float64 {
+		RewardsTopUpFactorInEpochCalled: func(_ uint32) float64 {
 			return topUpRewardFactor
 		},
 	}
@@ -1786,11 +1786,11 @@ func getRewardsCreatorV35Arguments() RewardsCreatorArgsV2 {
 	rewardsTopUpGradientPoint, _ := big.NewInt(0).SetString("2000000000000000000000000", 10)
 	topUpRewardFactor := 0.5
 
-	rewardsHandler := &economicsmocks.EconomicsHandlerStub{
-		RewardsTopUpGradientPointCalled: func() *big.Int {
+	rewardsHandler := &economicsmocks.EconomicsHandlerMock{
+		RewardsTopUpGradientPointInEpochCalled: func(_ uint32) *big.Int {
 			return big.NewInt(0).Set(rewardsTopUpGradientPoint)
 		},
-		RewardsTopUpFactorCalled: func() float64 {
+		RewardsTopUpFactorInEpochCalled: func(_ uint32) float64 {
 			return topUpRewardFactor
 		},
 	}
diff --git a/epochStart/metachain/rewards_test.go b/epochStart/metachain/rewards_test.go
index b40fe8882e9..431e310ba9c 100644
--- a/epochStart/metachain/rewards_test.go
+++ b/epochStart/metachain/rewards_test.go
@@ -93,28 +93,6 @@ func TestNewRewardsCreator_NilMarshalizer(t *testing.T) {
 	assert.Equal(t, epochStart.ErrNilMarshalizer, err)
 }
 
-func TestNewRewardsCreator_EmptyProtocolSustainabilityAddress(t *testing.T) {
-	t.Parallel()
-
-	args := getRewardsArguments()
-	args.ProtocolSustainabilityAddress = ""
-
-	rwd, err := NewRewardsCreator(args)
-	assert.True(t, check.IfNil(rwd))
-	assert.Equal(t, epochStart.ErrNilProtocolSustainabilityAddress, err)
-}
-
-func TestNewRewardsCreator_InvalidProtocolSustainabilityAddress(t *testing.T) {
-	t.Parallel()
-
-	args := getRewardsArguments()
-	args.ProtocolSustainabilityAddress = "xyz" // not a hex string
-
-	rwd, err := NewRewardsCreator(args)
-	assert.True(t, check.IfNil(rwd))
-	assert.NotNil(t, err)
-}
-
 func TestNewRewardsCreator_OkValsShouldWork(t *testing.T) {
 	t.Parallel()
 
@@ -207,7 +185,7 @@ func TestRewardsCreator_VerifyRewardsMiniBlocksRewardsMbNumDoesNotMatch(t *testi
 	protocolSustainabilityRewardTx := rewardTx.RewardTx{
 		Round:   0,
 		Value:   big.NewInt(50),
-		RcvAddr: []byte{17},
+		RcvAddr: []byte("11"),
 		Epoch:   0,
 	}
 	mb.EpochStart.Economics.RewardsForProtocolSustainability.Set(protocolSustainabilityRewardTx.Value)
@@ -253,7 +231,7 @@ func TestRewardsCreator_adjustProtocolSustainabilityRewardsPositiveValue(t *test
 	require.NotNil(t, rwd)
 
 	initialProtRewardValue := big.NewInt(1000000)
-	protRwAddr, _ := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
+	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
 		Value:   big.NewInt(0).Set(initialProtRewardValue),
@@ -284,7 +262,7 @@ func TestRewardsCreator_adjustProtocolSustainabilityRewardsNegValueShouldWork(t
 	require.NotNil(t, rwd)
 
 	initialProtRewardValue := big.NewInt(10)
-	protRwAddr, _ := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
+	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
 		Value:   big.NewInt(0).Set(initialProtRewardValue),
@@ -317,7 +295,7 @@ func TestRewardsCreator_adjustProtocolSustainabilityRewardsInitialNegativeValue(
 	require.NotNil(t, rwd)
 
 	initialProtRewardValue := big.NewInt(-100)
-	protRwAddr, _ := args.PubkeyConverter.Decode(args.ProtocolSustainabilityAddress)
+	protRwAddr, _ := args.PubkeyConverter.Decode(args.RewardsHandler.ProtocolSustainabilityAddressInEpoch(0))
 	protRwTx := &rewardTx.RewardTx{
 		Round:   100,
 		Value:   big.NewInt(0).Set(initialProtRewardValue),
@@ -356,7 +334,7 @@ func TestRewardsCreator_VerifyRewardsMiniBlocksShouldWork(t *testing.T) {
 	protocolSustainabilityRewardTx := rewardTx.RewardTx{
 		Round:   0,
 		Value:   big.NewInt(50),
-		RcvAddr: []byte{17},
+		RcvAddr: []byte("11"),
 		Epoch:   0,
 	}
 	commRwdTxHash, _ := core.CalculateHash(&marshal.JsonMarshalizer{}, &hashingMocks.HasherMock{}, protocolSustainabilityRewardTx)
@@ -424,7 +402,7 @@ func TestRewardsCreator_VerifyRewardsMiniBlocksShouldWorkEvenIfNotAllShardsHaveR
 	protocolSustainabilityRewardTx := rewardTx.RewardTx{
 		Round:   0,
 		Value:   big.NewInt(50),
-		RcvAddr: []byte{17},
+		RcvAddr: []byte("11"),
 		Epoch:   0,
 	}
 	commRwdTxHash, _ := core.CalculateHash(&marshal.JsonMarshalizer{}, &hashingMocks.HasherMock{}, protocolSustainabilityRewardTx)
@@ -671,7 +649,7 @@ func TestRewardsCreator_CreateProtocolSustainabilityRewardTransaction(t *testing
 	expectedRewardTx := &rewardTx.RewardTx{
 		Round:   0,
 		Value:   big.NewInt(50),
-		RcvAddr: []byte{17},
+		RcvAddr: []byte("11"),
 		Epoch:   0,
 	}
 
@@ -702,7 +680,7 @@ func TestRewardsCreator_AddProtocolSustainabilityRewardToMiniBlocks(t *testing.T
 	expectedRewardTx := &rewardTx.RewardTx{
 		Round:   0,
 		Value:   big.NewInt(50),
-		RcvAddr: []byte{17},
+		RcvAddr: []byte("11"),
 		Epoch:   0,
 	}
 	expectedRwdTxHash, _ := core.CalculateHash(&marshal.JsonMarshalizer{}, &hashingMocks.HasherMock{}, expectedRewardTx)
diff --git a/epochStart/mock/rewardsHandlerStub.go b/epochStart/mock/rewardsHandlerStub.go
index 2bd36587b6f..815a05bc82c 100644
--- a/epochStart/mock/rewardsHandlerStub.go
+++ b/epochStart/mock/rewardsHandlerStub.go
@@ -4,13 +4,19 @@ import "math/big"
 
 // RewardsHandlerStub -
 type RewardsHandlerStub struct {
-	LeaderPercentageCalled                 func() float64
-	ProtocolSustainabilityPercentageCalled func() float64
-	ProtocolSustainabilityAddressCalled    func() string
-	MinInflationRateCalled                 func() float64
-	MaxInflationRateCalled                 func(year uint32) float64
-	RewardsTopUpGradientPointCalled        func() *big.Int
-	RewardsTopUpFactorCalled               func() float64
+	LeaderPercentageCalled                        func() float64
+	ProtocolSustainabilityPercentageCalled        func() float64
+	ProtocolSustainabilityAddressCalled           func() string
+	MinInflationRateCalled                        func() float64
+	MaxInflationRateCalled                        func(year uint32) float64
+	RewardsTopUpGradientPointCalled               func() *big.Int
+	RewardsTopUpFactorCalled                      func() float64
+	LeaderPercentageInEpochCalled                 func(epoch uint32) float64
+	DeveloperPercentageInEpochCalled              func(epoch uint32) float64
+	ProtocolSustainabilityPercentageInEpochCalled func(epoch uint32) float64
+	ProtocolSustainabilityAddressInEpochCalled    func(epoch uint32) string
+	RewardsTopUpGradientPointInEpochCalled        func(epoch uint32) *big.Int
+	RewardsTopUpFactorInEpochCalled               func(epoch uint32) float64
 }
 
 // LeaderPercentage -
@@ -68,6 +74,54 @@ func (r *RewardsHandlerStub) RewardsTopUpFactor() float64 {
 	return r.RewardsTopUpFactorCalled()
 }
 
+// LeaderPercentageInEpoch -
+func (r *RewardsHandlerStub) LeaderPercentageInEpoch(epoch uint32) float64 {
+	if r.LeaderPercentageInEpochCalled != nil {
+		return r.LeaderPercentageInEpochCalled(epoch)
+	}
+	return 1
+}
+
+// DeveloperPercentageInEpoch -
+func (r *RewardsHandlerStub) DeveloperPercentageInEpoch(epoch uint32) float64 {
+	if r.DeveloperPercentageInEpochCalled != nil {
+		return r.DeveloperPercentageInEpochCalled(epoch)
+	}
+	return 0
+}
+
+// ProtocolSustainabilityPercentageInEpoch -
+func (r *RewardsHandlerStub) ProtocolSustainabilityPercentageInEpoch(epoch uint32) float64 {
+	if r.ProtocolSustainabilityPercentageInEpochCalled != nil {
+		return r.ProtocolSustainabilityPercentageInEpochCalled(epoch)
+	}
+	return 0
+}
+
+// ProtocolSustainabilityAddressInEpoch -
+func (r *RewardsHandlerStub) ProtocolSustainabilityAddressInEpoch(epoch uint32) string {
+	if r.ProtocolSustainabilityAddressInEpochCalled != nil {
+		return r.ProtocolSustainabilityAddressInEpochCalled(epoch)
+	}
+	return "1111"
+}
+
+// RewardsTopUpGradientPointInEpoch -
+func (r *RewardsHandlerStub) RewardsTopUpGradientPointInEpoch(epoch uint32) *big.Int {
+	if r.RewardsTopUpGradientPointInEpochCalled != nil {
+		return r.RewardsTopUpGradientPointInEpochCalled(epoch)
+	}
+	return big.NewInt(0)
+}
+
+// RewardsTopUpFactorInEpoch -
+func (r *RewardsHandlerStub) RewardsTopUpFactorInEpoch(epoch uint32) float64 {
+	if r.RewardsTopUpFactorInEpochCalled != nil {
+		return r.RewardsTopUpFactorInEpochCalled(epoch)
+	}
+	return 0
+}
+
 // IsInterfaceNil -
 func (r *RewardsHandlerStub) IsInterfaceNil() bool {
 	return r == nil
diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go
index 6f0d1026304..18dd6e80e30 100644
--- a/factory/api/apiResolverFactory_test.go
+++ b/factory/api/apiResolverFactory_test.go
@@ -329,7 +329,7 @@ func createMockSCQueryElementArgs() api.SCQueryElementArgs {
 			EpochChangeNotifier:          &epochNotifierMock.EpochNotifierStub{},
 			EnableEpochsHandlerField:     &enableEpochsHandlerMock.EnableEpochsHandlerStub{},
 			UInt64ByteSliceConv:          &testsMocks.Uint64ByteSliceConverterMock{},
-			EconomicsHandler:             &economicsmocks.EconomicsHandlerStub{},
+			EconomicsHandler:             &economicsmocks.EconomicsHandlerMock{},
 			NodesConfig:                  &genesisMocks.NodesSetupStub{},
 			Hash:                         &testscommon.HasherStub{},
 			RatingHandler:                &testscommon.RaterMock{},
diff --git a/factory/core/coreComponents.go b/factory/core/coreComponents.go
index 247ee7e05f8..1995aa43c72 100644
--- a/factory/core/coreComponents.go
+++ b/factory/core/coreComponents.go
@@ -246,12 +246,23 @@ func (ccf *coreComponentsFactory) Create() (*coreComponents, error) {
 
 	txVersionChecker := versioning.NewTxVersionChecker(ccf.config.GeneralSettings.MinTransactionVersion)
 
+	// This shard coordinator uses a hardcoded selfId of 0 as it does not know its selfId.
+	// Its main purpose is to validate the rewards config (protocol sustainability address shard against meta),
+	// inside economics data and should not be used for another scope.
+	// The real component will be created later on, as part of bootstrap components.
+	shardCoordinator, err := sharding.NewMultiShardCoordinator(genesisNodesConfig.NumberOfShards(), 0)
+	if err != nil {
+		return nil, err
+	}
+
 	log.Trace("creating economics data components")
 	argsNewEconomicsData := economics.ArgsNewEconomicsData{
 		Economics:           &ccf.economicsConfig,
 		EpochNotifier:       epochNotifier,
 		EnableEpochsHandler: enableEpochsHandler,
 		TxVersionChecker:    txVersionChecker,
+		PubkeyConverter:     addressPubkeyConverter,
+		ShardCoordinator:    shardCoordinator,
 	}
 	economicsData, err := economics.NewEconomicsData(argsNewEconomicsData)
 	if err != nil {
diff --git a/factory/processing/blockProcessorCreator.go b/factory/processing/blockProcessorCreator.go
index 0721efc6a23..9fa09ccc75c 100644
--- a/factory/processing/blockProcessorCreator.go
+++ b/factory/processing/blockProcessorCreator.go
@@ -797,21 +797,20 @@ func (pcf *processComponentsFactory) newMetaBlockProcessor(
 
 	argsEpochRewards := metachainEpochStart.RewardsCreatorProxyArgs{
 		BaseRewardsCreatorArgs: metachainEpochStart.BaseRewardsCreatorArgs{
-			ShardCoordinator:              pcf.bootstrapComponents.ShardCoordinator(),
-			PubkeyConverter:               pcf.coreData.AddressPubKeyConverter(),
-			RewardsStorage:                rewardsStorage,
-			MiniBlockStorage:              miniBlockStorage,
-			Hasher:                        pcf.coreData.Hasher(),
-			Marshalizer:                   pcf.coreData.InternalMarshalizer(),
-			DataPool:                      pcf.data.Datapool(),
-			ProtocolSustainabilityAddress: pcf.coreData.EconomicsData().ProtocolSustainabilityAddress(),
-			NodesConfigProvider:           pcf.nodesCoordinator,
-			UserAccountsDB:                pcf.state.AccountsAdapter(),
-			EnableEpochsHandler:           pcf.coreData.EnableEpochsHandler(),
-			ExecutionOrderHandler:         pcf.txExecutionOrderHandler,
+			ShardCoordinator:      pcf.bootstrapComponents.ShardCoordinator(),
+			PubkeyConverter:       pcf.coreData.AddressPubKeyConverter(),
+			RewardsStorage:        rewardsStorage,
+			MiniBlockStorage:      miniBlockStorage,
+			Hasher:                pcf.coreData.Hasher(),
+			Marshalizer:           pcf.coreData.InternalMarshalizer(),
+			DataPool:              pcf.data.Datapool(),
+			NodesConfigProvider:   pcf.nodesCoordinator,
+			UserAccountsDB:        pcf.state.AccountsAdapter(),
+			EnableEpochsHandler:   pcf.coreData.EnableEpochsHandler(),
+			ExecutionOrderHandler: pcf.txExecutionOrderHandler,
+			RewardsHandler:        pcf.coreData.EconomicsData(),
 		},
 		StakingDataProvider:   stakingDataProvider,
-		RewardsHandler:        pcf.coreData.EconomicsData(),
 		EconomicsDataProvider: economicsDataProvider,
 	}
 	epochRewards, err := metachainEpochStart.NewRewardsCreatorProxy(argsEpochRewards)
diff --git a/factory/processing/processComponents_test.go b/factory/processing/processComponents_test.go
index a1654ce3ba3..65fe42eb22b 100644
--- a/factory/processing/processComponents_test.go
+++ b/factory/processing/processComponents_test.go
@@ -199,10 +199,13 @@ func createMockProcessComponentsFactoryArgs() processComp.ProcessComponentsFacto
 				},
 			},
 			EpochChangeNotifier: &epochNotifier.EpochNotifierStub{},
-			EconomicsHandler: &economicsmocks.EconomicsHandlerStub{
-				ProtocolSustainabilityAddressCalled: func() string {
+			EconomicsHandler: &economicsmocks.EconomicsHandlerMock{
+				ProtocolSustainabilityAddressInEpochCalled: func(epoch uint32) string {
 					return testingProtocolSustainabilityAddress
 				},
+				GenesisTotalSupplyCalled: func() *big.Int {
+					return big.NewInt(100000000)
+				},
 			},
 			Hash:                         blake2b.NewBlake2b(),
 			TxVersionCheckHandler:        &testscommon.TxVersionCheckerStub{},
@@ -360,7 +363,7 @@ func TestNewProcessComponentsFactory(t *testing.T) {
 
 		args := createMockProcessComponentsFactoryArgs()
 		args.CoreData = &mock.CoreComponentsMock{
-			EconomicsHandler: &economicsmocks.EconomicsHandlerStub{},
+			EconomicsHandler: &economicsmocks.EconomicsHandlerMock{},
 			NodesConfig:      nil,
 		}
 		pcf, err := processComp.NewProcessComponentsFactory(args)
@@ -372,7 +375,7 @@ func TestNewProcessComponentsFactory(t *testing.T) {
 
 		args := createMockProcessComponentsFactoryArgs()
 		args.CoreData = &mock.CoreComponentsMock{
-			EconomicsHandler: &economicsmocks.EconomicsHandlerStub{},
+			EconomicsHandler: &economicsmocks.EconomicsHandlerMock{},
 			NodesConfig:      &nodesSetupMock.NodesSetupStub{},
 			AddrPubKeyConv:   nil,
 		}
@@ -385,7 +388,7 @@ func TestNewProcessComponentsFactory(t *testing.T) {
 
 		args := createMockProcessComponentsFactoryArgs()
 		args.CoreData = &mock.CoreComponentsMock{
-			EconomicsHandler:    &economicsmocks.EconomicsHandlerStub{},
+			EconomicsHandler:    &economicsmocks.EconomicsHandlerMock{},
 			NodesConfig:         &nodesSetupMock.NodesSetupStub{},
 			AddrPubKeyConv:      &testscommon.PubkeyConverterStub{},
 			EpochChangeNotifier: nil,
@@ -399,7 +402,7 @@ func TestNewProcessComponentsFactory(t *testing.T) {
 
 		args := createMockProcessComponentsFactoryArgs()
 		args.CoreData = &mock.CoreComponentsMock{
-			EconomicsHandler:    &economicsmocks.EconomicsHandlerStub{},
+			EconomicsHandler:    &economicsmocks.EconomicsHandlerMock{},
 			NodesConfig:         &nodesSetupMock.NodesSetupStub{},
 			AddrPubKeyConv:      &testscommon.PubkeyConverterStub{},
 			EpochChangeNotifier: &epochNotifier.EpochNotifierStub{},
@@ -414,7 +417,7 @@ func TestNewProcessComponentsFactory(t *testing.T) {
 
 		args := createMockProcessComponentsFactoryArgs()
 		args.CoreData = &mock.CoreComponentsMock{
-			EconomicsHandler:    &economicsmocks.EconomicsHandlerStub{},
+			EconomicsHandler:    &economicsmocks.EconomicsHandlerMock{},
 			NodesConfig:         &nodesSetupMock.NodesSetupStub{},
 			AddrPubKeyConv:      &testscommon.PubkeyConverterStub{},
 			EpochChangeNotifier: &epochNotifier.EpochNotifierStub{},
@@ -430,7 +433,7 @@ func TestNewProcessComponentsFactory(t *testing.T) {
 
 		args := createMockProcessComponentsFactoryArgs()
 		args.CoreData = &mock.CoreComponentsMock{
-			EconomicsHandler:    &economicsmocks.EconomicsHandlerStub{},
+			EconomicsHandler:    &economicsmocks.EconomicsHandlerMock{},
 			NodesConfig:         &nodesSetupMock.NodesSetupStub{},
 			AddrPubKeyConv:      &testscommon.PubkeyConverterStub{},
 			EpochChangeNotifier: &epochNotifier.EpochNotifierStub{},
diff --git a/factory/statusCore/statusCoreComponents_test.go b/factory/statusCore/statusCoreComponents_test.go
index bd85752faeb..0248500bbe7 100644
--- a/factory/statusCore/statusCoreComponents_test.go
+++ b/factory/statusCore/statusCoreComponents_test.go
@@ -92,7 +92,7 @@ func TestStatusCoreComponentsFactory_Create(t *testing.T) {
 		expectedErr := errors.New("expected error")
 		coreCompStub := factory.NewCoreComponentsHolderStubFromRealComponent(componentsMock.GetCoreComponents())
 		coreCompStub.EconomicsDataCalled = func() process.EconomicsDataHandler {
-			return &economicsmocks.EconomicsHandlerStub{
+			return &economicsmocks.EconomicsHandlerMock{
 				SetStatusHandlerCalled: func(statusHandler core.AppStatusHandler) error {
 					return expectedErr
 				},
diff --git a/genesis/process/genesisBlockCreator_test.go b/genesis/process/genesisBlockCreator_test.go
index a681a0e271c..4a6f5b22b85 100644
--- a/genesis/process/genesisBlockCreator_test.go
+++ b/genesis/process/genesisBlockCreator_test.go
@@ -235,7 +235,7 @@ func createMockArgument(
 	gasMap := wasmConfig.MakeGasMapForTests()
 	defaults.FillGasMapInternal(gasMap, 1)
 	arg.GasSchedule = testscommon.NewGasScheduleNotifierMock(gasMap)
-	ted := &economicsmocks.EconomicsHandlerStub{
+	ted := &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			return entireSupply
 		},
diff --git a/integrationTests/multiShard/block/executingRewardMiniblocks/executingRewardMiniblocks_test.go b/integrationTests/multiShard/block/executingRewardMiniblocks/executingRewardMiniblocks_test.go
index 645448af81a..38822aa6427 100644
--- a/integrationTests/multiShard/block/executingRewardMiniblocks/executingRewardMiniblocks_test.go
+++ b/integrationTests/multiShard/block/executingRewardMiniblocks/executingRewardMiniblocks_test.go
@@ -17,8 +17,8 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func getLeaderPercentage(node *integrationTests.TestProcessorNode) float64 {
-	return node.EconomicsData.LeaderPercentage()
+func getLeaderPercentage(node *integrationTests.TestProcessorNode, epoch uint32) float64 {
+	return node.EconomicsData.LeaderPercentageInEpoch(epoch)
 }
 
 func TestExecuteBlocksWithTransactionsAndCheckRewards(t *testing.T) {
@@ -325,7 +325,7 @@ func verifyRewardsForShards(
 	gasLimit uint64,
 ) {
 	rewardValue := big.NewInt(0)
-	feePerTxForLeader := float64(gasPrice) * float64(gasLimit) * getLeaderPercentage(nodesMap[0][0])
+	feePerTxForLeader := float64(gasPrice) * float64(gasLimit) * getLeaderPercentage(nodesMap[0][0], 0)
 
 	for address, nbRewards := range mapRewardsForAddress {
 		shard := nodesMap[0][0].ShardCoordinator.ComputeId([]byte(address))
diff --git a/integrationTests/testInitializer.go b/integrationTests/testInitializer.go
index a7c6cdac3c3..0b42ccb3e85 100644
--- a/integrationTests/testInitializer.go
+++ b/integrationTests/testInitializer.go
@@ -1041,7 +1041,7 @@ func CreateSimpleTxProcessor(accnts state.AccountsAdapter) process.TransactionPr
 		ScProcessor:      &testscommon.SCProcessorMock{},
 		TxFeeHandler:     &testscommon.UnsignedTxHandlerStub{},
 		TxTypeHandler:    &testscommon.TxTypeHandlerMock{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return tx.GetGasLimit()
 			},
diff --git a/integrationTests/testProcessorNode.go b/integrationTests/testProcessorNode.go
index 14c7a6a1ba2..8d54f421662 100644
--- a/integrationTests/testProcessorNode.go
+++ b/integrationTests/testProcessorNode.go
@@ -1103,11 +1103,14 @@ func (tpn *TestProcessorNode) initChainHandler() {
 
 func (tpn *TestProcessorNode) initEconomicsData(economicsConfig *config.EconomicsConfig) {
 	tpn.EnableEpochs.PenalizedTooMuchGasEnableEpoch = 0
+	pubKeyConv, _ := pubkeyConverter.NewBech32PubkeyConverter(32, "erd")
 	argsNewEconomicsData := economics.ArgsNewEconomicsData{
 		Economics:           economicsConfig,
 		EpochNotifier:       tpn.EpochNotifier,
 		EnableEpochsHandler: tpn.EnableEpochsHandler,
 		TxVersionChecker:    &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:     pubKeyConv,
+		ShardCoordinator:    tpn.ShardCoordinator,
 	}
 	economicsData, _ := economics.NewEconomicsData(argsNewEconomicsData)
 	tpn.EconomicsData = economics.NewTestEconomicsData(economicsData)
@@ -2303,21 +2306,20 @@ func (tpn *TestProcessorNode) initBlockProcessor() {
 		miniBlockStorage, _ := tpn.Storage.GetStorer(dataRetriever.MiniBlockUnit)
 		argsEpochRewards := metachain.RewardsCreatorProxyArgs{
 			BaseRewardsCreatorArgs: metachain.BaseRewardsCreatorArgs{
-				ShardCoordinator:              tpn.ShardCoordinator,
-				PubkeyConverter:               TestAddressPubkeyConverter,
-				RewardsStorage:                rewardsStorage,
-				MiniBlockStorage:              miniBlockStorage,
-				Hasher:                        TestHasher,
-				Marshalizer:                   TestMarshalizer,
-				DataPool:                      tpn.DataPool,
-				ProtocolSustainabilityAddress: testProtocolSustainabilityAddress,
-				NodesConfigProvider:           tpn.NodesCoordinator,
-				UserAccountsDB:                tpn.AccntState,
-				EnableEpochsHandler:           tpn.EnableEpochsHandler,
-				ExecutionOrderHandler:         tpn.TxExecutionOrderHandler,
+				ShardCoordinator:      tpn.ShardCoordinator,
+				PubkeyConverter:       TestAddressPubkeyConverter,
+				RewardsStorage:        rewardsStorage,
+				MiniBlockStorage:      miniBlockStorage,
+				Hasher:                TestHasher,
+				Marshalizer:           TestMarshalizer,
+				DataPool:              tpn.DataPool,
+				NodesConfigProvider:   tpn.NodesCoordinator,
+				UserAccountsDB:        tpn.AccntState,
+				EnableEpochsHandler:   tpn.EnableEpochsHandler,
+				ExecutionOrderHandler: tpn.TxExecutionOrderHandler,
+				RewardsHandler:        tpn.EconomicsData,
 			},
 			StakingDataProvider:   stakingDataProvider,
-			RewardsHandler:        tpn.EconomicsData,
 			EconomicsDataProvider: economicsDataProvider,
 		}
 		epochStartRewards, _ := metachain.NewRewardsCreatorProxy(argsEpochRewards)
@@ -3296,7 +3298,7 @@ func GetDefaultCoreComponents(enableEpochsConfig config.EnableEpochs) *mock.Core
 		AlarmSchedulerField:          &testscommon.AlarmSchedulerStub{},
 		SyncTimerField:               &testscommon.SyncTimerStub{},
 		RoundHandlerField:            &testscommon.RoundHandlerMock{},
-		EconomicsDataField:           &economicsmocks.EconomicsHandlerStub{},
+		EconomicsDataField:           &economicsmocks.EconomicsHandlerMock{},
 		RatingsDataField:             &testscommon.RatingsInfoMock{},
 		RaterField:                   &testscommon.RaterMock{},
 		GenesisNodesSetupField:       &genesisMocks.NodesSetupStub{},
diff --git a/integrationTests/vm/mockVM/vmGet/vmGet_test.go b/integrationTests/vm/mockVM/vmGet/vmGet_test.go
index 5083c44a276..bb2eb39303f 100644
--- a/integrationTests/vm/mockVM/vmGet/vmGet_test.go
+++ b/integrationTests/vm/mockVM/vmGet/vmGet_test.go
@@ -42,7 +42,7 @@ func TestVmGetShouldReturnValue(t *testing.T) {
 		}}
 	argsNewSCQueryService := smartContract.ArgsNewSCQueryService{
 		VmContainer: vmContainer,
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return uint64(math.MaxUint64)
 			},
diff --git a/integrationTests/vm/testInitializer.go b/integrationTests/vm/testInitializer.go
index c6e33ddc21a..8e5d42e2557 100644
--- a/integrationTests/vm/testInitializer.go
+++ b/integrationTests/vm/testInitializer.go
@@ -249,7 +249,7 @@ func (vmTestContext *VMTestContext) GetIntValueFromSCWithTransientVM(funcName st
 // GetVMOutputWithTransientVM -
 func (vmTestContext *VMTestContext) GetVMOutputWithTransientVM(funcName string, args ...[]byte) *vmcommon.VMOutput {
 	scAddressBytes := vmTestContext.Contract.Address
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -327,6 +327,7 @@ func createEconomicsData(enableEpochsConfig config.EnableEpochs, gasPriceModifie
 	enableEpochsHandler, _ := enablers.NewEnableEpochsHandler(enableEpochsConfig, realEpochNotifier)
 
 	argsNewEconomicsData := economics.ArgsNewEconomicsData{
+		TxVersionChecker: versioning.NewTxVersionChecker(minTransactionVersion),
 		Economics: &config.EconomicsConfig{
 			GlobalSettings: config.GlobalSettings{
 				GenesisTotalSupply: "2000000000000000000000",
@@ -369,7 +370,8 @@ func createEconomicsData(enableEpochsConfig config.EnableEpochs, gasPriceModifie
 		},
 		EpochNotifier:       realEpochNotifier,
 		EnableEpochsHandler: enableEpochsHandler,
-		TxVersionChecker:    versioning.NewTxVersionChecker(minTransactionVersion),
+		PubkeyConverter:     &testscommon.PubkeyConverterStub{},
+		ShardCoordinator:    &testscommon.ShardsCoordinatorMock{},
 	}
 
 	return economics.NewEconomicsData(argsNewEconomicsData)
@@ -1711,7 +1713,7 @@ func GetVmOutput(
 		_ = vmContainer.Close()
 	}()
 
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
diff --git a/integrationTests/vm/wasm/utils.go b/integrationTests/vm/wasm/utils.go
index bfe7b4b7ca9..69976a93b4f 100644
--- a/integrationTests/vm/wasm/utils.go
+++ b/integrationTests/vm/wasm/utils.go
@@ -253,6 +253,8 @@ func (context *TestContext) initFeeHandlers() {
 		EpochNotifier:       context.EpochNotifier,
 		EnableEpochsHandler: context.EnableEpochsHandler,
 		TxVersionChecker:    &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:     &testscommon.PubkeyConverterStub{},
+		ShardCoordinator:    &testscommon.ShardsCoordinatorMock{},
 	}
 	economicsData, _ := economics.NewEconomicsData(argsNewEconomicsData)
 
diff --git a/integrationTests/vm/wasm/wasmvm/wasmVM_test.go b/integrationTests/vm/wasm/wasmvm/wasmVM_test.go
index 2957aa42add..73a677def57 100644
--- a/integrationTests/vm/wasm/wasmvm/wasmVM_test.go
+++ b/integrationTests/vm/wasm/wasmvm/wasmVM_test.go
@@ -616,7 +616,7 @@ func TestExecuteTransactionAndTimeToProcessChange(t *testing.T) {
 		EnableEpochsHandler: enableEpochsHandler,
 	}
 	txTypeHandler, _ := coordinator.NewTxTypeHandler(argsTxTypeHandler)
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		ComputeMoveBalanceFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return big.NewInt(10)
 		},
@@ -638,7 +638,7 @@ func TestExecuteTransactionAndTimeToProcessChange(t *testing.T) {
 		ScProcessor:         &testscommon.SCProcessorMock{},
 		TxFeeHandler:        &testscommon.UnsignedTxHandlerStub{},
 		TxTypeHandler:       txTypeHandler,
-		EconomicsFee:        &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:        &economicsmocks.EconomicsHandlerMock{},
 		ReceiptForwarder:    &mock.IntermediateTransactionHandlerMock{},
 		BadTxForwarder:      &mock.IntermediateTransactionHandlerMock{},
 		ArgsParser:          smartContract.NewArgumentParser(),
diff --git a/node/chainSimulator/components/coreComponents.go b/node/chainSimulator/components/coreComponents.go
index 49a7269d74b..af28ce185ff 100644
--- a/node/chainSimulator/components/coreComponents.go
+++ b/node/chainSimulator/components/coreComponents.go
@@ -173,6 +173,8 @@ func CreateCoreComponents(args ArgsCoreComponentsHolder) (*coreComponentsHolder,
 		Economics:           &args.EconomicsConfig,
 		EpochNotifier:       instance.epochNotifier,
 		EnableEpochsHandler: instance.enableEpochsHandler,
+		PubkeyConverter:     instance.addressPubKeyConverter,
+		ShardCoordinator:    testscommon.NewMultiShardsCoordinatorMock(instance.genesisNodesSetup.NumberOfShards()),
 	}
 
 	instance.economicsData, err = economics.NewEconomicsData(argsEconomicsHandler)
diff --git a/node/chainSimulator/components/coreComponents_test.go b/node/chainSimulator/components/coreComponents_test.go
index 7056d9ae48c..25e4ba9310b 100644
--- a/node/chainSimulator/components/coreComponents_test.go
+++ b/node/chainSimulator/components/coreComponents_test.go
@@ -86,7 +86,7 @@ func createArgsCoreComponentsHolder() ArgsCoreComponentsHolder {
 						LeaderPercentage:                 0.1,
 						DeveloperPercentage:              0.1,
 						ProtocolSustainabilityPercentage: 0.1,
-						ProtocolSustainabilityAddress:    "erd1932eft30w753xyvme8d49qejgkjc09n5e49w4mwdjtm0neld797su0dlxp",
+						ProtocolSustainabilityAddress:    "2c5594ae2f77a913119bc9db52833245a5879674cd4aeaedcd92f6f9e7edf17d", // tests use hex address pub key conv
 						TopUpGradientPoint:               "300000000000000000000",
 						TopUpFactor:                      0.25,
 						EpochEnable:                      0,
diff --git a/node/chainSimulator/components/processComponents_test.go b/node/chainSimulator/components/processComponents_test.go
index a8cb2f053e7..536cb21abfc 100644
--- a/node/chainSimulator/components/processComponents_test.go
+++ b/node/chainSimulator/components/processComponents_test.go
@@ -146,7 +146,7 @@ func createArgsProcessComponentsHolder() ArgsProcessComponentsHolder {
 			ValPubKeyConv:       valPubKeyConv,
 			NodesConfig:         nodesSetup,
 			EpochChangeNotifier: &epochNotifier.EpochNotifierStub{},
-			EconomicsHandler: &economicsmocks.EconomicsHandlerStub{
+			EconomicsHandler: &economicsmocks.EconomicsHandlerMock{
 				ProtocolSustainabilityAddressCalled: func() string {
 					return testingProtocolSustainabilityAddress
 				},
diff --git a/node/chainSimulator/components/statusCoreComponents_test.go b/node/chainSimulator/components/statusCoreComponents_test.go
index a616890644f..c1a6a3336a7 100644
--- a/node/chainSimulator/components/statusCoreComponents_test.go
+++ b/node/chainSimulator/components/statusCoreComponents_test.go
@@ -42,7 +42,7 @@ func createArgs() (config.Configs, factory.CoreComponentsHolder) {
 	}
 
 	return cfg, &mock.CoreComponentsMock{
-		EconomicsHandler:    &economicsmocks.EconomicsHandlerStub{},
+		EconomicsHandler:    &economicsmocks.EconomicsHandlerMock{},
 		IntMarsh:            &testscommon.MarshallerStub{},
 		UInt64ByteSliceConv: &mockTests.Uint64ByteSliceConverterMock{},
 		NodesConfig:         &genesisMocks.NodesSetupStub{},
diff --git a/node/external/timemachine/fee/feeComputer_test.go b/node/external/timemachine/fee/feeComputer_test.go
index 46e2904d6d2..c3b2cd49655 100644
--- a/node/external/timemachine/fee/feeComputer_test.go
+++ b/node/external/timemachine/fee/feeComputer_test.go
@@ -21,7 +21,9 @@ import (
 func createEconomicsData() process.EconomicsDataHandler {
 	economicsConfig := testscommon.GetEconomicsConfig()
 	economicsData, _ := economics.NewEconomicsData(economics.ArgsNewEconomicsData{
-		Economics: &economicsConfig,
+		TxVersionChecker: &testscommon.TxVersionCheckerStub{},
+		Economics:        &economicsConfig,
+		EpochNotifier:    &epochNotifier.EpochNotifierStub{},
 		EnableEpochsHandler: &enableEpochsHandlerMock.EnableEpochsHandlerStub{
 			IsFlagEnabledInEpochCalled: func(flag core.EnableEpochFlag, epoch uint32) bool {
 				if flag == common.PenalizedTooMuchGasFlag {
@@ -33,8 +35,8 @@ func createEconomicsData() process.EconomicsDataHandler {
 				return false
 			},
 		},
-		TxVersionChecker: &testscommon.TxVersionCheckerStub{},
-		EpochNotifier:    &epochNotifier.EpochNotifierStub{},
+		PubkeyConverter:  &testscommon.PubkeyConverterStub{},
+		ShardCoordinator: &testscommon.ShardsCoordinatorMock{},
 	})
 
 	return economicsData
diff --git a/node/external/timemachine/fee/memoryFootprint/memory_test.go b/node/external/timemachine/fee/memoryFootprint/memory_test.go
index a854a286ddd..5f3742ffd11 100644
--- a/node/external/timemachine/fee/memoryFootprint/memory_test.go
+++ b/node/external/timemachine/fee/memoryFootprint/memory_test.go
@@ -44,6 +44,8 @@ func TestFeeComputer_MemoryFootprint(t *testing.T) {
 		},
 		TxVersionChecker: &testscommon.TxVersionCheckerStub{},
 		EpochNotifier:    &epochNotifier.EpochNotifierStub{},
+		PubkeyConverter:  &testscommon.PubkeyConverterStub{},
+		ShardCoordinator: &testscommon.ShardsCoordinatorMock{},
 	})
 	feeComputer, _ := fee.NewFeeComputer(economicsData)
 	computer := fee.NewTestFeeComputer(feeComputer)
diff --git a/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go b/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go
index b81ad1e03b9..954f1919f53 100644
--- a/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go
+++ b/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go
@@ -27,6 +27,8 @@ func createEconomicsData(enableEpochsHandler common.EnableEpochsHandler) process
 		EnableEpochsHandler: enableEpochsHandler,
 		TxVersionChecker:    &testscommon.TxVersionCheckerStub{},
 		EpochNotifier:       &epochNotifier.EpochNotifierStub{},
+		PubkeyConverter:     &testscommon.PubkeyConverterStub{},
+		ShardCoordinator:    &testscommon.ShardsCoordinatorMock{},
 	})
 
 	return economicsData
diff --git a/node/node_test.go b/node/node_test.go
index 7c516e18a93..8fe4d6dc648 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -2214,7 +2214,7 @@ func TestCreateTransaction_SignatureLengthChecks(t *testing.T) {
 	coreComponents.VmMarsh = getMarshalizer()
 	coreComponents.TxMarsh = getMarshalizer()
 	coreComponents.Hash = getHasher()
-	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerStub{
+	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			str := strings.Repeat("1", maxValueLength)
 			bi := big.NewInt(0)
@@ -2284,7 +2284,7 @@ func TestCreateTransaction_SenderLengthChecks(t *testing.T) {
 	coreComponents.ChainIdCalled = func() string {
 		return chainID
 	}
-	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerStub{
+	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			str := strings.Repeat("1", maxLength)
 			bi := big.NewInt(0)
@@ -2345,7 +2345,7 @@ func TestCreateTransaction_ReceiverLengthChecks(t *testing.T) {
 	coreComponents.ChainIdCalled = func() string {
 		return chainID
 	}
-	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerStub{
+	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			str := strings.Repeat("1", maxLength)
 			bi := big.NewInt(0)
@@ -2405,7 +2405,7 @@ func TestCreateTransaction_TooBigSenderUsernameShouldErr(t *testing.T) {
 	coreComponents.ChainIdCalled = func() string {
 		return chainID
 	}
-	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerStub{
+	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			str := strings.Repeat("1", maxLength)
 			bi := big.NewInt(0)
@@ -2458,7 +2458,7 @@ func TestCreateTransaction_TooBigReceiverUsernameShouldErr(t *testing.T) {
 	coreComponents.ChainIdCalled = func() string {
 		return chainID
 	}
-	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerStub{
+	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			str := strings.Repeat("1", maxLength)
 			bi := big.NewInt(0)
@@ -2511,7 +2511,7 @@ func TestCreateTransaction_DataFieldSizeExceedsMaxShouldErr(t *testing.T) {
 	coreComponents.ChainIdCalled = func() string {
 		return chainID
 	}
-	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerStub{
+	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			str := strings.Repeat("1", maxLength)
 			bi := big.NewInt(0)
@@ -2564,7 +2564,7 @@ func TestCreateTransaction_TooLargeValueFieldShouldErr(t *testing.T) {
 	coreComponents.ChainIdCalled = func() string {
 		return chainID
 	}
-	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerStub{
+	coreComponents.EconomicsHandler = &economicsmocks.EconomicsHandlerMock{
 		GenesisTotalSupplyCalled: func() *big.Int {
 			str := strings.Repeat("1", maxLength)
 			bi := big.NewInt(0)
@@ -2875,7 +2875,7 @@ func TestCreateTransaction_TxSignedWithHashShouldErrVersionShoudBe2(t *testing.T
 		return chainID
 	}
 
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return nil
 		},
@@ -2965,7 +2965,7 @@ func TestCreateTransaction_TxSignedWithHashNoEnabledShouldErr(t *testing.T) {
 		},
 	}
 
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return nil
 		},
diff --git a/outport/process/transactionsfee/transactionsFeeProcessor_test.go b/outport/process/transactionsfee/transactionsFeeProcessor_test.go
index 2aa399a26fe..d4801d88208 100644
--- a/outport/process/transactionsfee/transactionsFeeProcessor_test.go
+++ b/outport/process/transactionsfee/transactionsFeeProcessor_test.go
@@ -32,6 +32,8 @@ func createEconomicsData(enableEpochsHandler common.EnableEpochsHandler) process
 		EnableEpochsHandler: enableEpochsHandler,
 		TxVersionChecker:    &testscommon.TxVersionCheckerStub{},
 		EpochNotifier:       &epochNotifier.EpochNotifierStub{},
+		PubkeyConverter:     &testscommon.PubkeyConverterStub{},
+		ShardCoordinator:    &testscommon.ShardsCoordinatorMock{},
 	})
 
 	return economicsData
diff --git a/process/block/baseProcess_test.go b/process/block/baseProcess_test.go
index f88d7e8d667..c52c5bece52 100644
--- a/process/block/baseProcess_test.go
+++ b/process/block/baseProcess_test.go
@@ -448,7 +448,7 @@ func createMockTransactionCoordinatorArguments(
 		FeeHandler:                   &mock.FeeAccumulatorStub{},
 		BlockSizeComputation:         &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:           &testscommon.BalanceComputationStub{},
-		EconomicsFee:                 &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:                 &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:                &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor:     &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler:          enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
diff --git a/process/block/metablock.go b/process/block/metablock.go
index fb53f1207d7..56c90a33e84 100644
--- a/process/block/metablock.go
+++ b/process/block/metablock.go
@@ -2108,7 +2108,7 @@ func (mp *metaProcessor) computeAccumulatedFeesInEpoch(metaHdr data.MetaHeaderHa
 		"meta nonce", metaHdr.GetNonce(),
 		"accumulatedFees", metaHdr.GetAccumulatedFees().String(),
 		"devFees", metaHdr.GetDeveloperFees().String(),
-		"meta leader fees", core.GetIntTrimmedPercentageOfValue(big.NewInt(0).Sub(metaHdr.GetAccumulatedFees(), metaHdr.GetDeveloperFees()), mp.economicsData.LeaderPercentage()).String())
+		"meta leader fees", core.GetIntTrimmedPercentageOfValue(big.NewInt(0).Sub(metaHdr.GetAccumulatedFees(), metaHdr.GetDeveloperFees()), mp.economicsData.LeaderPercentageInEpoch(metaHdr.GetEpoch())).String())
 
 	for _, shardData := range metaHdr.GetShardInfoHandlers() {
 		log.Debug("computeAccumulatedFeesInEpoch - adding shard data fees",
@@ -2116,7 +2116,7 @@ func (mp *metaProcessor) computeAccumulatedFeesInEpoch(metaHdr data.MetaHeaderHa
 			"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.LeaderPercentage()).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())
diff --git a/process/block/postprocess/intermediateResults_test.go b/process/block/postprocess/intermediateResults_test.go
index 9ef1f6d0358..40b5beae955 100644
--- a/process/block/postprocess/intermediateResults_test.go
+++ b/process/block/postprocess/intermediateResults_test.go
@@ -43,7 +43,7 @@ func createMockArgsNewIntermediateResultsProcessor() ArgsNewIntermediateResultsP
 		Store:                   &storage.ChainStorerStub{},
 		BlockType:               block.SmartContractResultBlock,
 		CurrTxs:                 &mock.TxForCurrentBlockStub{},
-		EconomicsFee:            &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:            &economicsmocks.EconomicsHandlerMock{},
 		EnableEpochsHandler:     enableEpochsHandlerMock.NewEnableEpochsHandlerStub(common.KeepExecOrderOnCreatedSCRsFlag),
 		TxExecutionOrderHandler: &txExecOrderStub.TxExecutionOrderHandlerStub{},
 	}
@@ -286,8 +286,8 @@ func TestIntermediateResultsProcessor_AddIntermediateTransactionsShardIdMismatch
 	}
 	args := createMockArgsNewIntermediateResultsProcessor()
 	args.Coordinator = shardC
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return maxGasLimitPerBlock
 		},
 	}
@@ -347,8 +347,8 @@ func TestIntermediateResultsProcessor_AddIntermediateTransactionsAddrGood(t *tes
 	nrShards := 5
 	args := createMockArgsNewIntermediateResultsProcessor()
 	args.Coordinator = mock.NewMultiShardsCoordinatorMock(uint32(nrShards))
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return maxGasLimitPerBlock
 		},
 	}
@@ -424,8 +424,8 @@ func TestIntermediateResultsProcessor_CreateAllInterMiniBlocksNothingInCache(t *
 	nrShards := 5
 	args := createMockArgsNewIntermediateResultsProcessor()
 	args.Coordinator = mock.NewMultiShardsCoordinatorMock(uint32(nrShards))
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return maxGasLimitPerBlock
 		},
 	}
@@ -444,8 +444,8 @@ func TestIntermediateResultsProcessor_CreateAllInterMiniBlocksNotCrossShard(t *t
 	nrShards := 5
 	args := createMockArgsNewIntermediateResultsProcessor()
 	args.Coordinator = mock.NewMultiShardsCoordinatorMock(uint32(nrShards))
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return maxGasLimitPerBlock
 		},
 	}
@@ -476,8 +476,8 @@ func TestIntermediateResultsProcessor_CreateAllInterMiniBlocksCrossShard(t *test
 	shardCoordinator := mock.NewMultiShardsCoordinatorMock(uint32(nrShards))
 	args := createMockArgsNewIntermediateResultsProcessor()
 	args.Coordinator = shardCoordinator
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return maxGasLimitPerBlock
 		},
 	}
@@ -616,8 +616,8 @@ func TestIntermediateResultsProcessor_VerifyInterMiniBlocksBodyMiniBlockMissmatc
 	shardCoordinator := mock.NewMultiShardsCoordinatorMock(uint32(nrShards))
 	args := createMockArgsNewIntermediateResultsProcessor()
 	args.Coordinator = shardCoordinator
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return maxGasLimitPerBlock
 		},
 	}
@@ -660,8 +660,8 @@ func TestIntermediateResultsProcessor_VerifyInterMiniBlocksBodyShouldPass(t *tes
 	shardCoordinator := mock.NewMultiShardsCoordinatorMock(uint32(nrShards))
 	args := createMockArgsNewIntermediateResultsProcessor()
 	args.Coordinator = shardCoordinator
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return maxGasLimitPerBlock
 		},
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
@@ -910,7 +910,7 @@ func TestIntermediateResultsProcessor_SplitMiniBlocksIfNeededShouldWork(t *testi
 	args.Coordinator = shardCoordinator
 	args.Hasher = hasher
 	args.Marshalizer = marshalizer
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerMiniBlockForSafeCrossShardCalled: func() uint64 {
 			return gasLimit
 		},
diff --git a/process/block/postprocess/oneMBPostProcessor_test.go b/process/block/postprocess/oneMBPostProcessor_test.go
index 236f457198e..5cb2a7424fc 100644
--- a/process/block/postprocess/oneMBPostProcessor_test.go
+++ b/process/block/postprocess/oneMBPostProcessor_test.go
@@ -29,7 +29,7 @@ func TestNewOneMBPostProcessor_NilHasher(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	assert.Nil(t, irp)
@@ -46,7 +46,7 @@ func TestNewOneMBPostProcessor_NilMarshalizer(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	assert.Nil(t, irp)
@@ -63,7 +63,7 @@ func TestNewOneMBPostProcessor_NilShardCoord(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	assert.Nil(t, irp)
@@ -80,7 +80,7 @@ func TestNewOneMBPostProcessor_NilStorer(t *testing.T) {
 		nil,
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	assert.Nil(t, irp)
@@ -114,7 +114,7 @@ func TestNewOneMBPostProcessor_OK(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	assert.Nil(t, err)
@@ -131,7 +131,7 @@ func TestOneMBPostProcessor_CreateAllInterMiniBlocks(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	mbs := irp.CreateAllInterMiniBlocks()
@@ -148,7 +148,7 @@ func TestOneMBPostProcessor_CreateAllInterMiniBlocksOneMinBlock(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	txs := make([]data.TransactionHandler, 0)
@@ -174,7 +174,7 @@ func TestOneMBPostProcessor_VerifyNilBody(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	err := irp.VerifyInterMiniBlocks(&block.Body{})
@@ -191,7 +191,7 @@ func TestOneMBPostProcessor_VerifyTooManyBlock(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	txs := make([]data.TransactionHandler, 0)
@@ -236,7 +236,7 @@ func TestOneMBPostProcessor_VerifyNilMiniBlocks(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	miniBlock := &block.MiniBlock{
@@ -260,7 +260,7 @@ func TestOneMBPostProcessor_VerifyOk(t *testing.T) {
 		&storage.ChainStorerStub{},
 		block.TxBlock,
 		dataRetriever.TransactionUnit,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 	)
 
 	txs := make([]data.TransactionHandler, 0)
diff --git a/process/block/preprocess/gasComputation_test.go b/process/block/preprocess/gasComputation_test.go
index f60a7455fa6..c601570b21d 100644
--- a/process/block/preprocess/gasComputation_test.go
+++ b/process/block/preprocess/gasComputation_test.go
@@ -40,7 +40,7 @@ func TestNewGasComputation_NilEnableEpochsHandlerShouldErr(t *testing.T) {
 	t.Parallel()
 
 	gc, err := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		nil,
 	)
@@ -53,7 +53,7 @@ func TestNewGasComputation_InvalidEnableEpochsHandlerShouldErr(t *testing.T) {
 	t.Parallel()
 
 	gc, err := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		enableEpochsHandlerMock.NewEnableEpochsHandlerStubWithNoFlagsDefined(),
 	)
@@ -66,7 +66,7 @@ func TestNewGasComputation_ShouldWork(t *testing.T) {
 	t.Parallel()
 
 	gc, err := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		createEnableEpochsHandler(),
 	)
@@ -79,7 +79,7 @@ func TestGasProvided_ShouldWork(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		createEnableEpochsHandler(),
 	)
@@ -111,7 +111,7 @@ func TestGasRefunded_ShouldWork(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		createEnableEpochsHandler(),
 	)
@@ -143,7 +143,7 @@ func TestGasPenalized_ShouldWork(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		createEnableEpochsHandler(),
 	)
@@ -175,7 +175,7 @@ func TestComputeGasProvidedByTx_ShouldErrWrongTypeAssertion(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		createEnableEpochsHandler(),
 	)
@@ -188,7 +188,7 @@ func TestComputeGasProvidedByTx_ShouldWorkWhenTxReceiverAddressIsNotASmartContra
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -208,7 +208,7 @@ func TestComputeGasProvidedByTx_ShouldWorkWhenTxReceiverAddressIsASmartContractI
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -231,7 +231,7 @@ func TestComputeGasProvidedByTx_ShouldWorkWhenTxReceiverAddressIsASmartContractC
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -254,7 +254,7 @@ func TestComputeGasProvidedByTx_ShouldReturnZeroIf0GasLimit(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -277,7 +277,7 @@ func TestComputeGasProvidedByTx_ShouldReturnGasLimitIfLessThanMoveBalance(t *tes
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -300,7 +300,7 @@ func TestComputeGasProvidedByTx_ShouldReturnGasLimitWhenRelayed(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 0
 			},
@@ -323,7 +323,7 @@ func TestComputeGasProvidedByTx_ShouldReturnGasLimitWhenRelayedV2(t *testing.T)
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 0
 			},
@@ -346,7 +346,7 @@ func TestComputeGasProvidedByMiniBlock_ShouldErrMissingTransaction(t *testing.T)
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -375,7 +375,7 @@ func TestComputeGasProvidedByMiniBlock_ShouldReturnZeroWhenOneTxIsMissing(t *tes
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -407,7 +407,7 @@ func TestComputeGasProvidedByMiniBlock_ShouldWork(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -447,7 +447,7 @@ func TestComputeGasProvidedByMiniBlock_ShouldWorkV1(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -487,7 +487,7 @@ func TestComputeGasProvidedByTx_ShouldWorkWhenTxReceiverAddressIsNotASmartContra
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -507,7 +507,7 @@ func TestComputeGasProvidedByTx_ShouldWorkWhenTxReceiverAddressIsASmartContractI
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -530,7 +530,7 @@ func TestComputeGasProvidedByTx_ShouldWorkWhenTxReceiverAddressIsASmartContractC
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 6
 			},
@@ -553,7 +553,7 @@ func TestReset_ShouldWork(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		createEnableEpochsHandler(),
 	)
@@ -590,7 +590,7 @@ func TestRestoreGasSinceLastReset_ShouldWork(t *testing.T) {
 	t.Parallel()
 
 	gc, _ := preprocess.NewGasComputation(
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.TxTypeHandlerMock{},
 		createEnableEpochsHandler(),
 	)
diff --git a/process/block/preprocess/gasTracker_test.go b/process/block/preprocess/gasTracker_test.go
index 6f75da4aaa3..d02d28ce5a4 100644
--- a/process/block/preprocess/gasTracker_test.go
+++ b/process/block/preprocess/gasTracker_test.go
@@ -64,13 +64,19 @@ func createDefaultGasTracker(
 	shardCoordinator := &testscommon.ShardsCoordinatorMock{
 		CurrentShard: selfShardID,
 	}
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(shardID uint32) uint64 {
 			return 1500000000
 		},
 		ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 			return moveBalanceGas(tx.GetData())
 		},
+		MaxGasLimitPerTxCalled: func() uint64 {
+			return 1000000
+		},
+		MaxGasLimitPerBlockForSafeCrossShardCalled: func() uint64 {
+			return 1000000
+		},
 	}
 
 	gasHandler := &testscommon.GasHandlerStub{
diff --git a/process/block/preprocess/miniBlockBuilder_test.go b/process/block/preprocess/miniBlockBuilder_test.go
index 3ba49aa00a3..7b73c77fead 100644
--- a/process/block/preprocess/miniBlockBuilder_test.go
+++ b/process/block/preprocess/miniBlockBuilder_test.go
@@ -837,7 +837,17 @@ func createDefaultMiniBlockBuilderArgs() miniBlocksBuilderArgs {
 					return 0
 				},
 			},
-			economicsFee: &economicsmocks.EconomicsHandlerStub{},
+			economicsFee: &economicsmocks.EconomicsHandlerMock{
+				MaxGasLimitPerTxCalled: func() uint64 {
+					return 1000000
+				},
+				MaxGasLimitPerBlockForSafeCrossShardCalled: func() uint64 {
+					return 1000000
+				},
+				MaxGasLimitPerBlockCalled: func(shardID uint32) uint64 {
+					return 1000000
+				},
+			},
 			gasHandler: &testscommon.GasHandlerStub{
 				RemoveGasProvidedCalled: func(hashes [][]byte) {
 				},
diff --git a/process/block/preprocess/transactionsV2_test.go b/process/block/preprocess/transactionsV2_test.go
index 1c86454ddda..40ec747963d 100644
--- a/process/block/preprocess/transactionsV2_test.go
+++ b/process/block/preprocess/transactionsV2_test.go
@@ -37,7 +37,7 @@ func createTransactionPreprocessor() *transactions {
 		ShardCoordinator:     mock.NewMultiShardsCoordinatorMock(3),
 		Accounts:             &stateMock.AccountsStub{},
 		OnRequestTransaction: requestTransaction,
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerMiniBlockForSafeCrossShardCalled: func() uint64 {
 				return MaxGasLimitPerBlock
 			},
diff --git a/process/block/preprocess/transactions_test.go b/process/block/preprocess/transactions_test.go
index cf1bcca2ec8..193e08de309 100644
--- a/process/block/preprocess/transactions_test.go
+++ b/process/block/preprocess/transactions_test.go
@@ -52,15 +52,15 @@ type txInfoHolder struct {
 	tx   *transaction.Transaction
 }
 
-func feeHandlerMock() *economicsmocks.EconomicsHandlerStub {
-	return &economicsmocks.EconomicsHandlerStub{
+func feeHandlerMock() *economicsmocks.EconomicsHandlerMock {
+	return &economicsmocks.EconomicsHandlerMock{
 		ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 			return 0
 		},
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return MaxGasLimitPerBlock
 		},
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return MaxGasLimitPerBlock
 		},
 		MaxGasLimitPerBlockForSafeCrossShardCalled: func() uint64 {
@@ -1398,7 +1398,7 @@ func TestTransactionsPreprocessor_ComputeGasProvidedShouldWork(t *testing.T) {
 	txGasLimitInSender := maxGasLimit + 1
 	txGasLimitInReceiver := maxGasLimit
 	args := createDefaultTransactionsProcessorArgs()
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return maxGasLimit
 		},
@@ -1444,7 +1444,7 @@ func TestTransactionsPreprocessor_SplitMiniBlocksIfNeededShouldWork(t *testing.T
 	args := createDefaultTransactionsProcessorArgs()
 	enableEpochsHandlerStub := enableEpochsHandlerMock.NewEnableEpochsHandlerStub()
 	args.EnableEpochsHandler = enableEpochsHandlerStub
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerMiniBlockForSafeCrossShardCalled: func() uint64 {
 			return gasLimitPerMiniBlock
 		},
@@ -1512,7 +1512,7 @@ func TestTransactionsPreProcessor_preFilterTransactionsNoBandwidth(t *testing.T)
 			return txHandler.GetGasLimit(), txHandler.GetGasLimit(), nil
 		},
 	}
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		MinGasLimitCalled: func() uint64 {
 			return 10
 		},
@@ -1562,7 +1562,7 @@ func TestTransactionsPreProcessor_preFilterTransactionsLimitedBandwidthMultipleT
 			return txHandler.GetGasLimit(), txHandler.GetGasLimit(), nil
 		},
 	}
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		MinGasLimitCalled: func() uint64 {
 			return 10
 		},
@@ -1623,7 +1623,7 @@ func TestTransactionsPreProcessor_preFilterTransactionsLimitedBandwidthMultipleT
 			return txHandler.GetGasLimit(), txHandler.GetGasLimit(), nil
 		},
 	}
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		MinGasLimitCalled: func() uint64 {
 			return 10
 		},
@@ -1692,7 +1692,7 @@ func TestTransactionsPreProcessor_preFilterTransactionsHighBandwidth(t *testing.
 			return txHandler.GetGasLimit(), txHandler.GetGasLimit(), nil
 		},
 	}
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		MinGasLimitCalled: func() uint64 {
 			return 10
 		},
@@ -1752,7 +1752,7 @@ func TestTransactionsPreProcessor_getRemainingGasPerBlock(t *testing.T) {
 			return totalGasProvided
 		},
 	}
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(shardID uint32) uint64 {
 			return maxGasPerBlock
 		},
@@ -1782,7 +1782,7 @@ func TestTransactionsPreProcessor_getRemainingGasPerBlockAsScheduled(t *testing.
 			return totalGasProvided
 		},
 	}
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(shardID uint32) uint64 {
 			return maxGasPerBlock
 		},
diff --git a/process/block/shardblock_test.go b/process/block/shardblock_test.go
index d029b44e65b..f6caf783286 100644
--- a/process/block/shardblock_test.go
+++ b/process/block/shardblock_test.go
@@ -451,7 +451,7 @@ func TestShardProcessor_ProcessBlockWithInvalidTransactionShouldErr(t *testing.T
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 0
 			},
@@ -673,7 +673,7 @@ func TestShardProcessor_ProcessBlockWithErrOnProcessBlockTransactionsCallShouldR
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 0
 			},
@@ -2586,7 +2586,7 @@ func TestShardProcessor_MarshalizedDataToBroadcastShouldWork(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -2695,7 +2695,7 @@ func TestShardProcessor_MarshalizedDataMarshalWithoutSuccess(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -3075,7 +3075,7 @@ func TestShardProcessor_CreateMiniBlocksShouldWorkWithIntraShardTxs(t *testing.T
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 0
 			},
@@ -3278,7 +3278,7 @@ func TestShardProcessor_RestoreBlockIntoPoolsShouldWork(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
diff --git a/process/coordinator/process_test.go b/process/coordinator/process_test.go
index 344a5f8bf7d..5bdd8e086b1 100644
--- a/process/coordinator/process_test.go
+++ b/process/coordinator/process_test.go
@@ -51,15 +51,15 @@ const MaxGasLimitPerBlock = uint64(100000)
 
 var txHash = []byte("tx_hash1")
 
-func FeeHandlerMock() *economicsmocks.EconomicsHandlerStub {
-	return &economicsmocks.EconomicsHandlerStub{
+func FeeHandlerMock() *economicsmocks.EconomicsHandlerMock {
+	return &economicsmocks.EconomicsHandlerMock{
 		ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 			return 0
 		},
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return MaxGasLimitPerBlock
 		},
-		MaxGasLimitPerMiniBlockCalled: func() uint64 {
+		MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 			return MaxGasLimitPerBlock
 		},
 		MaxGasLimitPerBlockForSafeCrossShardCalled: func() uint64 {
@@ -239,7 +239,7 @@ func createMockTransactionCoordinatorArguments() ArgTransactionCoordinator {
 		FeeHandler:                   &mock.FeeAccumulatorStub{},
 		BlockSizeComputation:         &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:           &testscommon.BalanceComputationStub{},
-		EconomicsFee:                 &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:                 &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:                &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor:     &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler:          enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
@@ -574,7 +574,7 @@ func createInterimProcessorContainer() process.IntermediateProcessorContainer {
 		PubkeyConverter:         createMockPubkeyConverter(),
 		Store:                   initStore(),
 		PoolsHolder:             initDataPool([]byte("test_hash1")),
-		EconomicsFee:            &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:            &economicsmocks.EconomicsHandlerMock{},
 		EnableEpochsHandler:     enableEpochsHandlerMock.NewEnableEpochsHandlerStub(common.KeepExecOrderOnCreatedSCRsFlag),
 		TxExecutionOrderHandler: &commonMock.TxExecutionOrderHandlerStub{},
 	}
@@ -1417,7 +1417,7 @@ func TestTransactionCoordinator_CreateMbsAndProcessTransactionsFromMeMultipleMin
 	argsTransactionCoordinator.MiniBlockPool = tdp.MiniBlocks()
 	argsTransactionCoordinator.PreProcessors = createPreProcessorContainerWithDataPool(
 		tdp,
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return MaxGasLimitPerBlock
 			},
@@ -1488,7 +1488,7 @@ func TestTransactionCoordinator_CompactAndExpandMiniblocksShouldWork(t *testing.
 	argsTransactionCoordinator.MiniBlockPool = tdp.MiniBlocks()
 	argsTransactionCoordinator.PreProcessors = createPreProcessorContainerWithDataPool(
 		tdp,
-		&economicsmocks.EconomicsHandlerStub{
+		&economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return MaxGasLimitPerBlock
 			},
@@ -2265,7 +2265,7 @@ func TestTransactionCoordinator_VerifyCreatedBlockTransactionsNilOrMiss(t *testi
 		PubkeyConverter:         createMockPubkeyConverter(),
 		Store:                   &storageStubs.ChainStorerStub{},
 		PoolsHolder:             tdp,
-		EconomicsFee:            &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:            &economicsmocks.EconomicsHandlerMock{},
 		EnableEpochsHandler:     enableEpochsHandlerMock.NewEnableEpochsHandlerStub(common.KeepExecOrderOnCreatedSCRsFlag),
 		TxExecutionOrderHandler: &commonMock.TxExecutionOrderHandlerStub{},
 	}
@@ -2322,7 +2322,7 @@ func TestTransactionCoordinator_VerifyCreatedBlockTransactionsOk(t *testing.T) {
 		PubkeyConverter:  createMockPubkeyConverter(),
 		Store:            &storageStubs.ChainStorerStub{},
 		PoolsHolder:      tdp,
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return MaxGasLimitPerBlock
 			},
@@ -2646,7 +2646,7 @@ func TestTransactionCoordinator_VerifyCreatedMiniBlocksShouldReturnWhenEpochIsNo
 		FeeHandler:               &mock.FeeAccumulatorStub{},
 		BlockSizeComputation:     &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:       &testscommon.BalanceComputationStub{},
-		EconomicsFee:             &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:             &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:            &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor: &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler: &enableEpochsHandlerMock.EnableEpochsHandlerStub{
@@ -2693,14 +2693,14 @@ func TestTransactionCoordinator_VerifyCreatedMiniBlocksShouldErrMaxGasLimitPerMi
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return maxGasLimitPerBlock + 1
 			},
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return maxGasLimitPerBlock
 			},
-			MaxGasLimitPerMiniBlockCalled: func() uint64 {
+			MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 				return maxGasLimitPerBlock
 			},
 		},
@@ -2761,7 +2761,7 @@ func TestTransactionCoordinator_VerifyCreatedMiniBlocksShouldErrMaxAccumulatedFe
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return maxGasLimitPerBlock
 			},
@@ -2840,7 +2840,7 @@ func TestTransactionCoordinator_VerifyCreatedMiniBlocksShouldErrMaxDeveloperFees
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return maxGasLimitPerBlock
 			},
@@ -2919,7 +2919,7 @@ func TestTransactionCoordinator_VerifyCreatedMiniBlocksShouldWork(t *testing.T)
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return maxGasLimitPerBlock
 			},
@@ -2997,7 +2997,7 @@ func TestTransactionCoordinator_GetAllTransactionsShouldWork(t *testing.T) {
 		FeeHandler:                   &mock.FeeAccumulatorStub{},
 		BlockSizeComputation:         &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:           &testscommon.BalanceComputationStub{},
-		EconomicsFee:                 &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:                 &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:                &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor:     &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler:          enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
@@ -3072,11 +3072,11 @@ func TestTransactionCoordinator_VerifyGasLimitShouldErrMaxGasLimitPerMiniBlockIn
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return tx1GasLimit + tx2GasLimit + tx3GasLimit - 1
 			},
-			MaxGasLimitPerMiniBlockCalled: func() uint64 {
+			MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 				return tx1GasLimit + tx2GasLimit + tx3GasLimit - 1
 			},
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
@@ -3167,7 +3167,7 @@ func TestTransactionCoordinator_VerifyGasLimitShouldWork(t *testing.T) {
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return tx1GasLimit + tx2GasLimit + tx3GasLimit
 			},
@@ -3258,7 +3258,7 @@ func TestTransactionCoordinator_CheckGasProvidedByMiniBlockInReceiverShardShould
 		FeeHandler:                   &mock.FeeAccumulatorStub{},
 		BlockSizeComputation:         &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:           &testscommon.BalanceComputationStub{},
-		EconomicsFee:                 &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:                 &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:                &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor:     &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler:          enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
@@ -3302,7 +3302,7 @@ func TestTransactionCoordinator_CheckGasProvidedByMiniBlockInReceiverShardShould
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return tx.GetGasLimit() + 1
 			},
@@ -3361,7 +3361,7 @@ func TestTransactionCoordinator_CheckGasProvidedByMiniBlockInReceiverShardShould
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return 0
 			},
@@ -3425,11 +3425,11 @@ func TestTransactionCoordinator_CheckGasProvidedByMiniBlockInReceiverShardShould
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return tx1GasLimit + tx2GasLimit + tx3GasLimit - 1
 			},
-			MaxGasLimitPerMiniBlockCalled: func() uint64 {
+			MaxGasLimitPerMiniBlockCalled: func(shardID uint32) uint64 {
 				return tx1GasLimit + tx2GasLimit + tx3GasLimit - 1
 			},
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
@@ -3494,7 +3494,7 @@ func TestTransactionCoordinator_CheckGasProvidedByMiniBlockInReceiverShardShould
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return tx1GasLimit + tx2GasLimit + tx3GasLimit
 			},
@@ -3560,7 +3560,7 @@ func TestTransactionCoordinator_VerifyFeesShouldErrMissingTransaction(t *testing
 		FeeHandler:                   &mock.FeeAccumulatorStub{},
 		BlockSizeComputation:         &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:           &testscommon.BalanceComputationStub{},
-		EconomicsFee:                 &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:                 &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:                &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor:     &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler:          enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
@@ -3617,7 +3617,7 @@ func TestTransactionCoordinator_VerifyFeesShouldErrMaxAccumulatedFeesExceeded(t
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.1
 			},
@@ -3688,7 +3688,7 @@ func TestTransactionCoordinator_VerifyFeesShouldErrMaxDeveloperFeesExceeded(t *t
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.1
 			},
@@ -3760,7 +3760,7 @@ func TestTransactionCoordinator_VerifyFeesShouldErrMaxAccumulatedFeesExceededWhe
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.1
 			},
@@ -3846,7 +3846,7 @@ func TestTransactionCoordinator_VerifyFeesShouldErrMaxDeveloperFeesExceededWhenS
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.1
 			},
@@ -3932,7 +3932,7 @@ func TestTransactionCoordinator_VerifyFeesShouldWork(t *testing.T) {
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.1
 			},
@@ -4021,7 +4021,7 @@ func TestTransactionCoordinator_GetMaxAccumulatedAndDeveloperFeesShouldErr(t *te
 		FeeHandler:                   &mock.FeeAccumulatorStub{},
 		BlockSizeComputation:         &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:           &testscommon.BalanceComputationStub{},
-		EconomicsFee:                 &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:                 &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:                &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor:     &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler:          enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
@@ -4075,7 +4075,7 @@ func TestTransactionCoordinator_GetMaxAccumulatedAndDeveloperFeesShouldWork(t *t
 		FeeHandler:           &mock.FeeAccumulatorStub{},
 		BlockSizeComputation: &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:   &testscommon.BalanceComputationStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.1
 			},
@@ -4151,7 +4151,7 @@ func TestTransactionCoordinator_RevertIfNeededShouldWork(t *testing.T) {
 		},
 		BlockSizeComputation:         &testscommon.BlockSizeComputationStub{},
 		BalanceComputation:           &testscommon.BalanceComputationStub{},
-		EconomicsFee:                 &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:                 &economicsmocks.EconomicsHandlerMock{},
 		TxTypeHandler:                &testscommon.TxTypeHandlerMock{},
 		TransactionsLogProcessor:     &mock.TxLogsProcessorStub{},
 		EnableEpochsHandler:          enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
diff --git a/process/economics/economicsData.go b/process/economics/economicsData.go
index 84e161ef86f..84ca9cd22ef 100644
--- a/process/economics/economicsData.go
+++ b/process/economics/economicsData.go
@@ -13,6 +13,7 @@ import (
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/process"
+	"github.com/multiversx/mx-chain-go/sharding"
 	"github.com/multiversx/mx-chain-go/statusHandler"
 	logger "github.com/multiversx/mx-chain-logger-go"
 )
@@ -43,6 +44,8 @@ type ArgsNewEconomicsData struct {
 	Economics           *config.EconomicsConfig
 	EpochNotifier       process.EpochNotifier
 	EnableEpochsHandler common.EnableEpochsHandler
+	PubkeyConverter     core.PubkeyConverter
+	ShardCoordinator    sharding.Coordinator
 }
 
 // NewEconomicsData will create an object with information about economics parameters
@@ -56,6 +59,12 @@ func NewEconomicsData(args ArgsNewEconomicsData) (*economicsData, error) {
 	if check.IfNil(args.EnableEpochsHandler) {
 		return nil, process.ErrNilEnableEpochsHandler
 	}
+	if check.IfNil(args.PubkeyConverter) {
+		return nil, process.ErrNilPubkeyConverter
+	}
+	if check.IfNil(args.ShardCoordinator) {
+		return nil, process.ErrNilShardCoordinator
+	}
 	err := core.CheckHandlerCompatibility(args.EnableEpochsHandler, []core.EnableEpochFlag{
 		common.GasPriceModifierFlag,
 		common.PenalizedTooMuchGasFlag,
@@ -90,7 +99,7 @@ func NewEconomicsData(args ArgsNewEconomicsData) (*economicsData, error) {
 		return nil, err
 	}
 
-	ed.rewardsConfigHandler, err = newRewardsConfigHandler(args.Economics.RewardsSettings)
+	ed.rewardsConfigHandler, err = newRewardsConfigHandler(args.Economics.RewardsSettings, args.PubkeyConverter, args.ShardCoordinator)
 	if err != nil {
 		return nil, err
 	}
@@ -449,13 +458,13 @@ func (ed *economicsData) ProtocolSustainabilityPercentageInEpoch(epoch uint32) f
 	return ed.getProtocolSustainabilityPercentage(epoch)
 }
 
-// ProtocolSustainabilityAddress returns the protocol sustainability address
+// ProtocolSustainabilityAddress returns the decoded protocol sustainability address
 func (ed *economicsData) ProtocolSustainabilityAddress() string {
 	currentEpoch := ed.enableEpochsHandler.GetCurrentEpoch()
 	return ed.ProtocolSustainabilityAddressInEpoch(currentEpoch)
 }
 
-// ProtocolSustainabilityAddressInEpoch returns the protocol sustainability address in a specific epoch
+// ProtocolSustainabilityAddressInEpoch returns the decoded protocol sustainability address in a specific epoch
 func (ed *economicsData) ProtocolSustainabilityAddressInEpoch(epoch uint32) string {
 	return ed.getProtocolSustainabilityAddress(epoch)
 }
diff --git a/process/economics/economicsData_test.go b/process/economics/economicsData_test.go
index 1f2c913a826..6a09ee7ef50 100644
--- a/process/economics/economicsData_test.go
+++ b/process/economics/economicsData_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/multiversx/mx-chain-core-go/core"
+	"github.com/multiversx/mx-chain-core-go/core/pubkeyConverter"
 	"github.com/multiversx/mx-chain-core-go/data/smartContractResult"
 	"github.com/multiversx/mx-chain-core-go/data/transaction"
 	"github.com/multiversx/mx-chain-go/common"
@@ -16,6 +17,7 @@ import (
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/process"
 	"github.com/multiversx/mx-chain-go/process/economics"
+	"github.com/multiversx/mx-chain-go/sharding"
 	"github.com/multiversx/mx-chain-go/testscommon"
 	"github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock"
 	"github.com/multiversx/mx-chain-go/testscommon/epochNotifier"
@@ -95,6 +97,8 @@ func feeSettingsReal() config.FeeSettings {
 
 func createArgsForEconomicsData(gasModifier float64) economics.ArgsNewEconomicsData {
 	feeSettings := feeSettingsDummy(gasModifier)
+	pkConv, _ := pubkeyConverter.NewBech32PubkeyConverter(32, "erd")
+	shardC, _ := sharding.NewMultiShardCoordinator(2, 0)
 	args := economics.ArgsNewEconomicsData{
 		Economics:     createDummyEconomicsConfig(feeSettings),
 		EpochNotifier: &epochNotifier.EpochNotifierStub{},
@@ -104,12 +108,16 @@ func createArgsForEconomicsData(gasModifier float64) economics.ArgsNewEconomicsD
 			},
 		},
 		TxVersionChecker: &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:  pkConv,
+		ShardCoordinator: shardC,
 	}
 	return args
 }
 
 func createArgsForEconomicsDataRealFees() economics.ArgsNewEconomicsData {
 	feeSettings := feeSettingsReal()
+	pkConv, _ := pubkeyConverter.NewBech32PubkeyConverter(32, "erd")
+	shardC, _ := sharding.NewMultiShardCoordinator(2, 0)
 	args := economics.ArgsNewEconomicsData{
 		Economics:     createDummyEconomicsConfig(feeSettings),
 		EpochNotifier: &epochNotifier.EpochNotifierStub{},
@@ -119,6 +127,8 @@ func createArgsForEconomicsDataRealFees() economics.ArgsNewEconomicsData {
 			},
 		},
 		TxVersionChecker: &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:  pkConv,
+		ShardCoordinator: shardC,
 	}
 	return args
 }
@@ -560,6 +570,59 @@ func TestNewEconomicsData_InvalidEnableEpochsHandlerShouldErr(t *testing.T) {
 	assert.True(t, errors.Is(err, core.ErrInvalidEnableEpochsHandler))
 }
 
+func TestNewEconomicsData_NilPubkeyConverter(t *testing.T) {
+	t.Parallel()
+
+	args := createArgsForEconomicsData(1)
+	args.PubkeyConverter = nil
+
+	_, err := economics.NewEconomicsData(args)
+	require.Equal(t, process.ErrNilPubkeyConverter, err)
+}
+
+func TestNewEconomicsData_NilShardCoordinator(t *testing.T) {
+	t.Parallel()
+
+	args := createArgsForEconomicsData(1)
+	args.ShardCoordinator = nil
+
+	_, err := economics.NewEconomicsData(args)
+	require.Equal(t, process.ErrNilShardCoordinator, err)
+}
+
+func TestEconomicsData_InvalidProtocolSustainabilityAddressShouldError(t *testing.T) {
+
+	t.Run("empty address", func(t *testing.T) {
+		t.Parallel()
+
+		args := createArgsForEconomicsData(1)
+		args.Economics.RewardsSettings.RewardsConfigByEpoch[0].ProtocolSustainabilityAddress = ""
+
+		_, err := economics.NewEconomicsData(args)
+		require.Equal(t, process.ErrNilProtocolSustainabilityAddress, err)
+	})
+	t.Run("invalid address", func(t *testing.T) {
+		t.Parallel()
+
+		args := createArgsForEconomicsData(1)
+		args.Economics.RewardsSettings.RewardsConfigByEpoch[0].ProtocolSustainabilityAddress = "xyz" // not a hex string
+
+		_, err := economics.NewEconomicsData(args)
+		require.Error(t, err)
+	})
+	t.Run("meta address", func(t *testing.T) {
+		t.Parallel()
+
+		args := createArgsForEconomicsData(1)
+		// wrong configuration of staking system SC address (in metachain) as protocol sustainability address
+		metaAddress, _ := args.PubkeyConverter.Encode([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255})
+		args.Economics.RewardsSettings.RewardsConfigByEpoch[0].ProtocolSustainabilityAddress = metaAddress
+
+		_, err := economics.NewEconomicsData(args)
+		require.Equal(t, process.ErrProtocolSustainabilityAddressInMetachain, err)
+	})
+}
+
 func TestNewEconomicsData_ShouldWork(t *testing.T) {
 	t.Parallel()
 
@@ -576,7 +639,7 @@ func TestEconomicsData_LeaderPercentage(t *testing.T) {
 	args.Economics.RewardsSettings.RewardsConfigByEpoch[0].LeaderPercentage = leaderPercentage
 	economicsData, _ := economics.NewEconomicsData(args)
 
-	value := economicsData.LeaderPercentage()
+	value := economicsData.LeaderPercentageInEpoch(0)
 	assert.Equal(t, leaderPercentage, value)
 }
 
@@ -686,20 +749,22 @@ func TestEconomicsData_ConfirmedEpochRewardsSettingsChangeOrderedConfigs(t *test
 		},
 	}
 
+	expectedRS := getExpectedSettings(rs, args.PubkeyConverter)
+
 	args.Economics.RewardsSettings = config.RewardsSettings{RewardsConfigByEpoch: rs}
 	economicsData, _ := economics.NewEconomicsData(args)
 
 	rewardsActiveConfig := economicsData.GetRewardsActiveConfig(1)
 	require.NotNil(t, rewardsActiveConfig)
-	require.Equal(t, rs[0], *rewardsActiveConfig)
+	require.Equal(t, expectedRS[0], *rewardsActiveConfig)
 
 	rewardsActiveConfig = economicsData.GetRewardsActiveConfig(2)
 	require.NotNil(t, rewardsActiveConfig)
-	require.Equal(t, rs[0], *rewardsActiveConfig)
+	require.Equal(t, expectedRS[0], *rewardsActiveConfig)
 
 	rewardsActiveConfig = economicsData.GetRewardsActiveConfig(3)
 	require.NotNil(t, rewardsActiveConfig)
-	require.Equal(t, rs[1], *rewardsActiveConfig)
+	require.Equal(t, expectedRS[1], *rewardsActiveConfig)
 }
 
 func TestEconomicsData_ConfirmedGasLimitSettingsChangeOrderedConfigs(t *testing.T) {
@@ -769,21 +834,21 @@ func TestEconomicsData_ConfirmedEpochRewardsSettingsChangeUnOrderedConfigs(t *te
 			EpochEnable:                      0,
 		},
 	}
-
+	expectedRS := getExpectedSettings(rs, args.PubkeyConverter)
 	args.Economics.RewardsSettings = config.RewardsSettings{RewardsConfigByEpoch: rs}
 	economicsData, _ := economics.NewEconomicsData(args)
 
 	rewardsActiveConfig := economicsData.GetRewardsActiveConfig(1)
 	require.NotNil(t, rewardsActiveConfig)
-	require.Equal(t, rs[1], *rewardsActiveConfig)
+	require.Equal(t, expectedRS[1], *rewardsActiveConfig)
 
 	rewardsActiveConfig = economicsData.GetRewardsActiveConfig(2)
 	require.NotNil(t, rewardsActiveConfig)
-	require.Equal(t, rs[1], *rewardsActiveConfig)
+	require.Equal(t, expectedRS[1], *rewardsActiveConfig)
 
 	rewardsActiveConfig = economicsData.GetRewardsActiveConfig(3)
 	require.NotNil(t, rewardsActiveConfig)
-	require.Equal(t, rs[0], *rewardsActiveConfig)
+	require.Equal(t, expectedRS[0], *rewardsActiveConfig)
 }
 
 func TestEconomicsData_ConfirmedGasLimitSettingsChangeUnOrderedConfigs(t *testing.T) {
@@ -1582,7 +1647,7 @@ func TestEconomicsData_ProtocolSustainabilityPercentage(t *testing.T) {
 	args.Economics.RewardsSettings.RewardsConfigByEpoch[0].ProtocolSustainabilityPercentage = protocolSustainabilityPercentage
 	economicsData, _ := economics.NewEconomicsData(args)
 
-	value := economicsData.ProtocolSustainabilityPercentage()
+	value := economicsData.ProtocolSustainabilityPercentageInEpoch(0)
 	assert.Equal(t, protocolSustainabilityPercentage, value)
 }
 
@@ -1590,12 +1655,13 @@ func TestEconomicsData_ProtocolSustainabilityAddress(t *testing.T) {
 	t.Parallel()
 
 	args := createArgsForEconomicsData(1)
-	protocolSustainabilityAddress := "erd12345"
+	protocolSustainabilityAddress := "erd14uqxan5rgucsf6537ll4vpwyc96z7us5586xhc5euv8w96rsw95sfl6a49"
+	expectedAddress, _ := args.PubkeyConverter.Decode(protocolSustainabilityAddress)
 	args.Economics.RewardsSettings.RewardsConfigByEpoch[0].ProtocolSustainabilityAddress = protocolSustainabilityAddress
 	economicsData, _ := economics.NewEconomicsData(args)
 
 	value := economicsData.ProtocolSustainabilityAddress()
-	assert.Equal(t, protocolSustainabilityAddress, value)
+	assert.Equal(t, string(expectedAddress), value)
 }
 
 func TestEconomicsData_RewardsTopUpGradientPoint(t *testing.T) {
@@ -1621,3 +1687,22 @@ func TestEconomicsData_RewardsTopUpFactor(t *testing.T) {
 	value := economicsData.RewardsTopUpFactor()
 	assert.Equal(t, topUpFactor, value)
 }
+
+func getExpectedSettings(rs []config.EpochRewardSettings, pkConv core.PubkeyConverter) []config.EpochRewardSettings {
+	expectedRS := make([]config.EpochRewardSettings, 0, len(rs))
+	for _, rewardSettingsPerEpoch := range rs {
+		decodedAddr, _ := pkConv.Decode(rewardSettingsPerEpoch.ProtocolSustainabilityAddress)
+
+		expectedRS = append(expectedRS, config.EpochRewardSettings{
+			LeaderPercentage:                 rewardSettingsPerEpoch.LeaderPercentage,
+			DeveloperPercentage:              rewardSettingsPerEpoch.DeveloperPercentage,
+			ProtocolSustainabilityPercentage: rewardSettingsPerEpoch.ProtocolSustainabilityPercentage,
+			ProtocolSustainabilityAddress:    string(decodedAddr),
+			TopUpGradientPoint:               rewardSettingsPerEpoch.TopUpGradientPoint,
+			TopUpFactor:                      rewardSettingsPerEpoch.TopUpFactor,
+			EpochEnable:                      rewardSettingsPerEpoch.EpochEnable,
+		})
+	}
+
+	return expectedRS
+}
diff --git a/process/economics/rewardsConfigHandler.go b/process/economics/rewardsConfigHandler.go
index ed7096a4954..60a2dd93960 100644
--- a/process/economics/rewardsConfigHandler.go
+++ b/process/economics/rewardsConfigHandler.go
@@ -11,6 +11,7 @@ import (
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/process"
+	"github.com/multiversx/mx-chain-go/sharding"
 	"github.com/multiversx/mx-chain-go/statusHandler"
 )
 
@@ -31,8 +32,12 @@ type rewardsConfigHandler struct {
 }
 
 // newRewardsConfigHandler returns a new instance of rewardsConfigHandler
-func newRewardsConfigHandler(rewardsSettings config.RewardsSettings) (*rewardsConfigHandler, error) {
-	rewardsConfigSlice, err := checkAndParseRewardsSettings(rewardsSettings)
+func newRewardsConfigHandler(
+	rewardsSettings config.RewardsSettings,
+	pubkeyConverter core.PubkeyConverter,
+	shardCoordinator sharding.Coordinator,
+) (*rewardsConfigHandler, error) {
+	rewardsConfigSlice, err := checkAndParseRewardsSettings(rewardsSettings, pubkeyConverter, shardCoordinator)
 	if err != nil {
 		return nil, err
 	}
@@ -129,7 +134,11 @@ func (handler *rewardsConfigHandler) updateRewardsConfigMetrics(epoch uint32) {
 	)
 }
 
-func checkAndParseRewardsSettings(rewardsSettings config.RewardsSettings) ([]*rewardsConfig, error) {
+func checkAndParseRewardsSettings(
+	rewardsSettings config.RewardsSettings,
+	pubkeyConverter core.PubkeyConverter,
+	shardCoordinator sharding.Coordinator,
+) ([]*rewardsConfig, error) {
 	rewardsConfigSlice := make([]*rewardsConfig, 0, len(rewardsSettings.RewardsConfigByEpoch))
 	for _, rewardsCfg := range rewardsSettings.RewardsConfigByEpoch {
 		err := checkRewardConfig(rewardsCfg)
@@ -139,11 +148,26 @@ func checkAndParseRewardsSettings(rewardsSettings config.RewardsSettings) ([]*re
 
 		topUpGradientPoint, _ := big.NewInt(0).SetString(rewardsCfg.TopUpGradientPoint, 10)
 
+		decodedAddress, err := pubkeyConverter.Decode(rewardsCfg.ProtocolSustainabilityAddress)
+		if err != nil {
+			log.Warn("invalid protocol sustainability reward address",
+				"err", err,
+				"provided address", rewardsCfg.ProtocolSustainabilityAddress,
+				"epoch", rewardsCfg.EpochEnable,
+			)
+			return nil, err
+		}
+
+		protocolSustainabilityShardID := shardCoordinator.ComputeId(decodedAddress)
+		if protocolSustainabilityShardID == core.MetachainShardId {
+			return nil, process.ErrProtocolSustainabilityAddressInMetachain
+		}
+
 		rewardsConfigSlice = append(rewardsConfigSlice, &rewardsConfig{
 			rewardsSettingEpoch:              rewardsCfg.EpochEnable,
 			leaderPercentage:                 rewardsCfg.LeaderPercentage,
 			protocolSustainabilityPercentage: rewardsCfg.ProtocolSustainabilityPercentage,
-			protocolSustainabilityAddress:    rewardsCfg.ProtocolSustainabilityAddress,
+			protocolSustainabilityAddress:    string(decodedAddress),
 			developerPercentage:              rewardsCfg.DeveloperPercentage,
 			topUpGradientPoint:               topUpGradientPoint,
 			topUpFactor:                      rewardsCfg.TopUpFactor,
diff --git a/process/errors.go b/process/errors.go
index 2f58af09f46..7241933130f 100644
--- a/process/errors.go
+++ b/process/errors.go
@@ -1238,3 +1238,6 @@ var ErrRelayedByGuardianNotAllowed = errors.New("relayed by guardian not allowed
 
 // ErrInvalidRelayedTxV3 signals that an invalid relayed tx v3 has been provided
 var ErrInvalidRelayedTxV3 = errors.New("invalid relayed transaction")
+
+// ErrProtocolSustainabilityAddressInMetachain signals that protocol sustainability address is in metachain which is not allowed
+var ErrProtocolSustainabilityAddressInMetachain = errors.New("protocol sustainability address in metachain")
diff --git a/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go b/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go
index fe853c32662..87eeb5f91fb 100644
--- a/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go
+++ b/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go
@@ -688,7 +688,7 @@ func getArgumentsMeta(
 		Store:                        createMetaStore(),
 		DataPool:                     createMetaDataPools(),
 		MaxTxNonceDeltaAllowed:       maxTxNonceDeltaAllowed,
-		TxFeeHandler:                 &economicsmocks.EconomicsHandlerStub{},
+		TxFeeHandler:                 &economicsmocks.EconomicsHandlerMock{},
 		BlockBlackList:               &testscommon.TimeCacheStub{},
 		HeaderSigVerifier:            &mock.HeaderSigVerifierStub{},
 		HeaderIntegrityVerifier:      &mock.HeaderIntegrityVerifierStub{},
diff --git a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go
index 677876311e9..438e1a143cc 100644
--- a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go
+++ b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go
@@ -713,7 +713,7 @@ func getArgumentsShard(
 		Store:                        createShardStore(),
 		DataPool:                     createShardDataPools(),
 		MaxTxNonceDeltaAllowed:       maxTxNonceDeltaAllowed,
-		TxFeeHandler:                 &economicsmocks.EconomicsHandlerStub{},
+		TxFeeHandler:                 &economicsmocks.EconomicsHandlerMock{},
 		BlockBlackList:               &testscommon.TimeCacheStub{},
 		HeaderSigVerifier:            &mock.HeaderSigVerifierStub{},
 		HeaderIntegrityVerifier:      &mock.HeaderIntegrityVerifierStub{},
diff --git a/process/factory/metachain/intermediateProcessorsContainerFactory_test.go b/process/factory/metachain/intermediateProcessorsContainerFactory_test.go
index f58b8e41f72..d99f4361905 100644
--- a/process/factory/metachain/intermediateProcessorsContainerFactory_test.go
+++ b/process/factory/metachain/intermediateProcessorsContainerFactory_test.go
@@ -29,7 +29,7 @@ func createMockArgsNewIntermediateProcessorsFactory() metachain.ArgsNewIntermedi
 		PubkeyConverter:         createMockPubkeyConverter(),
 		Store:                   &storageStubs.ChainStorerStub{},
 		PoolsHolder:             dataRetrieverMock.NewPoolsHolderMock(),
-		EconomicsFee:            &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:            &economicsmocks.EconomicsHandlerMock{},
 		EnableEpochsHandler:     enableEpochsHandlerMock.NewEnableEpochsHandlerStub(common.KeepExecOrderOnCreatedSCRsFlag),
 		TxExecutionOrderHandler: &txExecOrderStub.TxExecutionOrderHandlerStub{},
 	}
diff --git a/process/factory/metachain/preProcessorsContainerFactory_test.go b/process/factory/metachain/preProcessorsContainerFactory_test.go
index f49ee25e372..325fdc9d76e 100644
--- a/process/factory/metachain/preProcessorsContainerFactory_test.go
+++ b/process/factory/metachain/preProcessorsContainerFactory_test.go
@@ -31,7 +31,7 @@ func TestNewPreProcessorsContainerFactory_NilShardCoordinator(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -61,7 +61,7 @@ func TestNewPreProcessorsContainerFactory_NilStore(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -91,7 +91,7 @@ func TestNewPreProcessorsContainerFactory_NilMarshalizer(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -121,7 +121,7 @@ func TestNewPreProcessorsContainerFactory_NilHasher(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -151,7 +151,7 @@ func TestNewPreProcessorsContainerFactory_NilDataPool(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -181,7 +181,7 @@ func TestNewPreProcessorsContainerFactory_NilAccounts(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -241,7 +241,7 @@ func TestNewPreProcessorsContainerFactory_NilTxProcessor(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		nil,
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -271,7 +271,7 @@ func TestNewPreProcessorsContainerFactory_NilRequestHandler(t *testing.T) {
 		nil,
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -300,7 +300,7 @@ func TestNewPreProcessorsContainerFactory_NilGasHandler(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		nil,
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -329,7 +329,7 @@ func TestNewPreProcessorsContainerFactory_NilBlockTracker(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		nil,
 		createMockPubkeyConverter(),
@@ -358,7 +358,7 @@ func TestNewPreProcessorsContainerFactory_NilPubkeyConverter(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		nil,
@@ -387,7 +387,7 @@ func TestNewPreProcessorsContainerFactory_NilBlockSizeComputationHandler(t *test
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -416,7 +416,7 @@ func TestNewPreProcessorsContainerFactory_NilBalanceComputationHandler(t *testin
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -445,7 +445,7 @@ func TestNewPreProcessorsContainerFactory_NilEnableEpochsHandler(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -474,7 +474,7 @@ func TestNewPreProcessorsContainerFactory_NilTxTypeHandler(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -503,7 +503,7 @@ func TestNewPreProcessorsContainerFactory_NilScheduledTxsExecutionHandler(t *tes
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -532,7 +532,7 @@ func TestNewPreProcessorsContainerFactory_NilProcessedMiniBlocksTracker(t *testi
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -561,7 +561,7 @@ func TestNewPreProcessorsContainerFactory_NilTxExecutionOrderHandler(t *testing.
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -591,7 +591,7 @@ func TestNewPreProcessorsContainerFactory(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -627,7 +627,7 @@ func TestPreProcessorsContainerFactory_CreateErrTxPreproc(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
@@ -661,7 +661,7 @@ func TestPreProcessorsContainerFactory_Create(t *testing.T) {
 		&testscommon.RequestHandlerStub{},
 		&testscommon.TxProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		createMockPubkeyConverter(),
diff --git a/process/factory/metachain/vmContainerFactory_test.go b/process/factory/metachain/vmContainerFactory_test.go
index ff542213ef4..e7a13d1dece 100644
--- a/process/factory/metachain/vmContainerFactory_test.go
+++ b/process/factory/metachain/vmContainerFactory_test.go
@@ -29,7 +29,7 @@ func createVmContainerMockArgument(gasSchedule core.GasScheduleNotifier) ArgsNew
 	return ArgsNewVMContainerFactory{
 		BlockChainHook:      &testscommon.BlockChainHookStub{},
 		PubkeyConv:          testscommon.NewPubkeyConverterMock(32),
-		Economics:           &economicsmocks.EconomicsHandlerStub{},
+		Economics:           &economicsmocks.EconomicsHandlerMock{},
 		MessageSignVerifier: &mock.MessageSignVerifierMock{},
 		GasSchedule:         gasSchedule,
 		NodesConfigProvider: &mock.NodesConfigProviderStub{},
@@ -323,6 +323,8 @@ func TestVmContainerFactory_Create(t *testing.T) {
 		EpochNotifier:       &epochNotifier.EpochNotifierStub{},
 		EnableEpochsHandler: enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
 		TxVersionChecker:    &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:     &testscommon.PubkeyConverterStub{},
+		ShardCoordinator:    &testscommon.ShardsCoordinatorMock{},
 	}
 	economicsData, _ := economics.NewEconomicsData(argsNewEconomicsData)
 
diff --git a/process/factory/shard/intermediateProcessorsContainerFactory_test.go b/process/factory/shard/intermediateProcessorsContainerFactory_test.go
index 5835a7361ac..eda43c07d4e 100644
--- a/process/factory/shard/intermediateProcessorsContainerFactory_test.go
+++ b/process/factory/shard/intermediateProcessorsContainerFactory_test.go
@@ -63,7 +63,7 @@ func createMockArgsNewIntermediateProcessorsFactory() shard.ArgsNewIntermediateP
 		PubkeyConverter:         createMockPubkeyConverter(),
 		Store:                   &storageStubs.ChainStorerStub{},
 		PoolsHolder:             createDataPools(),
-		EconomicsFee:            &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:            &economicsmocks.EconomicsHandlerMock{},
 		EnableEpochsHandler:     enableEpochsHandlerMock.NewEnableEpochsHandlerStub(common.KeepExecOrderOnCreatedSCRsFlag),
 		TxExecutionOrderHandler: &txExecOrderStub.TxExecutionOrderHandlerStub{},
 	}
diff --git a/process/factory/shard/preProcessorsContainerFactory_test.go b/process/factory/shard/preProcessorsContainerFactory_test.go
index f273a5e64f3..46c09f1530f 100644
--- a/process/factory/shard/preProcessorsContainerFactory_test.go
+++ b/process/factory/shard/preProcessorsContainerFactory_test.go
@@ -37,7 +37,7 @@ func TestNewPreProcessorsContainerFactory_NilShardCoordinator(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -69,7 +69,7 @@ func TestNewPreProcessorsContainerFactory_NilStore(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -101,7 +101,7 @@ func TestNewPreProcessorsContainerFactory_NilMarshalizer(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -133,7 +133,7 @@ func TestNewPreProcessorsContainerFactory_NilHasher(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -165,7 +165,7 @@ func TestNewPreProcessorsContainerFactory_NilDataPool(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -197,7 +197,7 @@ func TestNewPreProcessorsContainerFactory_NilAddrConv(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -229,7 +229,7 @@ func TestNewPreProcessorsContainerFactory_NilAccounts(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -261,7 +261,7 @@ func TestNewPreProcessorsContainerFactory_NilTxProcessor(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -293,7 +293,7 @@ func TestNewPreProcessorsContainerFactory_NilSCProcessor(t *testing.T) {
 		nil,
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -325,7 +325,7 @@ func TestNewPreProcessorsContainerFactory_NilSCR(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		nil,
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -357,7 +357,7 @@ func TestNewPreProcessorsContainerFactory_NilRewardTxProcessor(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		nil,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -389,7 +389,7 @@ func TestNewPreProcessorsContainerFactory_NilRequestHandler(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -453,7 +453,7 @@ func TestNewPreProcessorsContainerFactory_NilGasHandler(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		nil,
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -485,7 +485,7 @@ func TestNewPreProcessorsContainerFactory_NilBlockTracker(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		nil,
 		&testscommon.BlockSizeComputationStub{},
@@ -517,7 +517,7 @@ func TestNewPreProcessorsContainerFactory_NilBlockSizeComputationHandler(t *test
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		nil,
@@ -549,7 +549,7 @@ func TestNewPreProcessorsContainerFactory_NilBalanceComputationHandler(t *testin
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -581,7 +581,7 @@ func TestNewPreProcessorsContainerFactory_NilEnableEpochsHandler(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -613,7 +613,7 @@ func TestNewPreProcessorsContainerFactory_NilTxTypeHandler(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -645,7 +645,7 @@ func TestNewPreProcessorsContainerFactory_NilScheduledTxsExecutionHandler(t *tes
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -677,7 +677,7 @@ func TestNewPreProcessorsContainerFactory_NilProcessedMiniBlocksTracker(t *testi
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -709,7 +709,7 @@ func TestNewPreProcessorsContainerFactory_NilTxExecutionOrderHandler(t *testing.
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -741,7 +741,7 @@ func TestNewPreProcessorsContainerFactory(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -778,7 +778,7 @@ func TestPreProcessorsContainerFactory_CreateErrTxPreproc(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -821,7 +821,7 @@ func TestPreProcessorsContainerFactory_CreateErrScrPreproc(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
@@ -867,7 +867,7 @@ func TestPreProcessorsContainerFactory_Create(t *testing.T) {
 		&testscommon.SCProcessorMock{},
 		&testscommon.SmartContractResultsProcessorMock{},
 		&testscommon.RewardTxProcessorMock{},
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.GasHandlerStub{},
 		&mock.BlockTrackerMock{},
 		&testscommon.BlockSizeComputationStub{},
diff --git a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go
index e46692e6614..1930cb9a140 100644
--- a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go
+++ b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go
@@ -56,7 +56,7 @@ func createMockPubkeyConverter() core.PubkeyConverter {
 }
 
 func createMockFeeHandler() process.FeeHandler {
-	return &economicsmocks.EconomicsHandlerStub{}
+	return &economicsmocks.EconomicsHandlerMock{}
 }
 
 func createMockComponentHolders() (*mock.CoreComponentsMock, *mock.CryptoComponentsMock) {
diff --git a/process/interface.go b/process/interface.go
index e5800a54796..b6a2d198852 100644
--- a/process/interface.go
+++ b/process/interface.go
@@ -655,6 +655,12 @@ type rewardsHandler interface {
 	MaxInflationRate(year uint32) float64
 	RewardsTopUpGradientPoint() *big.Int
 	RewardsTopUpFactor() float64
+	LeaderPercentageInEpoch(epoch uint32) float64
+	DeveloperPercentageInEpoch(epoch uint32) float64
+	ProtocolSustainabilityPercentageInEpoch(epoch uint32) float64
+	ProtocolSustainabilityAddressInEpoch(epoch uint32) string
+	RewardsTopUpGradientPointInEpoch(epoch uint32) *big.Int
+	RewardsTopUpFactorInEpoch(epoch uint32) float64
 }
 
 // RewardsHandler will return information about rewards
diff --git a/process/mock/coreComponentsMock.go b/process/mock/coreComponentsMock.go
index 32455e5d54b..9082cbf7b37 100644
--- a/process/mock/coreComponentsMock.go
+++ b/process/mock/coreComponentsMock.go
@@ -162,7 +162,7 @@ func (ccm *CoreComponentsMock) EconomicsData() process.EconomicsDataHandler {
 		return ccm.EconomicsDataField
 	}
 
-	return &economicsmocks.EconomicsHandlerStub{}
+	return &economicsmocks.EconomicsHandlerMock{}
 }
 
 // ProcessStatusHandler -
diff --git a/process/peer/process.go b/process/peer/process.go
index 20e0b377365..6ca77b7cbed 100644
--- a/process/peer/process.go
+++ b/process/peer/process.go
@@ -408,6 +408,7 @@ func (vs *validatorStatistics) UpdatePeerState(header data.MetaHeaderHandler, ca
 		previousHeader.GetPubKeysBitmap(),
 		big.NewInt(0).Sub(previousHeader.GetAccumulatedFees(), previousHeader.GetDeveloperFees()),
 		previousHeader.GetShardID(),
+		previousHeader.GetEpoch(),
 	)
 	if err != nil {
 		return nil, err
@@ -931,6 +932,7 @@ func (vs *validatorStatistics) updateShardDataPeerState(
 			h.PubKeysBitmap,
 			big.NewInt(0).Sub(h.AccumulatedFees, h.DeveloperFees),
 			h.ShardID,
+			currentHeader.GetEpoch(),
 		)
 		if shardInfoErr != nil {
 			return shardInfoErr
@@ -1018,6 +1020,7 @@ func (vs *validatorStatistics) updateValidatorInfoOnSuccessfulBlock(
 	signingBitmap []byte,
 	accumulatedFees *big.Int,
 	shardId uint32,
+	epoch uint32,
 ) error {
 
 	if len(signingBitmap) == 0 {
@@ -1044,9 +1047,9 @@ func (vs *validatorStatistics) updateValidatorInfoOnSuccessfulBlock(
 			newRating = vs.rater.ComputeIncreaseProposer(shardId, peerAcc.GetTempRating())
 			var leaderAccumulatedFees *big.Int
 			if vs.enableEpochsHandler.IsFlagEnabled(common.StakingV2FlagAfterEpoch) {
-				leaderAccumulatedFees = core.GetIntTrimmedPercentageOfValue(accumulatedFees, vs.rewardsHandler.LeaderPercentage())
+				leaderAccumulatedFees = core.GetIntTrimmedPercentageOfValue(accumulatedFees, vs.rewardsHandler.LeaderPercentageInEpoch(epoch))
 			} else {
-				leaderAccumulatedFees = core.GetApproximatePercentageOfValue(accumulatedFees, vs.rewardsHandler.LeaderPercentage())
+				leaderAccumulatedFees = core.GetApproximatePercentageOfValue(accumulatedFees, vs.rewardsHandler.LeaderPercentageInEpoch(epoch))
 			}
 
 			peerAcc.AddToAccumulatedFees(leaderAccumulatedFees)
diff --git a/process/peer/process_test.go b/process/peer/process_test.go
index d4c85a5601f..eba20a61f56 100644
--- a/process/peer/process_test.go
+++ b/process/peer/process_test.go
@@ -105,6 +105,8 @@ func createMockArguments() peer.ArgValidatorStatisticsProcessor {
 		EpochNotifier:       &epochNotifier.EpochNotifierStub{},
 		EnableEpochsHandler: enableEpochsHandlerMock.NewEnableEpochsHandlerStub(),
 		TxVersionChecker:    &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:     &testscommon.PubkeyConverterStub{},
+		ShardCoordinator:    &testscommon.ShardsCoordinatorMock{},
 	}
 	economicsData, _ := economics.NewEconomicsData(argsNewEconomicsData)
 
diff --git a/process/smartContract/processProxy/processProxy_test.go b/process/smartContract/processProxy/processProxy_test.go
index d153615600f..c0186db7385 100644
--- a/process/smartContract/processProxy/processProxy_test.go
+++ b/process/smartContract/processProxy/processProxy_test.go
@@ -55,7 +55,7 @@ func createMockSmartContractProcessorArguments() scrCommon.ArgsNewSmartContractP
 		BadTxForwarder:   &mock.IntermediateTransactionHandlerMock{},
 		TxFeeHandler:     &mock.FeeAccumulatorStub{},
 		TxLogsProcessor:  &mock.TxLogsProcessorStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.0
 			},
diff --git a/process/smartContract/process_test.go b/process/smartContract/process_test.go
index b6c81113f45..a8d1b6512ae 100644
--- a/process/smartContract/process_test.go
+++ b/process/smartContract/process_test.go
@@ -100,7 +100,7 @@ func createMockSmartContractProcessorArguments() scrCommon.ArgsNewSmartContractP
 		BadTxForwarder:   &mock.IntermediateTransactionHandlerMock{},
 		TxFeeHandler:     &mock.FeeAccumulatorStub{},
 		TxLogsProcessor:  &mock.TxLogsProcessorStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.0
 			},
@@ -992,7 +992,7 @@ func TestScProcessor_DeploySmartContractEconomicsFeeValidateFails(t *testing.T)
 	arguments.VmContainer = vm
 	arguments.ArgsParser = argParser
 
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return expectedError
 		},
@@ -1206,7 +1206,7 @@ func TestScProcessor_DeploySmartContractUpdateDeveloperRewardsFails(t *testing.T
 	arguments.VmContainer = vm
 	arguments.ArgsParser = argParser
 	arguments.AccountsDB = accntState
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		DeveloperPercentageCalled: func() float64 {
 			return 0.0
 		},
@@ -1949,7 +1949,7 @@ func TestScProcessor_InitializeVMInputFromTx_ShouldErrNotEnoughGas(t *testing.T)
 	arguments := createMockSmartContractProcessorArguments()
 	arguments.VmContainer = vm
 	arguments.ArgsParser = argParser
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 			return 1000
 		},
@@ -2334,7 +2334,7 @@ func TestScProcessor_ProcessSCPaymentNotEnoughBalance(t *testing.T) {
 	t.Parallel()
 
 	arguments := createMockSmartContractProcessorArguments()
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeTxFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return core.SafeMul(tx.GetGasPrice(), tx.GetGasLimit())
 		}}
@@ -2395,7 +2395,7 @@ func TestScProcessor_ProcessSCPaymentWithNewFlags(t *testing.T) {
 	txFee := big.NewInt(25)
 
 	arguments := createMockSmartContractProcessorArguments()
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		DeveloperPercentageCalled: func() float64 {
 			return 0.0
 		},
@@ -2514,7 +2514,7 @@ func TestScProcessor_RefundGasToSender(t *testing.T) {
 
 	minGasPrice := uint64(10)
 	arguments := createMockSmartContractProcessorArguments()
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{MinGasPriceCalled: func() uint64 {
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{MinGasPriceCalled: func() uint64 {
 		return minGasPrice
 	}}
 	arguments.EnableEpochsHandler = enableEpochsHandlerMock.NewEnableEpochsHandlerStub()
@@ -2554,7 +2554,7 @@ func TestScProcessor_DoNotRefundGasToSenderForAsyncCall(t *testing.T) {
 
 	minGasPrice := uint64(10)
 	arguments := createMockSmartContractProcessorArguments()
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{MinGasPriceCalled: func() uint64 {
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{MinGasPriceCalled: func() uint64 {
 		return minGasPrice
 	}}
 	arguments.EnableEpochsHandler = enableEpochsHandlerMock.NewEnableEpochsHandlerStub()
@@ -3672,7 +3672,7 @@ func TestSmartContractProcessor_computeTotalConsumedFeeAndDevRwd(t *testing.T) {
 	shardCoordinator := &mock.CoordinatorStub{ComputeIdCalled: func(address []byte) uint32 {
 		return 0
 	}}
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 			return 0
 		},
@@ -3879,7 +3879,7 @@ func TestScProcessor_CreateRefundForRelayerFromAnotherShard(t *testing.T) {
 			return 0
 		}}
 	arguments.ShardCoordinator = shardCoordinator
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{ComputeFeeForProcessingCalled: func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{ComputeFeeForProcessingCalled: func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
 		return big.NewInt(100)
 	}}
 	sc, _ := NewSmartContractProcessor(arguments)
@@ -3969,7 +3969,7 @@ func TestProcessIfErrorCheckBackwardsCompatibilityProcessTransactionFeeCalledSho
 			return 0
 		}}
 	arguments.ShardCoordinator = shardCoordinator
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeFeeForProcessingCalled: func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
 			return big.NewInt(100)
 		},
@@ -4008,7 +4008,7 @@ func TestProcessIfErrorCheckBackwardsCompatibilityProcessTransactionFeeCalledSho
 			return 0
 		}}
 	arguments.ShardCoordinator = shardCoordinator
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeFeeForProcessingCalled: func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
 			return big.NewInt(100)
 		},
@@ -4247,6 +4247,8 @@ func createRealEconomicsDataArgs() *economics.ArgsNewEconomicsData {
 			},
 		},
 		TxVersionChecker: &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:  &testscommon.PubkeyConverterStub{},
+		ShardCoordinator: &testscommon.ShardsCoordinatorMock{},
 	}
 }
 
@@ -4423,7 +4425,7 @@ func TestScProcessor_CheckBuiltinFunctionIsExecutable(t *testing.T) {
 				return "SetGuardian", nil, nil
 			},
 		}
-		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return setGuardianCost
 			},
@@ -4441,7 +4443,7 @@ func TestScProcessor_CheckBuiltinFunctionIsExecutable(t *testing.T) {
 				return "SetGuardian", nil, nil
 			},
 		}
-		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return setGuardianCost
 			},
@@ -4462,7 +4464,7 @@ func TestScProcessor_CheckBuiltinFunctionIsExecutable(t *testing.T) {
 				return "SetGuardian", nil, nil
 			},
 		}
-		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return setGuardianCost
 			},
@@ -4482,7 +4484,7 @@ func TestScProcessor_CheckBuiltinFunctionIsExecutable(t *testing.T) {
 				return "SetGuardian", nil, nil
 			},
 		}
-		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return setGuardianCost
 			},
diff --git a/process/smartContract/processorV2/process_test.go b/process/smartContract/processorV2/process_test.go
index 526dc20c86f..95f8e51ea03 100644
--- a/process/smartContract/processorV2/process_test.go
+++ b/process/smartContract/processorV2/process_test.go
@@ -110,7 +110,7 @@ func createMockSmartContractProcessorArguments() scrCommon.ArgsNewSmartContractP
 		BadTxForwarder:   &mock.IntermediateTransactionHandlerMock{},
 		TxFeeHandler:     &mock.FeeAccumulatorStub{},
 		TxLogsProcessor:  &mock.TxLogsProcessorStub{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{
 			DeveloperPercentageCalled: func() float64 {
 				return 0.0
 			},
@@ -1013,7 +1013,7 @@ func TestScProcessor_DeploySmartContractEconomicsFeeValidateFails(t *testing.T)
 	arguments.VmContainer = vm
 	arguments.ArgsParser = argParser
 
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return expectedError
 		},
@@ -1227,7 +1227,7 @@ func TestScProcessor_DeploySmartContractUpdateDeveloperRewardsFails(t *testing.T
 	arguments.VmContainer = vm
 	arguments.ArgsParser = argParser
 	arguments.AccountsDB = accntState
-	economicsFee := &economicsmocks.EconomicsHandlerStub{
+	economicsFee := &economicsmocks.EconomicsHandlerMock{
 		DeveloperPercentageCalled: func() float64 {
 			return 0.0
 		},
@@ -2000,7 +2000,7 @@ func TestScProcessor_InitializeVMInputFromTx_ShouldErrNotEnoughGas(t *testing.T)
 	arguments := createMockSmartContractProcessorArguments()
 	arguments.VmContainer = vm
 	arguments.ArgsParser = argParser
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 			return 1000
 		},
@@ -2386,7 +2386,7 @@ func TestScProcessor_ProcessSCPaymentNotEnoughBalance(t *testing.T) {
 	t.Parallel()
 
 	arguments := createMockSmartContractProcessorArguments()
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeTxFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return core.SafeMul(tx.GetGasPrice(), tx.GetGasLimit())
 		}}
@@ -2556,7 +2556,7 @@ func TestScProcessor_ProcessSCPaymentWithNewFlags(t *testing.T) {
 	txFee := big.NewInt(25)
 
 	arguments := createMockSmartContractProcessorArguments()
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		DeveloperPercentageCalled: func() float64 {
 			return 0.0
 		},
@@ -3743,7 +3743,7 @@ func TestSmartContractProcessor_computeTotalConsumedFeeAndDevRwd(t *testing.T) {
 	shardCoordinator := &mock.CoordinatorStub{ComputeIdCalled: func(address []byte) uint32 {
 		return 0
 	}}
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 			return 0
 		},
@@ -3948,7 +3948,7 @@ func TestScProcessor_CreateRefundForRelayerFromAnotherShard(t *testing.T) {
 			return 0
 		}}
 	arguments.ShardCoordinator = shardCoordinator
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeFeeForProcessingCalled: func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
 			return big.NewInt(100)
 		}}
@@ -4039,7 +4039,7 @@ func TestProcessIfErrorCheckBackwardsCompatibilityProcessTransactionFeeCalledSho
 			return 0
 		}}
 	arguments.ShardCoordinator = shardCoordinator
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeFeeForProcessingCalled: func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
 			return big.NewInt(100)
 		},
@@ -4078,7 +4078,7 @@ func TestProcessIfErrorCheckBackwardsCompatibilityProcessTransactionFeeCalledSho
 			return 0
 		}}
 	arguments.ShardCoordinator = shardCoordinator
-	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	arguments.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeFeeForProcessingCalled: func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
 			return big.NewInt(100)
 		},
@@ -4301,6 +4301,8 @@ func createRealEconomicsDataArgs() *economics.ArgsNewEconomicsData {
 			},
 		},
 		TxVersionChecker: &testscommon.TxVersionCheckerStub{},
+		PubkeyConverter:  &testscommon.PubkeyConverterStub{},
+		ShardCoordinator: &testscommon.ShardsCoordinatorMock{},
 	}
 }
 
diff --git a/process/smartContract/scQueryService_test.go b/process/smartContract/scQueryService_test.go
index 4889dc87ac5..a7855a5b844 100644
--- a/process/smartContract/scQueryService_test.go
+++ b/process/smartContract/scQueryService_test.go
@@ -36,7 +36,7 @@ const DummyScAddress = "00000000000000000500fabd9501b7e5353de57a4e319857c2fb9908
 func createMockArgumentsForSCQuery() ArgsNewSCQueryService {
 	return ArgsNewSCQueryService{
 		VmContainer:  &mock.VMContainerMock{},
-		EconomicsFee: &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee: &economicsmocks.EconomicsHandlerMock{},
 		BlockChainHook: &testscommon.BlockChainHookStub{
 			GetAccountsAdapterCalled: func() state.AccountsAdapter {
 				return &stateMocks.AccountsStub{
@@ -346,7 +346,7 @@ func TestExecuteQuery_ShouldReceiveQueryCorrectly(t *testing.T) {
 				return mockVM, nil
 			},
 		}
-		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return uint64(math.MaxUint64)
 			},
@@ -392,7 +392,7 @@ func TestExecuteQuery_ShouldReceiveQueryCorrectly(t *testing.T) {
 				return mockVM, nil
 			},
 		}
-		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return uint64(math.MaxUint64)
 			},
@@ -499,7 +499,7 @@ func TestExecuteQuery_ShouldReceiveQueryCorrectly(t *testing.T) {
 				return mockVM, nil
 			},
 		}
-		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return uint64(math.MaxUint64)
 			},
@@ -701,7 +701,7 @@ func TestExecuteQuery_ReturnsCorrectly(t *testing.T) {
 			return mockVM, nil
 		},
 	}
-	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -742,7 +742,7 @@ func TestExecuteQuery_GasProvidedShouldBeApplied(t *testing.T) {
 				return mockVM, nil
 			},
 		}
-		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return uint64(math.MaxUint64)
 			},
@@ -779,7 +779,7 @@ func TestExecuteQuery_GasProvidedShouldBeApplied(t *testing.T) {
 				return mockVM, nil
 			},
 		}
-		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 				return uint64(math.MaxUint64)
 			},
@@ -818,7 +818,7 @@ func TestExecuteQuery_WhenNotOkCodeShouldNotErr(t *testing.T) {
 			return mockVM, nil
 		},
 	}
-	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -866,7 +866,7 @@ func TestExecuteQuery_ShouldCallRunScSequentially(t *testing.T) {
 			return mockVM, nil
 		},
 	}
-	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -914,7 +914,7 @@ func TestSCQueryService_ExecuteQueryShouldNotIncludeCallerAddressAndValue(t *tes
 			return mockVM, nil
 		},
 	}
-	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -956,7 +956,7 @@ func TestSCQueryService_ExecuteQueryShouldIncludeCallerAddressAndValue(t *testin
 			return mockVM, nil
 		},
 	}
-	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -1090,7 +1090,7 @@ func TestSCQueryService_ComputeTxCostScCall(t *testing.T) {
 			return mockVM, nil
 		},
 	}
-	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -1127,7 +1127,7 @@ func TestSCQueryService_ComputeScCallGasLimitRetCodeNotOK(t *testing.T) {
 			return mockVM, nil
 		},
 	}
-	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	argsNewSCQuery.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return uint64(math.MaxUint64)
 		},
@@ -1153,7 +1153,7 @@ func TestNewSCQueryService_CloseShouldWork(t *testing.T) {
 				return nil
 			},
 		},
-		EconomicsFee:             &economicsmocks.EconomicsHandlerStub{},
+		EconomicsFee:             &economicsmocks.EconomicsHandlerMock{},
 		BlockChainHook:           &testscommon.BlockChainHookStub{},
 		MainBlockChain:           &testscommon.ChainHandlerStub{},
 		APIBlockChain:            &testscommon.ChainHandlerStub{},
diff --git a/process/track/baseBlockTrack_test.go b/process/track/baseBlockTrack_test.go
index 8c919cd9ee7..04927db27fc 100644
--- a/process/track/baseBlockTrack_test.go
+++ b/process/track/baseBlockTrack_test.go
@@ -111,7 +111,7 @@ func CreateShardTrackerMockArguments() track.ArgShardTracker {
 	}
 	headerValidator, _ := processBlock.NewHeaderValidator(argsHeaderValidator)
 	whitelistHandler := &testscommon.WhiteListHandlerStub{}
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockForSafeCrossShardCalled: func() uint64 {
 			return maxGasLimitPerBlock
 		},
@@ -149,7 +149,7 @@ func CreateMetaTrackerMockArguments() track.ArgMetaTracker {
 	}
 	headerValidator, _ := processBlock.NewHeaderValidator(argsHeaderValidator)
 	whitelistHandler := &testscommon.WhiteListHandlerStub{}
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockForSafeCrossShardCalled: func() uint64 {
 			return maxGasLimitPerBlock
 		},
@@ -185,7 +185,7 @@ func CreateBaseTrackerMockArguments() track.ArgBaseTracker {
 		Marshalizer: &mock.MarshalizerMock{},
 	}
 	headerValidator, _ := processBlock.NewHeaderValidator(argsHeaderValidator)
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockForSafeCrossShardCalled: func() uint64 {
 			return maxGasLimitPerBlock
 		},
diff --git a/process/transaction/baseProcess_test.go b/process/transaction/baseProcess_test.go
index 7d4605239a9..2fd3b1d93a0 100644
--- a/process/transaction/baseProcess_test.go
+++ b/process/transaction/baseProcess_test.go
@@ -30,7 +30,7 @@ func createMockBaseTxProcessor() *baseTxProcessor {
 		accounts:         &stateMock.AccountsStub{},
 		shardCoordinator: mock.NewOneShardCoordinatorMock(),
 		pubkeyConv:       testscommon.NewPubkeyConverterMock(32),
-		economicsFee: &economicsmocks.EconomicsHandlerStub{
+		economicsFee: &economicsmocks.EconomicsHandlerMock{
 			CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 				return nil
 			},
@@ -199,7 +199,7 @@ func TestBaseTxProcessor_VerifyGuardian(t *testing.T) {
 		accounts:         &stateMock.AccountsStub{},
 		shardCoordinator: mock.NewOneShardCoordinatorMock(),
 		pubkeyConv:       testscommon.NewPubkeyConverterMock(32),
-		economicsFee: &economicsmocks.EconomicsHandlerStub{
+		economicsFee: &economicsmocks.EconomicsHandlerMock{
 			CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 				return nil
 			},
diff --git a/process/transaction/interceptedTransaction_test.go b/process/transaction/interceptedTransaction_test.go
index 7459e586241..4c888f60863 100644
--- a/process/transaction/interceptedTransaction_test.go
+++ b/process/transaction/interceptedTransaction_test.go
@@ -69,8 +69,8 @@ func createKeyGenMock() crypto.KeyGenerator {
 	}
 }
 
-func createFreeTxFeeHandler() *economicsmocks.EconomicsHandlerStub {
-	return &economicsmocks.EconomicsHandlerStub{
+func createFreeTxFeeHandler() *economicsmocks.EconomicsHandlerMock {
+	return &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return nil
 		},
@@ -228,7 +228,7 @@ func TestNewInterceptedTransaction_NilBufferShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -254,7 +254,7 @@ func TestNewInterceptedTransaction_NilArgsParser(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		nil,
 		[]byte("chainID"),
@@ -280,7 +280,7 @@ func TestNewInterceptedTransaction_NilVersionChecker(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -306,7 +306,7 @@ func TestNewInterceptedTransaction_NilMarshalizerShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -332,7 +332,7 @@ func TestNewInterceptedTransaction_NilSignMarshalizerShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -358,7 +358,7 @@ func TestNewInterceptedTransaction_NilHasherShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -384,7 +384,7 @@ func TestNewInterceptedTransaction_NilKeyGenShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -410,7 +410,7 @@ func TestNewInterceptedTransaction_NilSignerShouldErr(t *testing.T) {
 		nil,
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -436,7 +436,7 @@ func TestNewInterceptedTransaction_NilPubkeyConverterShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		nil,
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -462,7 +462,7 @@ func TestNewInterceptedTransaction_NilCoordinatorShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		nil,
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -514,7 +514,7 @@ func TestNewInterceptedTransaction_NilWhiteListerVerifiedTxsShouldErr(t *testing
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		nil,
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -540,7 +540,7 @@ func TestNewInterceptedTransaction_InvalidChainIDShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		nil,
@@ -566,7 +566,7 @@ func TestNewInterceptedTransaction_NilTxSignHasherShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -592,7 +592,7 @@ func TestNewInterceptedTransaction_NilEnableEpochsHandlerShouldErr(t *testing.T)
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -624,7 +624,7 @@ func TestNewInterceptedTransaction_UnmarshalingTxFailsShouldErr(t *testing.T) {
 		&mock.SignerMock{},
 		createMockPubKeyConverter(),
 		mock.NewOneShardCoordinatorMock(),
-		&economicsmocks.EconomicsHandlerStub{},
+		&economicsmocks.EconomicsHandlerMock{},
 		&testscommon.WhiteListHandlerStub{},
 		&testscommon.ArgumentParserMock{},
 		[]byte("chainID"),
@@ -890,7 +890,7 @@ func TestNewInterceptedTransaction_InsufficientFeeShouldErr(t *testing.T) {
 		Version:   minTxVersion,
 	}
 	errExpected := errors.New("insufficient fee")
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return errExpected
 		},
@@ -1820,7 +1820,7 @@ func TestInterceptedTransaction_checkMaxGasPrice(t *testing.T) {
 	t.Parallel()
 
 	maxAllowedGasPriceSetGuardian := uint64(2000000)
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		MaxGasPriceSetGuardianCalled: func() uint64 {
 			return maxAllowedGasPriceSetGuardian
 		},
@@ -1923,7 +1923,7 @@ func TestInterceptedTransaction_VerifyGuardianSig(t *testing.T) {
 			return true
 		},
 	}
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		MaxGasPriceSetGuardianCalled: func() uint64 {
 			return 1000
 		},
diff --git a/process/transaction/shardProcess_test.go b/process/transaction/shardProcess_test.go
index 75adbf3f3b9..5d4ed0fe5b2 100644
--- a/process/transaction/shardProcess_test.go
+++ b/process/transaction/shardProcess_test.go
@@ -47,8 +47,8 @@ func generateRandomByteSlice(size int) []byte {
 	return buff
 }
 
-func feeHandlerMock() *economicsmocks.EconomicsHandlerStub {
-	return &economicsmocks.EconomicsHandlerStub{
+func feeHandlerMock() *economicsmocks.EconomicsHandlerMock {
+	return &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return nil
 		},
@@ -729,7 +729,7 @@ func TestTxProcessor_ProcessWithTxFeeHandlerCheckErrorShouldErr(t *testing.T) {
 	args.Accounts = adb
 
 	expectedError := errors.New("validatity check failed")
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return expectedError
 		}}
@@ -780,7 +780,7 @@ func TestTxProcessor_ProcessWithTxFeeHandlerInsufficientFeeShouldErr(t *testing.
 	args := createArgsForTxProcessor()
 	args.Accounts = adb
 
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeTxFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return big.NewInt(0).Add(acntSrc.GetBalance(), big.NewInt(1))
 		}}
@@ -810,7 +810,7 @@ func TestTxProcessor_ProcessWithInsufficientFundsShouldCreateReceiptErr(t *testi
 	args := createArgsForTxProcessor()
 	args.Accounts = adb
 
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return process.ErrInsufficientFunds
 		}}
@@ -841,7 +841,7 @@ func TestTxProcessor_ProcessWithUsernameMismatchCreateReceiptErr(t *testing.T) {
 	args := createArgsForTxProcessor()
 	args.Accounts = adb
 
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return process.ErrUserNameDoesNotMatchInCrossShardTx
 		}}
@@ -870,7 +870,7 @@ func TestTxProcessor_ProcessWithUsernameMismatchAndSCProcessErrorShouldError(t *
 
 	args := createArgsForTxProcessor()
 	args.Accounts = adb
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return process.ErrUserNameDoesNotMatchInCrossShardTx
 		}}
@@ -1054,7 +1054,7 @@ func TestTxProcessor_MoveBalanceWithFeesShouldWork(t *testing.T) {
 	}
 
 	txCost := big.NewInt(16)
-	feeHandler := &economicsmocks.EconomicsHandlerStub{
+	feeHandler := &economicsmocks.EconomicsHandlerMock{
 		CheckValidityTxValuesCalled: func(tx data.TransactionWithFeeHandler) error {
 			return nil
 		},
@@ -1335,7 +1335,7 @@ func TestTxProcessor_ProcessTxFeeIntraShard(t *testing.T) {
 	negMoveBalanceFee := big.NewInt(0).Neg(moveBalanceFee)
 	totalGiven := big.NewInt(100)
 	args := createArgsForTxProcessor()
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeMoveBalanceFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return moveBalanceFee
 		},
@@ -1370,7 +1370,7 @@ func TestTxProcessor_ProcessTxFeeCrossShardMoveBalance(t *testing.T) {
 	negMoveBalanceFee := big.NewInt(0).Neg(moveBalanceFee)
 	totalGiven := big.NewInt(100)
 	args := createArgsForTxProcessor()
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeMoveBalanceFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return moveBalanceFee
 		},
@@ -1429,7 +1429,7 @@ func TestTxProcessor_ProcessTxFeeCrossShardSCCall(t *testing.T) {
 
 	moveBalanceFee := big.NewInt(50)
 	args := createArgsForTxProcessor()
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeMoveBalanceFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return moveBalanceFee
 		},
@@ -1468,7 +1468,7 @@ func TestTxProcessor_ProcessTxFeeMoveBalanceUserTx(t *testing.T) {
 	processingFee := big.NewInt(5)
 	negMoveBalanceFee := big.NewInt(0).Neg(moveBalanceFee)
 	args := createArgsForTxProcessor()
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeMoveBalanceFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return moveBalanceFee
 		},
@@ -1505,7 +1505,7 @@ func TestTxProcessor_ProcessTxFeeSCInvokeUserTx(t *testing.T) {
 	gasPerByte := uint64(1)
 	args := createArgsForTxProcessor()
 	args.EnableEpochsHandler = enableEpochsHandlerMock.NewEnableEpochsHandlerStub(common.PenalizedTooMuchGasFlag)
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeMoveBalanceFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return moveBalanceFee
 		},
@@ -1568,7 +1568,7 @@ func TestTxProcessor_ProcessTransactionShouldReturnErrForInvalidMetaTx(t *testin
 	args.Accounts = adb
 	args.ScProcessor = scProcessorMock
 	args.ShardCoordinator = shardC
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeMoveBalanceFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return big.NewInt(1)
 		},
@@ -1616,7 +1616,7 @@ func TestTxProcessor_ProcessTransactionShouldTreatAsInvalidTxIfTxTypeIsWrong(t *
 	args := createArgsForTxProcessor()
 	args.Accounts = adb
 	args.ShardCoordinator = shardC
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeTxFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return big.NewInt(1)
 		},
@@ -2801,7 +2801,7 @@ func TestTxProcessor_ProcessRelayedTransactionV3(t *testing.T) {
 		txCopy := *tx
 		txCopy.Nonce = acntSrc.GetNonce()
 		argsCopy := args
-		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+		argsCopy.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 			ComputeGasLimitCalled: func(tx data.TransactionWithFeeHandler) uint64 {
 				return txCopy.GasLimit + 1
 			},
@@ -2820,7 +2820,7 @@ func TestTxProcessor_ConsumeMoveBalanceWithUserTx(t *testing.T) {
 
 	args := createArgsForTxProcessor()
 	args.EnableEpochsHandler = enableEpochsHandlerMock.NewEnableEpochsHandlerStub()
-	args.EconomicsFee = &economicsmocks.EconomicsHandlerStub{
+	args.EconomicsFee = &economicsmocks.EconomicsHandlerMock{
 		ComputeTxFeeCalled: func(tx data.TransactionWithFeeHandler) *big.Int {
 			return big.NewInt(150)
 		},
diff --git a/process/transactionEvaluator/transactionEvaluator_test.go b/process/transactionEvaluator/transactionEvaluator_test.go
index bfcbf97f787..774bc44ecec 100644
--- a/process/transactionEvaluator/transactionEvaluator_test.go
+++ b/process/transactionEvaluator/transactionEvaluator_test.go
@@ -26,7 +26,7 @@ import (
 func createArgs() ArgsApiTransactionEvaluator {
 	return ArgsApiTransactionEvaluator{
 		TxTypeHandler:       &testscommon.TxTypeHandlerMock{},
-		FeeHandler:          &economicsmocks.EconomicsHandlerStub{},
+		FeeHandler:          &economicsmocks.EconomicsHandlerMock{},
 		TxSimulator:         &mock.TransactionSimulatorStub{},
 		Accounts:            &stateMock.AccountsStub{},
 		ShardCoordinator:    &mock.ShardCoordinatorStub{},
@@ -118,7 +118,7 @@ func TestComputeTransactionGasLimit_MoveBalance(t *testing.T) {
 			return process.MoveBalance, process.MoveBalance, false
 		},
 	}
-	args.FeeHandler = &economicsmocks.EconomicsHandlerStub{
+	args.FeeHandler = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return math.MaxUint64
 		},
@@ -157,7 +157,7 @@ func TestComputeTransactionGasLimit_MoveBalanceInvalidNonceShouldStillComputeCos
 			return process.MoveBalance, process.MoveBalance, false
 		},
 	}
-	args.FeeHandler = &economicsmocks.EconomicsHandlerStub{
+	args.FeeHandler = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return math.MaxUint64
 		},
@@ -191,7 +191,7 @@ func TestComputeTransactionGasLimit_BuiltInFunction(t *testing.T) {
 			return process.BuiltInFunctionCall, process.BuiltInFunctionCall, false
 		},
 	}
-	args.FeeHandler = &economicsmocks.EconomicsHandlerStub{
+	args.FeeHandler = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return math.MaxUint64
 		},
@@ -227,7 +227,7 @@ func TestComputeTransactionGasLimit_BuiltInFunctionShouldErr(t *testing.T) {
 			return process.BuiltInFunctionCall, process.BuiltInFunctionCall, false
 		},
 	}
-	args.FeeHandler = &economicsmocks.EconomicsHandlerStub{
+	args.FeeHandler = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return math.MaxUint64
 		},
@@ -257,7 +257,7 @@ func TestComputeTransactionGasLimit_NilVMOutput(t *testing.T) {
 			return process.BuiltInFunctionCall, process.BuiltInFunctionCall, false
 		},
 	}
-	args.FeeHandler = &economicsmocks.EconomicsHandlerStub{
+	args.FeeHandler = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return math.MaxUint64
 		},
@@ -288,7 +288,7 @@ func TestComputeTransactionGasLimit_RetCodeNotOk(t *testing.T) {
 			return process.BuiltInFunctionCall, process.BuiltInFunctionCall, false
 		},
 	}
-	args.FeeHandler = &economicsmocks.EconomicsHandlerStub{
+	args.FeeHandler = &economicsmocks.EconomicsHandlerMock{
 		MaxGasLimitPerBlockCalled: func(_ uint32) uint64 {
 			return math.MaxUint64
 		},
diff --git a/testscommon/components/default.go b/testscommon/components/default.go
index 514b8355407..0dfa6061dfa 100644
--- a/testscommon/components/default.go
+++ b/testscommon/components/default.go
@@ -49,7 +49,7 @@ func GetDefaultCoreComponents() *mock.CoreComponentsMock {
 		AlarmSch:                 &testscommon.AlarmSchedulerStub{},
 		NtpSyncTimer:             &testscommon.SyncTimerStub{},
 		RoundHandlerField:        &testscommon.RoundHandlerMock{},
-		EconomicsHandler:         &economicsmocks.EconomicsHandlerStub{},
+		EconomicsHandler:         &economicsmocks.EconomicsHandlerMock{},
 		RatingsConfig:            &testscommon.RatingsInfoMock{},
 		RatingHandler:            &testscommon.RaterMock{},
 		NodesConfig:              &genesisMocks.NodesSetupStub{},
diff --git a/testscommon/economicsmocks/economicsDataHandlerStub.go b/testscommon/economicsmocks/economicsDataHandlerStub.go
deleted file mode 100644
index a69206b12e6..00000000000
--- a/testscommon/economicsmocks/economicsDataHandlerStub.go
+++ /dev/null
@@ -1,381 +0,0 @@
-package economicsmocks
-
-import (
-	"math/big"
-
-	"github.com/multiversx/mx-chain-core-go/core"
-	"github.com/multiversx/mx-chain-core-go/data"
-)
-
-// EconomicsHandlerStub -
-type EconomicsHandlerStub struct {
-	MaxGasLimitPerBlockCalled                           func(shardID uint32) uint64
-	MaxGasLimitPerMiniBlockCalled                       func() uint64
-	MaxGasLimitPerBlockForSafeCrossShardCalled          func() uint64
-	MaxGasLimitPerMiniBlockForSafeCrossShardCalled      func() uint64
-	MaxGasLimitPerTxCalled                              func() uint64
-	ComputeGasLimitCalled                               func(tx data.TransactionWithFeeHandler) uint64
-	ComputeMoveBalanceFeeCalled                         func(tx data.TransactionWithFeeHandler) *big.Int
-	ComputeTxFeeCalled                                  func(tx data.TransactionWithFeeHandler) *big.Int
-	CheckValidityTxValuesCalled                         func(tx data.TransactionWithFeeHandler) error
-	DeveloperPercentageCalled                           func() float64
-	MinGasPriceCalled                                   func() uint64
-	GasPriceModifierCalled                              func() float64
-	LeaderPercentageCalled                              func() float64
-	ProtocolSustainabilityPercentageCalled              func() float64
-	ProtocolSustainabilityAddressCalled                 func() string
-	MinInflationRateCalled                              func() float64
-	MaxInflationRateCalled                              func(year uint32) float64
-	GasPerDataByteCalled                                func() uint64
-	MinGasLimitCalled                                   func() uint64
-	ExtraGasLimitGuardedTxCalled                        func() uint64
-	MaxGasPriceSetGuardianCalled                        func() uint64
-	GenesisTotalSupplyCalled                            func() *big.Int
-	ComputeFeeForProcessingCalled                       func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int
-	RewardsTopUpGradientPointCalled                     func() *big.Int
-	RewardsTopUpFactorCalled                            func() float64
-	SplitTxGasInCategoriesCalled                        func(tx data.TransactionWithFeeHandler) (uint64, uint64)
-	GasPriceForProcessingCalled                         func(tx data.TransactionWithFeeHandler) uint64
-	GasPriceForMoveCalled                               func(tx data.TransactionWithFeeHandler) uint64
-	MinGasPriceProcessingCalled                         func() uint64
-	ComputeGasUsedAndFeeBasedOnRefundValueCalled        func(tx data.TransactionWithFeeHandler, refundValue *big.Int) (uint64, *big.Int)
-	ComputeTxFeeBasedOnGasUsedCalled                    func(tx data.TransactionWithFeeHandler, gasUsed uint64) *big.Int
-	ComputeGasLimitBasedOnBalanceCalled                 func(tx data.TransactionWithFeeHandler, balance *big.Int) (uint64, error)
-	SetStatusHandlerCalled                              func(statusHandler core.AppStatusHandler) error
-	ComputeTxFeeInEpochCalled                           func(tx data.TransactionWithFeeHandler, epoch uint32) *big.Int
-	ComputeGasLimitInEpochCalled                        func(tx data.TransactionWithFeeHandler, epoch uint32) uint64
-	ComputeGasUsedAndFeeBasedOnRefundValueInEpochCalled func(tx data.TransactionWithFeeHandler, refundValue *big.Int, epoch uint32) (uint64, *big.Int)
-	ComputeTxFeeBasedOnGasUsedInEpochCalled             func(tx data.TransactionWithFeeHandler, gasUsed uint64, epoch uint32) *big.Int
-	ComputeMoveBalanceFeeInEpochCalled                  func(tx data.TransactionWithFeeHandler, epoch uint32) *big.Int
-	ComputeGasUnitsFromRefundValueCalled                func(tx data.TransactionWithFeeHandler, refundValue *big.Int, epoch uint32) uint64
-}
-
-// ComputeGasUnitsFromRefundValue -
-func (e *EconomicsHandlerStub) ComputeGasUnitsFromRefundValue(tx data.TransactionWithFeeHandler, refundValue *big.Int, epoch uint32) uint64 {
-	if e.ComputeGasUnitsFromRefundValueCalled != nil {
-		return e.ComputeGasUnitsFromRefundValueCalled(tx, refundValue, epoch)
-	}
-
-	return 0
-}
-
-// ComputeFeeForProcessing -
-func (e *EconomicsHandlerStub) ComputeFeeForProcessing(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int {
-	if e.ComputeFeeForProcessingCalled != nil {
-		return e.ComputeFeeForProcessingCalled(tx, gasToUse)
-	}
-	return big.NewInt(0)
-}
-
-// ComputeGasLimitBasedOnBalance -
-func (e *EconomicsHandlerStub) ComputeGasLimitBasedOnBalance(tx data.TransactionWithFeeHandler, balance *big.Int) (uint64, error) {
-	if e.ComputeGasLimitBasedOnBalanceCalled != nil {
-		return e.ComputeGasLimitBasedOnBalanceCalled(tx, balance)
-	}
-	return 0, nil
-}
-
-// LeaderPercentage -
-func (e *EconomicsHandlerStub) LeaderPercentage() float64 {
-	if e.LeaderPercentageCalled != nil {
-		return e.LeaderPercentageCalled()
-	}
-	return 0.0
-}
-
-// ProtocolSustainabilityPercentage -
-func (e *EconomicsHandlerStub) ProtocolSustainabilityPercentage() float64 {
-	if e.ProtocolSustainabilityAddressCalled != nil {
-		return e.ProtocolSustainabilityPercentageCalled()
-	}
-	return 0.0
-}
-
-// ProtocolSustainabilityAddress -
-func (e *EconomicsHandlerStub) ProtocolSustainabilityAddress() string {
-	if e.ProtocolSustainabilityAddressCalled != nil {
-		return e.ProtocolSustainabilityAddressCalled()
-	}
-	return ""
-}
-
-// MinInflationRate -
-func (e *EconomicsHandlerStub) MinInflationRate() float64 {
-	if e.MinInflationRateCalled != nil {
-		return e.MinInflationRateCalled()
-	}
-	return 0.0
-}
-
-// MaxInflationRate -
-func (e *EconomicsHandlerStub) MaxInflationRate(year uint32) float64 {
-	if e.MaxInflationRateCalled != nil {
-		return e.MaxInflationRateCalled(year)
-	}
-	return 0.0
-}
-
-// GasPerDataByte -
-func (e *EconomicsHandlerStub) GasPerDataByte() uint64 {
-	if e.GasPerDataByteCalled != nil {
-		return e.GasPerDataByteCalled()
-	}
-	return 0
-}
-
-// MinGasLimit -
-func (e *EconomicsHandlerStub) MinGasLimit() uint64 {
-	if e.MinGasLimitCalled != nil {
-		return e.MinGasLimitCalled()
-	}
-	return 0
-}
-
-// ExtraGasLimitGuardedTx -
-func (e *EconomicsHandlerStub) ExtraGasLimitGuardedTx() uint64 {
-	if e.ExtraGasLimitGuardedTxCalled != nil {
-		return e.ExtraGasLimitGuardedTxCalled()
-	}
-	return 0
-}
-
-// MaxGasPriceSetGuardian -
-func (e *EconomicsHandlerStub) MaxGasPriceSetGuardian() uint64 {
-	if e.MaxGasPriceSetGuardianCalled != nil {
-		return e.MaxGasPriceSetGuardianCalled()
-	}
-	return 0
-}
-
-// GenesisTotalSupply -
-func (e *EconomicsHandlerStub) GenesisTotalSupply() *big.Int {
-	if e.GenesisTotalSupplyCalled != nil {
-		return e.GenesisTotalSupplyCalled()
-	}
-	return big.NewInt(100000000)
-}
-
-// GasPriceModifier -
-func (e *EconomicsHandlerStub) GasPriceModifier() float64 {
-	if e.GasPriceModifierCalled != nil {
-		return e.GasPriceModifierCalled()
-	}
-	return 1.0
-}
-
-// MinGasPrice -
-func (e *EconomicsHandlerStub) MinGasPrice() uint64 {
-	if e.MinGasPriceCalled != nil {
-		return e.MinGasPriceCalled()
-	}
-	return 0
-}
-
-// DeveloperPercentage -
-func (e *EconomicsHandlerStub) DeveloperPercentage() float64 {
-	if e.DeveloperPercentageCalled != nil {
-		return e.DeveloperPercentageCalled()
-	}
-
-	return 0.0
-}
-
-// MaxGasLimitPerBlock -
-func (e *EconomicsHandlerStub) MaxGasLimitPerBlock(shardID uint32) uint64 {
-	if e.MaxGasLimitPerBlockCalled != nil {
-		return e.MaxGasLimitPerBlockCalled(shardID)
-	}
-	return 1000000
-}
-
-// MaxGasLimitPerMiniBlock -
-func (e *EconomicsHandlerStub) MaxGasLimitPerMiniBlock(uint32) uint64 {
-	if e.MaxGasLimitPerMiniBlockCalled != nil {
-		return e.MaxGasLimitPerMiniBlockCalled()
-	}
-	return 1000000
-}
-
-// MaxGasLimitPerBlockForSafeCrossShard -
-func (e *EconomicsHandlerStub) MaxGasLimitPerBlockForSafeCrossShard() uint64 {
-	if e.MaxGasLimitPerBlockForSafeCrossShardCalled != nil {
-		return e.MaxGasLimitPerBlockForSafeCrossShardCalled()
-	}
-	return 1000000
-}
-
-// MaxGasLimitPerMiniBlockForSafeCrossShard -
-func (e *EconomicsHandlerStub) MaxGasLimitPerMiniBlockForSafeCrossShard() uint64 {
-	if e.MaxGasLimitPerMiniBlockForSafeCrossShardCalled != nil {
-		return e.MaxGasLimitPerMiniBlockForSafeCrossShardCalled()
-	}
-	return 1000000
-}
-
-// MaxGasLimitPerTx -
-func (e *EconomicsHandlerStub) MaxGasLimitPerTx() uint64 {
-	if e.MaxGasLimitPerTxCalled != nil {
-		return e.MaxGasLimitPerTxCalled()
-	}
-	return 1000000
-}
-
-// ComputeGasLimit -
-func (e *EconomicsHandlerStub) ComputeGasLimit(tx data.TransactionWithFeeHandler) uint64 {
-	if e.ComputeGasLimitCalled != nil {
-		return e.ComputeGasLimitCalled(tx)
-	}
-	return 0
-}
-
-// ComputeMoveBalanceFee -
-func (e *EconomicsHandlerStub) ComputeMoveBalanceFee(tx data.TransactionWithFeeHandler) *big.Int {
-	if e.ComputeMoveBalanceFeeCalled != nil {
-		return e.ComputeMoveBalanceFeeCalled(tx)
-	}
-	return big.NewInt(0)
-}
-
-// ComputeMoveBalanceFeeInEpoch -
-func (e *EconomicsHandlerStub) ComputeMoveBalanceFeeInEpoch(tx data.TransactionWithFeeHandler, epoch uint32) *big.Int {
-	if e.ComputeMoveBalanceFeeInEpochCalled != nil {
-		return e.ComputeMoveBalanceFeeInEpochCalled(tx, epoch)
-	}
-	return big.NewInt(0)
-}
-
-// ComputeTxFee -
-func (e *EconomicsHandlerStub) ComputeTxFee(tx data.TransactionWithFeeHandler) *big.Int {
-	if e.ComputeTxFeeCalled != nil {
-		return e.ComputeTxFeeCalled(tx)
-	}
-	return big.NewInt(0)
-}
-
-// CheckValidityTxValues -
-func (e *EconomicsHandlerStub) CheckValidityTxValues(tx data.TransactionWithFeeHandler) error {
-	if e.CheckValidityTxValuesCalled != nil {
-		return e.CheckValidityTxValuesCalled(tx)
-	}
-	return nil
-}
-
-// RewardsTopUpGradientPoint -
-func (e *EconomicsHandlerStub) RewardsTopUpGradientPoint() *big.Int {
-	if e.RewardsTopUpGradientPointCalled != nil {
-		return e.RewardsTopUpGradientPointCalled()
-	}
-
-	return big.NewInt(0)
-}
-
-// RewardsTopUpFactor -
-func (e *EconomicsHandlerStub) RewardsTopUpFactor() float64 {
-	if e.RewardsTopUpFactorCalled != nil {
-		return e.RewardsTopUpFactorCalled()
-	}
-
-	return 0
-}
-
-// SplitTxGasInCategories -
-func (e *EconomicsHandlerStub) SplitTxGasInCategories(tx data.TransactionWithFeeHandler) (uint64, uint64) {
-	if e.SplitTxGasInCategoriesCalled != nil {
-		return e.SplitTxGasInCategoriesCalled(tx)
-	}
-
-	processingGas := uint64(0)
-	if e.ComputeGasLimit(tx) > e.MinGasLimit() {
-		processingGas = e.ComputeGasLimit(tx) - e.MinGasLimit()
-	}
-
-	return e.MinGasLimit(), processingGas
-}
-
-// GasPriceForProcessing -
-func (e *EconomicsHandlerStub) GasPriceForProcessing(tx data.TransactionWithFeeHandler) uint64 {
-	if e.GasPriceForProcessingCalled != nil {
-		return e.GasPriceForProcessingCalled(tx)
-	}
-	return 1
-}
-
-// GasPriceForMove -
-func (e *EconomicsHandlerStub) GasPriceForMove(tx data.TransactionWithFeeHandler) uint64 {
-	if e.GasPriceForMoveCalled != nil {
-		return e.GasPriceForMoveCalled(tx)
-	}
-	return 100
-}
-
-// MinGasPriceForProcessing -
-func (e *EconomicsHandlerStub) MinGasPriceForProcessing() uint64 {
-	if e.MinGasPriceProcessingCalled != nil {
-		return e.MinGasPriceProcessingCalled()
-	}
-
-	return 1
-}
-
-// ComputeGasUsedAndFeeBasedOnRefundValue -
-func (e *EconomicsHandlerStub) ComputeGasUsedAndFeeBasedOnRefundValue(tx data.TransactionWithFeeHandler, refundValue *big.Int) (uint64, *big.Int) {
-	if e.ComputeGasUsedAndFeeBasedOnRefundValueCalled != nil {
-		return e.ComputeGasUsedAndFeeBasedOnRefundValueCalled(tx, refundValue)
-	}
-
-	return 0, nil
-}
-
-// ComputeTxFeeBasedOnGasUsed -
-func (e *EconomicsHandlerStub) ComputeTxFeeBasedOnGasUsed(tx data.TransactionWithFeeHandler, gasUsed uint64) *big.Int {
-	if e.ComputeTxFeeBasedOnGasUsedCalled != nil {
-		return e.ComputeTxFeeBasedOnGasUsedCalled(tx, gasUsed)
-	}
-
-	return nil
-}
-
-// SetStatusHandler -
-func (e *EconomicsHandlerStub) SetStatusHandler(statusHandler core.AppStatusHandler) error {
-	if e.SetStatusHandlerCalled != nil {
-		return e.SetStatusHandlerCalled(statusHandler)
-	}
-	return nil
-}
-
-// ComputeTxFeeInEpoch -
-func (e *EconomicsHandlerStub) ComputeTxFeeInEpoch(tx data.TransactionWithFeeHandler, epoch uint32) *big.Int {
-	if e.ComputeTxFeeInEpochCalled != nil {
-		return e.ComputeTxFeeInEpochCalled(tx, epoch)
-	}
-	return nil
-}
-
-// ComputeGasLimitInEpoch -
-func (e *EconomicsHandlerStub) ComputeGasLimitInEpoch(tx data.TransactionWithFeeHandler, epoch uint32) uint64 {
-	if e.ComputeGasLimitInEpochCalled != nil {
-		return e.ComputeGasLimitInEpochCalled(tx, epoch)
-	}
-	return 0
-}
-
-// ComputeGasUsedAndFeeBasedOnRefundValueInEpoch -
-func (e *EconomicsHandlerStub) ComputeGasUsedAndFeeBasedOnRefundValueInEpoch(tx data.TransactionWithFeeHandler, refundValue *big.Int, epoch uint32) (uint64, *big.Int) {
-	if e.ComputeGasUsedAndFeeBasedOnRefundValueInEpochCalled != nil {
-		return e.ComputeGasUsedAndFeeBasedOnRefundValueInEpochCalled(tx, refundValue, epoch)
-	}
-	return 0, big.NewInt(0)
-}
-
-// ComputeTxFeeBasedOnGasUsedInEpoch -
-func (e *EconomicsHandlerStub) ComputeTxFeeBasedOnGasUsedInEpoch(tx data.TransactionWithFeeHandler, gasUsed uint64, epoch uint32) *big.Int {
-	if e.ComputeTxFeeBasedOnGasUsedInEpochCalled != nil {
-		return e.ComputeTxFeeBasedOnGasUsedInEpochCalled(tx, gasUsed, epoch)
-	}
-	return nil
-}
-
-// IsInterfaceNil returns true if there is no value under the interface
-func (e *EconomicsHandlerStub) IsInterfaceNil() bool {
-	return e == nil
-}
diff --git a/testscommon/economicsmocks/economicsHandlerMock.go b/testscommon/economicsmocks/economicsHandlerMock.go
index 304e86e37d2..894637846f6 100644
--- a/testscommon/economicsmocks/economicsHandlerMock.go
+++ b/testscommon/economicsmocks/economicsHandlerMock.go
@@ -30,6 +30,7 @@ type EconomicsHandlerMock struct {
 	ComputeTxFeeCalled                                  func(tx data.TransactionWithFeeHandler) *big.Int
 	DeveloperPercentageCalled                           func() float64
 	MinGasPriceCalled                                   func() uint64
+	MinGasLimitCalled                                   func() uint64
 	GasPerDataByteCalled                                func() uint64
 	RewardsTopUpGradientPointCalled                     func() *big.Int
 	RewardsTopUpFactorCalled                            func() float64
@@ -47,6 +48,14 @@ type EconomicsHandlerMock struct {
 	ComputeGasLimitInEpochCalled                        func(tx data.TransactionWithFeeHandler, epoch uint32) uint64
 	ComputeGasUsedAndFeeBasedOnRefundValueInEpochCalled func(tx data.TransactionWithFeeHandler, refundValue *big.Int, epoch uint32) (uint64, *big.Int)
 	ComputeTxFeeBasedOnGasUsedInEpochCalled             func(tx data.TransactionWithFeeHandler, gasUsed uint64, epoch uint32) *big.Int
+	GenesisTotalSupplyCalled                            func() *big.Int
+	MaxGasPriceSetGuardianCalled                        func() uint64
+	LeaderPercentageInEpochCalled                       func(epoch uint32) float64
+	DeveloperPercentageInEpochCalled                    func(epoch uint32) float64
+	ProtocolSustainabilityPercentageInEpochCalled       func(epoch uint32) float64
+	ProtocolSustainabilityAddressInEpochCalled          func(epoch uint32) string
+	RewardsTopUpGradientPointInEpochCalled              func(epoch uint32) *big.Int
+	RewardsTopUpFactorInEpochCalled                     func(epoch uint32) float64
 }
 
 // ComputeGasUnitsFromRefundValue -
@@ -89,6 +98,9 @@ func (ehm *EconomicsHandlerMock) MinGasPrice() uint64 {
 
 // MinGasLimit will return min gas limit
 func (ehm *EconomicsHandlerMock) MinGasLimit() uint64 {
+	if ehm.MinGasLimitCalled != nil {
+		return ehm.MinGasLimitCalled()
+	}
 	return 0
 }
 
@@ -99,6 +111,9 @@ func (ehm *EconomicsHandlerMock) ExtraGasLimitGuardedTx() uint64 {
 
 // MaxGasPriceSetGuardian -
 func (ehm *EconomicsHandlerMock) MaxGasPriceSetGuardian() uint64 {
+	if ehm.MaxGasPriceSetGuardianCalled != nil {
+		return ehm.MaxGasPriceSetGuardianCalled()
+	}
 	return 0
 }
 
@@ -109,11 +124,17 @@ func (ehm *EconomicsHandlerMock) GasPerDataByte() uint64 {
 
 // DeveloperPercentage -
 func (ehm *EconomicsHandlerMock) DeveloperPercentage() float64 {
-	return ehm.DeveloperPercentageCalled()
+	if ehm.DeveloperPercentageCalled != nil {
+		return ehm.DeveloperPercentageCalled()
+	}
+	return 0.0
 }
 
 // GenesisTotalSupply -
 func (ehm *EconomicsHandlerMock) GenesisTotalSupply() *big.Int {
+	if ehm.GenesisTotalSupplyCalled != nil {
+		return ehm.GenesisTotalSupplyCalled()
+	}
 	return big.NewInt(0)
 }
 
@@ -348,6 +369,54 @@ func (ehm *EconomicsHandlerMock) ComputeTxFeeBasedOnGasUsedInEpoch(tx data.Trans
 	return nil
 }
 
+// LeaderPercentageInEpoch -
+func (ehm *EconomicsHandlerMock) LeaderPercentageInEpoch(epoch uint32) float64 {
+	if ehm.LeaderPercentageInEpochCalled != nil {
+		return ehm.LeaderPercentageInEpochCalled(epoch)
+	}
+	return 0
+}
+
+// DeveloperPercentageInEpoch -
+func (ehm *EconomicsHandlerMock) DeveloperPercentageInEpoch(epoch uint32) float64 {
+	if ehm.DeveloperPercentageInEpochCalled != nil {
+		return ehm.DeveloperPercentageInEpochCalled(epoch)
+	}
+	return 0
+}
+
+// ProtocolSustainabilityPercentageInEpoch -
+func (ehm *EconomicsHandlerMock) ProtocolSustainabilityPercentageInEpoch(epoch uint32) float64 {
+	if ehm.ProtocolSustainabilityPercentageInEpochCalled != nil {
+		return ehm.ProtocolSustainabilityPercentageInEpochCalled(epoch)
+	}
+	return 0
+}
+
+// ProtocolSustainabilityAddressInEpoch -
+func (ehm *EconomicsHandlerMock) ProtocolSustainabilityAddressInEpoch(epoch uint32) string {
+	if ehm.ProtocolSustainabilityAddressInEpochCalled != nil {
+		return ehm.ProtocolSustainabilityAddressInEpochCalled(epoch)
+	}
+	return ""
+}
+
+// RewardsTopUpGradientPointInEpoch -
+func (ehm *EconomicsHandlerMock) RewardsTopUpGradientPointInEpoch(epoch uint32) *big.Int {
+	if ehm.RewardsTopUpGradientPointInEpochCalled != nil {
+		return ehm.RewardsTopUpGradientPointInEpochCalled(epoch)
+	}
+	return big.NewInt(0)
+}
+
+// RewardsTopUpFactorInEpoch -
+func (ehm *EconomicsHandlerMock) RewardsTopUpFactorInEpoch(epoch uint32) float64 {
+	if ehm.RewardsTopUpFactorInEpochCalled != nil {
+		return ehm.RewardsTopUpFactorInEpochCalled(epoch)
+	}
+	return 0
+}
+
 // IsInterfaceNil returns true if there is no value under the interface
 func (ehm *EconomicsHandlerMock) IsInterfaceNil() bool {
 	return ehm == nil
diff --git a/testscommon/stakingcommon/stakingCommon.go b/testscommon/stakingcommon/stakingCommon.go
index 1af9b441b9c..ed41d9917f8 100644
--- a/testscommon/stakingcommon/stakingCommon.go
+++ b/testscommon/stakingcommon/stakingCommon.go
@@ -10,6 +10,7 @@ import (
 	"github.com/multiversx/mx-chain-go/process"
 	economicsHandler "github.com/multiversx/mx-chain-go/process/economics"
 	"github.com/multiversx/mx-chain-go/state"
+	"github.com/multiversx/mx-chain-go/testscommon"
 	"github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock"
 	"github.com/multiversx/mx-chain-go/testscommon/epochNotifier"
 	"github.com/multiversx/mx-chain-go/vm"
@@ -277,6 +278,8 @@ func CreateEconomicsData() process.EconomicsDataHandler {
 		EpochNotifier:       &epochNotifier.EpochNotifierStub{},
 		EnableEpochsHandler: &enableEpochsHandlerMock.EnableEpochsHandlerStub{},
 		TxVersionChecker:    &disabled.TxVersionChecker{},
+		PubkeyConverter:     &testscommon.PubkeyConverterStub{},
+		ShardCoordinator:    &testscommon.ShardsCoordinatorMock{},
 	}
 	economicsData, _ := economicsHandler.NewEconomicsData(argsNewEconomicsData)
 	return economicsData
diff --git a/vm/factory/systemSCFactory_test.go b/vm/factory/systemSCFactory_test.go
index 76c46685cb1..4f6f6d068ec 100644
--- a/vm/factory/systemSCFactory_test.go
+++ b/vm/factory/systemSCFactory_test.go
@@ -3,12 +3,14 @@ package factory
 import (
 	"errors"
 	"fmt"
+	"math/big"
 	"testing"
 
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/testscommon"
+	"github.com/multiversx/mx-chain-go/testscommon/economicsmocks"
 	"github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock"
 	"github.com/multiversx/mx-chain-go/testscommon/hashingMocks"
 	"github.com/multiversx/mx-chain-go/vm"
@@ -24,8 +26,12 @@ func createMockNewSystemScFactoryArgs() ArgsNewSystemSCFactory {
 	gasMap = defaults.FillGasMapInternal(gasMap, 1)
 	gasSchedule := testscommon.NewGasScheduleNotifierMock(gasMap)
 	return ArgsNewSystemSCFactory{
-		SystemEI:            &mock.SystemEIStub{},
-		Economics:           &mock.EconomicsHandlerStub{},
+		SystemEI: &mock.SystemEIStub{},
+		Economics: &economicsmocks.EconomicsHandlerMock{
+			GenesisTotalSupplyCalled: func() *big.Int {
+				return big.NewInt(100000000)
+			},
+		},
 		SigVerifier:         &mock.MessageSignVerifierMock{},
 		GasSchedule:         gasSchedule,
 		NodesConfigProvider: &mock.NodesConfigProviderStub{},
diff --git a/vm/mock/validatorSettingsStub.go b/vm/mock/validatorSettingsStub.go
deleted file mode 100644
index 7715414b67d..00000000000
--- a/vm/mock/validatorSettingsStub.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package mock
-
-import "math/big"
-
-// EconomicsHandlerStub -
-type EconomicsHandlerStub struct {
-	TotalSupplyCalled func() *big.Int
-}
-
-// GenesisTotalSupply -
-func (v *EconomicsHandlerStub) GenesisTotalSupply() *big.Int {
-	if v.TotalSupplyCalled != nil {
-		return v.TotalSupplyCalled()
-	}
-	return big.NewInt(100000000000)
-}
-
-// IsInterfaceNil -
-func (v *EconomicsHandlerStub) IsInterfaceNil() bool {
-	return v == nil
-}