Merge branch 'feat/demo-refactor' into api-factory-refactor

cmd/sovereignnode/sovereignNodeRunner.go

@@ -518,7 +518,7 @@ func (snr *sovereignNodeRunner) executeOneComponentCreationCycle(
 		n.AddClosableComponent(sovereignWsReceiver)
 		return nil
 	}
-	currentNode, err := node.CreateNode(
+	nodeHandler, err := node.CreateNode(
 		configs.GeneralConfig,
 		managedStatusCoreComponents,
 		managedBootstrapComponents,
@@ -533,6 +533,7 @@ func (snr *sovereignNodeRunner) executeOneComponentCreationCycle(
 		managedConsensusComponents,
 		flagsConfig.BootstrapRoundIndex,
 		configs.ImportDbConfig.IsImportDBMode,
+		node.NewSovereignNodeFactory(),
 		extraOption,
 	)
 	if err != nil {
@@ -543,7 +544,7 @@ func (snr *sovereignNodeRunner) executeOneComponentCreationCycle(
 	allowExternalVMQueriesChan := make(chan struct{})
 
 	log.Debug("updating the API service after creating the node facade")
-	ef, err := snr.createApiFacade(currentNode, webServerHandler, gasScheduleNotifier, allowExternalVMQueriesChan)
+	ef, err := snr.createApiFacade(nodeHandler, webServerHandler, gasScheduleNotifier, allowExternalVMQueriesChan)
 	if err != nil {
 		return true, err
 	}
@@ -571,7 +572,7 @@ func (snr *sovereignNodeRunner) executeOneComponentCreationCycle(
 		healthService,
 		ef,
 		webServerHandler,
-		currentNode,
+		nodeHandler,
 		goRoutinesNumberStart,
 	)
 	if err != nil {
@@ -668,7 +669,7 @@ func getBaseAccountSyncerArgs(
 }
 
 func (snr *sovereignNodeRunner) createApiFacade(
-	currentNode *node.Node,
+	nodeHandler node.NodeHandler,
 	upgradableHttpServer shared.UpgradeableHttpServerHandler,
 	gasScheduleNotifier common.GasScheduleNotifierAPI,
 	allowVMQueriesChan chan struct{},
@@ -679,17 +680,17 @@ func (snr *sovereignNodeRunner) createApiFacade(
 
 	apiResolverArgs := &apiComp.ApiResolverArgs{
 		Configs:              configs.Configs,
-		CoreComponents:       currentNode.GetCoreComponents(),
-		DataComponents:       currentNode.GetDataComponents(),
-		StateComponents:      currentNode.GetStateComponents(),
-		BootstrapComponents:  currentNode.GetBootstrapComponents(),
-		CryptoComponents:     currentNode.GetCryptoComponents(),
-		ProcessComponents:    currentNode.GetProcessComponents(),
-		StatusCoreComponents: currentNode.GetStatusCoreComponents(),
+		CoreComponents:       nodeHandler.GetCoreComponents(),
+		DataComponents:       nodeHandler.GetDataComponents(),
+		StateComponents:      nodeHandler.GetStateComponents(),
+		BootstrapComponents:  nodeHandler.GetBootstrapComponents(),
+		CryptoComponents:     nodeHandler.GetCryptoComponents(),
+		ProcessComponents:    nodeHandler.GetProcessComponents(),
+		StatusCoreComponents: nodeHandler.GetStatusCoreComponents(),
 		GasScheduleNotifier:  gasScheduleNotifier,
-		Bootstrapper:         currentNode.GetConsensusComponents().Bootstrapper(),
+		Bootstrapper:         nodeHandler.GetConsensusComponents().Bootstrapper(),
 		AllowVMQueriesChan:   allowVMQueriesChan,
-		StatusComponents:     currentNode.GetStatusComponents(),
+		StatusComponents:     nodeHandler.GetStatusComponents(),
 		ChainRunType:         common.ChainRunTypeSovereign,
 	}
 
@@ -703,7 +704,7 @@ func (snr *sovereignNodeRunner) createApiFacade(
 	flagsConfig := configs.FlagsConfig
 
 	argNodeFacade := facade.ArgNodeFacade{
-		Node:                   currentNode,
+		Node:                   nodeHandler,
 		ApiResolver:            apiResolver,
 		RestAPIServerDebugMode: flagsConfig.EnableRestAPIServerDebugMode,
 		WsAntifloodConfig:      configs.GeneralConfig.WebServerAntiflood,
@@ -712,17 +713,17 @@ func (snr *sovereignNodeRunner) createApiFacade(
 			PprofEnabled:     flagsConfig.EnablePprof,
 		},
 		ApiRoutesConfig: *configs.ApiRoutesConfig,
-		AccountsState:   currentNode.GetStateComponents().AccountsAdapter(),
-		PeerState:       currentNode.GetStateComponents().PeerAccounts(),
-		Blockchain:      currentNode.GetDataComponents().Blockchain(),
+		AccountsState:   nodeHandler.GetStateComponents().AccountsAdapter(),
+		PeerState:       nodeHandler.GetStateComponents().PeerAccounts(),
+		Blockchain:      nodeHandler.GetDataComponents().Blockchain(),
 	}
 
 	ef, err := facade.NewNodeFacade(argNodeFacade)
 	if err != nil {
 		return nil, fmt.Errorf("%w while creating NodeFacade", err)
 	}
 
-	ef.SetSyncer(currentNode.GetCoreComponents().SyncTimer())
+	ef.SetSyncer(nodeHandler.GetCoreComponents().SyncTimer())
 
 	err = upgradableHttpServer.UpdateFacade(ef)
 	if err != nil {
@@ -925,7 +926,7 @@ func waitForSignal(
 	healthService closing.Closer,
 	ef closing.Closer,
 	httpServer shared.UpgradeableHttpServerHandler,
-	currentNode *node.Node,
+	nodeHandler node.NodeHandler,
 	goRoutinesNumberStart int,
 ) error {
 	var sig endProcess.ArgEndProcess
@@ -949,7 +950,7 @@ func waitForSignal(
 
 	chanCloseComponents := make(chan struct{})
 	go func() {
-		closeAllComponents(healthService, ef, httpServer, currentNode, chanCloseComponents)
+		closeAllComponents(healthService, ef, httpServer, nodeHandler, chanCloseComponents)
 	}()
 
 	select {
@@ -1536,7 +1537,7 @@ func closeAllComponents(
 	healthService io.Closer,
 	facade mainFactory.Closer,
 	httpServer shared.UpgradeableHttpServerHandler,
-	node *node.Node,
+	node node.NodeHandler,
 	chanCloseComponents chan struct{},
 ) {
 	log.Debug("closing health service...")

errors/errors.go

@@ -655,3 +655,6 @@ var ErrInvalidReceivedExtendedShardHeader = errors.New("invalid extended shard h
 
 // ErrNilTxPreProcessorCreator signals that a nil tx pre-processor creator has been provided
 var ErrNilTxPreProcessorCreator = errors.New("nil tx pre-processor creator has been provided")
+
+// ErrNilNode signals that a nil node was provided
+var ErrNilNode = errors.New("nil node")

facade/errors.go

@@ -5,9 +5,6 @@ import "github.com/pkg/errors"
 // ErrHeartbeatsNotActive signals that the heartbeat system is not active
 var ErrHeartbeatsNotActive = errors.New("heartbeat system not active")
 
-// ErrNilNode signals that a nil node instance has been provided
-var ErrNilNode = errors.New("nil node")
-
 // ErrNilApiResolver signals that a nil api resolver instance has been provided
 var ErrNilApiResolver = errors.New("nil api resolver")
 

facade/nodeFacade.go

@@ -21,6 +21,7 @@ import (
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/debug"
 	"github.com/multiversx/mx-chain-go/epochStart/bootstrap/disabled"
+	"github.com/multiversx/mx-chain-go/errors"
 	"github.com/multiversx/mx-chain-go/heartbeat/data"
 	"github.com/multiversx/mx-chain-go/node/external"
 	"github.com/multiversx/mx-chain-go/ntp"
@@ -36,7 +37,7 @@ import (
 const DefaultRestInterface = "localhost:8080"
 
 // DefaultRestPortOff is the default value that should be passed if it is desired
-//  to start the node without a REST endpoint available
+// to start the node without a REST endpoint available
 const DefaultRestPortOff = "off"
 
 var log = logger.GetOrCreate("facade")
@@ -72,7 +73,7 @@ type nodeFacade struct {
 // NewNodeFacade creates a new Facade with a NodeWrapper
 func NewNodeFacade(arg ArgNodeFacade) (*nodeFacade, error) {
 	if check.IfNil(arg.Node) {
-		return nil, ErrNilNode
+		return nil, errors.ErrNilNode
 	}
 	if check.IfNil(arg.ApiResolver) {
 		return nil, ErrNilApiResolver
@@ -163,7 +164,7 @@ func (nf *nodeFacade) RestAPIServerDebugMode() bool {
 
 // RestApiInterface returns the interface on which the rest API should start on, based on the config file provided.
 // The API will start on the DefaultRestInterface value unless a correct value is passed or
-//  the value is explicitly set to off, in which case it will not start at all
+// the value is explicitly set to off, in which case it will not start at all
 func (nf *nodeFacade) RestApiInterface() string {
 	if nf.config.RestApiInterface == "" {
 		return DefaultRestInterface

facade/nodeFacade_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/debug"
+	errorsMx "github.com/multiversx/mx-chain-go/errors"
 	"github.com/multiversx/mx-chain-go/facade/mock"
 	"github.com/multiversx/mx-chain-go/heartbeat/data"
 	"github.com/multiversx/mx-chain-go/node/external"
@@ -84,7 +85,7 @@ func TestNewNodeFacade(t *testing.T) {
 		nf, err := NewNodeFacade(arg)
 
 		require.Nil(t, nf)
-		require.Equal(t, ErrNilNode, err)
+		require.Equal(t, errorsMx.ErrNilNode, err)
 	})
 	t.Run("nil ApiResolver should error", func(t *testing.T) {
 		t.Parallel()

genesis/process/sovereignGenesisBlockCreator.go

@@ -36,11 +36,16 @@ func NewSovereignGenesisBlockCreator(gbc *genesisBlockCreator) (*sovereignGenesi
 
 // CreateGenesisBlocks will create sovereign genesis blocks
 func (gbc *sovereignGenesisBlockCreator) CreateGenesisBlocks() (map[uint32]data.HeaderHandler, error) {
+	err := gbc.initSystemAccount()
+	if err != nil {
+		return nil, err
+	}
+
 	if !mustDoGenesisProcess(gbc.arg) {
 		return gbc.createSovereignEmptyGenesisBlocks()
 	}
 
-	err := gbc.computeSovereignDNSAddresses(gbc.arg.EpochConfig.EnableEpochs)
+	err = gbc.computeSovereignDNSAddresses(gbc.arg.EpochConfig.EnableEpochs)
 	if err != nil {
 		return nil, err
 	}
@@ -55,6 +60,20 @@ func (gbc *sovereignGenesisBlockCreator) CreateGenesisBlocks() (map[uint32]data.
 	return gbc.createSovereignHeaders(argsCreateBlock)
 }
 
+func (gbc *sovereignGenesisBlockCreator) initSystemAccount() error {
+	acc, err := gbc.arg.Accounts.LoadAccount(core.SystemAccountAddress)
+	if err != nil {
+		return err
+	}
+
+	err = gbc.arg.Accounts.SaveAccount(acc)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (gbc *sovereignGenesisBlockCreator) createSovereignEmptyGenesisBlocks() (map[uint32]data.HeaderHandler, error) {
 	err := gbc.computeSovereignDNSAddresses(createGenesisConfig())
 	if err != nil {

genesis/process/sovereignGenesisBlockCreator_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/multiversx/mx-chain-go/process"
 	"github.com/multiversx/mx-chain-go/sharding"
 	"github.com/multiversx/mx-chain-go/sharding/nodesCoordinator"
+	stateErrors "github.com/multiversx/mx-chain-go/state"
 	"github.com/multiversx/mx-chain-go/testscommon"
 	"github.com/multiversx/mx-chain-go/testscommon/state"
 	"github.com/multiversx/mx-chain-go/vm"
@@ -158,3 +159,26 @@ func TestSovereignGenesisBlockCreator_setSovereignStakedData(t *testing.T) {
 	require.Nil(t, err)
 	require.Equal(t, []data.TransactionHandler{expectedTx}, txs)
 }
+
+func TestSovereignGenesisBlockCreator_InitSystemAccountCalled(t *testing.T) {
+	t.Parallel()
+
+	arg := createMockArgument(t, "testdata/genesisTest1.json", &mock.InitialNodesHandlerStub{}, big.NewInt(22000))
+	arg.ShardCoordinator = sharding.NewSovereignShardCoordinator(core.SovereignChainShardId)
+	arg.DNSV2Addresses = []string{"00000000000000000500761b8c4a25d3979359223208b412285f635e71300102"}
+
+	gbc, _ := NewGenesisBlockCreator(arg)
+	sgbc, _ := NewSovereignGenesisBlockCreator(gbc)
+	require.NotNil(t, sgbc)
+
+	acc, err := arg.Accounts.GetExistingAccount(core.SystemAccountAddress)
+	require.Nil(t, acc)
+	require.Equal(t, err, stateErrors.ErrAccNotFound)
+
+	_, err = sgbc.CreateGenesisBlocks()
+	require.Nil(t, err)
+
+	acc, err = arg.Accounts.GetExistingAccount(core.SystemAccountAddress)
+	require.NotNil(t, acc)
+	require.Nil(t, err)
+}

node/interface.go

@@ -5,6 +5,9 @@ import (
 	"time"
 
 	"github.com/multiversx/mx-chain-core-go/core"
+	"github.com/multiversx/mx-chain-go/debug"
+	"github.com/multiversx/mx-chain-go/facade"
+	mainFactory "github.com/multiversx/mx-chain-go/factory"
 	"github.com/multiversx/mx-chain-go/p2p"
 	"github.com/multiversx/mx-chain-go/update"
 	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
@@ -62,3 +65,28 @@ type accountHandlerWithDataTrieMigrationStatus interface {
 	vmcommon.AccountHandler
 	IsDataTrieMigrated() (bool, error)
 }
+
+// NodeFactory can create a new node
+type NodeFactory interface {
+	CreateNewNode(opts ...Option) (NodeHandler, error)
+	IsInterfaceNil() bool
+}
+
+// NodeHandler defines the behavior of a node
+type NodeHandler interface {
+	facade.NodeHandler
+	CreateShardedStores() error
+	AddQueryHandler(name string, handler debug.QueryHandler) error
+	GetCoreComponents() mainFactory.CoreComponentsHolder
+	GetStatusCoreComponents() mainFactory.StatusCoreComponentsHolder
+	GetCryptoComponents() mainFactory.CryptoComponentsHolder
+	GetConsensusComponents() mainFactory.ConsensusComponentsHolder
+	GetBootstrapComponents() mainFactory.BootstrapComponentsHolder
+	GetDataComponents() mainFactory.DataComponentsHolder
+	GetHeartbeatV2Components() mainFactory.HeartbeatV2ComponentsHolder
+	GetNetworkComponents() mainFactory.NetworkComponentsHolder
+	GetProcessComponents() mainFactory.ProcessComponentsHolder
+	GetStateComponents() mainFactory.StateComponentsHolder
+	GetStatusComponents() mainFactory.StatusComponentsHolder
+	Close() error
+}

node/mock/factory/networkComponentsMock.go

@@ -17,11 +17,12 @@ type NetworkComponentsMock struct {
 	PeersRatingMonitorField          p2p.PeersRatingMonitor
 	FullArchiveNetworkMessengerField p2p.Messenger
 	FullArchivePreferredPeersHolder  factory.PreferredPeersHolderHandler
+	PubKeyCacherField                process.TimeCacher
 }
 
 // PubKeyCacher -
 func (ncm *NetworkComponentsMock) PubKeyCacher() process.TimeCacher {
-	panic("implement me")
+	return ncm.PubKeyCacherField
 }
 
 // PeerHonestyHandler -

node/node.go

@@ -210,6 +210,10 @@ func (n *Node) GetAllIssuedESDTs(tokenType string, ctx context.Context) ([]strin
 		return nil, ErrMetachainOnlyEndpoint
 	}
 
+	return n.baseGetAllIssuedESDTs(tokenType, ctx)
+}
+
+func (n *Node) baseGetAllIssuedESDTs(tokenType string, ctx context.Context) ([]string, error) {
 	userAccount, _, err := n.loadUserAccountHandlerByPubKey(vm.ESDTSCAddress, api.AccountQueryOptions{})
 	if err != nil {
 		// don't return 0 values here - not finding the ESDT SC address is an error that should be returned
@@ -443,6 +447,14 @@ func (n *Node) getTokensIDsWithFilter(
 		return nil, api.BlockInfo{}, ErrMetachainOnlyEndpoint
 	}
 
+	return n.baseGetTokensIDsWithFilter(f, options, ctx)
+}
+
+func (n *Node) baseGetTokensIDsWithFilter(
+	f filter,
+	options api.AccountQueryOptions,
+	ctx context.Context,
+) ([]string, api.BlockInfo, error) {
 	userAccount, blockInfo, err := n.loadUserAccountHandlerByPubKey(vm.ESDTSCAddress, options)
 	if err != nil {
 		return nil, api.BlockInfo{}, err

node/nodeFactory.go

@@ -0,0 +1,19 @@
+package node
+
+type nodeFactory struct {
+}
+
+// NewNodeFactory creates a new node factory instance for regular/main chain
+func NewNodeFactory() *nodeFactory {
+	return &nodeFactory{}
+}
+
+// CreateNewNode will create a new NodeHandler
+func (nf *nodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) {
+	return NewNode(opts...)
+}
+
+// IsInterfaceNil checks if the underlying pointer is nil
+func (nf *nodeFactory) IsInterfaceNil() bool {
+	return nf == nil
+}

node/nodeFactory_test.go

@@ -0,0 +1,26 @@
+package node_test
+
+import (
+	"fmt"
+	"github.com/multiversx/mx-chain-go/node"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestNewNodeFactory(t *testing.T) {
+	t.Parallel()
+
+	nodeFactory := node.NewNodeFactory()
+	require.False(t, nodeFactory.IsInterfaceNil())
+}
+
+func TestNodeFactory_CreateNewNode(t *testing.T) {
+	t.Parallel()
+
+	nodeFactory := node.NewNodeFactory()
+
+	n, err := nodeFactory.CreateNewNode()
+	require.Nil(t, err)
+	require.NotNil(t, n)
+	require.Equal(t, "*node.Node", fmt.Sprintf("%T", n))
+}