Adapt gas tracker to follow the new block limits

genesis/process/disabled/disabled_test.go

@@ -109,6 +109,10 @@ func TestFeeHandler(t *testing.T) {
 	require.Equal(t, uint64(math.MaxUint64), handler.MaxGasLimitPerBlockForSafeCrossShard())
 	require.Equal(t, uint64(math.MaxUint64), handler.MaxGasLimitPerMiniBlockForSafeCrossShard())
 	require.Equal(t, uint64(math.MaxUint64), handler.MaxGasLimitPerTx())
+	require.Equal(t, uint64(math.MaxUint64), handler.BlockCapacityOverestimationFactor())
+	require.Equal(t, uint64(math.MaxUint64), handler.MaxGasLimitPerTxInEpoch(0))
+	require.Equal(t, uint64(math.MaxUint64), handler.MaxGasLimitPerBlockForSafeCrossShardInEpoch(0))
+	require.Equal(t, uint64(math.MaxUint64), handler.MaxGasLimitPerBlockInEpoch(0, 0))
 	require.Equal(t, uint64(0), handler.ComputeGasLimit(nil))
 	require.Equal(t, big.NewInt(0), handler.ComputeMoveBalanceFee(nil))
 	require.Equal(t, big.NewInt(0), handler.ComputeFeeForProcessing(nil, 0))

genesis/process/disabled/feeHandler.go

@@ -57,11 +57,21 @@ func (fh *FeeHandler) MaxGasPriceSetGuardian() uint64 {
 	return math.MaxUint64
 }
 
+// BlockCapacityOverestimationFactor returns max uint64
+func (fh *FeeHandler) BlockCapacityOverestimationFactor() uint64 {
+	return math.MaxUint64
+}
+
 // MaxGasLimitPerBlock returns max uint64
 func (fh *FeeHandler) MaxGasLimitPerBlock(uint32) uint64 {
 	return math.MaxUint64
 }
 
+// MaxGasLimitPerBlockInEpoch returns max uint64
+func (fh *FeeHandler) MaxGasLimitPerBlockInEpoch(_ uint32, _ uint32) uint64 {
+	return math.MaxUint64
+}
+
 // MaxGasLimitPerMiniBlock returns max uint64
 func (fh *FeeHandler) MaxGasLimitPerMiniBlock(uint32) uint64 {
 	return math.MaxUint64
@@ -72,6 +82,11 @@ func (fh *FeeHandler) MaxGasLimitPerBlockForSafeCrossShard() uint64 {
 	return math.MaxUint64
 }
 
+// MaxGasLimitPerBlockForSafeCrossShardInEpoch returns max uint64
+func (fh *FeeHandler) MaxGasLimitPerBlockForSafeCrossShardInEpoch(_ uint32) uint64 {
+	return math.MaxUint64
+}
+
 // MaxGasLimitPerMiniBlockForSafeCrossShard returns max uint64
 func (fh *FeeHandler) MaxGasLimitPerMiniBlockForSafeCrossShard() uint64 {
 	return math.MaxUint64
@@ -87,6 +102,11 @@ func (fh *FeeHandler) MaxGasLimitPerTx() uint64 {
 	return math.MaxUint64
 }
 
+// MaxGasLimitPerTxInEpoch returns max uint64
+func (fh *FeeHandler) MaxGasLimitPerTxInEpoch(_ uint32) uint64 {
+	return math.MaxUint64
+}
+
 // ComputeGasLimit returns 0
 func (fh *FeeHandler) ComputeGasLimit(_ data.TransactionWithFeeHandler) uint64 {
 	return 0

genesis/process/metaGenesisBlockCreator.go

@@ -15,9 +15,6 @@ import (
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	"github.com/multiversx/mx-chain-core-go/data/transaction"
 	"github.com/multiversx/mx-chain-core-go/marshal"
-	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
-	vmcommonBuiltInFunctions "github.com/multiversx/mx-chain-vm-common-go/builtInFunctions"
-	"github.com/multiversx/mx-chain-vm-common-go/parsers"
 
 	processBlock "github.com/multiversx/mx-chain-go/process/block"
 
@@ -51,6 +48,9 @@ import (
 	"github.com/multiversx/mx-chain-go/update"
 	hardForkProcess "github.com/multiversx/mx-chain-go/update/process"
 	"github.com/multiversx/mx-chain-go/vm"
+	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
+	vmcommonBuiltInFunctions "github.com/multiversx/mx-chain-vm-common-go/builtInFunctions"
+	"github.com/multiversx/mx-chain-vm-common-go/parsers"
 )
 
 // CreateMetaGenesisBlock will create a metachain genesis block

genesis/process/shardGenesisBlockCreator.go

@@ -10,9 +10,6 @@ import (
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-core-go/data"
 	dataBlock "github.com/multiversx/mx-chain-core-go/data/block"
-	logger "github.com/multiversx/mx-chain-logger-go"
-	"github.com/multiversx/mx-chain-vm-common-go/parsers"
-
 	"github.com/multiversx/mx-chain-go/common"
 	disabledCommon "github.com/multiversx/mx-chain-go/common/disabled"
 	"github.com/multiversx/mx-chain-go/common/enablers"
@@ -45,6 +42,8 @@ import (
 	"github.com/multiversx/mx-chain-go/txcache"
 	"github.com/multiversx/mx-chain-go/update"
 	hardForkProcess "github.com/multiversx/mx-chain-go/update/process"
+	logger "github.com/multiversx/mx-chain-logger-go"
+	"github.com/multiversx/mx-chain-vm-common-go/parsers"
 )
 
 const unreachableEpoch = ^uint32(0)

process/block/preprocess/gasTracker.go

@@ -3,14 +3,19 @@ package preprocess
 import (
 	"github.com/multiversx/mx-chain-core-go/core"
 	"github.com/multiversx/mx-chain-core-go/data"
+	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/process"
 	"github.com/multiversx/mx-chain-go/sharding"
 )
 
+const noOverestimationFactor = uint64(100)
+
 type gasTracker struct {
-	shardCoordinator sharding.Coordinator
-	economicsFee     process.FeeHandler
-	gasHandler       process.GasHandler
+	shardCoordinator    sharding.Coordinator
+	economicsFee        process.FeeHandler
+	gasHandler          process.GasHandler
+	enableEpochsHandler common.EnableEpochsHandler
+	enableRoundsHandler common.EnableRoundsHandler
 }
 
 func (gt *gasTracker) computeGasProvided(
@@ -29,22 +34,24 @@ func (gt *gasTracker) computeGasProvided(
 		return 0, err
 	}
 
+	epoch, overEstimationFactor := gt.getEpochAndOverestimationFactorForGasLimits()
+
 	gasProvidedByTxInSelfShard := uint64(0)
 	if gt.shardCoordinator.SelfId() == senderShardId {
 		gasProvidedByTxInSelfShard = gasProvidedByTxInSenderShard
 
-		if gasProvidedByTxInReceiverShard > gt.economicsFee.MaxGasLimitPerTx() {
+		if gasProvidedByTxInReceiverShard > gt.getMaxGasLimitPerTx(epoch) {
 			return 0, process.ErrMaxGasLimitPerOneTxInReceiverShardIsReached
 		}
 
-		if gasInfo.gasConsumedByMiniBlockInReceiverShard+gasProvidedByTxInReceiverShard > gt.economicsFee.MaxGasLimitPerBlockForSafeCrossShard() {
+		if gasInfo.gasConsumedByMiniBlockInReceiverShard+gasProvidedByTxInReceiverShard > gt.getMaxGasLimitPerBlockForSafeCrossShard(epoch, overEstimationFactor) {
 			return 0, process.ErrMaxGasLimitPerMiniBlockInReceiverShardIsReached
 		}
 	} else {
 		gasProvidedByTxInSelfShard = gasProvidedByTxInReceiverShard
 	}
 
-	if gasInfo.totalGasConsumedInSelfShard+gasProvidedByTxInSelfShard > gt.economicsFee.MaxGasLimitPerBlock(gt.shardCoordinator.SelfId()) {
+	if gasInfo.totalGasConsumedInSelfShard+gasProvidedByTxInSelfShard > gt.getMaxGasLimitPerBlock(epoch, overEstimationFactor) {
 		return 0, process.ErrMaxGasLimitPerBlockInSelfShardIsReached
 	}
 
@@ -55,6 +62,45 @@ func (gt *gasTracker) computeGasProvided(
 	return gasProvidedByTxInSelfShard, nil
 }
 
+func (gt *gasTracker) getEpochAndOverestimationFactorForGasLimits() (epoch uint32, overestimationFactor uint64) {
+	epoch = gt.enableEpochsHandler.GetCurrentEpoch()
+	overestimationFactor = noOverestimationFactor
+
+	// TODO: optimize this to be called once per epoch, not once per tx
+	isSupernovaEpochEnabled := gt.enableEpochsHandler.IsFlagEnabled(common.SupernovaFlag)
+	if !isSupernovaEpochEnabled {
+		return
+	}
+
+	isSupernovaRoundEnabled := gt.enableRoundsHandler.IsFlagEnabled(common.SupernovaRoundFlag)
+	if !isSupernovaRoundEnabled {
+		// if Supernova epoch is active, but round not yet,
+		// use the limits from previous epoch with no overestimation factor
+		if epoch > 0 {
+			epoch = epoch - 1
+		}
+
+		return
+	}
+
+	// new limits and overestimation should be enabled once the Supernova round is active
+	overestimationFactor = gt.economicsFee.BlockCapacityOverestimationFactor()
+
+	return
+}
+
+func (gt *gasTracker) getMaxGasLimitPerTx(epoch uint32) uint64 {
+	return gt.economicsFee.MaxGasLimitPerTxInEpoch(epoch)
+}
+
+func (gt *gasTracker) getMaxGasLimitPerBlockForSafeCrossShard(epoch uint32, overEstimationFactor uint64) uint64 {
+	return gt.economicsFee.MaxGasLimitPerBlockForSafeCrossShardInEpoch(epoch) * overEstimationFactor / 100
+}
+
+func (gt *gasTracker) getMaxGasLimitPerBlock(epoch uint32, overEstimationFactor uint64) uint64 {
+	return gt.economicsFee.MaxGasLimitPerBlockInEpoch(gt.shardCoordinator.SelfId(), epoch) * overEstimationFactor / 100
+}
+
 func (gt *gasTracker) computeGasProvidedByTx(
 	senderShardId uint32,
 	receiverShardId uint32,