[DO NOT MERGE] SF 2.0

cmd/node/flags.go

@@ -230,7 +230,7 @@ var (
 	allValidatorKeysPemFile = cli.StringFlag{
 		Name:  "all-validator-keys-pem-file",
 		Usage: "The `filepath` for the PEM file which contains all the secret keys managed by the current node.",
-		Value: "./config/allValidatorsKeys.pem",
+		Value: "./config/allValidatorsKeysSF.pem",
 	}
 
 	// logLevel defines the logger level

cmd/node/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 	"runtime"
 	"time"
 
@@ -82,13 +83,43 @@ func main() {
 		return startNodeRunner(c, log, baseVersion, app.Version)
 	}
 
+	// TODO: remove this after the first release
+	// renameDB()
+
 	err := app.Run(os.Args)
 	if err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 }
 
+func renameDB() {
+	// Define source and destination paths
+	sourcePath := filepath.Join("db", "1")
+	destPath := filepath.Join("db", "B")
+
+	// Check if source directory exists
+	if _, err := os.Stat(sourcePath); os.IsNotExist(err) {
+		fmt.Printf("Error: Source directory '%s' does not exist\n", sourcePath)
+		os.Exit(1)
+	}
+
+	// Check if destination already exists
+	if _, err := os.Stat(destPath); err == nil {
+		fmt.Printf("Error: Destination directory '%s' already exists\n", destPath)
+		os.Exit(1)
+	}
+
+	// Rename the directory
+	err := os.Rename(sourcePath, destPath)
+	if err != nil {
+		fmt.Printf("Error renaming directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("Successfully renamed '%s' to '%s'\n", sourcePath, destPath)
+}
+
 func startNodeRunner(c *cli.Context, log logger.Logger, baseVersion string, version string) error {
 	flagsConfig := getFlagsConfig(c, log)
 

common/common.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"math/big"
 	"math/bits"
+	"os"
 	"reflect"
 	"strconv"
 	"strings"
@@ -612,3 +613,121 @@ func GetFeePayer(tx data.TransactionHandler) []byte {
 
 	return tx.GetSndAddr()
 }
+
+type EnableEpochsHandlerWithSet interface {
+	SetActivationRound(flag EnableRoundFlag, round uint64)
+}
+
+type ProcessConfigsHandlerWithSet interface {
+	SetActivationRound(round uint64, log logger.Logger)
+}
+
+type CommonConfigsHandlerWithSet interface {
+	SetActivationRound(round uint64, log logger.Logger)
+}
+
+type VersionsConfigWithSet interface {
+	SetActivationRound(round uint64, log logger.Logger)
+}
+
+type AntifloodConfigsHandlerWithSet interface {
+	SetActivationRound(round uint64, log logger.Logger)
+}
+
+var erh EnableEpochsHandlerWithSet
+var eeh EnableEpochsHandler
+var pch ProcessConfigsHandlerWithSet
+var cch CommonConfigsHandlerWithSet
+var vch VersionsConfigWithSet
+var ach AntifloodConfigsHandlerWithSet
+
+var mainConfigPath string
+var roundConfigPath string
+
+func SetEnableRoundsHandler(enableRoundsHandler EnableEpochsHandlerWithSet) {
+	erh = enableRoundsHandler
+}
+
+func SetProcessConfigsHandler(pcHandler ProcessConfigsHandler) {
+	pch = pcHandler
+}
+
+func SetCommonConfigsHandler(ccHandler CommonConfigsHandler) {
+	cch = ccHandler
+}
+
+func SetEnableEpochsHandler(enableEpochsHandler EnableEpochsHandler) {
+	eeh = enableEpochsHandler
+}
+
+func SetVersionsConfigHandler(versions *config.VersionsConfig) {
+	vch = versions
+}
+
+func SetAntifloodConfigsHandler(handler AntifloodConfigsHandler) {
+	ach = handler
+}
+
+// SetConfigPaths sets the file paths for the main config and round activation config files
+func SetConfigPaths(mainPath, roundPath string) {
+	mainConfigPath = mainPath
+	roundConfigPath = roundPath
+}
+
+func SetSuperNovaActivationRound(epoch uint32, round uint64) {
+	isEnabled := eeh.GetActivationEpoch(SupernovaFlag) == epoch && eeh.IsFlagEnabledInEpoch(SupernovaFlag, epoch)
+	log.Info("SetSuperNovaActivationRound", "currentRound", round, "activationRound", round+20, "epoch", epoch, "is enabled in current round", isEnabled)
+	if isEnabled {
+		supernovaRound := round + 20
+		erh.SetActivationRound(SupernovaRoundFlag, supernovaRound)
+		pch.SetActivationRound(supernovaRound, log)
+		cch.SetActivationRound(supernovaRound, log)
+		vch.SetActivationRound(supernovaRound, log)
+		ach.SetActivationRound(supernovaRound, log)
+		persistSupernovaRoundToConfigs(supernovaRound)
+	}
+}
+
+func persistSupernovaRoundToConfigs(round uint64) {
+	roundStr := strconv.FormatUint(round, 10)
+
+	if mainConfigPath != "" {
+		patchFileRoundValues(mainConfigPath, roundStr, false)
+	}
+
+	if roundConfigPath != "" {
+		patchFileRoundValues(roundConfigPath, roundStr, true)
+	}
+}
+
+func patchFileRoundValues(filePath string, roundStr string, isRoundConfig bool) {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		log.Warn("failed to read config file for round persistence", "path", filePath, "error", err)
+		return
+	}
+
+	original := string(data)
+	modified := original
+
+	if isRoundConfig {
+		modified = strings.ReplaceAll(modified, `Round = "99999999"`, `Round = "`+roundStr+`"`)
+	} else {
+		modified = strings.ReplaceAll(modified, "EnableRound = 99999999", "EnableRound = "+roundStr)
+		modified = strings.ReplaceAll(modified, "StartRound = 99999999", "StartRound = "+roundStr)
+		modified = strings.ReplaceAll(modified, "Round = 99999999", "Round = "+roundStr)
+	}
+
+	if modified == original {
+		log.Debug("no round placeholder found to replace", "path", filePath)
+		return
+	}
+
+	err = os.WriteFile(filePath, []byte(modified), 0644)
+	if err != nil {
+		log.Warn("failed to write config file for round persistence", "path", filePath, "error", err)
+		return
+	}
+
+	log.Info("persisted supernova round to config file", "path", filePath, "round", roundStr)
+}

common/configs/antifloodConfigs.go

@@ -6,6 +6,8 @@ import (
 	"sort"
 
 	"github.com/multiversx/mx-chain-core-go/core/check"
+	logger "github.com/multiversx/mx-chain-logger-go"
+
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/process"
@@ -194,6 +196,13 @@ func (ac *antifloodConfigs) GetFloodPreventerConfigByType(configType common.Floo
 	}
 }
 
+// SetActivationRound -
+func (ac *antifloodConfigs) SetActivationRound(round uint64, log logger.Logger) {
+	nr := len(ac.orderedConfigsByRound)
+	log.Info("antifloodConfigs.SetActivationRound", "enableRound", round, "oldRound", ac.orderedConfigsByRound[nr-1].Round)
+	ac.orderedConfigsByRound[nr-1].Round = round
+}
+
 // IsInterfaceNil checks if the instance is nil
 func (ac *antifloodConfigs) IsInterfaceNil() bool {
 	return ac == nil

common/configs/antifloodConfigs_test.go

@@ -5,6 +5,8 @@ import (
 	"strings"
 	"testing"
 
+	logger "github.com/multiversx/mx-chain-logger-go"
+
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/common/configs"
 	"github.com/multiversx/mx-chain-go/config"
@@ -244,3 +246,40 @@ func TestAntifloodConfigs_GetFloodPreventerConfigByType(t *testing.T) {
 	other := handler.GetFloodPreventerConfigByType(common.FloodPreventerType("other"))
 	require.Equal(t, config.FloodPreventerConfig{}, other) // empty config
 }
+
+func TestAntifloodConfigs_SetActivationRound(t *testing.T) {
+	t.Parallel()
+
+	afConf := config.AntifloodConfig{
+		Enabled:        true,
+		ConfigsByRound: getAntifloodConfigsByRound(),
+	}
+
+	currentRound := uint64(50)
+	roundNotifier := &epochNotifier.RoundNotifierStub{
+		CurrentRoundCalled: func() uint64 {
+			return currentRound
+		},
+	}
+	handler, err := configs.NewAntifloodConfigsHandler(afConf, roundNotifier)
+	require.NoError(t, err)
+	require.NotNil(t, handler)
+
+	// Before SetActivationRound, the last config has round 100
+	currentRound = 120
+	currentConfig := handler.GetCurrentConfig()
+	require.Equal(t, uint64(100), currentConfig.Round)
+
+	// Set activation round to 500
+	testLog := logger.GetOrCreate("test")
+	handler.SetActivationRound(500, testLog)
+
+	// Now at round 120, the last config (round 500) should not be active
+	currentConfig = handler.GetCurrentConfig()
+	require.Equal(t, uint64(0), currentConfig.Round)
+
+	// At round 500, the last config should be active
+	currentRound = 500
+	currentConfig = handler.GetCurrentConfig()
+	require.Equal(t, uint64(500), currentConfig.Round)
+}

common/configs/commonConfigs.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 
 	"github.com/multiversx/mx-chain-go/config"
+	logger "github.com/multiversx/mx-chain-logger-go"
 )
 
 const (
@@ -188,3 +189,10 @@ func (cc *commonConfigs) GetNumRoundsToWaitBeforeSignalingChronologyStuck(epoch
 func (cc *commonConfigs) IsInterfaceNil() bool {
 	return cc == nil
 }
+
+// SetActivationRound -
+func (cc *commonConfigs) SetActivationRound(round uint64, log logger.Logger) {
+	nr := len(cc.orderedEpochStartConfigByRound)
+	log.Info("commonConfigs.SetActivationRound", "enableRound", round, "oldRound", cc.orderedEpochStartConfigByRound[nr-1].EnableRound)
+	cc.orderedEpochStartConfigByRound[nr-1].EnableRound = round
+}

common/configs/processConfigs.go

@@ -314,3 +314,10 @@ func (pce *processConfigsByEpoch) getValueByRound(
 func (pce *processConfigsByEpoch) IsInterfaceNil() bool {
 	return pce == nil
 }
+
+// SetActivationRound -
+func (pce *processConfigsByEpoch) SetActivationRound(round uint64, log logger.Logger) {
+	nr := len(pce.orderedConfigByRound)
+	log.Info("processConfigsByEpoch.SetActivationRound", "enableRound", round, "oldRound", pce.orderedConfigByRound[nr-1].EnableRound)
+	pce.orderedConfigByRound[nr-1].EnableRound = round
+}

common/constants.go

@@ -64,7 +64,7 @@ const DisabledShardIDAsObserver = uint32(0xFFFFFFFF) - 7
 
 // MaxTxNonceDeltaAllowed specifies the maximum difference between an account's nonce and a received transaction's nonce
 // in order to mark the transaction as valid.
-const MaxTxNonceDeltaAllowed = 100
+const MaxTxNonceDeltaAllowed = 100000
 
 // MaxBulkTransactionSize specifies the maximum size of one bulk with txs which can be send over the network
 // TODO convert this const into a var and read it from config when this code moves to another binary

common/enablers/enableRoundsHandler.go

@@ -184,3 +184,14 @@ func (handler *enableRoundsHandler) GetAllEnableRounds() map[string]uint64 {
 func (handler *enableRoundsHandler) IsInterfaceNil() bool {
 	return handler == nil
 }
+
+// SetActivationRound sets the activation round of the provided flag
+func (handler *enableRoundsHandler) SetActivationRound(flag common.EnableRoundFlag, round uint64) {
+	handler.allFlagsDefined[flag] = roundFlagHandler{
+		isActiveInRound: func(r uint64) bool {
+			return r >= round
+		},
+		activationRound: round,
+	}
+	log.Debug("SetActivationRound", "flag", flag, "round", round)
+}

common/export_test.go

@@ -27,3 +27,8 @@ func TimeDurationToUnix(
 ) int64 {
 	return timeDurationToUnix(duration, enableEpochsHandler, epoch)
 }
+
+// PatchFileRoundValues -
+func PatchFileRoundValues(filePath string, roundStr string, isRoundConfig bool) {
+	patchFileRoundValues(filePath, roundStr, isRoundConfig)
+}

common/interface.go

@@ -9,6 +9,7 @@ import (
 	"github.com/multiversx/mx-chain-core-go/data"
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	crypto "github.com/multiversx/mx-chain-crypto-go"
+	logger "github.com/multiversx/mx-chain-logger-go"
 
 	"github.com/multiversx/mx-chain-go/common/configs/dto"
 	"github.com/multiversx/mx-chain-go/config"
@@ -498,6 +499,8 @@ type ProcessConfigsHandler interface {
 
 	GetValue(variable dto.ConfigVariable) uint64
 
+	SetActivationRound(round uint64, log logger.Logger)
+
 	IsInterfaceNil() bool
 }
 
@@ -508,6 +511,8 @@ type CommonConfigsHandler interface {
 	GetMaxRoundsWithoutCommittedStartInEpochBlockInRound(round uint64) uint32
 	GetNumRoundsToWaitBeforeSignalingChronologyStuck(epoch uint32) uint32
 
+	SetActivationRound(round uint64, log logger.Logger)
+
 	IsInterfaceNil() bool
 }
 
@@ -516,6 +521,7 @@ type AntifloodConfigsHandler interface {
 	GetCurrentConfig() config.AntifloodConfigByRound
 	GetFloodPreventerConfigByType(configType FloodPreventerType) config.FloodPreventerConfig
 	IsEnabled() bool
+	SetActivationRound(round uint64, log logger.Logger)
 	IsInterfaceNil() bool
 }
 

config/config.go

@@ -1,6 +1,9 @@
 package config
 
-import p2pConfig "github.com/multiversx/mx-chain-go/p2p/config"
+import (
+	p2pConfig "github.com/multiversx/mx-chain-go/p2p/config"
+	logger "github.com/multiversx/mx-chain-logger-go"
+)
 
 // CacheConfig will map the cache configuration
 type CacheConfig struct {
@@ -743,6 +746,14 @@ type VersionsConfig struct {
 	VersionsByEpochs []VersionByEpochs
 }
 
+func (vc *VersionsConfig) SetActivationRound(round uint64, log logger.Logger) {
+	if len(vc.VersionsByEpochs) > 0 {
+		oldRound := vc.VersionsByEpochs[len(vc.VersionsByEpochs)-1].StartRound
+		vc.VersionsByEpochs[len(vc.VersionsByEpochs)-1].StartRound = round
+		log.Info("Set activation round for versions", "round", round, "oldRound", oldRound)
+	}
+}
+
 // Configs is a holder for the node configuration parameters
 type Configs struct {
 	GeneralConfig            *Config