Sovereign chain simulator implementation

cmd/sovereignnode/chainSimulator/process/sovereignBlockProcessorFactory.go

@@ -0,0 +1,45 @@
+package process
+
+import (
+	"time"
+
+	chainSimulatorProcess "github.com/multiversx/mx-chain-go/node/chainSimulator/process"
+	"github.com/multiversx/mx-chain-go/process"
+
+	"github.com/multiversx/mx-chain-core-go/core/check"
+	"github.com/multiversx/mx-chain-core-go/data"
+)
+
+type sovereignBlockProcessorFactory struct {
+}
+
+// NewSovereignBlockProcessorFactory creates a new block processor factory for sovereign chain simulator
+func NewSovereignBlockProcessorFactory() chainSimulatorProcess.BlocksProcessorFactory {
+	return &sovereignBlockProcessorFactory{}
+}
+
+// ProcessBlock will create and process a block in sovereign chain simulator
+func (sbpf *sovereignBlockProcessorFactory) ProcessBlock(blockProcessor process.BlockProcessor, header data.HeaderHandler) (data.HeaderHandler, data.BodyHandler, error) {
+	if check.IfNil(blockProcessor) {
+		return nil, nil, process.ErrNilBlockProcessor
+	}
+	if check.IfNil(header) {
+		return nil, nil, process.ErrNilHeaderHandler
+	}
+
+	header, block, err := blockProcessor.CreateBlock(header, func() bool {
+		return true
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return blockProcessor.ProcessBlock(header, block, func() time.Duration {
+		return time.Second
+	})
+}
+
+// IsInterfaceNil returns true if there is no value under the interface
+func (sbpf *sovereignBlockProcessorFactory) IsInterfaceNil() bool {
+	return sbpf == nil
+}

cmd/sovereignnode/chainSimulator/process/sovereignBlockProcessorFactory_test.go

@@ -0,0 +1,61 @@
+package process
+
+import (
+	"testing"
+	"time"
+
+	"github.com/multiversx/mx-chain-go/process"
+	"github.com/multiversx/mx-chain-go/testscommon"
+
+	"github.com/multiversx/mx-chain-core-go/data"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewSovereignBlockProcessorFactory(t *testing.T) {
+	t.Parallel()
+
+	fact := NewSovereignBlockProcessorFactory()
+
+	require.False(t, fact.IsInterfaceNil())
+	require.IsType(t, new(sovereignBlockProcessorFactory), fact)
+}
+
+func TestNewSovereignBlockProcessorFactory_ProcessBlock(t *testing.T) {
+	t.Parallel()
+
+	t.Run("nil block processor should error", func(t *testing.T) {
+		fact := NewSovereignBlockProcessorFactory()
+		header, block, err := fact.ProcessBlock(nil, &testscommon.HeaderHandlerStub{})
+		require.ErrorIs(t, err, process.ErrNilBlockProcessor)
+		require.Nil(t, header)
+		require.Nil(t, block)
+	})
+	t.Run("nil header handler should error", func(t *testing.T) {
+		fact := NewSovereignBlockProcessorFactory()
+		header, block, err := fact.ProcessBlock(&testscommon.BlockProcessorStub{}, nil)
+		require.ErrorIs(t, err, process.ErrNilHeaderHandler)
+		require.Nil(t, header)
+		require.Nil(t, block)
+	})
+	t.Run("should work", func(t *testing.T) {
+		fact := NewSovereignBlockProcessorFactory()
+
+		createWasCalled := false
+		processWasCalled := false
+		bp := &testscommon.BlockProcessorStub{
+			CreateBlockCalled: func(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error) {
+				createWasCalled = true
+				return nil, nil, nil
+			},
+			ProcessBlockCalled: func(header data.HeaderHandler, body data.BodyHandler, haveTime func() time.Duration) (data.HeaderHandler, data.BodyHandler, error) {
+				processWasCalled = true
+				return nil, nil, nil
+			},
+		}
+
+		_, _, err := fact.ProcessBlock(bp, &testscommon.HeaderHandlerStub{})
+		require.Nil(t, err)
+		require.Equal(t, true, createWasCalled)
+		require.Equal(t, true, processWasCalled)
+	})
+}

cmd/sovereignnode/chainSimulator/sovereignChainHandlerFactory.go

@@ -0,0 +1,25 @@
+package chainSimulator
+
+import (
+	"github.com/multiversx/mx-chain-go/node/chainSimulator"
+	"github.com/multiversx/mx-chain-go/node/chainSimulator/process"
+	sovProcess "github.com/multiversx/mx-chain-go/sovereignnode/chainSimulator/process"
+)
+
+type sovereignProcessorFactory struct {
+}
+
+// NewSovereignChainHandlerFactory creates a new chain handler factory for sovereign chain simulator
+func NewSovereignChainHandlerFactory() chainSimulator.ChainHandlerFactory {
+	return &sovereignProcessorFactory{}
+}
+
+// CreateChainHandler creates a new chain handler for sovereign chain simulator
+func (spf *sovereignProcessorFactory) CreateChainHandler(nodeHandler process.NodeHandler) (chainSimulator.ChainHandler, error) {
+	return process.NewBlocksCreator(nodeHandler, sovProcess.NewSovereignBlockProcessorFactory())
+}
+
+// IsInterfaceNil returns true if there is no value under the interface
+func (spf *sovereignProcessorFactory) IsInterfaceNil() bool {
+	return spf == nil
+}

cmd/sovereignnode/chainSimulator/sovereignChainHandlerFactory_test.go

@@ -0,0 +1,35 @@
+package chainSimulator
+
+import (
+	"testing"
+
+	"github.com/multiversx/mx-chain-go/node/chainSimulator/process"
+	"github.com/multiversx/mx-chain-go/testscommon/chainSimulator"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewSovereignProcessorFactory(t *testing.T) {
+	t.Parallel()
+
+	fact := NewSovereignChainHandlerFactory()
+	require.False(t, fact.IsInterfaceNil())
+	require.IsType(t, new(sovereignProcessorFactory), fact)
+}
+
+func TestNewSovereignProcessorFactory_CreateChainHandler(t *testing.T) {
+	t.Parallel()
+
+	t.Run("nil node handler should error", func(t *testing.T) {
+		fact := NewSovereignChainHandlerFactory()
+		chainHandler, err := fact.CreateChainHandler(nil)
+		require.Nil(t, chainHandler)
+		require.ErrorIs(t, err, process.ErrNilNodeHandler)
+	})
+	t.Run("should work", func(t *testing.T) {
+		fact := NewSovereignChainHandlerFactory()
+		chainHandler, err := fact.CreateChainHandler(&chainSimulator.NodeHandlerMock{})
+		require.Nil(t, err)
+		require.NotNil(t, chainHandler)
+	})
+}

cmd/sovereignnode/chainSimulator/sovereignChainSimulator.go

@@ -0,0 +1,124 @@
+package chainSimulator
+
+import (
+	"path"
+
+	"github.com/multiversx/mx-chain-go/common"
+	"github.com/multiversx/mx-chain-go/config"
+	"github.com/multiversx/mx-chain-go/dataRetriever"
+	"github.com/multiversx/mx-chain-go/factory"
+	"github.com/multiversx/mx-chain-go/factory/runType"
+	chainSimulatorIntegrationTests "github.com/multiversx/mx-chain-go/integrationTests/chainSimulator"
+	"github.com/multiversx/mx-chain-go/node"
+	"github.com/multiversx/mx-chain-go/node/chainSimulator"
+	"github.com/multiversx/mx-chain-go/process"
+	"github.com/multiversx/mx-chain-go/process/rating"
+	"github.com/multiversx/mx-chain-go/sharding"
+	sovereignConfig "github.com/multiversx/mx-chain-go/sovereignnode/config"
+	"github.com/multiversx/mx-chain-go/sovereignnode/incomingHeader"
+	sovRunType "github.com/multiversx/mx-chain-go/sovereignnode/runType"
+
+	"github.com/multiversx/mx-chain-core-go/core"
+)
+
+const (
+	numOfShards = 1
+)
+
+// ArgsSovereignChainSimulator holds the arguments for sovereign chain simulator
+type ArgsSovereignChainSimulator struct {
+	SovereignConfigPath string
+	*chainSimulator.ArgsChainSimulator
+}
+
+// NewSovereignChainSimulator will create a new instance of sovereign chain simulator
+func NewSovereignChainSimulator(args ArgsSovereignChainSimulator) (chainSimulatorIntegrationTests.ChainSimulator, error) {
+	args.NumOfShards = numOfShards
+
+	alterConfigs := args.AlterConfigsFunction
+	configs, err := loadSovereignConfigs(args.SovereignConfigPath)
+	if err != nil {
+		return nil, err
+	}
+	args.AlterConfigsFunction = func(cfg *config.Configs) {
+		cfg.EconomicsConfig = configs.EconomicsConfig
+		cfg.EpochConfig = configs.EpochConfig
+		cfg.GeneralConfig.SovereignConfig = *configs.SovereignExtraConfig
+		cfg.GeneralConfig.VirtualMachine.Execution.WasmVMVersions = []config.WasmVMVersionByEpoch{{StartEpoch: 0, Version: "v1.5"}}
+		cfg.GeneralConfig.VirtualMachine.Querying.WasmVMVersions = []config.WasmVMVersionByEpoch{{StartEpoch: 0, Version: "v1.5"}}
+
+		if alterConfigs != nil {
+			alterConfigs(cfg)
+		}
+	}
+
+	args.CreateGenesisNodesSetup = func(nodesFilePath string, addressPubkeyConverter core.PubkeyConverter, validatorPubkeyConverter core.PubkeyConverter, _ uint32) (sharding.GenesisNodesSetupHandler, error) {
+		return sharding.NewSovereignNodesSetup(&sharding.SovereignNodesSetupArgs{
+			NodesFilePath:            nodesFilePath,
+			AddressPubKeyConverter:   addressPubkeyConverter,
+			ValidatorPubKeyConverter: validatorPubkeyConverter,
+		})
+	}
+	args.CreateRatingsData = func(arg rating.RatingsDataArg) (process.RatingsInfoHandler, error) {
+		return rating.NewSovereignRatingsData(arg)
+	}
+	args.CreateIncomingHeaderSubscriber = func(config *config.NotifierConfig, dataPool dataRetriever.PoolsHolder, mainChainNotarizationStartRound uint64, runTypeComponents factory.RunTypeComponentsHolder) (process.IncomingHeaderSubscriber, error) {
+		return incomingHeader.CreateIncomingHeaderProcessor(config, dataPool, mainChainNotarizationStartRound, runTypeComponents)
+	}
+	args.CreateRunTypeComponents = func(argsRunType runType.ArgsRunTypeComponents) (factory.RunTypeComponentsHolder, error) {
+		return createSovereignRunTypeComponents(argsRunType, *configs.SovereignExtraConfig)
+	}
+	args.NodeFactory = node.NewSovereignNodeFactory()
+	args.ChainProcessorFactory = NewSovereignChainHandlerFactory()
+
+	return chainSimulator.NewChainSimulator(*args.ArgsChainSimulator)
+}
+
+// loadSovereignConfigs loads sovereign configs
+func loadSovereignConfigs(configsPath string) (*sovereignConfig.SovereignConfig, error) {
+	epochConfig, err := common.LoadEpochConfig(path.Join(configsPath, "enableEpochs.toml"))
+	if err != nil {
+		return nil, err
+	}
+
+	economicsConfig, err := common.LoadEconomicsConfig(path.Join(configsPath, "economics.toml"))
+	if err != nil {
+		return nil, err
+	}
+
+	sovereignExtraConfig, err := sovereignConfig.LoadSovereignGeneralConfig(path.Join(configsPath, "sovereignConfig.toml"))
+	if err != nil {
+		return nil, err
+	}
+
+	return &sovereignConfig.SovereignConfig{
+		Configs: &config.Configs{
+			EpochConfig:     epochConfig,
+			EconomicsConfig: economicsConfig,
+		},
+		SovereignExtraConfig: sovereignExtraConfig,
+	}, nil
+}
+
+func createSovereignRunTypeComponents(args runType.ArgsRunTypeComponents, sovereignExtraConfig config.SovereignConfig) (factory.RunTypeComponentsHolder, error) {
+	argsSovRunType, err := sovRunType.CreateSovereignArgsRunTypeComponents(args, sovereignExtraConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	sovereignComponentsFactory, err := runType.NewSovereignRunTypeComponentsFactory(*argsSovRunType)
+	if err != nil {
+		return nil, err
+	}
+
+	managedRunTypeComponents, err := runType.NewManagedRunTypeComponents(sovereignComponentsFactory)
+	if err != nil {
+		return nil, err
+	}
+	err = managedRunTypeComponents.Create()
+	if err != nil {
+		return nil, err
+	}
+
+	return managedRunTypeComponents, nil
+}