multiversx · sasurobert · Nov 14, 2024 · Jun 18, 2024 · Jun 18, 2024 · Jun 18, 2024
diff --git a/cmd/node/config/economics.toml b/cmd/node/config/economics.toml
@@ -39,9 +39,10 @@
 
 [FeeSettings]
     GasLimitSettings = [
-        {EnableEpoch = 0, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "1500000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "15000000000", MaxGasLimitPerTx = "1500000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000"},
-        {EnableEpoch = 1, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000"},
-        {EnableEpoch = 2, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000"},
+        {EnableEpoch = 0, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "1500000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "15000000000", MaxGasLimitPerTx = "1500000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "10"},
+        {EnableEpoch = 1, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "10"},
+        {EnableEpoch = 2, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "10"},
+        {EnableEpoch = 3, MaxGasLimitPerBlock = "1500000000", MaxGasLimitPerMiniBlock = "250000000", MaxGasLimitPerMetaBlock = "15000000000", MaxGasLimitPerMetaMiniBlock = "250000000", MaxGasLimitPerTx = "600000000", MinGasLimit = "50000", ExtraGasLimitGuardedTx  = "50000", MaxGasHigherFactorAccepted = "2"},
     ]
     MinGasPrice             = "1000000000" #will yield min tx fee of 0.00005 eGLD
     GasPriceModifier        = 0.01

diff --git a/config/economicsConfig.go b/config/economicsConfig.go
@@ -41,6 +41,7 @@ type GasLimitSetting struct {
 	MaxGasLimitPerTx            string
 	MinGasLimit                 string
 	ExtraGasLimitGuardedTx      string
+	MaxGasHigherFactorAccepted  string
 }
 
 // FeeSettings will hold economics fee settings

diff --git a/config/tomlConfig_test.go b/config/tomlConfig_test.go
@@ -271,7 +271,9 @@ func TestTomlEconomicsParser(t *testing.T) {
 	minGasLimit := "18446744073709551615"
 	extraGasLimitGuardedTx := "50000"
 	maxGasPriceSetGuardian := "1234567"
+	maxGasHigherFactorAccepted := "10"
 	protocolSustainabilityAddress := "erd1932eft30w753xyvme8d49qejgkjc09n5e49w4mwdjtm0neld797su0dlxp"
+
 	denomination := 18
 
 	cfgEconomicsExpected := EconomicsConfig{
@@ -299,9 +301,10 @@ func TestTomlEconomicsParser(t *testing.T) {
 		FeeSettings: FeeSettings{
 			GasLimitSettings: []GasLimitSetting{
 				{
-					MaxGasLimitPerBlock:    maxGasLimitPerBlock,
-					MinGasLimit:            minGasLimit,
-					ExtraGasLimitGuardedTx: extraGasLimitGuardedTx,
+					MaxGasLimitPerBlock:        maxGasLimitPerBlock,
+					MinGasLimit:                minGasLimit,
+					ExtraGasLimitGuardedTx:     extraGasLimitGuardedTx,
+					MaxGasHigherFactorAccepted: maxGasHigherFactorAccepted,
 				},
 			},
 			MinGasPrice:            minGasPrice,
@@ -328,7 +331,7 @@ func TestTomlEconomicsParser(t *testing.T) {
     ProtocolSustainabilityAddress = "` + protocolSustainabilityAddress + `"
 
 [FeeSettings]
-    GasLimitSettings = [{EnableEpoch = 0, MaxGasLimitPerBlock = "` + maxGasLimitPerBlock + `", MaxGasLimitPerMiniBlock = "", MaxGasLimitPerMetaBlock = "", MaxGasLimitPerMetaMiniBlock = "", MaxGasLimitPerTx = "", MinGasLimit = "` + minGasLimit + `", ExtraGasLimitGuardedTx = "` + extraGasLimitGuardedTx + `"}] 
+    GasLimitSettings = [{EnableEpoch = 0, MaxGasLimitPerBlock = "` + maxGasLimitPerBlock + `", MaxGasLimitPerMiniBlock = "", MaxGasLimitPerMetaBlock = "", MaxGasLimitPerMetaMiniBlock = "", MaxGasLimitPerTx = "", MinGasLimit = "` + minGasLimit + `", ExtraGasLimitGuardedTx = "` + extraGasLimitGuardedTx + `", MaxGasHigherFactorAccepted = "` + maxGasHigherFactorAccepted + `"}] 
     MinGasPrice = "` + minGasPrice + `"
 	MaxGasPriceSetGuardian = "` + maxGasPriceSetGuardian + `"
 `

diff --git a/genesis/process/disabled/feeHandler.go b/genesis/process/disabled/feeHandler.go
@@ -72,6 +72,11 @@ func (fh *FeeHandler) MaxGasLimitPerMiniBlockForSafeCrossShard() uint64 {
 	return math.MaxUint64
 }
 
+// MaxGasHigherFactorAccepted returns 10
+func (fh *FeeHandler) MaxGasHigherFactorAccepted() uint64 {
+	return 10
+}
+
 // MaxGasLimitPerTx returns max uint64
 func (fh *FeeHandler) MaxGasLimitPerTx() uint64 {
 	return math.MaxUint64
@@ -164,22 +169,22 @@ func (fh *FeeHandler) ComputeTxFeeBasedOnGasUsed(_ data.TransactionWithFeeHandle
 }
 
 // ComputeTxFeeInEpoch returns 0
-func (fh *FeeHandler) ComputeTxFeeInEpoch(tx data.TransactionWithFeeHandler, epoch uint32) *big.Int {
+func (fh *FeeHandler) ComputeTxFeeInEpoch(_ data.TransactionWithFeeHandler, _ uint32) *big.Int {
 	return big.NewInt(0)
 }
 
 // ComputeGasLimitInEpoch returns 0
-func (fh *FeeHandler) ComputeGasLimitInEpoch(tx data.TransactionWithFeeHandler, epoch uint32) uint64 {
+func (fh *FeeHandler) ComputeGasLimitInEpoch(_ data.TransactionWithFeeHandler, _ uint32) uint64 {
 	return 0
 }
 
 // ComputeGasUsedAndFeeBasedOnRefundValueInEpoch returns 0
-func (fh *FeeHandler) ComputeGasUsedAndFeeBasedOnRefundValueInEpoch(tx data.TransactionWithFeeHandler, refundValue *big.Int, epoch uint32) (uint64, *big.Int) {
+func (fh *FeeHandler) ComputeGasUsedAndFeeBasedOnRefundValueInEpoch(_ data.TransactionWithFeeHandler, _ *big.Int, _ uint32) (uint64, *big.Int) {
 	return 0, big.NewInt(0)
 }
 
 // ComputeTxFeeBasedOnGasUsedInEpoch returns 0
-func (fh *FeeHandler) ComputeTxFeeBasedOnGasUsedInEpoch(tx data.TransactionWithFeeHandler, gasUsed uint64, epoch uint32) *big.Int {
+func (fh *FeeHandler) ComputeTxFeeBasedOnGasUsedInEpoch(_ data.TransactionWithFeeHandler, _ uint64, _ uint32) *big.Int {
 	return big.NewInt(0)
 }
 

diff --git a/integrationTests/chainSimulator/relayedTx/relayedTx_test.go b/integrationTests/chainSimulator/relayedTx/relayedTx_test.go
@@ -96,7 +96,7 @@ func testFixRelayedMoveBalanceWithChainSimulatorScCall(
 		require.NoError(t, err)
 
 		// send relayed tx, fix still not active
-		innerTx = generateTransaction(owner.Bytes, 2, scAddressBytes, big.NewInt(0), txDataAdd, 3000000)
+		innerTx = generateTransaction(owner.Bytes, 2, scAddressBytes, big.NewInt(0), txDataAdd, 1230000)
 		marshalledTx, err = json.Marshal(innerTx)
 		require.NoError(t, err)
 		txData = []byte("relayedTx@" + hex.EncodeToString(marshalledTx))
@@ -119,7 +119,7 @@ func testFixRelayedMoveBalanceWithChainSimulatorScCall(
 		require.NoError(t, err)
 
 		// send relayed tx after fix
-		innerTx = generateTransaction(owner.Bytes, 3, scAddressBytes, big.NewInt(0), txDataAdd, 3000000)
+		innerTx = generateTransaction(owner.Bytes, 3, scAddressBytes, big.NewInt(0), txDataAdd, 1500000)
 		marshalledTx, err = json.Marshal(innerTx)
 		require.NoError(t, err)
 		txData = []byte("relayedTx@" + hex.EncodeToString(marshalledTx))

diff --git a/integrationTests/chainSimulator/staking/stake/stakeAndUnStake_test.go b/integrationTests/chainSimulator/staking/stake/stakeAndUnStake_test.go
@@ -1884,7 +1884,7 @@ func testChainSimulatorDirectStakedWithdrawUnstakedFundsInBatches(t *testing.T,
 	require.Nil(t, err)
 	require.NotNil(t, unStakeTx)
 
-	unStakeTxFee, _ := big.NewInt(0).SetString(unStakeTx.Fee, 10)
+	unStakeTxFee1, _ := big.NewInt(0).SetString(unStakeTx.Fee, 10)
 
 	testEpoch := targetEpoch + 1
 	err = cs.GenerateBlocksUntilEpochIsReached(testEpoch)
@@ -1898,6 +1898,8 @@ func testChainSimulatorDirectStakedWithdrawUnstakedFundsInBatches(t *testing.T,
 	require.Nil(t, err)
 	require.NotNil(t, unStakeTx)
 
+	unStakeTxFee2, _ := big.NewInt(0).SetString(unStakeTx.Fee, 10)
+
 	testEpoch++
 	err = cs.GenerateBlocksUntilEpochIsReached(testEpoch)
 	require.Nil(t, err)
@@ -1910,6 +1912,8 @@ func testChainSimulatorDirectStakedWithdrawUnstakedFundsInBatches(t *testing.T,
 	require.Nil(t, err)
 	require.NotNil(t, unStakeTx)
 
+	unStakeTxFee3, _ := big.NewInt(0).SetString(unStakeTx.Fee, 10)
+
 	testEpoch++
 	err = cs.GenerateBlocksUntilEpochIsReached(testEpoch)
 	require.Nil(t, err)
@@ -1977,9 +1981,9 @@ func testChainSimulatorDirectStakedWithdrawUnstakedFundsInBatches(t *testing.T,
 
 	txsFee.Add(txsFee, stakeTxFee)
 	txsFee.Add(txsFee, unBondTxFee)
-	txsFee.Add(txsFee, unStakeTxFee)
-	txsFee.Add(txsFee, unStakeTxFee)
-	txsFee.Add(txsFee, unStakeTxFee)
+	txsFee.Add(txsFee, unStakeTxFee1)
+	txsFee.Add(txsFee, unStakeTxFee2)
+	txsFee.Add(txsFee, unStakeTxFee3)
 
 	balanceAfterUnbonding.Add(balanceAfterUnbonding, txsFee)
 

diff --git a/integrationTests/chainSimulator/staking/stakingProvider/delegation_test.go b/integrationTests/chainSimulator/staking/stakingProvider/delegation_test.go
@@ -34,7 +34,7 @@ import (
 var log = logger.GetOrCreate("stakingProvider")
 
 const gasLimitForConvertOperation = 510_000_000
-const gasLimitForDelegationContractCreationOperation = 500_000_000
+const gasLimitForDelegationContractCreationOperation = 100_000_000
 const gasLimitForAddNodesOperation = 500_000_000
 const gasLimitForUndelegateOperation = 500_000_000
 const gasLimitForMergeOperation = 600_000_000

diff --git a/integrationTests/testProcessorNode.go b/integrationTests/testProcessorNode.go
@@ -1151,6 +1151,7 @@ func createDefaultEconomicsConfig() *config.EconomicsConfig {
 					MaxGasLimitPerTx:            maxGasLimitPerBlock,
 					MinGasLimit:                 minGasLimit,
 					ExtraGasLimitGuardedTx:      "50000",
+					MaxGasHigherFactorAccepted:  "10",
 				},
 			},
 			MinGasPrice:            minGasPrice,

diff --git a/integrationTests/vm/testInitializer.go b/integrationTests/vm/testInitializer.go
@@ -359,6 +359,7 @@ func createEconomicsData(enableEpochsConfig config.EnableEpochs, gasPriceModifie
 						MaxGasLimitPerTx:            maxGasLimitPerBlock,
 						MinGasLimit:                 minGasLimit,
 						ExtraGasLimitGuardedTx:      "50000",
+						MaxGasHigherFactorAccepted:  "10",
 					},
 				},
 				MinGasPrice:            minGasPrice,

diff --git a/integrationTests/vm/wasm/utils.go b/integrationTests/vm/wasm/utils.go
@@ -242,6 +242,7 @@ func (context *TestContext) initFeeHandlers() {
 						MaxGasLimitPerTx:            maxGasLimitPerBlock,
 						MinGasLimit:                 minGasLimit,
 						ExtraGasLimitGuardedTx:      "50000",
+						MaxGasHigherFactorAccepted:  "10",
 					},
 				},
 				MinGasPrice:            minGasPrice,

diff --git a/node/chainSimulator/components/coreComponents_test.go b/node/chainSimulator/components/coreComponents_test.go
@@ -73,6 +73,7 @@ func createArgsCoreComponentsHolder() ArgsCoreComponentsHolder {
 						MaxGasLimitPerTx:            "10000000000",
 						MinGasLimit:                 "10",
 						ExtraGasLimitGuardedTx:      "50000",
+						MaxGasHigherFactorAccepted:  "10",
 					},
 				},
 				GasPriceModifier:       0.01,

diff --git a/process/economics/economicsData.go b/process/economics/economicsData.go
@@ -400,6 +400,17 @@ func (ed *economicsData) MaxGasLimitPerBlockForSafeCrossShard() uint64 {
 	return ed.MaxGasLimitPerBlockForSafeCrossShardInEpoch(currentEpoch)
 }
 
+// MaxGasHigherFactorAccepted returns maximum gas higher factor accepted
+func (ed *economicsData) MaxGasHigherFactorAccepted() uint64 {
+	currentEpoch := ed.enableEpochsHandler.GetCurrentEpoch()
+	return ed.MaxGasHigherFactorAcceptedInEpoch(currentEpoch)
+}
+
+// MaxGasHigherFactorAcceptedInEpoch returns maximum gas higher factor accepted for epoch
+func (ed *economicsData) MaxGasHigherFactorAcceptedInEpoch(epoch uint32) uint64 {
+	return ed.getGasHigherFactorAccepted(epoch)
+}
+
 // MaxGasLimitPerBlockForSafeCrossShardInEpoch returns maximum gas limit per block for safe cross shard in a specific epoch
 func (ed *economicsData) MaxGasLimitPerBlockForSafeCrossShardInEpoch(epoch uint32) uint64 {
 	return ed.getMaxGasLimitPerBlockForSafeCrossShard(epoch)

diff --git a/process/economics/economicsData_test.go b/process/economics/economicsData_test.go
@@ -64,6 +64,7 @@ func feeSettingsDummy(gasModifier float64) config.FeeSettings {
 				MaxGasLimitPerTx:            "100000",
 				MinGasLimit:                 "500",
 				ExtraGasLimitGuardedTx:      "50000",
+				MaxGasHigherFactorAccepted:  "10",
 			},
 		},
 		MinGasPrice:            "18446744073709551615",
@@ -84,6 +85,7 @@ func feeSettingsReal() config.FeeSettings {
 				MaxGasLimitPerTx:            "1500000000",
 				MinGasLimit:                 "50000",
 				ExtraGasLimitGuardedTx:      "50000",
+				MaxGasHigherFactorAccepted:  "10",
 			},
 		},
 		MinGasPrice:            "1000000000",
@@ -389,6 +391,36 @@ func TestNewEconomicsData_InvalidExtraGasLimitGuardedTxShouldErr(t *testing.T) {
 	}
 }
 
+func TestNewEconomicsData_InvalidMaxGasHigherFactorAccepted(t *testing.T) {
+	t.Parallel()
+
+	args := createArgsForEconomicsData(1)
+	badExtraMaxGasHigherFactorAccepted := []string{
+		"-1",
+		"-100000000000000000000",
+		"badValue",
+		"",
+		"#########",
+		"11112S",
+		"1111O0000",
+		"10ERD",
+	}
+
+	for _, gasLimitGuardedTx := range badExtraMaxGasHigherFactorAccepted {
+		args.Economics.FeeSettings.GasLimitSettings[0].MaxGasHigherFactorAccepted = gasLimitGuardedTx
+		_, err := economics.NewEconomicsData(args)
+		assert.True(t, errors.Is(err, process.ErrInvalidMaxGasHigherFactorAccepted))
+	}
+
+	args.Economics.FeeSettings.GasLimitSettings[0].MaxGasHigherFactorAccepted = "0"
+	_, err := economics.NewEconomicsData(args)
+	assert.True(t, errors.Is(err, process.ErrInvalidMaxGasHigherFactorAccepted))
+
+	args.Economics.FeeSettings.GasLimitSettings[0].MaxGasHigherFactorAccepted = "2"
+	_, err = economics.NewEconomicsData(args)
+	assert.Nil(t, err)
+}
+
 func TestNewEconomicsData_MaxGasLimitPerBlockLowerThanMinGasLimitShouldErr(t *testing.T) {
 	t.Parallel()
 
@@ -716,6 +748,7 @@ func TestEconomicsData_ConfirmedGasLimitSettingsChangeOrderedConfigs(t *testing.
 			MaxGasLimitPerTx:            "1500000000",
 			MinGasLimit:                 "50000",
 			ExtraGasLimitGuardedTx:      "50000",
+			MaxGasHigherFactorAccepted:  "10",
 		},
 		{
 			EnableEpoch:                 2,
@@ -726,6 +759,7 @@ func TestEconomicsData_ConfirmedGasLimitSettingsChangeOrderedConfigs(t *testing.
 			MaxGasLimitPerTx:            "500000000",
 			MinGasLimit:                 "50000",
 			ExtraGasLimitGuardedTx:      "50000",
+			MaxGasHigherFactorAccepted:  "10",
 		},
 	}
 
@@ -800,6 +834,7 @@ func TestEconomicsData_ConfirmedGasLimitSettingsChangeUnOrderedConfigs(t *testin
 			MaxGasLimitPerTx:            "500000000",
 			MinGasLimit:                 "50000",
 			ExtraGasLimitGuardedTx:      "50000",
+			MaxGasHigherFactorAccepted:  "10",
 		},
 		{
 			EnableEpoch:                 0,
@@ -810,6 +845,7 @@ func TestEconomicsData_ConfirmedGasLimitSettingsChangeUnOrderedConfigs(t *testin
 			MaxGasLimitPerTx:            "1500000000",
 			MinGasLimit:                 "50000",
 			ExtraGasLimitGuardedTx:      "50000",
+			MaxGasHigherFactorAccepted:  "10",
 		},
 	}
 

diff --git a/process/economics/export_test.go b/process/economics/export_test.go
@@ -37,6 +37,7 @@ func (ed *economicsData) GetGasLimitSetting(epoch uint32) *config.GasLimitSettin
 	gasLimitSetting.MaxGasLimitPerTx = strconv.FormatUint(cfg.maxGasLimitPerTx, 10)
 	gasLimitSetting.MinGasLimit = strconv.FormatUint(cfg.minGasLimit, 10)
 	gasLimitSetting.ExtraGasLimitGuardedTx = strconv.FormatUint(cfg.extraGasLimitGuardedTx, 10)
+	gasLimitSetting.MaxGasHigherFactorAccepted = strconv.FormatUint(cfg.maxGasHigherFactorAccepted, 10)
 
 	return gasLimitSetting
 }
diff --git a/process/economics/gasConfigHandler.go b/process/economics/gasConfigHandler.go
@@ -26,6 +26,7 @@ type gasConfig struct {
 	maxGasLimitPerTx            uint64
 	minGasLimit                 uint64
 	extraGasLimitGuardedTx      uint64
+	maxGasHigherFactorAccepted  uint64
 }
 
 type gasConfigHandler struct {
@@ -113,6 +114,12 @@ func (handler *gasConfigHandler) getMaxGasLimitPerMiniBlock(epoch uint32) uint64
 	return gc.maxGasLimitPerMiniBlock
 }
 
+// getMaxGasLimitPerMiniBlock returns max gas limit per mini block in a specific epoch
+func (handler *gasConfigHandler) getGasHigherFactorAccepted(epoch uint32) uint64 {
+	gc := handler.getGasConfigForEpoch(epoch)
+	return gc.maxGasHigherFactorAccepted
+}
+
 // getMaxGasLimitPerBlockForSafeCrossShard returns maximum gas limit per block for safe cross shard in a specific epoch
 func (handler *gasConfigHandler) getMaxGasLimitPerBlockForSafeCrossShard(epoch uint32) uint64 {
 	gc := handler.getGasConfigForEpoch(epoch)
@@ -225,6 +232,11 @@ func checkAndParseGasLimitSettings(gasLimitSetting config.GasLimitSetting) (*gas
 		return nil, fmt.Errorf("%w for epoch %d", process.ErrInvalidExtraGasLimitGuardedTx, gasLimitSetting.EnableEpoch)
 	}
 
+	gc.maxGasHigherFactorAccepted, err = strconv.ParseUint(gasLimitSetting.MaxGasHigherFactorAccepted, conversionBase, bitConversionSize)
+	if err != nil {
+		return nil, fmt.Errorf("%w for epoch %d", process.ErrInvalidMaxGasHigherFactorAccepted, gasLimitSetting.EnableEpoch)
+	}
+
 	if gc.maxGasLimitPerBlock < gc.minGasLimit {
 		return nil, fmt.Errorf("%w: maxGasLimitPerBlock = %d minGasLimit = %d in epoch %d", process.ErrInvalidMaxGasLimitPerBlock, gc.maxGasLimitPerBlock, gc.minGasLimit, gasLimitSetting.EnableEpoch)
 	}
@@ -240,6 +252,9 @@ func checkAndParseGasLimitSettings(gasLimitSetting config.GasLimitSetting) (*gas
 	if gc.maxGasLimitPerTx < gc.minGasLimit {
 		return nil, fmt.Errorf("%w: maxGasLimitPerTx = %d minGasLimit = %d in epoch %d", process.ErrInvalidMaxGasLimitPerTx, gc.maxGasLimitPerTx, gc.minGasLimit, gasLimitSetting.EnableEpoch)
 	}
+	if gc.maxGasHigherFactorAccepted < 1 {
+		return nil, fmt.Errorf("%w for epoch %d, it is set to 0", process.ErrInvalidMaxGasHigherFactorAccepted, gasLimitSetting.EnableEpoch)
+	}
 
 	return gc, nil
 }

diff --git a/process/economics/testEconomicsData.go b/process/economics/testEconomicsData.go
@@ -68,6 +68,11 @@ func (ted *TestEconomicsData) SetMaxInflationRate(maximumInflation float64) {
 	ted.yearSettings[0].MaximumInflation = maximumInflation
 }
 
+// MaxGasHigherFactorAccepted returns 10
+func (ted *TestEconomicsData) MaxGasHigherFactorAccepted() uint64 {
+	return 10
+}
+
 // SetStatusHandler returns nil
 func (ted *TestEconomicsData) SetStatusHandler(_ core.AppStatusHandler) error {
 	return nil

diff --git a/process/errors.go b/process/errors.go
@@ -534,6 +534,9 @@ var ErrInvalidExtraGasLimitGuardedTx = errors.New("invalid extra gas limit for g
 // ErrInvalidMaxGasPriceSetGuardian signals that an invalid maximum gas price has been provided in the config file
 var ErrInvalidMaxGasPriceSetGuardian = errors.New("invalid maximum gas price for set guardian")
 
+// ErrInvalidMaxGasHigherFactorAccepted signals that an invalid gas factor has been provided in the config file
+var ErrInvalidMaxGasHigherFactorAccepted = errors.New("invalid gas higher factor accepted")
+
 // ErrGuardianSignatureNotExpected signals that the guardian signature is not expected
 var ErrGuardianSignatureNotExpected = errors.New("guardian signature not expected")
 

diff --git a/process/factory/metachain/vmContainerFactory_test.go b/process/factory/metachain/vmContainerFactory_test.go
@@ -312,6 +312,7 @@ func TestVmContainerFactory_Create(t *testing.T) {
 						MaxGasLimitPerTx:            "10000000000",
 						MinGasLimit:                 "10",
 						ExtraGasLimitGuardedTx:      "50000",
+						MaxGasHigherFactorAccepted:  "10",
 					},
 				},
 				MinGasPrice:            "10",

diff --git a/process/interface.go b/process/interface.go
@@ -699,6 +699,7 @@ type feeHandler interface {
 	ComputeGasLimitInEpoch(tx data.TransactionWithFeeHandler, epoch uint32) uint64
 	ComputeGasUsedAndFeeBasedOnRefundValueInEpoch(tx data.TransactionWithFeeHandler, refundValue *big.Int, epoch uint32) (uint64, *big.Int)
 	ComputeTxFeeBasedOnGasUsedInEpoch(tx data.TransactionWithFeeHandler, gasUsed uint64, epoch uint32) *big.Int
+	MaxGasHigherFactorAccepted() uint64
 }
 
 // TxGasHandler handles a transaction gas and gas cost

diff --git a/process/peer/process_test.go b/process/peer/process_test.go
@@ -94,6 +94,7 @@ func createMockArguments() peer.ArgValidatorStatisticsProcessor {
 						MaxGasLimitPerTx:            "10000000",
 						MinGasLimit:                 "10",
 						ExtraGasLimitGuardedTx:      "50000",
+						MaxGasHigherFactorAccepted:  "10",
 					},
 				},
 				MinGasPrice:            "10",